@sideboard-ai/core 0.1.135 → 0.1.136

package/dist/{chunk-2ESCEK2Q.js → chunk-K5YT5GX2.js}

@@ -2,12 +2,16 @@
 
 import {
   ensureGlobalCoordinatorCwd
-} from "./chunk-K7EX47QG.js";
+} from "./chunk-TQ4S5AGJ.js";
 import {
   allocateTeamName,
   takenSlugsFromThread,
   teamSlugFromName
 } from "./chunk-QAV3HGVS.js";
+import {
+  ATTACHMENTS_DIR,
+  attachmentsGitignoreBody
+} from "./chunk-B3SJXYIJ.js";
 import {
   createEmptyThread,
   listThreads,
@@ -44,6 +48,233 @@ var CLOUD_COORDINATOR_TIMEOUT_REPLY = [
   "What do you want me to do? (retry later, wait, force-stop, rephrase, or cancel)"
 ].join(" ");
 
+// src/composer/stage-files.ts
+import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { basename, extname, join } from "path";
+import { randomUUID } from "crypto";
+var IMAGE_EXTENSIONS = /* @__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 MAX_INLINE_BYTES = 4e5;
+var MAX_PREVIEW_BYTES = 5e6;
+function fileExtension(filePath) {
+  const base = basename(filePath).toLowerCase();
+  return base.includes(".") ? base.split(".").pop() || "" : "";
+}
+function isImageFilePath(filePath) {
+  return IMAGE_EXTENSIONS.has(fileExtension(filePath));
+}
+function imageMimeType(filePath) {
+  return IMAGE_MIME_BY_EXT[fileExtension(filePath)] || "image/png";
+}
+function ensureAttachmentsDir(worktreePath) {
+  const dir = join(worktreePath, ATTACHMENTS_DIR);
+  mkdirSync(dir, { recursive: true });
+  const gi = join(dir, ".gitignore");
+  if (!existsSync(gi)) {
+    writeFileSync(gi, attachmentsGitignoreBody(), "utf8");
+  }
+  return dir;
+}
+function uniqueAttachmentName(dir, originalName) {
+  const safe = originalName.replace(/[/\\]/g, "_") || "file";
+  if (!existsSync(join(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 (!existsSync(join(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 stageAbsolutePathsAsAttachments(worktreePath, absolutePaths) {
+  if (absolutePaths.length === 0) return [];
+  const dir = ensureAttachmentsDir(worktreePath);
+  const out = [];
+  for (const abs of absolutePaths) {
+    const originalName = basename(abs);
+    try {
+      const st = statSync(abs);
+      if (!st.isFile()) continue;
+      const name = uniqueAttachmentName(dir, originalName);
+      const destAbs = join(dir, name);
+      copyFileSync(abs, destAbs);
+      const rel = `${ATTACHMENTS_DIR}/${name}`;
+      const buf = readFileSync(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 = join(dir, name);
+      writeFileSync(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 isWorktreeRelativePath(p) {
+  if (!p || p.includes("..")) return false;
+  if (p.startsWith("/")) return false;
+  if (/^[A-Za-z]:[\\/]/.test(p)) return false;
+  return true;
+}
+function dataUrlToBase64(url) {
+  if (!url) return null;
+  const m = /^data:[^;]+;base64,(.+)$/s.exec(url);
+  return m?.[1] ?? null;
+}
+var IMAGE_HINT_RE = /^Image attached:/;
+var PLACEHOLDER_CONTENT_RE = /^\((could not |file too large|binary file|not a file|invalid path)/;
+function persistPendingFileAttachments(worktreePath, attachments) {
+  if (attachments.length === 0) return attachments;
+  const keep = [];
+  const buffers = [];
+  for (const att of attachments) {
+    if (att.kind !== "file") {
+      keep.push(att);
+      continue;
+    }
+    if (att.path && isWorktreeRelativePath(att.path)) {
+      keep.push(att);
+      continue;
+    }
+    const fromPreview = dataUrlToBase64(att.previewDataUrl);
+    if (fromPreview) {
+      buffers.push({ name: att.name, dataBase64: fromPreview });
+      continue;
+    }
+    if (att.content && !IMAGE_HINT_RE.test(att.content) && !PLACEHOLDER_CONTENT_RE.test(att.content)) {
+      buffers.push({
+        name: att.name,
+        dataBase64: Buffer.from(att.content, "utf8").toString("base64")
+      });
+      continue;
+    }
+    keep.push(att);
+  }
+  if (buffers.length === 0) return attachments;
+  return [...keep, ...stageBuffersAsAttachments(worktreePath, buffers)];
+}
+function attachmentsFromWorktreePaths(worktreePath, relativePaths) {
+  const out = [];
+  for (const rel of relativePaths) {
+    if (!rel || rel.includes("..") || rel.startsWith("/")) {
+      out.push({
+        id: randomUUID(),
+        name: basename(rel) || "file",
+        kind: "file",
+        content: `(invalid path: ${rel})`
+      });
+      continue;
+    }
+    const name = basename(rel);
+    try {
+      const abs = join(worktreePath, rel);
+      const st = statSync(abs);
+      if (!st.isFile()) continue;
+      const buf = readFileSync(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/agents/orchestrator-capable.ts
 var ORCHESTRATOR_AGENT_KINDS = [
   "claude",
@@ -139,6 +370,7 @@ function createGlobalChat(opts) {
     fast: opts.fast
   });
   const agent = assertOrchestratorCapableAgent(resolved.agent);
+  const worktreePath = globalAgentCwd();
   const thread = createEmptyThread({
     title,
     // Stick nicknames the same way chat tabs do (avoid later sync overwrites).
@@ -146,7 +378,7 @@ function createGlobalChat(opts) {
     sourceType: "orchestration",
     sourceRef,
     branchName: "global",
-    worktreePath: globalAgentCwd(),
+    worktreePath,
     repoPath: GLOBAL_WORKSPACE_ID,
     agent,
     autonomy: opts.autonomy ?? "default",
@@ -154,7 +386,10 @@ function createGlobalChat(opts) {
     effort: resolved.effort,
     fast: resolved.fast,
     planMode: Boolean(opts.planMode),
-    attachments: opts.attachments ?? [],
+    attachments: persistPendingFileAttachments(
+      worktreePath,
+      opts.attachments ?? []
+    ),
     parentThreadId: opts.parentThreadId ?? null,
     status: "idle"
   });
@@ -276,6 +511,10 @@ function ensureCloudCoordinator(agent) {
 }
 
 export {
+  stageAbsolutePathsAsAttachments,
+  stageBuffersAsAttachments,
+  persistPendingFileAttachments,
+  attachmentsFromWorktreePaths,
   ORCHESTRATOR_AGENT_KINDS,
   isOrchestratorCapableAgent,
   assertOrchestratorCapableAgent,

package/dist/{chunk-LOKXPQ4U.js → chunk-MDCKV2NF.js}

@@ -1,6 +1,6 @@
 import {
   isGlobalRepoPath
-} from "./chunk-XUEI4GCF.js";
+} from "./chunk-GSKRGF7B.js";
 import {
   ensureGhPreferOrigin,
   resolveRepoRoot