mexus-cli 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mexus-cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Local web console for managing multiple CLI AI Agent instances in parallel",
   "type": "module",
   "bin": {

package/packages/server/dist/cli.mjs

@@ -45,9 +45,34 @@ var init_ConfigManager = __esm({
           statusline: true,
           env: {}
         },
+        codex: {
+          bin: "codex",
+          continue_flag: "",
+          resume_flag: "",
+          yolo_flag: "",
+          statusline: false,
+          env: {}
+        },
         opencode: {
           bin: "opencode",
           continue_flag: "--continue",
+          resume_flag: "",
+          yolo_flag: "--yolo",
+          statusline: false,
+          env: {}
+        },
+        "kimi-cli": {
+          bin: "kimi",
+          continue_flag: "--continue",
+          resume_flag: "",
+          yolo_flag: "",
+          statusline: false,
+          env: {}
+        },
+        qodercli: {
+          bin: "qodercli",
+          continue_flag: "-c",
+          resume_flag: "-r",
           yolo_flag: "--yolo",
           statusline: false,
           env: {}
@@ -147,7 +172,7 @@ var init_ConfigManager = __esm({
           { key: "codex", bin: "codex", flag: "", statusline: false },
           { key: "opencode", bin: "opencode", flag: "--continue", statusline: false },
           { key: "kimi-cli", bin: "kimi", flag: "--continue", statusline: false },
-          { key: "qwencode", bin: "qwen-code", flag: "--continue", statusline: false }
+          { key: "qodercli", bin: "qodercli", flag: "-c", statusline: false }
         ];
         const results = await Promise.allSettled(
           agentBins.map(async (agent) => {
@@ -210,7 +235,7 @@ var init_ConfigManager = __esm({
           { key: "codex", bin: "codex", installHint: "npm install -g @openai/codex" },
           { key: "opencode", bin: "opencode", installHint: "go install github.com/opencode-ai/opencode@latest" },
           { key: "kimi-cli", bin: "kimi", installHint: "pip install kimi-cli" },
-          { key: "qwencode", bin: "qwen-code", installHint: "pip install qwen-code" }
+          { key: "qodercli", bin: "qodercli", installHint: "See https://docs.qoder.com/zh/cli/using-cli" }
         ];
         const checks = await Promise.allSettled(
           knownAgents.map(async (agent) => {
@@ -275,6 +300,7 @@ var KNOWN_FIELDS = {
   // Claude Code may add more fields — add them here as discovered
 };
 var MIN_KNOWN_FIELDS = 2;
+var MAX_BUFFER_SIZE = 64 * 1024;
 var StatuslineParser = class {
   buffer = "";
   /**
@@ -286,6 +312,9 @@ var StatuslineParser = class {
     let meta = null;
     if (!data.includes("\n")) {
       this.buffer += data;
+      if (this.buffer.length > MAX_BUFFER_SIZE) {
+        this.buffer = "";
+      }
       return { cleanData: data, meta: null };
     }
     const combined = this.buffer + data;
@@ -913,9 +942,17 @@ var PtyManager = class {
         entry.stateAnalyzer.onOutput();
         entry.scrollback.push(cleanData);
         entry.scrollbackBytes += cleanData.length;
-        while (entry.scrollbackBytes > MAX_SCROLLBACK_BYTES && entry.scrollback.length > 1) {
-          const removed = entry.scrollback.shift();
-          entry.scrollbackBytes -= removed.length;
+        if (entry.scrollbackBytes > MAX_SCROLLBACK_BYTES) {
+          let bytesToRemove = entry.scrollbackBytes - MAX_SCROLLBACK_BYTES;
+          let removeCount = 0;
+          while (removeCount < entry.scrollback.length - 1 && bytesToRemove > 0) {
+            bytesToRemove -= entry.scrollback[removeCount].length;
+            entry.scrollbackBytes -= entry.scrollback[removeCount].length;
+            removeCount++;
+          }
+          if (removeCount > 0) {
+            entry.scrollback.splice(0, removeCount);
+          }
         }
         for (const cb of entry.onDataCallbacks) {
           cb(cleanData);
@@ -1101,6 +1138,35 @@ var WorktreeManager = class {
     this.worktrees.set(paneId, entry);
     return { worktreePath, branch };
   }
+  /**
+   * Restore a worktree from a previous session.
+   * If the worktree directory still exists, re-register it.
+   * If not, recreate it from the existing branch.
+   * Returns false if the branch no longer exists (stale config).
+   */
+  async restore(paneId, branch, worktreePath) {
+    const baseBranch = await this.getCurrentBranch();
+    try {
+      await this.git.raw(["rev-parse", "--verify", branch]);
+    } catch {
+      return false;
+    }
+    if (fs3.existsSync(worktreePath)) {
+      this.worktrees.set(paneId, { path: worktreePath, branch, baseBranch });
+      return true;
+    }
+    try {
+      await this.git.raw(["worktree", "prune"]).catch(() => {
+      });
+      fs3.mkdirSync(path3.dirname(worktreePath), { recursive: true });
+      await this.git.raw(["worktree", "add", worktreePath, branch]);
+      this.worktrees.set(paneId, { path: worktreePath, branch, baseBranch });
+      return true;
+    } catch (err) {
+      console.warn(`[WorktreeManager] Failed to restore worktree for ${paneId}:`, err.message);
+      return false;
+    }
+  }
   /**
    * Remove a worktree. Branch is kept for later merge/PR.
    */
@@ -1181,6 +1247,60 @@ var WorktreeManager = class {
     }
     return diffs;
   }
+  /**
+   * Merge the worktree branch into the base branch (e.g. main).
+   * First commits any uncommitted changes in the worktree, then merges.
+   */
+  async merge(paneId) {
+    const entry = this.worktrees.get(paneId);
+    if (!entry) {
+      return { success: false, message: "Worktree not found for this pane" };
+    }
+    const wtGit = simpleGit(entry.path);
+    try {
+      const status = await wtGit.status();
+      const hasChanges = status.modified.length > 0 || status.created.length > 0 || status.deleted.length > 0 || status.staged.length > 0 || status.not_added.length > 0;
+      if (hasChanges) {
+        await wtGit.add("-A");
+        await wtGit.commit(`nexus: auto-commit before merge (${entry.branch})`);
+      }
+      const log = await wtGit.log([`${entry.baseBranch}..${entry.branch}`]);
+      if (log.total === 0) {
+        return { success: false, message: "No changes to merge" };
+      }
+      await this.git.merge([entry.branch]);
+      return {
+        success: true,
+        message: `Merged ${log.total} commit${log.total !== 1 ? "s" : ""} from ${entry.branch} into ${entry.baseBranch}`
+      };
+    } catch (err) {
+      try {
+        await this.git.merge(["--abort"]);
+      } catch {
+      }
+      return {
+        success: false,
+        message: `Merge conflict: ${err.message}`
+      };
+    }
+  }
+  /**
+   * Discard all changes: remove worktree and delete the branch.
+   */
+  async discard(paneId) {
+    const entry = this.worktrees.get(paneId);
+    if (!entry) {
+      return { success: false, message: "Worktree not found for this pane" };
+    }
+    const branch = entry.branch;
+    await this.forceRemoveWorktree(entry.path);
+    try {
+      await this.git.raw(["branch", "-D", branch]);
+    } catch {
+    }
+    this.worktrees.delete(paneId);
+    return { success: true, message: `Discarded branch ${branch}` };
+  }
   getWorktreePath(paneId) {
     return this.worktrees.get(paneId)?.path;
   }
@@ -1494,7 +1614,7 @@ var WorkspaceManager = class {
     this.ptyManager = new PtyManager(configManager);
     this.worktreeManager = new WorktreeManager(configManager.getProjectDir());
   }
-  init() {
+  async init() {
     const wsConfig = this.configManager.initWorkspace();
     this.wsName = wsConfig.name;
     this.wsDescription = wsConfig.description || "";
@@ -1511,8 +1631,25 @@ var WorkspaceManager = class {
       if (paneConfig.sessionId && paneConfig.agent !== "__shell__") {
         paneConfig.restore = "resume";
       }
+      if (paneConfig.isolation === "worktree" && paneConfig.branch && paneConfig.worktreePath) {
+        try {
+          const restored = await this.worktreeManager.restore(paneConfig.id, paneConfig.branch, paneConfig.worktreePath);
+          if (!restored) {
+            console.warn(`Skipping worktree pane ${paneConfig.id} (${paneConfig.name}): branch no longer exists`);
+            failCount++;
+            continue;
+          }
+        } catch (err) {
+          console.warn(`Skipping worktree pane ${paneConfig.id} (${paneConfig.name}): restore failed:`, err.message);
+          failCount++;
+          continue;
+        }
+      }
       try {
         this.spawnPane(paneConfig);
+        if (paneConfig.isolation === "worktree" && paneConfig.worktreePath) {
+          await this.startPaneGitService(paneConfig.id, paneConfig.worktreePath);
+        }
       } catch (err) {
         console.warn(`Skipping stale pane ${paneConfig.id} (${paneConfig.name}):`, err.message);
         failCount++;
@@ -1605,6 +1742,28 @@ var WorkspaceManager = class {
     this.spawnPane(config);
     this.updatePaneConfigSessionId(paneId, resolvedSessionId);
   }
+  async mergeWorktree(paneId) {
+    const pane = this.panes.get(paneId);
+    if (!pane || pane.isolation !== "worktree") {
+      return { success: false, message: "Pane is not a worktree pane" };
+    }
+    return this.worktreeManager.merge(paneId);
+  }
+  async discardWorktree(paneId) {
+    const pane = this.panes.get(paneId);
+    if (!pane || pane.isolation !== "worktree") {
+      return { success: false, message: "Pane is not a worktree pane" };
+    }
+    this.stopPaneGitService(paneId);
+    const result = await this.worktreeManager.discard(paneId);
+    if (result.success) {
+      pane.isolation = "shared";
+      pane.worktreePath = void 0;
+      pane.branch = void 0;
+      this.emit("onPaneDiff", paneId, []);
+    }
+    return result;
+  }
   writeToPane(paneId, data) {
     this.ptyManager.write(paneId, data);
   }
@@ -1795,7 +1954,6 @@ var WorkspaceManager = class {
     for (const [paneId] of this.perPaneGitServices) {
       this.stopPaneGitService(paneId);
     }
-    await this.worktreeManager.removeAll();
   }
 };
 
@@ -2024,18 +2182,23 @@ function setupWsHandlers(socket, workspaceManager, gitService) {
     state
   });
   const SCROLLBACK_CHUNK_SIZE = 64 * 1024;
-  for (const pane of state.panes) {
-    const scrollback = workspaceManager.getScrollback(pane.id);
-    if (scrollback) {
+  const replayScrollback = async () => {
+    for (const pane of state.panes) {
+      const scrollback = workspaceManager.getScrollback(pane.id);
+      if (!scrollback) continue;
       if (scrollback.length <= SCROLLBACK_CHUNK_SIZE) {
         send({ type: "terminal.output", paneId: pane.id, data: scrollback });
       } else {
         for (let i = 0; i < scrollback.length; i += SCROLLBACK_CHUNK_SIZE) {
+          if (socket.readyState !== socket.OPEN) return;
           send({ type: "terminal.output", paneId: pane.id, data: scrollback.slice(i, i + SCROLLBACK_CHUNK_SIZE) });
+          await new Promise((resolve) => setImmediate(resolve));
         }
       }
     }
-  }
+  };
+  replayScrollback().catch(() => {
+  });
   const paneDiffs = workspaceManager.getPaneDiffs();
   for (const [paneId, diffs] of paneDiffs) {
     if (diffs.length > 0) {
@@ -2163,6 +2326,22 @@ function setupWsHandlers(socket, workspaceManager, gitService) {
           });
         }
         break;
+      case "pane.merge":
+        workspaceManager.mergeWorktree(event.paneId).then((result) => {
+          send({ type: "pane.merge.result", paneId: event.paneId, ...result });
+          gitService?.refresh();
+        }).catch((err) => {
+          send({ type: "pane.merge.result", paneId: event.paneId, success: false, message: String(err) });
+        });
+        break;
+      case "pane.discard":
+        workspaceManager.discardWorktree(event.paneId).then((result) => {
+          send({ type: "pane.merge.result", paneId: event.paneId, ...result });
+          gitService?.refresh();
+        }).catch((err) => {
+          send({ type: "pane.merge.result", paneId: event.paneId, success: false, message: String(err) });
+        });
+        break;
       case "pane.diff.refresh":
         workspaceManager.refreshPaneDiff(event.paneId);
         break;
@@ -2742,7 +2921,7 @@ async function startServer(port, projectDir) {
   const configManager = new ConfigManager(projectDir);
   configManager.loadGlobalConfig();
   const workspaceManager = new WorkspaceManager(configManager);
-  workspaceManager.init();
+  await workspaceManager.init();
   const agentsWriter = new AgentsYamlWriter(projectDir);
   workspaceManager.onEvents({
     onPaneAdded: () => agentsWriter.update(workspaceManager.getPanes()),