refactor: rename src/core/launch.ts to open.ts

src/core/open.ts

@@ -0,0 +1,226 @@
+import * as fs from "node:fs";
+import type { MultiModelOptions, MultiModelResult } from "../types";
+import {
+  runCommand,
+  normalizeModels,
+  findDuplicates,
+  createWindowPlans,
+  formatInvalidModelError,
+  sanitizeName,
+  getWorktreePath,
+  getSessionPath,
+  undoWorktree,
+  launchModelInWindow,
+} from "./utils";
+
+/**
+ * Launches multiple AI models in a tmux session with git worktrees.
+ *
+ * Creates a tmux session with one window per model, each in its own git worktree.
+ * Validates models against `opencode models` output before launching.
+ *
+ * @param options Launch configuration including session name and model list.
+ * @returns Result with success status, window names, and usage instructions.
+ *
+ * @example
+ * ```ts
+ * const result = await launchMultiModel({
+ *   sessionName: "compare",
+ *   models: ["openai/gpt-5.2", "anthropic/claude-3-5-sonnet"],
+ *   binaryName: "opencode",
+ * });
+ * if (result.success) {
+ *   console.log(result.instructions);
+ * }
+ * ```
+ */
+export async function launchMultiModel(options: MultiModelOptions): Promise<MultiModelResult> {
+  const sessionName = options.sessionName.trim();
+  const safeSessionName = sanitizeName(sessionName);
+  const models = normalizeModels(options.models);
+  const binaryName = options.binaryName || "opencode";
+  const mode = options.mode || "cli";
+
+  if (!sessionName) {
+    return { success: false, sessionName: "", error: "Error: `sessionName` must not be empty." };
+  }
+
+  if (models.length === 0) {
+    return { success: false, sessionName, error: "Error: Model names must not be empty." };
+  }
+
+  const duplicateModels = findDuplicates(models);
+  if (duplicateModels.length > 0) {
+    return {
+      success: false,
+      sessionName,
+      error: `Error: Duplicate model names are not allowed: ${duplicateModels.map((item) => `'${item}'`).join(", ")}.`,
+    };
+  }
+
+  const gitRepoCheck = await runCommand(["git", "rev-parse", "--is-inside-work-tree"]);
+  if (!gitRepoCheck.ok) {
+    return { success: false, sessionName, error: "Error: `multi-model` requires a git repository." };
+  }
+
+  const tmuxExists = await runCommand(["command", "-v", "tmux"]);
+  if (!tmuxExists.ok) {
+    return { success: false, sessionName, error: "Error: `tmux` is not installed or not on `PATH`." };
+  }
+
+  const binaryExists = await runCommand(["command", "-v", binaryName]);
+  if (!binaryExists.ok) {
+    return { success: false, sessionName, error: `Error: \`${binaryName}\` is not installed or not on \`PATH\`.` };
+  }
+
+  const modelListResult = await runCommand([binaryName, "models"]);
+  if (!modelListResult.ok) {
+    return {
+      success: false,
+      sessionName,
+      error: `Error: Failed to load valid models from \`${binaryName} models\`${modelListResult.stderr ? `: ${modelListResult.stderr}` : "."}`,
+    };
+  }
+
+  const allowlist = modelListResult.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  const invalidModels = models.filter((model) => !allowlist.includes(model));
+  if (invalidModels.length > 0) {
+    return { success: false, sessionName, error: formatInvalidModelError(invalidModels, allowlist) };
+  }
+
+  const sessionExists = await runCommand(["tmux", "has-session", "-t", sessionName]);
+  if (sessionExists.ok) {
+    return { success: false, sessionName, error: "Error: Session already exists. Use a different `sessionName`." };
+  }
+
+  const windowPlans = createWindowPlans(models);
+  const succeededModels: string[] = [];
+  const failedModels: string[] = [];
+
+  for (let i = 0; i < windowPlans.length; i++) {
+    const plan = windowPlans[i]!;
+    const isFirst = i === 0;
+
+    const worktreePath = getWorktreePath(safeSessionName, plan.windowName);
+    const branchName = `opencode/${safeSessionName}/${plan.windowName}`;
+
+    if (fs.existsSync(worktreePath)) {
+      if (!isFirst) {
+        failedModels.push(`${plan.model} (Worktree path already exists at ${worktreePath})`);
+        continue;
+      } else {
+        return { success: false, sessionName, error: `Error: Worktree path already exists at ${worktreePath}. Clean it up first.` };
+      }
+    }
+
+    const branchExists = await runCommand(["git", "show-ref", "--verify", "--quiet", `refs/heads/${branchName}`]);
+    if (branchExists.ok) {
+      if (!isFirst) {
+        failedModels.push(`${plan.model} (Branch '${branchName}' already exists)`);
+        continue;
+      } else {
+        return { success: false, sessionName, error: `Error: Branch '${branchName}' already exists.` };
+      }
+    }
+
+    const worktreeResult = await runCommand(["git", "worktree", "add", "-b", branchName, worktreePath]);
+    if (!worktreeResult.ok) {
+      if (!isFirst) {
+        failedModels.push(`${plan.model} (Failed to create worktree: ${worktreeResult.stderr})`);
+        continue;
+      } else {
+        return { success: false, sessionName, error: `Error: Failed to create worktree for ${plan.model}: ${worktreeResult.stderr}` };
+      }
+    }
+
+    if (isFirst) {
+      const sessionCreateResult = await runCommand([
+        "tmux",
+        "new-session",
+        "-d",
+        "-s",
+        sessionName,
+        "-n",
+        plan.windowName,
+        "-c",
+        worktreePath,
+      ]);
+
+      if (!sessionCreateResult.ok) {
+        const undoErrors = await undoWorktree(worktreePath, branchName);
+        let errorMsg = `Error: Failed to create tmux session '${sessionName}'.${sessionCreateResult.stderr ? ` ${sessionCreateResult.stderr}` : ""}`;
+        if (undoErrors.length > 0) errorMsg += ` Cleanup errors: ${undoErrors.join(", ")}`;
+        return { success: false, sessionName, error: errorMsg };
+      }
+    } else {
+      const windowCreateResult = await runCommand([
+        "tmux",
+        "new-window",
+        "-d",
+        "-t",
+        sessionName,
+        "-n",
+        plan.windowName,
+        "-c",
+        worktreePath,
+      ]);
+
+      if (!windowCreateResult.ok) {
+        failedModels.push(`${plan.model} (${windowCreateResult.stderr || "failed to create window"})`);
+        const undoErrors = await undoWorktree(worktreePath, branchName);
+        if (undoErrors.length > 0) failedModels.push(`cleanup failed for ${plan.model}: ${undoErrors.join(", ")}`);
+        continue;
+      }
+    }
+
+    const launchResult = await launchModelInWindow(sessionName, plan, binaryName);
+    if (launchResult.ok) {
+      succeededModels.push(plan.model);
+    } else {
+      failedModels.push(`${plan.model} (${launchResult.stderr || "failed to send launch command"})`);
+      const undoErrors = await undoWorktree(worktreePath, branchName);
+      if (undoErrors.length > 0) failedModels.push(`cleanup failed for ${plan.model}: ${undoErrors.join(", ")}`);
+    }
+  }
+
+  const windowNames = windowPlans.map((p) => p.windowName);
+  const attachCommand = `tmux attach -t ${sessionName}`;
+  const cleanupCommand = `tmux kill-session -t ${sessionName} && rm -rf ~/.local/share/opencode/multi-model/${safeSessionName} && git worktree prune && git branch -D $(git branch --format='%(refname:short)' --list 'opencode/${safeSessionName}/*')`;
+  const primaryCleanup =
+    mode === "tool"
+      ? `call tool multi-model-close with sessionName: ${sessionName}`
+      : `opencode-multi-model close ${sessionName}`;
+
+  if (failedModels.length > 0) {
+    return {
+      success: true,
+      sessionName,
+      windows: windowNames,
+      instructions: [
+        `Error: Created tmux session '${sessionName}', but some model launches failed.`,
+        `Succeeded: ${succeededModels.length > 0 ? succeededModels.join(", ") : "none"}.`,
+        `Failed: ${failedModels.join(", ")}.`,
+        `Attach with \`${attachCommand}\` to inspect the session.`,
+        `Cleanup when done using either:`,
+        `1. ${primaryCleanup}`,
+        `2. Or run manually: \`${cleanupCommand}\``,
+      ].join("\n"),
+    };
+  }
+
+  return {
+    success: true,
+    sessionName,
+    windows: windowNames,
+    instructions: [
+      `Use \`${attachCommand}\` to join session.`,
+      `When finished, clean up using either:`,
+      `1. ${primaryCleanup}`,
+      `2. Or run manually: \`${cleanupCommand}\``,
+    ].join("\n"),
+  };
+}