@vellumai/credential-executor 0.10.7-dev.202607091111.4355283 → 0.10.7-dev.202607091507.bac9bfe

package/node_modules/@vellumai/service-contracts/package.json

@@ -16,6 +16,7 @@
     "./grants": "./src/grants.ts",
     "./rpc": "./src/rpc.ts",
     "./rendering": "./src/rendering.ts",
+    "./attachment-naming": "./src/attachment-naming.ts",
     "./error": "./src/error.ts"
   },
   "scripts": {

package/node_modules/@vellumai/service-contracts/src/__tests__/attachment-naming.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  inferMimeType,
+  resolveAttachmentFilename,
+} from "../attachment-naming.js";
+
+describe("inferMimeType", () => {
+  test("maps known extensions case-insensitively", () => {
+    expect(inferMimeType("shot.PNG")).toBe("image/png");
+    expect(inferMimeType("report.pdf")).toBe("application/pdf");
+  });
+
+  test("falls back to octet-stream for unknown or missing extensions", () => {
+    expect(inferMimeType("desktop")).toBe("application/octet-stream");
+    expect(inferMimeType("archive.xyz")).toBe("application/octet-stream");
+  });
+});
+
+describe("resolveAttachmentFilename", () => {
+  test("uses explicit filenames verbatim", () => {
+    expect(
+      resolveAttachmentFilename("custom.dat", "/tmp/shot.png", "explicit"),
+    ).toBe("custom.dat");
+  });
+
+  test("honors labels with recognized extensions", () => {
+    expect(
+      resolveAttachmentFilename("nice-name.png", "/tmp/shot.png", "label"),
+    ).toBe("nice-name.png");
+  });
+
+  test("keeps bare labels and appends the POSIX path extension", () => {
+    expect(resolveAttachmentFilename("desktop", "/tmp/shot.png", "label")).toBe(
+      "desktop.png",
+    );
+  });
+
+  test("keeps bare labels and appends the Windows path extension", () => {
+    expect(
+      resolveAttachmentFilename(
+        "desktop",
+        "C:\\Users\\user1\\Pictures\\shot.png",
+        "label",
+      ),
+    ).toBe("desktop.png");
+  });
+
+  test("bare labels to files sharing a basename resolve to unique names", () => {
+    expect(
+      resolveAttachmentFilename("first", "/workspace/a/result.png", "label"),
+    ).toBe("first.png");
+    expect(
+      resolveAttachmentFilename("second", "/workspace/b/result.png", "label"),
+    ).toBe("second.png");
+  });
+
+  test("does not duplicate an unknown extension the label already has", () => {
+    expect(
+      resolveAttachmentFilename(
+        "report.xlsx",
+        "/workspace/report.xlsx",
+        "label",
+      ),
+    ).toBe("report.xlsx");
+  });
+
+  test("matches the existing extension case-insensitively", () => {
+    expect(
+      resolveAttachmentFilename("data.YAML", "/workspace/data.yaml", "label"),
+    ).toBe("data.YAML");
+  });
+
+  test("still appends when the label ends differently", () => {
+    expect(
+      resolveAttachmentFilename(
+        "summary.v2",
+        "/workspace/data.parquet",
+        "label",
+      ),
+    ).toBe("summary.v2.parquet");
+  });
+
+  test("falls back to the basename when the path has no extension", () => {
+    expect(resolveAttachmentFilename("label", "/tmp/rawfile", "label")).toBe(
+      "rawfile",
+    );
+  });
+
+  test("uses the basename when no preferred name is given", () => {
+    expect(
+      resolveAttachmentFilename(undefined, "C:\\temp\\report.pdf", "label"),
+    ).toBe("report.pdf");
+    expect(resolveAttachmentFilename(undefined, "/tmp/report.pdf")).toBe(
+      "report.pdf",
+    );
+  });
+
+  test("ignores trailing separators", () => {
+    expect(resolveAttachmentFilename(undefined, "/tmp/dir/", "label")).toBe(
+      "dir",
+    );
+  });
+});

package/node_modules/@vellumai/service-contracts/src/attachment-naming.ts

@@ -0,0 +1,118 @@
+/**
+ * Attachment filename contract shared by the daemon (which materializes
+ * `vellum://` links and `<vellum-attachment>` directives into stored
+ * attachments) and the web client (which resolves clicked links back to
+ * those attachments). Both sides must agree on the stored filename, so the
+ * naming rule lives here once.
+ */
+
+const EXTENSION_MIME_MAP: Record<string, string> = {
+  // Images
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  bmp: "image/bmp",
+  heic: "image/heic",
+  heif: "image/heif",
+
+  // Documents
+  pdf: "application/pdf",
+  json: "application/json",
+  xml: "application/xml",
+  csv: "text/csv",
+  txt: "text/plain",
+  md: "text/markdown",
+  html: "text/html",
+  css: "text/css",
+  js: "text/javascript",
+  ts: "text/typescript",
+
+  // Audio
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  flac: "audio/flac",
+  aac: "audio/aac",
+  m4a: "audio/x-m4a",
+  opus: "audio/opus",
+
+  // Video
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  mpeg: "video/mpeg",
+
+  // Archives
+  zip: "application/zip",
+  gz: "application/gzip",
+  tar: "application/x-tar",
+};
+
+/**
+ * Infer a MIME type from a filename extension.
+ * Returns `application/octet-stream` when the extension is unrecognised.
+ */
+export function inferMimeType(filename: string): string {
+  const dot = filename.lastIndexOf(".");
+  if (dot === -1) {
+    return "application/octet-stream";
+  }
+  const ext = filename.slice(dot + 1).toLowerCase();
+  return EXTENSION_MIME_MAP[ext] ?? "application/octet-stream";
+}
+
+/**
+ * Pick the stored attachment filename for a materialized file directive.
+ *
+ * Explicit filenames (`<vellum-attachment filename="..." />` attributes)
+ * are an authoring contract and always used verbatim. Link display text
+ * (`[label](vellum://...)`) is cosmetic: it is only honored as the filename
+ * when it carries a recognized extension. A bare label
+ * (e.g. `[desktop](vellum://.../shot.png)`) would otherwise produce an
+ * extensionless download with an `application/octet-stream` MIME type,
+ * which macOS opens as raw text. In that case the label keeps the path's
+ * extension (`desktop.png`), staying unique per link even when several
+ * links share a basename; the raw basename is the last resort.
+ *
+ * The basename fallback splits on both `/` and `\\` so it handles POSIX
+ * sandbox paths, `vellum://` URL paths, and Windows host paths alike.
+ * Splitting on both separators regardless of the runtime platform also
+ * covers Windows host paths resolved by a non-Windows daemon, which
+ * platform-selected `node:path` semantics cannot.
+ */
+export function resolveAttachmentFilename(
+  preferred: string | undefined,
+  resolvedPath: string,
+  filenameSource: "explicit" | "label" = "explicit",
+): string {
+  const fallback =
+    resolvedPath.split(/[\\/]/).filter(Boolean).pop() ?? resolvedPath;
+  if (!preferred) {
+    return fallback;
+  }
+  if (filenameSource === "explicit") {
+    return preferred;
+  }
+  if (inferMimeType(preferred) !== "application/octet-stream") {
+    return preferred;
+  }
+  // Bare label: keep the label as a per-link disambiguator (two links to
+  // different files sharing a basename must not collide, because the
+  // transcript resolves clicks by filename) and append the path's
+  // extension so the stored name carries the correct type. Skip the
+  // append when the label already ends with that extension (a label like
+  // `report.xlsx` for `report.xlsx` must not become `report.xlsx.xlsx`).
+  const dot = fallback.lastIndexOf(".");
+  if (dot > 0 && dot < fallback.length - 1) {
+    const ext = fallback.slice(dot + 1);
+    if (preferred.toLowerCase().endsWith(`.${ext.toLowerCase()}`)) {
+      return preferred;
+    }
+    return `${preferred}.${ext}`;
+  }
+  return fallback;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/credential-executor",
-  "version": "0.10.7-dev.202607091111.4355283",
+  "version": "0.10.7-dev.202607091507.bac9bfe",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/main.ts

@@ -610,6 +610,7 @@ function serveStandaloneSocket(opts: {
   });
 
   netServer.on("connection", (socket: Socket) => {
+    connectionCount++;
     const readable = new Readable({ read() {} });
     const writable = new Writable({
       write(chunk, _encoding, callback) {
@@ -634,7 +635,6 @@ function serveStandaloneSocket(opts: {
         logger,
         signal,
         onHandshakeComplete: (sessionId, apiKey, assistantId) => {
-          rpcConnected = true;
           onHandshakeComplete?.(sessionId, apiKey, assistantId);
         },
         onApiKeyUpdate: onApiKeyUpdate ?? (() => {}),
@@ -646,7 +646,7 @@ function serveStandaloneSocket(opts: {
           "CES connection ended with a transport error",
         );
       }).then(() => {
-        rpcConnected = false;
+        connectionCount = Math.max(0, connectionCount - 1);
       });
   });
 
@@ -672,7 +672,7 @@ function serveStandaloneSocket(opts: {
 // Health server (managed mode only)
 // ---------------------------------------------------------------------------
 
-let rpcConnected = false;
+let connectionCount = 0;
 
 function startHealthServer(
   port: number,
@@ -695,7 +695,7 @@ function startHealthServer(
         // scheduling during dark-launch.  The sidecar can't do useful work
         // without a connection anyway, so readiness is purely about the
         // process being up and able to accept a future connection.
-        return new Response(JSON.stringify({ status: "ok", rpcConnected }), {
+        return new Response(JSON.stringify({ status: "ok", connections: connectionCount, rpcConnected: connectionCount > 0 }), {
           status: 200,
           headers: { "Content-Type": "application/json" },
         });
@@ -834,11 +834,13 @@ async function main(): Promise<void> {
     log,
     onHandshakeComplete: refs
       ? (_hsSessionId, hsApiKey, hsAssistantId) => {
-          // Overwrite the credential refs on every handshake. The handler
-          // registry persists across reconnects, so a new session that omits
-          // the API key / assistant ID must fail closed (falling back to the
-          // env key, or no key) rather than reusing the previous session's
-          // credentials.
+          // Update the process-scoped credential refs on every handshake.
+          // With multi-client CES, multiple connections from the same
+          // assistant instance share these refs. All connections belong to
+          // the same guardian, so they carry the same API key - last
+          // handshake wins is correct. A connection that omits the key
+          // fails closed (falling back to the env key, or no key) rather
+          // than reusing a previous session's credentials.
           applyManagedCredentialRefs(
             refs.apiKeyRef,
             refs.assistantIdRef,