@vellumai/credential-executor 0.11.7 → 0.11.8-staging.1

package/node_modules/@vellumai/credential-storage/src/static-credentials.ts

@@ -216,6 +216,8 @@ export interface StaticCredentialPolicyInput {
  */
 export class StaticCredentialMetadataStore {
   private metadataPath: string;
+  /** When set, reads and writes stay in process and do not touch the file. */
+  private memory: MetadataFile | null = null;
 
   constructor(metadataPath: string) {
     this.metadataPath = metadataPath;
@@ -224,6 +226,17 @@ export class StaticCredentialMetadataStore {
   /** Update the metadata file path (primarily for testing). */
   setPath(path: string): void {
     this.metadataPath = path;
+    this.memory = null;
+  }
+
+  /**
+   * Switch to an in-memory backing filled with `records`.
+   */
+  useMemory(records: StaticCredentialRecord[] = []): void {
+    this.memory = {
+      version: CURRENT_VERSION,
+      credentials: records.map((record) => ({ ...record })),
+    };
   }
 
   /** Get the current metadata file path. */
@@ -231,13 +244,28 @@ export class StaticCredentialMetadataStore {
     return this.metadataPath;
   }
 
+  private load(): LoadResult {
+    if (this.memory) {
+      return this.memory;
+    }
+    return loadFile(this.metadataPath, saveFile);
+  }
+
+  private persist(data: MetadataFile): void {
+    if (this.memory) {
+      this.memory = data;
+      return;
+    }
+    saveFile(data, this.metadataPath);
+  }
+
   /**
    * Throws if the metadata file has an unrecognized version.
    * Call this before performing irreversible credential store operations
    * so the operation fails cleanly before any side effects.
    */
   assertWritable(): void {
-    const result = loadFile(this.metadataPath, saveFile);
+    const result = this.load();
     if (isUnknownVersion(result)) {
       throw new Error(
         "Credential metadata file has an unrecognized version; refusing to mutate to avoid data loss"
@@ -254,7 +282,7 @@ export class StaticCredentialMetadataStore {
     field: string,
     policy?: StaticCredentialPolicyInput
   ): StaticCredentialRecord {
-    const result = loadFile(this.metadataPath, saveFile);
+    const result = this.load();
     if (isUnknownVersion(result)) {
       throw new Error(
         "Credential metadata file has an unrecognized version; refusing to mutate to avoid data loss"
@@ -268,12 +296,15 @@ export class StaticCredentialMetadataStore {
     );
 
     if (existing) {
-      if (policy?.allowedTools !== undefined)
+      if (policy?.allowedTools !== undefined) {
         existing.allowedTools = policy.allowedTools;
-      if (policy?.allowedDomains !== undefined)
+      }
+      if (policy?.allowedDomains !== undefined) {
         existing.allowedDomains = policy.allowedDomains;
-      if (policy?.usageDescription !== undefined)
+      }
+      if (policy?.usageDescription !== undefined) {
         existing.usageDescription = policy.usageDescription;
+      }
       if (policy?.alias !== undefined) {
         if (policy.alias == null) {
           delete existing.alias;
@@ -289,7 +320,7 @@ export class StaticCredentialMetadataStore {
         }
       }
       existing.updatedAt = now;
-      saveFile(data, this.metadataPath);
+      this.persist(data);
       return existing;
     }
 
@@ -307,7 +338,7 @@ export class StaticCredentialMetadataStore {
     };
 
     data.credentials.push(record);
-    saveFile(data, this.metadataPath);
+    this.persist(data);
     return record;
   }
 
@@ -318,7 +349,7 @@ export class StaticCredentialMetadataStore {
     service: string,
     field: string
   ): StaticCredentialRecord | undefined {
-    const result = loadFile(this.metadataPath, saveFile);
+    const result = this.load();
     if (isUnknownVersion(result)) return undefined;
     return result.credentials.find(
       (c) => c.service === service && c.field === field
@@ -329,7 +360,7 @@ export class StaticCredentialMetadataStore {
    * Get metadata for a credential by its opaque ID.
    */
   getById(credentialId: string): StaticCredentialRecord | undefined {
-    const result = loadFile(this.metadataPath, saveFile);
+    const result = this.load();
     if (isUnknownVersion(result)) return undefined;
     return result.credentials.find((c) => c.credentialId === credentialId);
   }
@@ -338,7 +369,7 @@ export class StaticCredentialMetadataStore {
    * List all credential metadata records.
    */
   list(): StaticCredentialRecord[] {
-    const result = loadFile(this.metadataPath, saveFile);
+    const result = this.load();
     if (isUnknownVersion(result)) return [];
     return result.credentials;
   }
@@ -347,7 +378,7 @@ export class StaticCredentialMetadataStore {
    * Delete metadata for a credential.
    */
   delete(service: string, field: string): boolean {
-    const result = loadFile(this.metadataPath, saveFile);
+    const result = this.load();
     if (isUnknownVersion(result)) {
       throw new Error(
         "Credential metadata file has an unrecognized version; refusing to mutate to avoid data loss"
@@ -359,7 +390,7 @@ export class StaticCredentialMetadataStore {
     );
     if (idx === -1) return false;
     data.credentials.splice(idx, 1);
-    saveFile(data, this.metadataPath);
+    this.persist(data);
     return true;
   }
 }

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

@@ -11,6 +11,7 @@
     "./client-metadata": "./src/client-metadata.ts",
     "./credential-rpc": "./src/credential-rpc.ts",
     "./ingress": "./src/ingress.ts",
+    "./no-response": "./src/no-response.ts",
     "./remote-web-pairing": "./src/remote-web-pairing.ts",
     "./twilio-ingress": "./src/twilio-ingress.ts",
     "./trust-rules": "./src/trust-rules.ts",

package/node_modules/@vellumai/service-contracts/src/channels.ts

@@ -66,6 +66,13 @@ export function isChannelId(value: unknown): value is ChannelId {
  * That irregularity is why this is stated rather than derived from the key,
  * and it is stated here because this file already owns what a channel is.
  *
+ * Both senses can hold a user token, which is the sharpest edge. The `slack`
+ * integration's persisted token *is* the installer's user token, held on its
+ * OAuth connection. `slack_channel` holds an optional `user_token` in the
+ * credential store, beside its bot and app tokens. Same words, different
+ * homes, and only the second is a credential-store key: a pasted token is
+ * always the channel's, because the integration's never leaves the exchange.
+ *
  * Deliberately only the key. What fields each credential requires is declared
  * once already, per service, in the gateway's credential specs; restating it
  * here would be a second copy of a different fact.

package/node_modules/@vellumai/service-contracts/src/index.ts

@@ -27,6 +27,7 @@ export * from "./handles.js";
 export * from "./rpc.js";
 export * from "./trust-rules.js";
 export * from "./ingress.js";
+export * from "./no-response.js";
 export * from "./remote-web-pairing.js";
 export * from "./twilio-ingress.js";
 export * from "./url-normalization.js";

package/node_modules/@vellumai/service-contracts/src/no-response.ts

@@ -0,0 +1,84 @@
+/**
+ * The `<no_response/>` sentinel: the cross-service convention for a turn
+ * that deliberately produces no user-visible reply.
+ *
+ * The model emits it, the daemon stamps and strips it, channel delivery
+ * suppresses it, and clients hold live-streamed prefixes of it back from
+ * display. One definition here keeps every consumer's parsing identical;
+ * a hand-rolled copy in any one of them is how the case-sensitivity of a
+ * regex drifts.
+ */
+
+/** Matches a message whose entire content is the sentinel. */
+const NO_RESPONSE_ONLY_RE = /^\s*<no_response\s*\/?>\s*$/i;
+
+/**
+ * Whether `text` is nothing but the sentinel: the whole reply is a
+ * deliberate non-response, as opposed to real content with an inline
+ * sentinel mixed in.
+ */
+export function isNoResponseOnlyText(text: string): boolean {
+  return NO_RESPONSE_ONLY_RE.test(text);
+}
+
+/** Matches every sentinel occurrence for stripping it out of mixed content. */
+export const NO_RESPONSE_INLINE_RE = /<no_response\s*\/?>/gi;
+
+/**
+ * Detection variant without the `g` flag: a `g`-flagged regex is stateful
+ * under `.test()` (it resumes from `lastIndex`), so reusing
+ * {@link NO_RESPONSE_INLINE_RE} for detection would alternate between
+ * matches and misses across calls.
+ */
+const NO_RESPONSE_MARKER_RE = new RegExp(NO_RESPONSE_INLINE_RE.source, "i");
+
+/** Whether `text` contains the sentinel anywhere. */
+export function containsNoResponseMarker(text: string): boolean {
+  return NO_RESPONSE_MARKER_RE.test(text);
+}
+
+/** Removes every sentinel occurrence, trimming the leftover whitespace. */
+export function stripNoResponseMarkers(text: string): string {
+  return text.replace(NO_RESPONSE_INLINE_RE, "").trim();
+}
+
+const NO_RESPONSE_SENTINEL_FORMS = [
+  "<no_response/>",
+  "<no_response />",
+  "<no_response>",
+] as const;
+
+/**
+ * Whether `text` could still grow into the sentinel, i.e. it is a leading
+ * substring of one of its forms. Holding on these keeps a slowly-streamed
+ * `<no_response/>` from surfacing as visible partial content.
+ */
+export function isPotentialNoResponsePrefix(text: string): boolean {
+  const lower = text.trim().toLowerCase();
+  if (lower.length === 0) {
+    return false;
+  }
+  return NO_RESPONSE_SENTINEL_FORMS.some((sentinel) =>
+    sentinel.startsWith(lower),
+  );
+}
+
+/**
+ * Whether `text` carries user-visible content worth acting on now. Returns
+ * `false` for empty text, the standalone sentinel, and any prefix that could
+ * still complete into one; returns `true` once real content remains after
+ * stripping inline sentinels.
+ */
+export function hasDeliverableAssistantText(text: string): boolean {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return false;
+  }
+  if (NO_RESPONSE_ONLY_RE.test(trimmed)) {
+    return false;
+  }
+  if (isPotentialNoResponsePrefix(trimmed)) {
+    return false;
+  }
+  return stripNoResponseMarkers(trimmed).length > 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/credential-executor",
-  "version": "0.11.7",
+  "version": "0.11.8-staging.1",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/credential-record-store.test.ts

@@ -1,11 +1,13 @@
-import { mkdtempSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { describe, expect, test } from "bun:test";
 
+import type { SecureKeyBackend } from "@vellumai/credential-storage";
 import type { CredentialRecord } from "@vellumai/service-contracts/credential-rpc";
 
+import { importWorkspaceMetadataMigration } from "../migrations/003-import-workspace-metadata.js";
 import {
   CesMetadataStore,
   getMetadataPath,
@@ -89,3 +91,122 @@ describe("parseCredentialAccount", () => {
     expect(parseCredentialAccount("oauth/google/access")).toBeUndefined();
   });
 });
+
+describe("003-import-workspace-metadata", () => {
+  test("imports leftover workspace metadata without deleting the file", async () => {
+    const workspace = mkdtempSync(join(tmpdir(), "ces-ws-"));
+    const cesData = mkdtempSync(join(tmpdir(), "ces-data-"));
+    const leftoverPath = join(workspace, "data", "credentials", "metadata.json");
+    mkdirSync(join(workspace, "data", "credentials"), { recursive: true });
+    writeFileSync(
+      leftoverPath,
+      JSON.stringify({
+        version: 5,
+        credentials: [
+          makeRecord("vercel", "api_token", { allowedTools: ["publish_page"] }),
+        ],
+      }),
+    );
+
+    const prevWorkspace = process.env.VELLUM_WORKSPACE_DIR;
+    const prevMode = process.env.CES_MODE;
+    const prevData = process.env.CES_DATA_DIR;
+    process.env.VELLUM_WORKSPACE_DIR = workspace;
+    process.env.CES_MODE = "managed";
+    process.env.CES_DATA_DIR = cesData;
+
+    const unusedBackend: SecureKeyBackend = {
+      get: async () => undefined,
+      set: async () => true,
+      delete: async () => "not-found",
+      list: async () => [],
+    };
+
+    try {
+      await importWorkspaceMetadataMigration.run(unusedBackend);
+      const store = new CesMetadataStore(getMetadataPath(cesData));
+      const imported = store.getByAccount("credential/vercel/api_token");
+      expect(imported?.allowedTools).toEqual(["publish_page"]);
+      expect(imported?.credentialId).toBe("id-vercel-api_token");
+      expect(existsSync(leftoverPath)).toBe(true);
+    } finally {
+      if (prevWorkspace === undefined) {
+        delete process.env.VELLUM_WORKSPACE_DIR;
+      } else {
+        process.env.VELLUM_WORKSPACE_DIR = prevWorkspace;
+      }
+      if (prevMode === undefined) {
+        delete process.env.CES_MODE;
+      } else {
+        process.env.CES_MODE = prevMode;
+      }
+      if (prevData === undefined) {
+        delete process.env.CES_DATA_DIR;
+      } else {
+        process.env.CES_DATA_DIR = prevData;
+      }
+    }
+  });
+
+  test("keeps an existing CES record instead of overwriting it", async () => {
+    const workspace = mkdtempSync(join(tmpdir(), "ces-ws-"));
+    const cesData = mkdtempSync(join(tmpdir(), "ces-data-"));
+    const leftoverPath = join(workspace, "data", "credentials", "metadata.json");
+    mkdirSync(join(workspace, "data", "credentials"), { recursive: true });
+    writeFileSync(
+      leftoverPath,
+      JSON.stringify({
+        version: 5,
+        credentials: [
+          makeRecord("vercel", "api_token", { allowedTools: ["bash"] }),
+        ],
+      }),
+    );
+    const store = new CesMetadataStore(getMetadataPath(cesData));
+    store.setByAccount(
+      "credential/vercel/api_token",
+      makeRecord("vercel", "api_token", {
+        credentialId: "id-ces-newer",
+        allowedTools: ["publish_page"],
+      }),
+    );
+
+    const prevWorkspace = process.env.VELLUM_WORKSPACE_DIR;
+    const prevMode = process.env.CES_MODE;
+    const prevData = process.env.CES_DATA_DIR;
+    process.env.VELLUM_WORKSPACE_DIR = workspace;
+    process.env.CES_MODE = "managed";
+    process.env.CES_DATA_DIR = cesData;
+
+    const unusedBackend: SecureKeyBackend = {
+      get: async () => undefined,
+      set: async () => true,
+      delete: async () => "not-found",
+      list: async () => [],
+    };
+
+    try {
+      await importWorkspaceMetadataMigration.run(unusedBackend);
+      const kept = store.getByAccount("credential/vercel/api_token");
+      expect(kept?.credentialId).toBe("id-ces-newer");
+      expect(kept?.allowedTools).toEqual(["publish_page"]);
+      expect(existsSync(leftoverPath)).toBe(true);
+    } finally {
+      if (prevWorkspace === undefined) {
+        delete process.env.VELLUM_WORKSPACE_DIR;
+      } else {
+        process.env.VELLUM_WORKSPACE_DIR = prevWorkspace;
+      }
+      if (prevMode === undefined) {
+        delete process.env.CES_MODE;
+      } else {
+        process.env.CES_MODE = prevMode;
+      }
+      if (prevData === undefined) {
+        delete process.env.CES_DATA_DIR;
+      } else {
+        process.env.CES_DATA_DIR = prevData;
+      }
+    }
+  });
+});

package/src/http/log-export-routes.ts

@@ -177,6 +177,7 @@ export async function handleLogExportRoute(
     const proc = spawnSync("tar", ["czf", "-", "-C", staging, "."], {
       maxBuffer: MAX_LOG_BYTES * 2, // allow headroom for tar overhead
       timeout: 30_000,
+      windowsHide: true,
     });
 
     if (proc.status !== 0) {

package/src/migrations/003-import-workspace-metadata.ts

@@ -0,0 +1,76 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+import type { SecureKeyBackend } from "@vellumai/credential-storage";
+
+import { getLogger } from "../logger.js";
+import { getCesDataRoot } from "../paths.js";
+import {
+  accountForRecord,
+  CesMetadataStore,
+  getMetadataPath,
+} from "../records/metadata-store.js";
+import type { CesMigration } from "./types.js";
+
+function leftoverWorkspaceMetadataPath(
+  workspaceDir: string | undefined,
+): string | undefined {
+  if (!workspaceDir || workspaceDir.trim() === "") {
+    return undefined;
+  }
+  return join(workspaceDir, "data", "credentials", "metadata.json");
+}
+
+const log = getLogger("ces-migrations");
+
+/**
+ * Copy workspace `metadata.json` catalog rows into the CES metadata store.
+ *
+ * CES does not delete the workspace file (the workspace volume is
+ * read-only in managed mode).
+ */
+export const importWorkspaceMetadataMigration: CesMigration = {
+  id: "003-import-workspace-metadata",
+  description:
+    "Import workspace credential metadata.json into the CES metadata store",
+
+  async run(_backend: SecureKeyBackend): Promise<void> {
+    const workspaceDir = process.env["VELLUM_WORKSPACE_DIR"]?.trim();
+    const leftoverPath = leftoverWorkspaceMetadataPath(workspaceDir);
+    if (!leftoverPath || !existsSync(leftoverPath)) {
+      log.info("CES metadata import: no workspace metadata.json; skipping");
+      return;
+    }
+
+    const source = new CesMetadataStore(leftoverPath);
+    const records = source.list();
+    if (records.length === 0) {
+      log.info("CES metadata import: workspace metadata.json has no rows");
+      return;
+    }
+
+    const store = new CesMetadataStore(getMetadataPath(getCesDataRoot()));
+    let imported = 0;
+    let skipped = 0;
+    for (const { record } of records) {
+      const account = accountForRecord(record);
+      const existing = store.getByAccount(account);
+      if (existing) {
+        skipped += 1;
+        continue;
+      }
+      const ok = store.setByAccount(account, record);
+      if (ok) {
+        imported += 1;
+      }
+    }
+    log.info(
+      { imported, skipped, total: records.length },
+      "CES metadata import from workspace metadata.json complete",
+    );
+  },
+
+  async down(_backend: SecureKeyBackend): Promise<void> {
+    // Forward-only: records remain in CES.
+  },
+};

package/src/migrations/registry.ts

@@ -1,5 +1,6 @@
-import { apiKeyToCredentialsMigration } from "./002-api-keys-to-credentials.js";
 import { noOpMigration } from "./001-no-op.js";
+import { apiKeyToCredentialsMigration } from "./002-api-keys-to-credentials.js";
+import { importWorkspaceMetadataMigration } from "./003-import-workspace-metadata.js";
 import type { CesMigration } from "./types.js";
 
 /**
@@ -12,4 +13,5 @@ import type { CesMigration } from "./types.js";
 export const CES_MIGRATIONS: CesMigration[] = [
   noOpMigration,
   apiKeyToCredentialsMigration,
+  importWorkspaceMetadataMigration,
 ];