@sideboard-ai/core 0.1.32 → 0.1.33

package/dist/agents/cursor-runner.cjs

@@ -27,6 +27,50 @@ function appDataDir() {
   return base;
 }
 
+// src/agents/error-detail.ts
+function formatUnknownDetail(err) {
+  if (err == null) return "";
+  if (typeof err === "string") return err.trim();
+  if (err instanceof Error) {
+    const base = err.message.trim() || err.name;
+    const code = "code" in err && typeof err.code === "string" ? err.code.trim() : "";
+    return code && !base.includes(code) ? `${base} (${code})` : base;
+  }
+  if (typeof err === "object") {
+    const o = err;
+    const nested = o.error != null && typeof o.error === "object" ? formatUnknownDetail(o.error) : "";
+    const message = typeof o.message === "string" ? o.message.trim() : typeof o.error === "string" ? o.error.trim() : typeof o.result === "string" ? o.result.trim() : nested;
+    const code = typeof o.code === "string" ? o.code.trim() : "";
+    if (message) return code && !message.includes(code) ? `${message} (${code})` : message;
+    try {
+      const json = JSON.stringify(err);
+      if (json && json !== "{}" && json !== "null") return json;
+    } catch {
+    }
+  }
+  const fallback = String(err);
+  return fallback === "[object Object]" ? "" : fallback;
+}
+function extractJsonErrorMessage(obj) {
+  const nested = obj.error != null && typeof obj.error === "object" ? obj.error : null;
+  const candidates = [
+    typeof obj.message === "string" ? obj.message : null,
+    typeof obj.error === "string" ? obj.error : null,
+    nested && typeof nested.message === "string" ? nested.message : null,
+    typeof obj.result === "string" ? obj.result : null,
+    typeof obj.detail === "string" ? obj.detail : null
+  ];
+  for (const c of candidates) {
+    const t = c?.trim();
+    if (t) return t;
+  }
+  if (Array.isArray(obj.errors)) {
+    const parts = obj.errors.map((e) => formatUnknownDetail(e)).map((s) => s.trim()).filter(Boolean);
+    if (parts.length) return parts.join("; ");
+  }
+  return null;
+}
+
 // src/agents/cursor-events.ts
 function usageFromCursor(usage) {
   if (!usage) return null;
@@ -92,7 +136,12 @@ function cursorSdkMessageToEvents(msg) {
     if (usage) return [{ type: "usage", data: usage }];
   }
   if (msg.type === "status" && msg.status === "ERROR") {
-    const detail = msg.message || msg.text || "Cursor run entered ERROR status";
+    const rawMessage = msg.message;
+    const detail = (typeof rawMessage === "string" ? rawMessage.trim() : "") || extractJsonErrorMessage(msg) || formatUnknownDetail(msg.error) || msg.text || "Cursor run entered ERROR status";
+    return [{ type: "stderr", data: detail }];
+  }
+  if (msg.type === "error") {
+    const detail = extractJsonErrorMessage(msg) || formatUnknownDetail(msg.error) || msg.text || "Cursor run error";
     return [{ type: "stderr", data: detail }];
   }
   return [];
@@ -171,12 +220,14 @@ async function main() {
       }
       const result = await run.wait();
       if (result.status === "error") {
+        const detail = formatUnknownDetail(result.error);
         emit({
           type: "stderr",
-          data: `Cursor run failed (${result.id})${result.error ? `: ${String(result.error)}` : ""}`
+          data: detail ? `Cursor run failed (${result.id}): ${detail}` : `Cursor run failed (${result.id})`
         });
         return 2;
       }
+      if (result.status === "cancelled") return 0;
       return 0;
     } finally {
       await agent[Symbol.asyncDispose]();

package/dist/agents/cursor-runner.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import {
-  cursorSdkMessageToEvents
-} from "../chunk-3DKGI32Q.js";
+  cursorSdkMessageToEvents,
+  formatUnknownDetail
+} from "../chunk-BSZX63TV.js";
 import {
   appDataDir
 } from "../chunk-M37RITA6.js";
@@ -83,12 +84,14 @@ async function main() {
       }
       const result = await run.wait();
       if (result.status === "error") {
+        const detail = formatUnknownDetail(result.error);
         emit({
           type: "stderr",
-          data: `Cursor run failed (${result.id})${result.error ? `: ${String(result.error)}` : ""}`
+          data: detail ? `Cursor run failed (${result.id}): ${detail}` : `Cursor run failed (${result.id})`
         });
         return 2;
       }
+      if (result.status === "cancelled") return 0;
       return 0;
     } finally {
       await agent[Symbol.asyncDispose]();

package/dist/{agents-HWIPJLC3.js → agents-2OX5XXYP.js}

@@ -21,12 +21,12 @@ import {
   opencodeAdapter,
   permissionMode,
   resolveCursorModelId
-} from "./chunk-4YLTMPEO.js";
+} from "./chunk-MULWZLDI.js";
 import "./chunk-ILQK4P5R.js";
 import {
   cursorSdkMessageToEvents,
   parseCursorRunnerLine
-} from "./chunk-3DKGI32Q.js";
+} from "./chunk-BSZX63TV.js";
 import "./chunk-3WF3X46L.js";
 import "./chunk-M37RITA6.js";
 import {

package/dist/{chunk-OY47OEY2.js → chunk-AL2GL5HJ.js}

@@ -25,7 +25,14 @@ import {
   allAdapters,
   getAdapter,
   parseBrightsyCliLine
-} from "./chunk-4YLTMPEO.js";
+} from "./chunk-MULWZLDI.js";
+import {
+  fallbackTurnFailDetail,
+  formatTurnExitError,
+  looksLikeAgentFailureMessage,
+  pushTurnStderr,
+  summarizeTurnStderr
+} from "./chunk-BSZX63TV.js";
 import {
   childEnvWithAppSettings,
   getLinearApiKey,
@@ -846,6 +853,49 @@ function pipeLines(stream, onLine) {
   const rl = createInterface2({ input: stream });
   rl.on("line", onLine);
 }
+function killScriptTree(child, ports = []) {
+  const pid = child.pid;
+  if (pid) {
+    try {
+      if (process.platform === "win32") {
+        void execa2("taskkill", ["/pid", String(pid), "/T", "/F"], { reject: false });
+      } else {
+        process.kill(-pid, "SIGTERM");
+        setTimeout(() => {
+          try {
+            process.kill(-pid, "SIGKILL");
+          } catch {
+          }
+        }, 2500).unref?.();
+      }
+    } catch {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+  for (const port of ports) {
+    if (!Number.isFinite(port) || port <= 0) continue;
+    if (process.platform === "win32") {
+      void execa2(
+        "powershell",
+        [
+          "-NoProfile",
+          "-Command",
+          `Get-NetTCPConnection -LocalPort ${port} -ErrorAction SilentlyContinue | ForEach-Object { Stop-Process -Id $_.OwningProcess -Force -ErrorAction SilentlyContinue }`
+        ],
+        { reject: false }
+      );
+    } else {
+      void execa2(
+        "zsh",
+        ["-lc", `pids=$(lsof -tiTCP:${port} -sTCP:LISTEN 2>/dev/null); [ -n "$pids" ] && kill -TERM $pids 2>/dev/null; true`],
+        { reject: false }
+      );
+    }
+  }
+}
 async function spawnWorkspaceScript(command, opts) {
   const loginEnv = await captureLoginEnv();
   const env = buildWorkspaceScriptEnv(
@@ -862,18 +912,17 @@ async function spawnWorkspaceScript(command, opts) {
   const child = execa2(shell, ["-lc", command], {
     cwd: opts.worktreePath,
     reject: false,
-    env
+    env,
+    // Own process group so Stop can tear down the whole tree (not just the shell).
+    // There is no settings.toml `stop=` / teardown hook for run scripts.
+    ...process.platform === "win32" ? {} : { detached: true }
   });
   pipeLines(child.stdout, opts.onLine);
   pipeLines(child.stderr, opts.onLine);
+  const ports = opts.ports ?? [];
   return {
     pid: child.pid,
-    kill: () => {
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
-    },
+    kill: () => killScriptTree(child, ports),
     done: child.then((r) => r.exitCode ?? null),
     child
   };
@@ -2557,7 +2606,7 @@ async function createThread(input, onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-HWIPJLC3.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-2OX5XXYP.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -3252,6 +3301,11 @@ var Orchestrator = class {
    * the killed turn's handle.done resolves.
    */
   stoppedTurns = /* @__PURE__ */ new Set();
+  /**
+   * Pause drainQueue after the in-flight turn unwinds (Stop with a preserved
+   * queue). Cleared when the user sends or promotes a queued message again.
+   */
+  haltDrain = /* @__PURE__ */ new Set();
   /** WIP snapshot SHA at the start of the latest agent turn (per thread). */
   turnBaselines = /* @__PURE__ */ new Map();
   maxConcurrent;
@@ -3319,7 +3373,7 @@ var Orchestrator = class {
     } catch {
     }
     for (const thread of listThreads()) {
-      if (thread.queue.length > 0) {
+      if (thread.queue.length > 0 && thread.status !== "stopped") {
         void this.drainQueue(thread.id);
       }
     }
@@ -3380,6 +3434,7 @@ var Orchestrator = class {
     return withThreadLock(thread.id, async () => {
       const current = this.requireThread(thread.id);
       const queue = [...current.queue, prompt];
+      this.haltDrain.delete(thread.id);
       updateThread(thread.id, { queue, status: "queued" });
       this.emit({ type: "queue_changed", threadId: thread.id, queue });
       this.emit({ type: "status_changed", threadId: thread.id, status: "queued" });
@@ -3394,11 +3449,75 @@ var Orchestrator = class {
     }
     return results;
   }
+  /** Edit the text of a not-yet-started queued message. */
+  async editQueuedMessage(threadRef, index, text) {
+    const thread = this.requireThread(threadRef);
+    return withThreadLock(thread.id, async () => {
+      const current = this.requireThread(thread.id);
+      const trimmed = text.trim();
+      if (!trimmed || index < 0 || index >= current.queue.length) {
+        return current;
+      }
+      const queue = current.queue.map((p, i) => i === index ? trimmed : p);
+      updateThread(thread.id, { queue });
+      this.emit({ type: "queue_changed", threadId: thread.id, queue });
+      return this.requireThread(thread.id);
+    });
+  }
+  /** Remove a not-yet-started queued message. */
+  async removeQueuedMessage(threadRef, index) {
+    const thread = this.requireThread(threadRef);
+    return withThreadLock(thread.id, async () => {
+      const current = this.requireThread(thread.id);
+      if (index < 0 || index >= current.queue.length) return current;
+      const queue = current.queue.filter((_, i) => i !== index);
+      const stillQueued = queue.length > 0;
+      const inFlight = this.activeTurns.has(thread.id) || this.startingTurns.has(thread.id);
+      updateThread(thread.id, {
+        queue,
+        status: !stillQueued && !inFlight && current.status === "queued" ? "idle" : current.status
+      });
+      this.emit({ type: "queue_changed", threadId: thread.id, queue });
+      const next = this.requireThread(thread.id);
+      this.emit({ type: "status_changed", threadId: thread.id, status: next.status });
+      return next;
+    });
+  }
+  /**
+   * Promote a queued message to run next, interrupting the in-flight turn (if any).
+   * The current turn is stopped without clearing the rest of the queue — drainQueue
+   * picks the promoted message up as soon as the interrupted turn unwinds.
+   */
+  async sendQueuedMessageNow(threadRef, index) {
+    const thread = this.requireThread(threadRef);
+    const promoted = await withThreadLock(thread.id, async () => {
+      const current = this.requireThread(thread.id);
+      if (index < 0 || index >= current.queue.length) return false;
+      const item = current.queue[index];
+      const rest = current.queue.filter((_, i) => i !== index);
+      const queue = [item, ...rest];
+      this.haltDrain.delete(thread.id);
+      updateThread(thread.id, { queue });
+      this.emit({ type: "queue_changed", threadId: thread.id, queue });
+      return true;
+    });
+    if (!promoted) return this.requireThread(thread.id);
+    const inFlight = this.activeTurns.has(thread.id) || this.startingTurns.has(thread.id);
+    if (inFlight) {
+      this.stop(thread.id, { clearQueue: false, continueQueue: true });
+    } else {
+      void this.drainQueue(thread.id);
+    }
+    return this.requireThread(thread.id);
+  }
   async drainQueue(threadId) {
     if (this.draining.has(threadId)) return;
     this.draining.add(threadId);
     try {
       while (true) {
+        if (this.haltDrain.has(threadId)) {
+          break;
+        }
         const thread = readThread(threadId);
         if (!thread || thread.queue.length === 0) {
           if (thread && thread.status === "queued") {
@@ -3411,7 +3530,7 @@ var Orchestrator = class {
           await new Promise((r) => setTimeout(r, 250));
           continue;
         }
-        if (this.activeTurns.has(threadId)) {
+        if (this.activeTurns.has(threadId) || this.startingTurns.has(threadId)) {
           await new Promise((r) => setTimeout(r, 100));
           continue;
         }
@@ -3546,7 +3665,7 @@ var Orchestrator = class {
       ...fresh.agent === "claude" && fresh.sessionId ? [] : [instructions, seed]
     ].filter(Boolean).join("\n\n---\n\n");
     try {
-      let lastStderr = "";
+      const stderrTail = [];
       const handle = await spawnAgentTurn(
         fresh,
         { cachedPrefix, prompt: agentPrompt },
@@ -3555,8 +3674,8 @@ var Orchestrator = class {
           if (event.type === "session_id") {
             updateThread(threadId, { sessionId: event.data });
           }
-          if (event.type === "stderr" && typeof event.data === "string" && event.data.trim()) {
-            lastStderr = event.data.trim();
+          if (event.type === "stderr" && typeof event.data === "string") {
+            pushTurnStderr(stderrTail, event.data);
           }
         }
       );
@@ -3581,10 +3700,12 @@ var Orchestrator = class {
       if (result.sessionId) {
         updateThread(threadId, { sessionId: result.sessionId });
       }
-      if (result.assistantText.trim() || result.parts.length > 0) {
+      const assistantText = result.assistantText.trim();
+      const failureOnlyMessage = result.exitCode !== 0 && looksLikeAgentFailureMessage(assistantText) && !result.parts.some((p) => p.type === "tool" || p.type === "thinking");
+      if (!failureOnlyMessage && (assistantText || result.parts.length > 0)) {
         appendMessage(threadId, {
           role: "agent",
-          text: result.assistantText.trim(),
+          text: assistantText,
           parts: result.parts.length > 0 ? result.parts : void 0,
           durationMs: Math.max(0, Date.now() - turnStartedAt),
           usage: result.usage ?? void 0,
@@ -3603,7 +3724,9 @@ var Orchestrator = class {
         this.emit({ type: "status_changed", threadId, status: "stopped" });
         this.emit({ type: "turn_finished", threadId, exitCode: result.exitCode });
       } else {
-        const failDetail = lastStderr ? `exit ${result.exitCode}: ${lastStderr.slice(0, 500)}` : `exit ${result.exitCode}`;
+        const lastStderr = summarizeTurnStderr(stderrTail);
+        const detail = lastStderr || (result.exitCode !== 0 ? fallbackTurnFailDetail(assistantText) : "");
+        const failDetail = formatTurnExitError(result.exitCode, detail);
         setStatus(
           threadId,
           result.exitCode === 0 ? "idle" : "error",
@@ -3639,20 +3762,30 @@ var Orchestrator = class {
   }
   /**
    * Stop an in-flight agent turn.
-   * Default `clearQueue: true` (force-stop): kills the turn AND empties queued prompts
-   * so drainQueue cannot continue / re-start work after an intentional stop. Desktop,
-   * CLI, MCP, and cloud-connect all share this default.
+   *
+   * - Default `clearQueue: true` (force-stop): empties queued prompts so nothing
+   *   resumes. Used by MCP force-stop, archive, and cloud-connect.
+   * - Desktop Stop uses `{ clearQueue: false }` so follow-ups stay editable.
+   * - `continueQueue: true` (Send now): keep the queue and let drainQueue resume
+   *   after the interrupted turn unwinds. Without it, drain pauses until send /
+   *   promote.
    */
   stop(threadRef, opts) {
     const clearQueue = opts?.clearQueue !== false;
+    const continueQueue = opts?.continueQueue === true;
     const thread = this.requireThread(threadRef);
     const inFlight = this.activeTurns.has(thread.id) || this.startingTurns.has(thread.id);
     if (inFlight) {
       this.stoppedTurns.add(thread.id);
     }
     if (clearQueue && thread.queue.length > 0) {
+      this.haltDrain.delete(thread.id);
       updateThread(thread.id, { queue: [] });
       this.emit({ type: "queue_changed", threadId: thread.id, queue: [] });
+    } else if (!clearQueue && !continueQueue) {
+      this.haltDrain.add(thread.id);
+    } else if (continueQueue) {
+      this.haltDrain.delete(thread.id);
     }
     const handle = this.activeTurns.get(thread.id);
     if (handle) handle.kill();
@@ -4247,9 +4380,11 @@ function getOrchestrator() {
 }
 async function startOrchestration(opts) {
   const repoPath = opts.repoPath?.trim();
+  const goal = opts.goal.trim();
+  const orch = getOrchestrator();
   if (!repoPath || isGlobalRepoPath(repoPath)) {
-    return createGlobalChat({
-      sourceRef: opts.goal,
+    const thread2 = createGlobalChat({
+      sourceRef: goal,
       agent: opts.agent,
       autonomy: opts.autonomy,
       model: opts.model,
@@ -4257,9 +4392,13 @@ async function startOrchestration(opts) {
       planMode: opts.planMode,
       attachments: opts.attachments
     });
+    if (goal) {
+      return orch.send(thread2.id, goal);
+    }
+    return thread2;
   }
   const { titleFromPrompt } = await import("./title-4A2ATYNY.js");
-  const title = titleFromPrompt(opts.goal) || "Orchestration";
+  const title = titleFromPrompt(goal) || "Orchestration";
   const createOpts = {
     agent: opts.agent,
     repoPath,
@@ -4286,10 +4425,14 @@ async function startOrchestration(opts) {
     });
   });
   const { updateThread: upd } = await import("./thread-store-UNPZNIFW.js");
-  return upd(thread.id, {
+  const updated = upd(thread.id, {
     sourceType: "orchestration",
-    sourceRef: opts.goal
+    sourceRef: goal
   });
+  if (goal) {
+    return orch.send(updated.id, goal);
+  }
+  return updated;
 }
 
 // src/mcp/server.ts
@@ -4379,11 +4522,15 @@ async function startMcpServer() {
   );
   server.tool(
     "present_artifact",
-    "Show an HTML, SVG, or markdown document in Sideboard\u2019s Claude-style side column (desktop). Use instead of claude.ai\u2019s artifact tool \u2014 pass the full document content. Prefer type=html for interactive pages.",
+    "Show an HTML, SVG, markdown, or React document in Sideboard\u2019s Claude-style side column (desktop). Use instead of claude.ai\u2019s artifact tool \u2014 pass the full document content. Prefer type=html for interactive pages. For type=react, pass a single component module that `export default`s a component (JSX/TSX ok) \u2014 Sideboard bootstraps React/ReactDOM/Babel and renders it; only `react`/`react-dom` imports are available, no other npm packages.",
     {
       title: z.string().describe("Short title shown in the artifact pane header"),
-      type: z.enum(["html", "svg", "markdown"]).describe("Artifact kind \u2014 html opens an iframe preview"),
-      content: z.string().describe("Full document body (complete HTML page, SVG markup, or markdown)"),
+      type: z.enum(["html", "svg", "markdown", "react"]).describe(
+        "Artifact kind \u2014 html opens an iframe preview; react transpiles and renders a default-exported component in a sandboxed iframe"
+      ),
+      content: z.string().describe(
+        "Full document body (complete HTML page, SVG markup, markdown, or a React component module with a default export)"
+      ),
       artifact_id: z.string().optional().describe("Stable id when updating the same artifact across turns")
     },
     async ({ title, type, content, artifact_id }) => {