@sideboard-ai/core 0.1.225 → 0.1.227

package/dist/mcp/run-stdio.cjs

@@ -13346,6 +13346,12 @@ function samePrIdentity(a, b) {
   const rn = right.match(/\/pull\/(\d+)/i)?.[1];
   return Boolean(ln && rn && ln === rn);
 }
+function shouldStopRunOnPrRetarget(previousPrUrl, nextPrUrl) {
+  const prev = (previousPrUrl ?? "").trim();
+  const next = (nextPrUrl ?? "").trim();
+  if (!prev || !next) return false;
+  return !samePrIdentity(prev, next);
+}
 function shouldPersistFetchedPrMeta(opts) {
   const meta = opts.metaUrl?.trim() || "";
   if (!meta) return false;
@@ -14429,6 +14435,44 @@ function pipeLines(stream, onLine) {
   const rl = (0, import_node_readline3.createInterface)({ input: stream });
   rl.on("line", onLine);
 }
+function killListenersOnPorts(ports) {
+  for (const port of ports) {
+    if (!Number.isFinite(port) || port <= 0) continue;
+    try {
+      if (process.platform === "win32") {
+        (0, import_node_child_process4.execFileSync)(
+          "powershell",
+          [
+            "-NoProfile",
+            "-Command",
+            `Get-NetTCPConnection -LocalPort ${port} -ErrorAction SilentlyContinue | ForEach-Object { Stop-Process -Id $_.OwningProcess -Force -ErrorAction SilentlyContinue }`
+          ],
+          { stdio: "ignore", timeout: 3e3 }
+        );
+        continue;
+      }
+      let raw = "";
+      try {
+        raw = (0, import_node_child_process4.execFileSync)("lsof", [`-tiTCP:${port}`, "-sTCP:LISTEN"], {
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"],
+          timeout: 2e3
+        });
+      } catch {
+        continue;
+      }
+      for (const token of raw.trim().split(/\s+/)) {
+        const pid = Number(token);
+        if (!Number.isFinite(pid) || pid <= 0) continue;
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+}
 function killScriptTree(child, ports = []) {
   const pid = child.pid;
   if (pid) {
@@ -14451,26 +14495,7 @@ function killScriptTree(child, ports = []) {
       }
     }
   }
-  for (const port of ports) {
-    if (!Number.isFinite(port) || port <= 0) continue;
-    if (process.platform === "win32") {
-      void (0, import_execa4.execa)(
-        "powershell",
-        [
-          "-NoProfile",
-          "-Command",
-          `Get-NetTCPConnection -LocalPort ${port} -ErrorAction SilentlyContinue | ForEach-Object { Stop-Process -Id $_.OwningProcess -Force -ErrorAction SilentlyContinue }`
-        ],
-        { reject: false }
-      );
-    } else {
-      void (0, import_execa4.execa)(
-        "zsh",
-        ["-lc", `pids=$(lsof -tiTCP:${port} -sTCP:LISTEN 2>/dev/null); [ -n "$pids" ] && kill -TERM $pids 2>/dev/null; true`],
-        { reject: false }
-      );
-    }
-  }
+  killListenersOnPorts(ports);
 }
 async function spawnWorkspaceScript(command, opts) {
   const loginEnv = await captureLoginEnv();
@@ -14661,11 +14686,12 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
     done: handle.done
   };
 }
-var import_node_fs37, import_node_net, import_node_path39, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
+var import_node_fs37, import_node_child_process4, import_node_net, import_node_path39, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
 var init_conductor = __esm({
   "src/hook/conductor.ts"() {
     "use strict";
     import_node_fs37 = require("fs");
+    import_node_child_process4 = require("child_process");
     import_node_net = require("net");
     import_node_path39 = require("path");
     import_execa4 = require("execa");
@@ -18497,7 +18523,7 @@ function importConductorWorkspace(workspaceId) {
       }
       let repoPath = worktreePath;
       try {
-        repoPath = (0, import_node_child_process4.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+        repoPath = (0, import_node_child_process5.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
           cwd: worktreePath,
           encoding: "utf8"
         }).trim();
@@ -18526,11 +18552,11 @@ function importConductorWorkspace(workspaceId) {
 async function importConductorWorkspaceAsync(workspaceId) {
   return importConductorWorkspace(workspaceId);
 }
-var import_node_child_process4, import_node_fs45, import_node_os14, import_node_path45, import_node_module4, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
+var import_node_child_process5, import_node_fs45, import_node_os14, import_node_path45, import_node_module4, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
 var init_adopt = __esm({
   "src/threads/adopt.ts"() {
     "use strict";
-    import_node_child_process4 = require("child_process");
+    import_node_child_process5 = require("child_process");
     import_node_fs45 = require("fs");
     import_node_os14 = require("os");
     import_node_path45 = require("path");
@@ -20929,7 +20955,7 @@ function setCaffeinateHold(enabled, opts) {
   if (platform !== "darwin") {
     return idleState(platform);
   }
-  const spawnImpl = hooks.spawn ?? import_node_child_process5.spawn;
+  const spawnImpl = hooks.spawn ?? import_node_child_process6.spawn;
   const child = spawnImpl("caffeinate", ["-dimsu"], {
     detached: true,
     stdio: "ignore"
@@ -20956,11 +20982,11 @@ function releaseCaffeinateHoldForThread(threadId) {
   }
   return setCaffeinateHold(false, { threadId: id });
 }
-var import_node_child_process5, import_node_fs52, import_node_path51, hooks;
+var import_node_child_process6, import_node_fs52, import_node_path51, hooks;
 var init_caffeinate_hold = __esm({
   "src/store/caffeinate-hold.ts"() {
     "use strict";
-    import_node_child_process5 = require("child_process");
+    import_node_child_process6 = require("child_process");
     import_node_fs52 = require("fs");
     import_node_path51 = require("path");
     init_paths();
@@ -21458,6 +21484,16 @@ function writeLiveStatus(threadId, status, lastError) {
   if (!latest || latest.status === "archived") return latest;
   return setStatus(threadId, status, lastError);
 }
+function collectActiveRunPorts(runs) {
+  const ports = /* @__PURE__ */ new Set();
+  for (const run2 of runs) {
+    const list = run2.ports?.length ? run2.ports : run2.port != null ? [run2.port] : [];
+    for (const p of list) {
+      if (Number.isFinite(p) && p > 0) ports.add(p);
+    }
+  }
+  return [...ports];
+}
 function getOrchestrator() {
   if (!singleton) {
     singleton = new Orchestrator();
@@ -21733,6 +21769,9 @@ var init_orchestrator = __esm({
             this.emit({ type: "status_changed", threadId: thread.id, status: "stopped" });
           }
         }
+        if (reclaimStaleTurns) {
+          this.reapOrphanedRunScripts();
+        }
         const repoPaths = (repoPath ? [repoPath] : [...new Set(listThreads({ includeArchived: true }).map((t) => t.repoPath))]).filter((p) => !isGlobalRepoPath(p));
         await this.reconcileOrphans(repoPaths);
         try {
@@ -22951,13 +22990,30 @@ var init_orchestrator = __esm({
             worktreeRunProcessKey(thread.worktreePath, scriptName),
             ...siblings.map((t) => `${t.id}:run:${scriptName}`)
           ];
+          let hadHandle2 = false;
           for (const key of keys) {
             const proc = this.processes.get(key);
-            if (proc) proc.kill();
+            if (proc) {
+              proc.kill();
+              hadHandle2 = true;
+            }
             this.processes.delete(key);
           }
+          const legacyKey = worktreeDevProcessKey(thread.worktreePath);
+          const legacy = this.processes.get(legacyKey);
+          if (legacy?.scriptName === scriptName || !legacy?.scriptName && scriptName === "dev") {
+            if (legacy && !hadHandle2) {
+              legacy.kill();
+              hadHandle2 = true;
+            }
+            this.processes.delete(legacyKey);
+          }
+          const run2 = shared.activeRuns.find((r) => r.scriptName === scriptName);
+          if (!hadHandle2 && run2) {
+            killListenersOnPorts(collectActiveRunPorts([run2]));
+          }
           const remaining = shared.activeRuns.filter((r) => r.scriptName !== scriptName);
-          const isPrimary = shared.devPort != null && shared.activeRuns.find((r) => r.scriptName === scriptName)?.port === shared.devPort;
+          const isPrimary = shared.devPort != null && run2?.port === shared.devPort;
           this.syncWorktreeRuns(
             thread.worktreePath,
             remaining,
@@ -22966,15 +23022,66 @@ var init_orchestrator = __esm({
           this.emit({ type: "dev_server_stopped", threadId: thread.id, scriptName });
           return;
         }
+        let hadHandle = false;
         for (const [key, proc] of [...this.processes.entries()]) {
           if (isWorktreeRunProcessKey(key, thread.worktreePath) || siblings.some((t) => key.startsWith(`${t.id}:run:`) || key === `${t.id}:dev`)) {
             proc.kill();
+            hadHandle = true;
             this.processes.delete(key);
           }
         }
+        if (!hadHandle && shared.activeRuns.length > 0) {
+          killListenersOnPorts(collectActiveRunPorts(shared.activeRuns));
+        }
         this.syncWorktreeRuns(thread.worktreePath, [], null);
         this.emit({ type: "dev_server_stopped", threadId: thread.id });
       }
+      /**
+       * App quit: tear down every registered run/setup child and free persisted
+       * ports so the next launch is not blocked by orphans.
+       */
+      stopAllRunScripts() {
+        for (const [key, proc] of [...this.processes.entries()]) {
+          if (proc.kind !== "dev" && proc.kind !== "setup") continue;
+          try {
+            proc.kill();
+          } catch {
+          }
+          this.processes.delete(key);
+        }
+        this.reapOrphanedRunScripts({ force: true });
+      }
+      /**
+       * After restart (or force quit), in-memory handles are gone but `activeRuns`
+       * and OS listeners may remain. Kill by port and clear disk metadata.
+       * Skips worktrees that still have a live handle unless `force` (quit path).
+       */
+      reapOrphanedRunScripts(opts) {
+        const force = opts?.force === true;
+        const seen = /* @__PURE__ */ new Set();
+        for (const thread of listThreads({ includeArchived: true })) {
+          if (thread.status === "archived") continue;
+          if (isGlobalThread(thread)) continue;
+          const wt = normalizeWorktreePath(thread.worktreePath);
+          if (seen.has(wt)) continue;
+          seen.add(wt);
+          const siblings = threadsSharingWorktree(thread.worktreePath);
+          const shared = mergeWorktreeActiveRuns(siblings);
+          if (shared.activeRuns.length === 0 && shared.devPort == null) continue;
+          const hasLiveHandle = [...this.processes.keys()].some(
+            (k) => isWorktreeRunProcessKey(k, thread.worktreePath) || siblings.some((t) => k.startsWith(`${t.id}:run:`) || k === `${t.id}:dev`)
+          );
+          if (!force && hasLiveHandle) continue;
+          killListenersOnPorts(collectActiveRunPorts(shared.activeRuns));
+          if (shared.devPort != null) {
+            killListenersOnPorts([shared.devPort]);
+          }
+          this.syncWorktreeRuns(thread.worktreePath, [], null);
+          for (const sibling of siblings) {
+            this.emit({ type: "dev_server_stopped", threadId: sibling.id });
+          }
+        }
+      }
       syncWorktreeRuns(worktreePath, activeRuns, devPort) {
         for (const sibling of threadsSharingWorktree(worktreePath)) {
           updateThread(sibling.id, { activeRuns, devPort });
@@ -23330,6 +23437,9 @@ var init_orchestrator = __esm({
         this.assertNotGlobal(thread, "Land");
         const result = await confirmLand(thread, opts);
         if (result.prUrl) {
+          if (shouldStopRunOnPrRetarget(thread.prUrl, result.prUrl)) {
+            this.stopDev(thread.id);
+          }
           const patch = { prUrl: result.prUrl };
           try {
             const meta = await getPrMeta(thread.worktreePath, result.prUrl);
@@ -23439,6 +23549,9 @@ var init_orchestrator = __esm({
       async persistPrMetaAndMaybeArchive(thread, meta) {
         const prevState = normalizePrState(thread.prState);
         const nextState = normalizePrState(meta.state);
+        if (shouldStopRunOnPrRetarget(thread.prUrl, meta.url)) {
+          this.stopDev(thread.id);
+        }
         const siblings = threadsSharingWorktree(thread.worktreePath);
         const targets = siblings.length > 0 ? siblings : [thread];
         for (const t of targets) {
@@ -23481,6 +23594,9 @@ var init_orchestrator = __esm({
         if (current?.position != null && thread.stackLayer !== current.position) {
           patch.stackLayer = current.position;
         }
+        if (current?.prUrl && shouldStopRunOnPrRetarget(thread.prUrl, current.prUrl)) {
+          this.stopDev(thread.id);
+        }
         if (current?.prUrl && current.prUrl !== thread.prUrl) patch.prUrl = current.prUrl;
         if (current?.title && current.title !== thread.prTitle) patch.prTitle = current.title;
         if (current?.branchName && current.branchName !== thread.branchName) {

package/dist/mcp/run-stdio.js

@@ -50,7 +50,7 @@ import {
   syncBoardPins,
   updateSchedule,
   waitForDetachedJob
-} from "../chunk-5L66IONI.js";
+} from "../chunk-FUDJ6NFM.js";
 import "../chunk-JFOPOMK7.js";
 import "../chunk-YWI3IBP2.js";
 import {

package/dist/{orchestrator-ZAJ2M4UW.js → orchestrator-CWOSAYAE.js}

@@ -10,7 +10,7 @@ import {
   resolveSendFollowUp,
   startOrchestration,
   waitForPidExit
-} from "./chunk-5L66IONI.js";
+} from "./chunk-FUDJ6NFM.js";
 import "./chunk-JFOPOMK7.js";
 import "./chunk-YWI3IBP2.js";
 import "./chunk-SQHRPJ7P.js";

package/dist/{orchestrator-O3FNYIRE.js → orchestrator-VKPHI64Q.js}

@@ -8,7 +8,7 @@ import {
   resolveSendFollowUp,
   startOrchestration,
   waitForPidExit
-} from "./chunk-MPSXJ7WU.js";
+} from "./chunk-I2HOATRJ.js";
 import "./chunk-DJU54RYW.js";
 import "./chunk-VUW3VKLW.js";
 import "./chunk-N2VST3NL.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sideboard-ai/core",
-  "version": "0.1.225",
+  "version": "0.1.227",
   "description": "Sideboard core — orchestration, agents, git worktrees, MCP server",
   "license": "Apache-2.0",
   "type": "module",