relay-companion 0.1.30 → 0.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-companion",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "Relay companion: connects local coding agents to Relay tasks, approvals, and connector tools.",
   "type": "module",
   "bin": {

package/src/materializer.js

@@ -108,6 +108,7 @@ async function resolveRow(id, { log = () => {} } = {}) {
     // before staging; this is only a last-resort merge default.
     senderName: firstNonEmpty(rowState.senderName, content?.sender?.name, content?.sender?.handle) || "",
     attachments: rowState.attachments || content?.attachments || [],
+    attachmentUrls: rowState.attachmentUrls || content?.attachmentUrls || {},
     delivery: content?.delivery || rowState.delivery || null,
     sender: content?.sender || (rowState.senderName ? { name: rowState.senderName } : null),
   };
@@ -213,10 +214,14 @@ export async function openRelay({ id, host = "claude", log = () => {} } = {}) {
 async function materializeRowInHost({ id, row, rowState = {}, host = "claude", log = () => {} }) {
   const cleanHost = String(host || "claude").toLowerCase();
   const cwd = resolveCwd();
+  const rowWithAttachments = await materializeAttachmentFiles(row, { log });
+  const materializationSignature = rowMaterializationSignature(rowWithAttachments);
+  const materializationStale =
+    hasAttachments(rowWithAttachments) && rowState.attachmentMaterializationSignature !== materializationSignature;
   // The human reads `visible`; the agent-only `operatorNote` (real ids + the tool
   // call to make) rides a hidden channel per host (Claude: a system-meta transcript
   // row; Codex: developerInstructions) so it never enters the visible transcript.
-  const { visible: briefing, operatorNote } = renderRelayRowSeed(row);
+  const { visible: briefing, operatorNote } = renderRelayRowSeed(rowWithAttachments);
   let url = null;
   let openedInHost = false;
   let skipExternalOpen = false;
@@ -224,14 +229,20 @@ async function materializeRowInHost({ id, row, rowState = {}, host = "claude", l
   if (cleanHost === "codex") {
     let threadId = rowState.threadId || null;
     let sessionPath = rowState.sessionPath || null;
+    if (materializationStale) {
+      threadId = null;
+      sessionPath = null;
+    }
     if (!threadId || !codexRolloutExists(threadId)) {
-      const thread = await createCodexThread({ row, briefing, operatorNote, cwd });
+      const thread = await createCodexThread({ row: rowWithAttachments, briefing, operatorNote, cwd });
       threadId = thread.id;
       sessionPath = thread.path;
       rememberRow(id, {
         threadId,
         sessionPath,
-        title: row.displayTitle,
+        title: rowWithAttachments.displayTitle,
+        attachments: rowWithAttachments.attachments || [],
+        attachmentMaterializationSignature: materializationSignature,
         materializedSurfaces: {
           codex: true,
           claudeCode: Boolean(rowState.materializedSurfaces?.claudeCode || rowState.claudeNativeSession),
@@ -243,9 +254,9 @@ async function materializeRowInHost({ id, row, rowState = {}, host = "claude", l
     ensureRelayCodexIndexMarker({ threadId, sessionPath, packetId: id });
     finalizeCodexThreadState({
       threadId,
-      title: row.displayTitle,
+      title: rowWithAttachments.displayTitle,
       cwd,
-      preview: relayThreadPreview(row),
+      preview: relayThreadPreview(rowWithAttachments),
     });
     try {
       setThreadPinned(threadId, true);
@@ -275,26 +286,29 @@ async function materializeRowInHost({ id, row, rowState = {}, host = "claude", l
     url = `codex://threads/${encodeURIComponent(threadId)}`;
   } else {
     let claudeNativeSession = rowState.claudeNativeSession || null;
+    if (materializationStale) claudeNativeSession = null;
     if (!isClaudeNativeSessionImported(claudeNativeSession)) {
-      const claude = materializeRowForClaude(row, { cwd, forceClaudeCode: true });
+      const claude = materializeRowForClaude(rowWithAttachments, { cwd, forceClaudeCode: true });
       claudeNativeSession = claude.nativeSession || null;
       const previousSurfaces = rowState.materializedSurfaces || {};
       rememberRow(id, {
         claudeMarkdownPaths: claude.paths,
         claudeNativeSession,
+        attachments: rowWithAttachments.attachments || [],
+        attachmentMaterializationSignature: materializationSignature,
         materializedSurfaces: {
           codex: Boolean(previousSurfaces.codex || rowState.threadId),
           claudeCode: Boolean(previousSurfaces.claudeCode || claude.nativeSession || claude.surfaces?.claudeCode),
           claudeCowork: Boolean(previousSurfaces.claudeCowork || claude.surfaces?.claudeCowork),
         },
         materializedAt: new Date().toISOString(),
-        title: row.displayTitle,
+        title: rowWithAttachments.displayTitle,
       });
     } else {
       claudeNativeSession = ensureClaudeDesktopImported(claudeNativeSession, {
-        title: relayRowTitle(row),
+        title: relayRowTitle(rowWithAttachments),
         cwd,
-        createdAt: row.createdAt,
+        createdAt: rowWithAttachments.createdAt,
       });
       rememberRow(id, { claudeNativeSession });
     }
@@ -304,6 +318,91 @@ async function materializeRowInHost({ id, row, rowState = {}, host = "claude", l
   return { id, host: cleanHost, url, openedInHost, skipExternalOpen };
 }
 
+async function materializeAttachmentFiles(row, { log = () => {} } = {}) {
+  const attachments = Array.isArray(row?.attachments) ? row.attachments : [];
+  if (!attachments.length) return row;
+  const attachmentUrls = row?.attachmentUrls && typeof row.attachmentUrls === "object" ? row.attachmentUrls : {};
+  const dir = path.join(storeDir(), "attachments", safeFileStem(row?.id || row?.relayId || "relay"));
+  const materialized = [];
+  for (const [index, attachment] of attachments.entries()) {
+    if (!attachment || typeof attachment !== "object") continue;
+    const name = String(attachment.name || attachment.filename || `attachment-${index + 1}`).trim() || `attachment-${index + 1}`;
+    const url = String(attachmentUrls[attachment.id] || attachment.openUrl || "").trim();
+    const localPath = await ensureAttachmentLocalCopy({ attachment, url, dir, name, index, log });
+    materialized.push({
+      ...attachment,
+      name,
+      filename: name,
+      openUrl: url || attachment.openUrl,
+      ...(localPath ? { localPath } : {}),
+    });
+  }
+  return { ...row, attachments: materialized };
+}
+
+async function ensureAttachmentLocalCopy({ attachment, url, dir, name, index, log }) {
+  const existing = String(attachment.localPath || "").trim();
+  if (existing && fs.existsSync(existing) && sizeMatches(existing, attachment.bytes)) return existing;
+  if (!url) return existing || "";
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const filePath = path.join(dir, attachmentFileName(attachment, name, index));
+  if (fs.existsSync(filePath) && sizeMatches(filePath, attachment.bytes)) return filePath;
+  try {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const body = Buffer.from(await res.arrayBuffer());
+    const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, body, { mode: 0o600 });
+    fs.renameSync(tmp, filePath);
+    return filePath;
+  } catch (error) {
+    log(`relay attachment download failed for ${name}: ${error instanceof Error ? error.message : String(error)}`);
+    return existing || "";
+  }
+}
+
+function sizeMatches(filePath, expectedBytes) {
+  if (!Number.isFinite(Number(expectedBytes))) return true;
+  try {
+    return fs.statSync(filePath).size === Number(expectedBytes);
+  } catch {
+    return false;
+  }
+}
+
+function attachmentFileName(attachment, name, index) {
+  const prefix = safeFileStem(attachment.id || `attachment-${index + 1}`);
+  const clean = safeFilename(name);
+  return `${prefix}-${clean}`;
+}
+
+function safeFilename(value) {
+  return String(value || "attachment")
+    .replace(/[/\\?%*:|"<>]+/g, "-")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 160) || "attachment";
+}
+
+function rowMaterializationSignature(row) {
+  const attachments = Array.isArray(row?.attachments) ? row.attachments : [];
+  return JSON.stringify({
+    renderer: "relay-attachments-table-v2",
+    body: String(row?.bodyMarkdown || row?.briefingMarkdown || ""),
+    attachments: attachments.map((attachment) => ({
+      id: attachment.id || "",
+      name: attachment.name || attachment.filename || "",
+      bytes: attachment.bytes || 0,
+      sha256: attachment.sha256 || "",
+      localPath: attachment.localPath || "",
+    })),
+  });
+}
+
+function hasAttachments(row) {
+  return Array.isArray(row?.attachments) && row.attachments.length > 0;
+}
+
 // `relay open --task <taskId> --host <host>` — materialize a Relay task into a
 // visible native agent session (exactly like a staged relay row). The task object
 // (GET /v1/tasks/:id, unwrapped) carries title/objective/state but NO messages or
@@ -434,6 +533,10 @@ function firstNonEmpty(...values) {
   return "";
 }
 
+function safeFileStem(value) {
+  return String(value || new Date().toISOString()).replace(/[^0-9A-Za-z._-]+/g, "-").replace(/^-|-$/g, "");
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/relay-briefing.js

@@ -66,6 +66,7 @@ export function renderRelayRowSeed(row) {
     seed = renderMessageSeed(row, task);
   }
   let visible = String(seed?.visible || "").trim();
+  visible = insertAttachmentSection(visible, row);
   const operatorNote = String(seed?.operatorNote || "").trim();
   if (!visible) visible = renderMinimalSeed(row);
   return { visible, operatorNote };
@@ -243,6 +244,54 @@ function renderMinimalSeed(row) {
   return joinSections([`# ${title}`, "No content was available to seed this session."]);
 }
 
+function insertAttachmentSection(visible, row) {
+  const attachments = Array.isArray(row?.attachments) ? row.attachments : [];
+  const rendered = attachments.map(renderAttachmentTableRow).filter(Boolean);
+  if (!rendered.length) return visible;
+  const section = ["## Attachments", "", "| File | Size |", "| --- | ---: |", ...rendered].join("\n");
+  const cleanVisible = String(visible || "").trim();
+  const lines = cleanVisible.split("\n");
+  if (/^#\s+/.test(lines[0] || "")) {
+    const title = lines.shift();
+    return joinSections([title, section, lines.join("\n")]);
+  }
+  return joinSections([section, cleanVisible]);
+}
+
+function renderAttachmentTableRow(attachment) {
+  if (!attachment || typeof attachment !== "object") return "";
+  const name = String(attachment.name || attachment.filename || "attachment").trim() || "attachment";
+  const size = humanBytes(attachment.bytes);
+  const localPath = String(attachment.localPath || "").trim();
+  const openUrl = String(attachment.openUrl || "").trim();
+  const href = localPath || openUrl;
+  const label = escapeTableCell(name);
+  const file = href
+    ? `[${escapeMarkdownLinkText(label)}](<${escapeMarkdownHref(href)}>)`
+    : label;
+  return `| ${file} | ${escapeTableCell(size || "-")} |`;
+}
+
+function humanBytes(bytes) {
+  const n = Number(bytes);
+  if (!Number.isFinite(n) || n <= 0) return "";
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(n < 10 * 1024 ? 1 : 0)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(n < 10 * 1024 * 1024 ? 1 : 0)} MB`;
+}
+
+function escapeMarkdownLinkText(value) {
+  return String(value).replace(/[[\]\\]/g, "\\$&");
+}
+
+function escapeMarkdownHref(value) {
+  return String(value).replace(/[<>]/g, encodeURIComponent);
+}
+
+function escapeTableCell(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\n+/g, " ").trim();
+}
+
 function relayKind(row) {
   return String(row?.relayNotificationKind || row?.kind || "").trim().toLowerCase();
 }