@sideboard-ai/core 0.1.23 → 0.1.30

package/dist/{chunk-JNMLRJ3D.js → chunk-RPSHBKLW.js}

@@ -1776,6 +1776,9 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
     parts.push("");
     parts.push(`## Attachment: ${att.name}`);
     parts.push(`Kind: ${att.kind}`);
+    if (att.path) {
+      parts.push(`Path in worktree: \`${att.path}\``);
+    }
     parts.push("");
     parts.push(att.content);
   }
@@ -1818,6 +1821,234 @@ function expandComposerPrompt(worktreePath, prompt, opts) {
   };
 }
 
+// src/composer/stage-files.ts
+import { copyFileSync as copyFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename2, extname, join as join6 } from "path";
+import { randomUUID } from "crypto";
+var IMAGE_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "svg",
+  "bmp",
+  "ico"
+]);
+var IMAGE_MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  bmp: "image/bmp",
+  ico: "image/x-icon"
+};
+var ATTACHMENTS_DIR = ".sideboard/attachments";
+var ATTACHMENTS_GITIGNORE = `# Sideboard review / composer attachments (local only)
+*
+!.gitignore
+`;
+var MAX_INLINE_BYTES = 4e5;
+var MAX_PREVIEW_BYTES = 5e6;
+function fileExtension(filePath) {
+  const base = basename2(filePath).toLowerCase();
+  return base.includes(".") ? base.split(".").pop() || "" : "";
+}
+function isImageFilePath(filePath) {
+  return IMAGE_EXTENSIONS2.has(fileExtension(filePath));
+}
+function imageMimeType(filePath) {
+  return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
+}
+function ensureAttachmentsDir(worktreePath) {
+  const dir = join6(worktreePath, ATTACHMENTS_DIR);
+  mkdirSync3(dir, { recursive: true });
+  const gi = join6(dir, ".gitignore");
+  if (!existsSync6(gi)) {
+    writeFileSync2(gi, ATTACHMENTS_GITIGNORE, "utf8");
+  }
+  return dir;
+}
+function uniqueAttachmentName(dir, originalName) {
+  const safe = originalName.replace(/[/\\]/g, "_") || "file";
+  if (!existsSync6(join6(dir, safe))) return safe;
+  const ext = extname(safe);
+  const stem = ext ? safe.slice(0, -ext.length) : safe;
+  for (let i = 1; i < 1e4; i++) {
+    const candidate = `${stem}-${i}${ext}`;
+    if (!existsSync6(join6(dir, candidate))) return candidate;
+  }
+  return `${stem}-${randomUUID()}${ext}`;
+}
+function previewDataUrlFromBuf(filePath, buf) {
+  if (!isImageFilePath(filePath)) return void 0;
+  if (buf.length > MAX_PREVIEW_BYTES) return void 0;
+  return `data:${imageMimeType(filePath)};base64,${buf.toString("base64")}`;
+}
+function attachmentFromBuffer(name, buf, opts) {
+  const previewDataUrl = previewDataUrlFromBuf(name, buf);
+  if (isImageFilePath(name)) {
+    const pathHint = opts.path ? `\`${opts.path}\`` : opts.sourceLabel || name;
+    return {
+      id: randomUUID(),
+      name,
+      kind: "file",
+      path: opts.path,
+      previewDataUrl,
+      content: [
+        `Image attached: ${pathHint}`,
+        opts.path ? `Use the Read tool on \`${opts.path}\` to view this image.` : "The image is shown in the composer; copy it into the worktree if you need to inspect pixels."
+      ].join("\n")
+    };
+  }
+  if (buf.length > MAX_INLINE_BYTES) {
+    return {
+      id: randomUUID(),
+      name,
+      kind: "file",
+      path: opts.path,
+      content: opts.path ? `(file too large to attach inline: \`${opts.path}\`, ${buf.length} bytes \u2014 use the Read tool)` : `(file too large to attach inline: ${opts.sourceLabel || name}, ${buf.length} bytes)`
+    };
+  }
+  if (buf.includes(0)) {
+    return {
+      id: randomUUID(),
+      name,
+      kind: "file",
+      path: opts.path,
+      content: opts.path ? `(binary file at \`${opts.path}\` \u2014 use tools to inspect)` : `(binary file attached by path only: ${opts.sourceLabel || name})`
+    };
+  }
+  return {
+    id: randomUUID(),
+    name,
+    kind: "file",
+    path: opts.path,
+    content: buf.toString("utf8")
+  };
+}
+function attachmentFromAbsolutePath(absolutePath) {
+  const name = basename2(absolutePath);
+  try {
+    const st = statSync4(absolutePath);
+    if (!st.isFile()) {
+      return {
+        id: randomUUID(),
+        name,
+        kind: "file",
+        content: `(not a file: ${absolutePath})`
+      };
+    }
+    const buf = readFileSync6(absolutePath);
+    return attachmentFromBuffer(name, buf, { sourceLabel: absolutePath });
+  } catch (err) {
+    return {
+      id: randomUUID(),
+      name,
+      kind: "file",
+      content: `(could not read ${absolutePath}: ${err instanceof Error ? err.message : String(err)})`
+    };
+  }
+}
+function stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
+  if (absolutePaths.length === 0) return [];
+  const dir = ensureAttachmentsDir(worktreePath);
+  const out = [];
+  for (const abs of absolutePaths) {
+    const originalName = basename2(abs);
+    try {
+      const st = statSync4(abs);
+      if (!st.isFile()) continue;
+      const name = uniqueAttachmentName(dir, originalName);
+      const destAbs = join6(dir, name);
+      copyFileSync2(abs, destAbs);
+      const rel = `${ATTACHMENTS_DIR}/${name}`;
+      const buf = readFileSync6(destAbs);
+      out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
+    } catch (err) {
+      out.push({
+        id: randomUUID(),
+        name: originalName,
+        kind: "file",
+        content: `(could not attach ${abs}: ${err instanceof Error ? err.message : String(err)})`
+      });
+    }
+  }
+  return out;
+}
+function stageBuffersAsAttachments(worktreePath, buffers) {
+  if (buffers.length === 0) return [];
+  const dir = ensureAttachmentsDir(worktreePath);
+  const out = [];
+  for (const item of buffers) {
+    const originalName = (item.name || "file").replace(/[/\\]/g, "_") || "file";
+    try {
+      const buf = Buffer.from(item.dataBase64, "base64");
+      const name = uniqueAttachmentName(dir, originalName);
+      const destAbs = join6(dir, name);
+      writeFileSync2(destAbs, buf);
+      const rel = `${ATTACHMENTS_DIR}/${name}`;
+      out.push(attachmentFromBuffer(name, buf, { path: rel }));
+    } catch (err) {
+      out.push({
+        id: randomUUID(),
+        name: originalName,
+        kind: "file",
+        content: `(could not attach ${originalName}: ${err instanceof Error ? err.message : String(err)})`
+      });
+    }
+  }
+  return out;
+}
+function attachmentsFromBuffers(buffers) {
+  return buffers.map((item) => {
+    const name = (item.name || "file").replace(/[/\\]/g, "_") || "file";
+    try {
+      const buf = Buffer.from(item.dataBase64, "base64");
+      return attachmentFromBuffer(name, buf, { sourceLabel: name });
+    } catch (err) {
+      return {
+        id: randomUUID(),
+        name,
+        kind: "file",
+        content: `(could not attach ${name}: ${err instanceof Error ? err.message : String(err)})`
+      };
+    }
+  });
+}
+function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
+  const out = [];
+  for (const rel of relativePaths) {
+    if (!rel || rel.includes("..") || rel.startsWith("/")) {
+      out.push({
+        id: randomUUID(),
+        name: basename2(rel) || "file",
+        kind: "file",
+        content: `(invalid path: ${rel})`
+      });
+      continue;
+    }
+    const name = basename2(rel);
+    try {
+      const abs = join6(worktreePath, rel);
+      const st = statSync4(abs);
+      if (!st.isFile()) continue;
+      const buf = readFileSync6(abs);
+      out.push(attachmentFromBuffer(name, buf, { path: rel, sourceLabel: abs }));
+    } catch (err) {
+      out.push({
+        id: randomUUID(),
+        name,
+        kind: "file",
+        content: `(could not read ${rel}: ${err instanceof Error ? err.message : String(err)})`
+      });
+    }
+  }
+  return out;
+}
+
 // src/composer/summarize.ts
 var MAX_TRANSCRIPT_CHARS = 12e4;
 var MAX_SUMMARY_CHARS = 6e3;
@@ -2249,11 +2480,11 @@ async function confirmLand(thread, opts) {
 }
 
 // src/threads/create.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 async function createThread(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!existsSync6(repoPath)) {
+  if (!existsSync7(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   let sourceRef = input.sourceRef;
@@ -2336,7 +2567,7 @@ async function listLinearIssues(agent, repoPath) {
 }
 
 // src/threads/chat-tabs.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function sameWorktreePath(a, b) {
   return normalizeWorktreePath(a) === normalizeWorktreePath(b);
 }
@@ -2387,7 +2618,7 @@ function forkMessageSlice(from, throughIndex) {
 function buildForkTranscriptAttachment(baseTitle, messages) {
   const title = baseTitle || "Chat";
   return {
-    id: randomUUID(),
+    id: randomUUID2(),
     name: `Transcript of ${title}.md`,
     kind: "transcript",
     content: formatTranscriptMarkdown(title, messages)
@@ -2445,35 +2676,39 @@ async function forkThreadWorktree(input, onSetupLine) {
       repoPath: from.repoPath,
       agent: input.agent ?? from.agent,
       autonomy: from.autonomy,
+      model: from.model,
+      fast: from.fast,
+      planMode: from.planMode,
       title: input.title?.trim() || void 0,
-      parentThreadId: from.id
+      parentThreadId: from.id,
+      attachments: [attachment]
     },
     onSetupLine
   );
-  return updateThread(thread.id, { attachments: [attachment] });
+  return thread;
 }
 
 // src/threads/adopt.ts
 import { execFileSync } from "child_process";
 import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync7,
+  copyFileSync as copyFileSync3,
+  existsSync as existsSync8,
   mkdtempSync,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   rmSync
 } from "fs";
 import { tmpdir } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import Database from "better-sqlite3";
-var CONDUCTOR_APP_SUPPORT = join6(
+var CONDUCTOR_APP_SUPPORT = join7(
   process.env.HOME ?? "",
   "Library",
   "Application Support",
   "com.conductor.app"
 );
-var CONDUCTOR_DB = join6(CONDUCTOR_APP_SUPPORT, "conductor.db");
-var CURSOR_SDK_STORE = join6(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+var CONDUCTOR_DB = join7(CONDUCTOR_APP_SUPPORT, "conductor.db");
+var CURSOR_SDK_STORE = join7(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
 function mapAgentType(raw) {
   if (!raw) return null;
   const v = raw.toLowerCase();
@@ -2485,7 +2720,7 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !existsSync7(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !existsSync8(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
@@ -2495,11 +2730,11 @@ function resolveConductorCursorAgentId(workspacePath) {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = join6(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!existsSync7(agentsFile)) continue;
+    const agentsFile = join7(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!existsSync8(agentsFile)) continue;
     let text;
     try {
-      text = readFileSync6(agentsFile, "utf8");
+      text = readFileSync7(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -2523,7 +2758,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!existsSync7(input.worktreePath)) {
+  if (!existsSync8(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -2550,18 +2785,18 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!existsSync7(CONDUCTOR_DB)) {
+  if (!existsSync8(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join6(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join6(tmp, "conductor.db");
+  const tmp = mkdtempSync(join7(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join7(tmp, "conductor.db");
   try {
-    copyFileSync2(CONDUCTOR_DB, snapshot);
+    copyFileSync3(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync7(src)) {
+      if (existsSync8(src)) {
         try {
-          copyFileSync2(src, `${snapshot}${suffix}`);
+          copyFileSync3(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -2641,18 +2876,18 @@ function listConductorWorkspaces() {
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!existsSync7(CONDUCTOR_DB)) {
+  if (!existsSync8(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = mkdtempSync(join6(tmpdir(), "sideboard-conductor-"));
-  const snapshot = join6(tmp, "conductor.db");
+  const tmp = mkdtempSync(join7(tmpdir(), "sideboard-conductor-"));
+  const snapshot = join7(tmp, "conductor.db");
   try {
-    copyFileSync2(CONDUCTOR_DB, snapshot);
+    copyFileSync3(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if (existsSync7(src)) {
+      if (existsSync8(src)) {
         try {
-          copyFileSync2(src, `${snapshot}${suffix}`);
+          copyFileSync3(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -2670,7 +2905,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!existsSync7(worktreePath)) {
+      if (!existsSync8(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -2741,8 +2976,8 @@ async function importConductorWorkspaceAsync(workspaceId) {
 }
 
 // src/git/orphan-cleanup.ts
-import { existsSync as existsSync8, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
+import { join as join8 } from "path";
 function isSideboardWorktreePath(path) {
   return path.includes("/.sideboard/worktrees/") || path.includes("/sideboard/workspaces/");
 }
@@ -2753,7 +2988,7 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if (existsSync8(homeRoot)) {
+  if (existsSync9(homeRoot)) {
     try {
       for (const entry of readdirSync4(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
@@ -2765,7 +3000,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !existsSync8(repoPath)) continue;
+    if (!repoPath || !existsSync9(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -2776,7 +3011,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path);
         let mtimeMs = 0;
         try {
-          mtimeMs = statSync4(path).mtimeMs;
+          mtimeMs = statSync5(path).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -2786,16 +3021,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if (existsSync8(root)) {
+      if (existsSync9(root)) {
         for (const entry of readdirSync4(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path = join7(root, entry.name).replace(/\/$/, "");
+          const path = join8(root, entry.name).replace(/\/$/, "");
           if (known.has(path) || seen.has(path)) continue;
-          if (!existsSync8(join7(path, ".git"))) continue;
+          if (!existsSync9(join8(path, ".git"))) continue;
           seen.add(path);
           let mtimeMs = 0;
           try {
-            mtimeMs = statSync4(path).mtimeMs;
+            mtimeMs = statSync5(path).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -2940,20 +3175,20 @@ async function applyThreadIntoMain(thread, opts) {
 }
 
 // src/git/clone-repo.ts
-import { existsSync as existsSync9 } from "fs";
-import { basename as basename2, join as join8 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { basename as basename3, join as join9 } from "path";
 import { execa as execa5 } from "execa";
 async function cloneRepoIntoSideboard(opts) {
   const url = opts.url.trim();
   if (!url) throw new Error("Clone URL is required");
   let name = opts.name?.trim();
   if (!name) {
-    const leaf = basename2(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = basename3(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = join8(sideboardReposDir(), name);
-  if (existsSync9(dest)) {
+  const dest = join9(sideboardReposDir(), name);
+  if (existsSync10(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -2971,7 +3206,7 @@ async function cloneRepoIntoSideboard(opts) {
 
 // src/orchestrator/orchestrator.ts
 import { EventEmitter } from "events";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 
 // src/threads/sync-branch.ts
 async function syncThreadBranchFromGit(threadId) {
@@ -3058,7 +3293,7 @@ var Orchestrator = class {
         }
         continue;
       }
-      if (!existsSync10(thread.worktreePath)) {
+      if (!existsSync11(thread.worktreePath)) {
         setStatus(thread.id, "broken", "Worktree missing on disk");
         this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
         continue;
@@ -3870,6 +4105,23 @@ var Orchestrator = class {
   setAttachments(threadRef, attachments) {
     return updateThread(this.requireThread(threadRef).id, { attachments });
   }
+  /**
+   * Stage OS / worktree files into composer attachments (copies external files
+   * into `.sideboard/attachments/` so agents can Read images and binaries).
+   */
+  attachComposerFiles(threadRef, opts) {
+    const thread = this.requireThread(threadRef);
+    const fromAbs = stageAbsolutePathsAsAttachments(
+      thread.worktreePath,
+      opts.absolutePaths ?? []
+    );
+    const fromRel = attachmentsFromWorktreePaths(
+      thread.worktreePath,
+      opts.relativePaths ?? []
+    );
+    const fromBuf = stageBuffersAsAttachments(thread.worktreePath, opts.buffers ?? []);
+    return [...fromAbs, ...fromRel, ...fromBuf];
+  }
   listWorktreeChats(threadRef) {
     const thread = this.requireThread(threadRef);
     return threadsSharingWorktree(thread.worktreePath);
@@ -3929,7 +4181,7 @@ var Orchestrator = class {
       updateThread(thread.id, { worktreePath: globalAgentCwd() });
       return setStatus(thread.id, "idle");
     }
-    if (!existsSync10(thread.worktreePath)) {
+    if (!existsSync11(thread.worktreePath)) {
       const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-RYTBDHHP.js");
       const { execa: execa6 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
@@ -4028,7 +4280,7 @@ async function startOrchestration(opts) {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { basename as basename3 } from "path";
+import { basename as basename4 } from "path";
 
 // src/mcp/archive-guard.ts
 function mcpArchiveBlockedReason(thread) {
@@ -4073,7 +4325,7 @@ async function startMcpServer() {
     async () => {
       const threads = orch.getThreads(true);
       const lines = threads.map((t) => {
-        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : basename3(t.repoPath) || t.repoPath;
+        const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : basename4(t.repoPath) || t.repoPath;
         return `${t.id.slice(0, 8)}  ${t.status.padEnd(9)}  ${t.agent.padEnd(8)}  ${repo}  ${t.sourceType}:${t.sourceRef}  ${t.title}  sideboard://thread/${t.id}${t.devPort ? `  http://localhost:${t.devPort}` : ""}`;
       });
       return {
@@ -4647,6 +4899,12 @@ export {
   discoverSkills,
   readSkillBody,
   expandComposerPrompt,
+  isImageFilePath,
+  attachmentFromAbsolutePath,
+  stageAbsolutePathsAsAttachments,
+  stageBuffersAsAttachments,
+  attachmentsFromBuffers,
+  attachmentsFromWorktreePaths,
   summarizeConversation,
   extractiveSummary,
   CONTEXT_COMPACT_CHARS,