@vellumai/assistant 0.6.6 → 0.7.0

package/src/runtime/migrations/job-registry.ts

@@ -0,0 +1,281 @@
+/**
+ * In-memory registry for async migration jobs (export/import).
+ *
+ * Each job has a UUID, a type, a lifecycle (`pending` -> `running` ->
+ * `complete`/`failed`), and optional result/error payloads. Runners are
+ * scheduled with `queueMicrotask` so `startJob` returns synchronously and
+ * callers can immediately poll the job record.
+ *
+ * At most one job of each `MigrationJobType` may be in-flight at a time;
+ * attempting to start a second one while another is pending or running
+ * rejects with `JobAlreadyInProgressError`.
+ *
+ * Completed/failed jobs are kept for `completedJobTtlMs` (default 10
+ * minutes) so clients can still fetch the final status after the runner
+ * finishes, then evicted by `sweep()` which is wired to a periodic
+ * `setInterval` on the singleton. The interval is `unref()`'d so it does
+ * not block process shutdown.
+ */
+
+import { randomUUID } from "node:crypto";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type MigrationJobType = "export" | "import";
+
+export type MigrationJobStatus = "pending" | "running" | "complete" | "failed";
+
+export interface MigrationJobError {
+  code: string;
+  message: string;
+  upstreamStatus?: number;
+}
+
+export interface MigrationJob {
+  id: string;
+  type: MigrationJobType;
+  status: MigrationJobStatus;
+  createdAt: number;
+  startedAt?: number;
+  completedAt?: number;
+  error?: MigrationJobError;
+  result?: unknown;
+}
+
+/**
+ * Thrown by `MigrationJobRegistry.startJob` when a job of the same type
+ * is already pending or running.
+ */
+export class JobAlreadyInProgressError extends Error {
+  public readonly existingJobId: string;
+
+  constructor(type: MigrationJobType, existingJobId: string) {
+    super(
+      `A ${type} migration job is already in progress (id=${existingJobId}).`,
+    );
+    this.name = "JobAlreadyInProgressError";
+    this.existingJobId = existingJobId;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// kFetchBodyError — preserve the tag convention used by the URL-body import
+// path in `routes/migration-routes.ts`. An error object carrying this symbol
+// was thrown from a failed upstream fetch body; we translate it into
+// `error.code = "fetch_failed"` for clients.
+// ---------------------------------------------------------------------------
+
+const kFetchBodyError = Symbol.for("vellum.migrationImport.fetchBodyError");
+
+function isFetchBodyError(err: unknown): boolean {
+  if (!err || typeof err !== "object") return false;
+  return (err as unknown as Record<symbol, boolean>)[kFetchBodyError] === true;
+}
+
+function extractUpstreamStatus(err: unknown): number | undefined {
+  if (!err || typeof err !== "object") return undefined;
+  const status = (err as { upstreamStatus?: unknown }).upstreamStatus;
+  return typeof status === "number" ? status : undefined;
+}
+
+function mapError(err: unknown): MigrationJobError {
+  const message =
+    err instanceof Error
+      ? err.message
+      : typeof err === "object" &&
+          err !== null &&
+          "message" in err &&
+          typeof (err as { message?: unknown }).message === "string"
+        ? (err as { message: string }).message
+        : String(err);
+
+  if (isFetchBodyError(err)) {
+    const mapped: MigrationJobError = {
+      code: "fetch_failed",
+      message,
+    };
+    const upstreamStatus = extractUpstreamStatus(err);
+    if (upstreamStatus !== undefined) {
+      mapped.upstreamStatus = upstreamStatus;
+    }
+    return mapped;
+  }
+
+  // Runner-provided override: `err.code` wins over the `"unknown"` default
+  // so callers that throw typed errors get their codes preserved.
+  const overrideCode =
+    typeof err === "object" &&
+    err !== null &&
+    typeof (err as { code?: unknown }).code === "string"
+      ? (err as { code: string }).code
+      : undefined;
+
+  const mapped: MigrationJobError = {
+    code: overrideCode ?? "unknown",
+    message,
+  };
+  const upstreamStatus = extractUpstreamStatus(err);
+  if (upstreamStatus !== undefined) {
+    mapped.upstreamStatus = upstreamStatus;
+  }
+  return mapped;
+}
+
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+
+/**
+ * Default TTL for completed/failed jobs before `sweep()` evicts them.
+ * Exposed as a class field so tests can override the singleton's value.
+ */
+const DEFAULT_COMPLETED_JOB_TTL_MS = 10 * 60 * 1000;
+
+/**
+ * Return a shallow clone of a `MigrationJob` that is decoupled from the
+ * internal registry record. The optional `error` object is spread so
+ * callers cannot mutate the stored error either. `result` is `unknown` by
+ * design — callers that pass mutable values in and then mutate them
+ * externally are already outside the registry's invariants.
+ */
+function cloneJob(job: MigrationJob): MigrationJob {
+  const snapshot: MigrationJob = {
+    id: job.id,
+    type: job.type,
+    status: job.status,
+    createdAt: job.createdAt,
+  };
+  if (job.startedAt !== undefined) snapshot.startedAt = job.startedAt;
+  if (job.completedAt !== undefined) snapshot.completedAt = job.completedAt;
+  if (job.error !== undefined) snapshot.error = { ...job.error };
+  if (job.result !== undefined) snapshot.result = job.result;
+  return snapshot;
+}
+
+export class MigrationJobRegistry {
+  private readonly jobs = new Map<string, MigrationJob>();
+  /** Tracks the single in-flight (pending or running) job id per type. */
+  private readonly inFlight = new Map<MigrationJobType, string>();
+
+  /** TTL for completed/failed jobs; mutable so tests can tighten it. */
+  public completedJobTtlMs: number = DEFAULT_COMPLETED_JOB_TTL_MS;
+
+  /**
+   * Start a new migration job. Returns a snapshot of the `MigrationJob`
+   * record synchronously (status `"pending"`); the runner is scheduled via
+   * `queueMicrotask` so the caller can poll via `getJob(id)` immediately.
+   *
+   * The returned object is a shallow clone decoupled from the internal
+   * record so that external mutation cannot violate the single-in-flight
+   * invariant (e.g. flipping a running job's status to `"complete"` must
+   * not unblock a same-type `startJob` while the runner is still active).
+   *
+   * Throws `JobAlreadyInProgressError` if another job of the same type is
+   * already pending or running.
+   */
+  public startJob<T>(
+    type: MigrationJobType,
+    runner: (job: MigrationJob) => Promise<T>,
+  ): MigrationJob {
+    const existingId = this.inFlight.get(type);
+    if (existingId !== undefined) {
+      const existing = this.jobs.get(existingId);
+      if (
+        existing &&
+        (existing.status === "pending" || existing.status === "running")
+      ) {
+        throw new JobAlreadyInProgressError(type, existingId);
+      }
+      // Stale entry (e.g. sweep raced with a new start) — clear it.
+      this.inFlight.delete(type);
+    }
+
+    const job: MigrationJob = {
+      id: randomUUID(),
+      type,
+      status: "pending",
+      createdAt: Date.now(),
+    };
+    this.jobs.set(job.id, job);
+    this.inFlight.set(type, job.id);
+
+    queueMicrotask(() => {
+      job.status = "running";
+      job.startedAt = Date.now();
+      Promise.resolve()
+        .then(() => runner(job))
+        .then(
+          (result) => {
+            job.status = "complete";
+            job.completedAt = Date.now();
+            job.result = result;
+            if (this.inFlight.get(type) === job.id) {
+              this.inFlight.delete(type);
+            }
+          },
+          (err: unknown) => {
+            job.status = "failed";
+            job.completedAt = Date.now();
+            job.error = mapError(err);
+            if (this.inFlight.get(type) === job.id) {
+              this.inFlight.delete(type);
+            }
+          },
+        );
+    });
+
+    return cloneJob(job);
+  }
+
+  public getJob(id: string): MigrationJob | null {
+    const job = this.jobs.get(id);
+    return job ? cloneJob(job) : null;
+  }
+
+  public listJobs(): MigrationJob[] {
+    return Array.from(this.jobs.values(), cloneJob);
+  }
+
+  /**
+   * Drop completed/failed jobs whose `completedAt` is older than
+   * `completedJobTtlMs`. Pending/running jobs are always retained.
+   */
+  public sweep(): void {
+    const now = Date.now();
+    for (const [id, job] of this.jobs) {
+      if (job.status !== "complete" && job.status !== "failed") continue;
+      const completedAt = job.completedAt;
+      if (completedAt === undefined) continue;
+      if (now - completedAt >= this.completedJobTtlMs) {
+        this.jobs.delete(id);
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Singleton + sweep interval
+// ---------------------------------------------------------------------------
+
+/** Process-wide registry used by migration routes. */
+export const migrationJobs = new MigrationJobRegistry();
+
+/**
+ * How often the sweep runs. The singleton wires this via `setInterval`;
+ * the interval is `unref()`'d so it does not keep the event loop alive
+ * during shutdown. Tests that need to stop the interval can call
+ * `clearInterval(sweepIntervalId)`.
+ */
+const SWEEP_INTERVAL_MS = 60 * 1000;
+
+const sweepIntervalId: NodeJS.Timeout = setInterval(() => {
+  migrationJobs.sweep();
+}, SWEEP_INTERVAL_MS);
+
+// `.unref()` exists on Node/Bun Timeout objects. Guard defensively in case
+// an alternative runtime returns a plain number.
+if (typeof (sweepIntervalId as { unref?: () => void }).unref === "function") {
+  (sweepIntervalId as { unref: () => void }).unref();
+}

package/src/runtime/migrations/vbundle-builder.ts

@@ -6,7 +6,7 @@
  * - workspace/: the entire ~/.vellum/workspace/ directory tree (DB, config,
  *   skills, prompts, attachments, etc.) — excluding large/regenerable
  *   dirs (embedding-models/, data/qdrant/)
- * - trust/trust.json: trust rules (optional, lives in protected/ outside workspace)
+ * - trust/trust.json: trust rules (optional)
  */
 
 import { createHash, randomUUID } from "node:crypto";
@@ -455,8 +455,7 @@ export interface BuildExportVBundleOptions {
  * Walks the entire workspace directory (~/.vellum/workspace/) and includes
  * all files in the archive, skipping only large/regenerable directories
  * (embedding-models/, data/qdrant/). Binary files (SQLite DB, attachments)
- * are included. Trust rules (in protected/, outside workspace) are handled
- * separately.
+ * are included. Trust rules are handled separately.
  *
  * The WAL is checkpointed before the walk so the exported DB file contains
  * all committed rows.
@@ -505,7 +504,7 @@ export function buildExportVBundle(
     configEntry.data = new TextEncoder().encode(sanitized);
   }
 
-  // Include trust rules if the file exists (lives in protected/, outside workspace).
+  // Include trust rules if the file exists.
   if (trustPath && existsSync(trustPath)) {
     const trustData = new Uint8Array(readFileSync(trustPath));
     files.push({ path: "trust/trust.json", data: trustData });

package/src/runtime/migrations/vbundle-importer.ts

@@ -53,7 +53,7 @@ export const CONFIG_ARCHIVE_PATHS: ReadonlySet<string> = new Set([
  * `readServiceCredentials` can still locate the platform API key after a
  * local→platform teleport. Both importers consult this constant.
  */
-export const CREDENTIAL_METADATA_ARCHIVE_PATH =
+const CREDENTIAL_METADATA_ARCHIVE_PATH =
   "workspace/data/credentials/metadata.json";
 
 /**

package/src/runtime/migrations/vbundle-streaming-importer.ts

@@ -50,7 +50,6 @@ import { pipeline } from "node:stream/promises";
 import { invalidateConfigCache } from "../../config/loader.js";
 import { sanitizeConfigForTransfer } from "../../config/sanitize-for-transfer.js";
 import { resetDb } from "../../memory/db-connection.js";
-import { clearCache as clearTrustCache } from "../../permissions/trust-store.js";
 import { isGuardianPersonaCustomized } from "../../prompts/persona-resolver.js";
 import { getLogger } from "../../util/logger.js";
 import type { PathResolver } from "./vbundle-import-analyzer.js";
@@ -832,12 +831,6 @@ export async function streamCommitImport(
       log.warn({ err }, "invalidateConfigCache threw after legacy import");
     }
 
-    try {
-      clearTrustCache();
-    } catch (err) {
-      log.warn({ err }, "clearTrustCache threw after legacy import");
-    }
-
     const report = buildReport(manifest, importedFiles, warnings);
     return { ok: true, report };
   }
@@ -1123,12 +1116,6 @@ export async function streamCommitImport(
     log.warn({ err }, "invalidateConfigCache threw after import");
   }
 
-  try {
-    clearTrustCache();
-  } catch (err) {
-    log.warn({ err }, "clearTrustCache threw after import");
-  }
-
   // Attempt to remove the backup dir (best-effort). Leaving it around is not
   // a correctness issue, only a disk-space one, so we swallow errors. The
   // backup dir now always exists once swap succeeds — we created it during

package/src/runtime/migrations/vbundle-tar-stream.ts

@@ -155,9 +155,17 @@ export async function* parseVBundleStream(
     extractor.destroy(err);
   });
 
-  // Kick off the pipeline. We wire stages with `.pipe(..., { end: true })`
-  // so that clean EOF from the source triggers `finish` on the extractor.
-  source.pipe(gunzip).pipe(extractor);
+  // `pipe()` is a no-op on an already-destroyed Readable, so gunzip and
+  // extractor would never see `end` and `nextEntry()` would await forever.
+  // Synthesize a terminal error instead.
+  if (source.destroyed) {
+    const err = new Error("vbundle source stream was destroyed before parse");
+    pushError(err);
+    gunzip.destroy(err);
+    extractor.destroy(err);
+  } else {
+    source.pipe(gunzip).pipe(extractor);
+  }
 
   function nextEntry(): Promise<PendingEntry | null> {
     if (pipelineError) return Promise.reject(pipelineError);

package/src/runtime/nl-approval-parser.ts

@@ -2,19 +2,19 @@
  * Natural language approval intent parser.
  *
  * Parses short inbound messages (e.g. from Slack) to determine whether the
- * entire message expresses an approval, rejection, or timed-approval intent.
+ * entire message expresses an approval or rejection intent.
  * Only matches when the full message is an approval/rejection phrase -- does
  * NOT match partial intent inside longer sentences like "yes but also do X".
  *
- * This parser covers a broad set of colloquial patterns, emoji, and
- * timed-approval variants for approval intent detection.
+ * This parser covers a broad set of colloquial patterns and emoji
+ * for approval intent detection.
  */
 
 // ---------------------------------------------------------------------------
 // Public types
 // ---------------------------------------------------------------------------
 
-export type ApprovalDecision = "approve" | "reject" | "approve_10m";
+export type ApprovalDecision = "approve" | "reject";
 
 export interface ApprovalIntent {
   decision: ApprovalDecision;
@@ -66,15 +66,6 @@ const REJECT_EXACT: ReadonlySet<string> = new Set([
   "\u{1F44E}", // 👎
 ]);
 
-/**
- * Patterns for timed approval (e.g. "approve for 10 minutes", "yes for now").
- * Matched after normalization.
- */
-const TIMED_PATTERNS: readonly RegExp[] = [
-  /^(?:approve|yes|ok|okay|sure|yep|yeah|go ahead)\s+for\s+10\s*(?:min(?:utes?)?|m)$/,
-  /^(?:approve|yes|ok|okay|sure|yep|yeah)\s+for\s+now$/,
-  /^approve\s+10\s*(?:min(?:utes?)?|m)$/,
-];
 
 // ---------------------------------------------------------------------------
 // Normalization
@@ -113,16 +104,8 @@ export function parseApprovalIntent(text: string): ApprovalIntent | null {
 
   // Reject messages that are too long to be a simple decision phrase.
   // This prevents matching approval words buried inside longer messages.
-  // The longest timed-approval phrase is ~30 chars; allow some padding.
   if (normalized.length > 40) return null;
 
-  // Check timed approval patterns first (more specific).
-  for (const pattern of TIMED_PATTERNS) {
-    if (pattern.test(normalized)) {
-      return { decision: "approve_10m", confidence: 0.95 };
-    }
-  }
-
   // Exact approval match.
   if (APPROVE_EXACT.has(normalized)) {
     return { decision: "approve", confidence: 0.95 };
@@ -133,5 +116,17 @@ export function parseApprovalIntent(text: string): ApprovalIntent | null {
     return { decision: "reject", confidence: 0.95 };
   }
 
+  // Legacy timed/persistent phrases — treat as simple approval.
+  // These used to produce approve_10m / approve_always but now collapse to approve.
+  const LEGACY_TIMED_PATTERN =
+    /^(?:yes|ok|okay|sure|yep|yeah|go\s+ahead|approve|allow)\s+(?:(?:for\s+)?\d+\s*(?:m|min|minutes?)|for\s+now)$/i;
+  if (
+    /^always\s+allow$/i.test(normalized) ||
+    /^approve\s+always$/i.test(normalized) ||
+    LEGACY_TIMED_PATTERN.test(normalized)
+  ) {
+    return { decision: "approve", confidence: 0.95 };
+  }
+
   return null;
 }

package/src/runtime/pending-interactions.ts

@@ -1,11 +1,12 @@
 /**
  * In-memory tracker that maps requestId to conversation info for pending
- * confirmation, secret, host_bash, host_file, host_cu, and host_browser
- * interactions.
+ * confirmation, secret, host_bash, host_file, host_cu, host_browser, and
+ * host_transfer interactions.
  *
  * When the agent loop emits a confirmation_request, secret_request,
- * host_bash_request, host_file_request, host_cu_request, or
- * host_browser_request, the onEvent callback registers the interaction here.
+ * host_bash_request, host_file_request, host_cu_request,
+ * host_browser_request, or host_transfer_request, the onEvent callback
+ * registers the interaction here.
  * Standalone HTTP endpoints (/v1/confirm, /v1/secret, /v1/trust-rules,
  * /v1/host-bash-result, /v1/host-file-result, /v1/host-cu-result,
  * /v1/host-browser-result) look up the conversation from this tracker to
@@ -27,7 +28,6 @@ export interface ConfirmationDetails {
   }>;
   scopeOptions: Array<{ label: string; scope: string }>;
   persistentDecisionsAllowed?: boolean;
-  temporaryOptionsAvailable?: Array<"allow_10m" | "allow_conversation">;
   /** ACP tool kind from the agent (e.g. "read", "edit", "execute"). */
   acpToolKind?: string;
   /** ACP permission options from the agent. */
@@ -48,6 +48,7 @@ export interface PendingInteraction {
     | "host_file"
     | "host_cu"
     | "host_browser"
+    | "host_transfer"
     | "acp_confirmation";
   confirmationDetails?: ConfirmationDetails;
   /** For ACP permissions: resolves directly without a Conversation object. */
@@ -103,13 +104,13 @@ export function getByConversation(
  * Remove pending confirmation and secret interactions for a given conversation.
  * Used when auto-denying all pending interactions (e.g. new user message).
  *
- * host_bash, host_file, host_cu, and host_browser interactions are
- * intentionally skipped — they represent in-flight tool executions proxied to
- * the client, not confirmations to auto-deny. Removing them would orphan the
- * request: the client would POST to /v1/host-bash-result,
- * /v1/host-file-result, /v1/host-cu-result, or /v1/host-browser-result after
- * completing the operation, get a 404, and the proxy timer would fire with a
- * spurious timeout error.
+ * host_bash, host_file, host_cu, host_browser, and host_transfer interactions
+ * are intentionally skipped — they represent in-flight tool executions proxied
+ * to the client, not confirmations to auto-deny. Removing them would orphan
+ * the request: the client would POST to /v1/host-bash-result,
+ * /v1/host-file-result, /v1/host-cu-result, /v1/host-browser-result, or
+ * /v1/host-transfer-result after completing the operation, get a 404, and the
+ * proxy timer would fire with a spurious timeout error.
  */
 export function removeByConversation(conversation: Conversation): void {
   for (const [requestId, interaction] of pending) {
@@ -119,6 +120,7 @@ export function removeByConversation(conversation: Conversation): void {
       interaction.kind !== "host_file" &&
       interaction.kind !== "host_cu" &&
       interaction.kind !== "host_browser" &&
+      interaction.kind !== "host_transfer" &&
       interaction.kind !== "acp_confirmation"
     ) {
       pending.delete(requestId);
@@ -126,6 +128,21 @@ export function removeByConversation(conversation: Conversation): void {
   }
 }
 
+/**
+ * Return all pending interactions of a given kind.
+ */
+export function getByKind(
+  kind: PendingInteraction["kind"],
+): Array<{ requestId: string } & PendingInteraction> {
+  const results: Array<{ requestId: string } & PendingInteraction> = [];
+  for (const [requestId, interaction] of pending) {
+    if (interaction.kind === kind) {
+      results.push({ requestId, ...interaction });
+    }
+  }
+  return results;
+}
+
 /** Clear all pending interactions. Useful for testing. */
 export function clear(): void {
   pending.clear();