@vellumai/assistant 0.7.0 → 0.7.2

package/src/runtime/routes/host-transfer-routes.ts

@@ -7,29 +7,21 @@
  */
 import { z } from "zod";
 
+import { HostTransferProxy } from "../../daemon/host-transfer-proxy.js";
 import * as pendingInteractions from "../pending-interactions.js";
-import {
-  BadRequestError,
-  ConflictError,
-  NotFoundError,
-} from "./errors.js";
+import { BadRequestError, ConflictError, ForbiddenError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 /**
- * Find the HostTransferProxy that owns a given transferId by scanning
- * all pending host_transfer interactions. Returns the proxy and the
- * interaction entry (with its requestId) so callers can resolve the
- * pending interaction when appropriate.
+ * Find the singleton HostTransferProxy if it owns the given transferId.
+ * Returns the proxy and the matching requestId so callers can resolve
+ * the pending interaction when appropriate.
  */
 function findProxyByTransferId(transferId: string) {
-  const interactions = pendingInteractions.getByKind("host_transfer");
-  for (const interaction of interactions) {
-    const proxy = interaction.conversation?.getHostTransferProxy();
-    if (proxy?.hasPendingTransfer(transferId)) {
-      return { proxy, interaction };
-    }
-  }
-  return null;
+  const proxy = HostTransferProxy.instance;
+  const requestId = proxy.getRequestIdForTransfer(transferId);
+  if (!requestId) return null;
+  return { proxy, requestId };
 }
 
 // ---------------------------------------------------------------------------
@@ -38,6 +30,7 @@ function findProxyByTransferId(transferId: string) {
 
 function handleTransferContentGet({
   pathParams = {},
+  headers = {},
 }: RouteHandlerArgs): Uint8Array {
   const transferId = pathParams.transferId;
   if (!transferId) {
@@ -49,6 +42,13 @@ function handleTransferContentGet({
     throw new NotFoundError("Unknown or consumed transfer");
   }
 
+  const targetClientId = match.proxy.getTargetClientIdForTransfer(transferId);
+  if (targetClientId != null) {
+    const submittingClientId = (headers as Record<string, string>)["x-vellum-client-id"]?.trim() || undefined;
+    if (!submittingClientId) throw new BadRequestError("x-vellum-client-id header required for targeted transfer");
+    if (submittingClientId !== targetClientId) throw new ForbiddenError(`Client "${submittingClientId}" is not the owner of this transfer`);
+  }
+
   const content = match.proxy.getTransferContent(transferId);
   if (!content) {
     throw new NotFoundError("Unknown or consumed transfer");
@@ -59,8 +59,11 @@ function handleTransferContentGet({
 
 /**
  * Resolve Content-Length and X-Transfer-SHA256 response headers for the
- * GET transfer content endpoint. Called by the HTTP adapter before
- * sending the response.
+ * GET transfer content endpoint. Called by the HTTP adapter AFTER the handler
+ * runs (`http-adapter.ts:107-125`), so the entry has already been consumed by
+ * `getTransferContent`. We read the size/sha256 from
+ * `takeJustConsumedTransferMetadata`, which the proxy populates synchronously
+ * during the handler's `getTransferContent` call.
  */
 function resolveTransferContentGetHeaders({
   pathParams = {},
@@ -70,16 +73,14 @@ function resolveTransferContentGetHeaders({
   const transferId = pathParams?.transferId;
   if (!transferId) return { "Content-Type": "application/octet-stream" };
 
-  const match = findProxyByTransferId(transferId);
-  if (!match) return { "Content-Type": "application/octet-stream" };
-
-  const content = match.proxy.getTransferContent(transferId);
-  if (!content) return { "Content-Type": "application/octet-stream" };
+  const meta =
+    HostTransferProxy.instance.takeJustConsumedTransferMetadata(transferId);
+  if (!meta) return { "Content-Type": "application/octet-stream" };
 
   return {
     "Content-Type": "application/octet-stream",
-    "Content-Length": content.sizeBytes.toString(),
-    "X-Transfer-SHA256": content.sha256,
+    "Content-Length": meta.sizeBytes.toString(),
+    "X-Transfer-SHA256": meta.sha256,
   };
 }
 
@@ -102,6 +103,13 @@ async function handleTransferContentPut({
     throw new NotFoundError("Unknown or consumed transfer");
   }
 
+  const targetClientId = match.proxy.getTargetClientIdForTransfer(transferId);
+  if (targetClientId != null) {
+    const submittingClientId = (headers as Record<string, string>)["x-vellum-client-id"]?.trim() || undefined;
+    if (!submittingClientId) throw new BadRequestError("x-vellum-client-id header required for targeted transfer");
+    if (submittingClientId !== targetClientId) throw new ForbiddenError(`Client "${submittingClientId}" is not the owner of this transfer`);
+  }
+
   const data = rawBody ? Buffer.from(rawBody) : Buffer.alloc(0);
   const sha256 = headers["x-transfer-sha256"] ?? "";
 
@@ -111,11 +119,6 @@ async function handleTransferContentPut({
     sha256,
   );
 
-  // For to_sandbox transfers there is no separate /v1/host-transfer-result
-  // callback — the PUT handler is the terminal event. Always clean up the
-  // pending interaction so it doesn't leak.
-  pendingInteractions.resolve(match.interaction.requestId);
-
   if (!result.accepted) {
     throw new BadRequestError(result.error ?? "Transfer content rejected");
   }
@@ -127,7 +130,7 @@ async function handleTransferContentPut({
 // POST /v1/host-transfer-result
 // ---------------------------------------------------------------------------
 
-function handleTransferResult({ body }: RouteHandlerArgs) {
+function handleTransferResult({ body, headers }: RouteHandlerArgs) {
   if (!body || typeof body !== "object") {
     throw new BadRequestError("Request body is required");
   }
@@ -145,9 +148,7 @@ function handleTransferResult({ body }: RouteHandlerArgs) {
 
   const peeked = pendingInteractions.get(requestId);
   if (!peeked) {
-    throw new NotFoundError(
-      "No pending interaction found for this requestId",
-    );
+    throw new NotFoundError("No pending interaction found for this requestId");
   }
 
   if (peeked.kind !== "host_transfer") {
@@ -156,9 +157,14 @@ function handleTransferResult({ body }: RouteHandlerArgs) {
     );
   }
 
-  const interaction = pendingInteractions.resolve(requestId)!;
+  if (peeked.targetClientId != null) {
+    const rawClientId = (headers as Record<string, string | undefined>)?.["x-vellum-client-id"];
+    const submittingClientId = rawClientId?.trim() || undefined;
+    if (!submittingClientId) throw new BadRequestError("x-vellum-client-id header is missing for a targeted host transfer request.");
+    if (submittingClientId !== peeked.targetClientId) throw new ForbiddenError(`Client "${submittingClientId}" is not the target for this request (expected "${peeked.targetClientId}").`);
+  }
 
-  interaction.conversation!.resolveHostTransfer(requestId, {
+  HostTransferProxy.instance.resolveTransferResult(requestId, {
     isError: isError ?? false,
     bytesWritten,
     errorMessage,
@@ -183,6 +189,16 @@ export const ROUTES: RouteDefinition[] = [
       "Serve raw file bytes for a to_host transfer. Single-use: returns 404 after first consumption.",
     tags: ["host-transfer"],
     responseHeaders: resolveTransferContentGetHeaders,
+    additionalResponses: {
+      "400": {
+        description:
+          "x-vellum-client-id header is missing for a targeted transfer.",
+      },
+      "403": {
+        description:
+          "Submitting client does not match the targeted client for this transfer.",
+      },
+    },
     handler: handleTransferContentGet,
   },
   {
@@ -195,6 +211,16 @@ export const ROUTES: RouteDefinition[] = [
     description:
       "Receive raw file bytes for a to_sandbox transfer. Verifies SHA-256 integrity via the X-Transfer-SHA256 header.",
     tags: ["host-transfer"],
+    additionalResponses: {
+      "400": {
+        description:
+          "x-vellum-client-id header is missing for a targeted transfer.",
+      },
+      "403": {
+        description:
+          "Submitting client does not match the targeted client for this transfer.",
+      },
+    },
     handler: handleTransferContentPut,
   },
   {
@@ -215,6 +241,16 @@ export const ROUTES: RouteDefinition[] = [
     responseBody: z.object({
       accepted: z.boolean(),
     }),
+    additionalResponses: {
+      "400": {
+        description:
+          "x-vellum-client-id header is missing for a targeted host transfer request.",
+      },
+      "403": {
+        description:
+          "Submitting client does not match the targeted client for this transfer.",
+      },
+    },
     handler: handleTransferResult,
   },
 ];

package/src/runtime/routes/http-adapter.ts

@@ -163,6 +163,7 @@ export function routeDefinitionsToHTTPRoutes(
             err.code as HttpErrorCode,
             err.message,
             err.statusCode,
+            err.details,
           );
         }
         throw err;

package/src/runtime/routes/identity-intro-cache.ts

@@ -48,6 +48,36 @@ function readWorkspaceFile(name: string): string {
   }
 }
 
+function parseIdentityIntroSection(content: string): string | null {
+  let inSection = false;
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (/^#+\s/.test(trimmed)) {
+      inSection = trimmed.toLowerCase().includes("identity intro");
+      continue;
+    }
+    if (inSection && trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Read the explicit `## Identity Intro` section from workspace prompt files.
+ *
+ * BOOTSTRAP.md instructs the assistant to write this section in IDENTITY.md.
+ * SOUL.md remains a fallback for older workspaces that stored the intro there.
+ */
+export function readWorkspaceIdentityIntro(): string | null {
+  return (
+    parseIdentityIntroSection(readWorkspaceFile("IDENTITY.md")) ??
+    parseIdentityIntroSection(readWorkspaceFile("SOUL.md"))
+  );
+}
+
 /** Compute a SHA-256 hex hash of the concatenated identity file contents. */
 export function computeIdentityContentHash(): string {
   const staticFiles = IDENTITY_FILES.map(readWorkspaceFile).join("\n---\n");

package/src/runtime/routes/identity-routes.ts

@@ -2,12 +2,17 @@
  * Identity and health endpoint handlers.
  */
 
-import { existsSync, readFileSync, statfsSync, statSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, statfsSync } from "node:fs";
 import { availableParallelism, cpus, totalmem } from "node:os";
 
 import { z } from "zod";
 
-import { getCpuLimit, getIsPlatform } from "../../config/env-registry.js";
+import {
+  getCpuLimit,
+  getIsPlatform,
+  getMinikubeStorageSize,
+} from "../../config/env-registry.js";
 import { parseIdentityFields } from "../../daemon/handlers/identity.js";
 import { getProfilerRuntimeStatus } from "../../daemon/profiler-run-store.js";
 import { getMaxMigrationVersion } from "../../memory/migrations/registry.js";
@@ -16,6 +21,7 @@ import {
   getWorkspacePromptPath,
 } from "../../util/platform.js";
 import { APP_VERSION } from "../../version.js";
+import { resolveHatchedAtReadOnly } from "../../workspace/hatched-date.js";
 import { WORKSPACE_MIGRATIONS } from "../../workspace/migrations/registry.js";
 import { getLastWorkspaceMigrationId } from "../../workspace/migrations/runner.js";
 import { NotFoundError } from "./errors.js";
@@ -29,20 +35,87 @@ interface DiskSpaceInfo {
   freeMb: number;
 }
 
+/**
+ * Measure the on-disk usage of one or more directory paths using `du -sb`.
+ * Returns the sum of all paths in bytes, or null on failure.
+ */
+function getDirectorySizeBytes(paths: string[]): number | null {
+  try {
+    const existing = paths.filter((p) => existsSync(p));
+    if (existing.length === 0) return null;
+    const result = spawnSync("du", ["-sb", ...existing], {
+      encoding: "utf-8",
+      timeout: 30_000,
+    });
+    if (result.status !== 0) return null;
+    let total = 0;
+    for (const line of result.stdout.trim().split("\n")) {
+      const size = parseInt(line.split("\t")[0], 10);
+      if (!isNaN(size) && size > 0) total += size;
+    }
+    return total > 0 ? total : null;
+  } catch {
+    return null;
+  }
+}
+
+const DU_CACHE_TTL_MS = 60_000;
+let duCacheValue: number | null = null;
+let duCacheTime = 0;
+let duCachePaths: string | null = null;
+
+function getCachedDirectorySizeBytes(paths: string[]): number | null {
+  const key = paths.join("\0");
+  const now = Date.now();
+  if (duCachePaths === key && now - duCacheTime < DU_CACHE_TTL_MS) {
+    return duCacheValue;
+  }
+  duCacheValue = getDirectorySizeBytes(paths);
+  duCacheTime = now;
+  duCachePaths = key;
+  return duCacheValue;
+}
+
 function getDiskSpaceInfo(): DiskSpaceInfo | null {
   try {
     const wsDir = getWorkspaceDir();
     const diskPath = existsSync(wsDir) ? wsDir : "/";
     const stats = statfsSync(diskPath);
-    const totalBytes = stats.bsize * stats.blocks;
-    const freeBytes = stats.bsize * stats.bavail;
+    const fsTotalBytes = stats.bsize * stats.blocks;
+    const fsFreeBytes = stats.bsize * stats.bavail;
     const bytesToMb = (b: number) =>
       Math.round((b / (1024 * 1024)) * 100) / 100;
+
+    // Minikube mode: the platform passes the PVC storage size so we can
+    // report accurate capacity. On hostPath-backed PVCs statfsSync reports
+    // the host's entire filesystem rather than the PVC. Detect this by
+    // comparing filesystem size against PVC size — if the filesystem is
+    // larger, measure actual directory usage with `du` instead.
+    const storageSizeRaw = getMinikubeStorageSize();
+    if (storageSizeRaw) {
+      const pvcTotalBytes = parseK8sMemoryBytes(storageSizeRaw);
+      if (pvcTotalBytes !== null && fsTotalBytes > pvcTotalBytes * 1.1) {
+        const volumePaths = [diskPath];
+        if (diskPath !== "/data" && existsSync("/data")) {
+          volumePaths.push("/data");
+        }
+        const usedBytes = getCachedDirectorySizeBytes(volumePaths);
+        if (usedBytes !== null) {
+          return {
+            path: diskPath,
+            totalMb: bytesToMb(pvcTotalBytes),
+            usedMb: bytesToMb(usedBytes),
+            freeMb: bytesToMb(Math.max(0, pvcTotalBytes - usedBytes)),
+          };
+        }
+      }
+    }
+
     return {
       path: diskPath,
-      totalMb: bytesToMb(totalBytes),
-      usedMb: bytesToMb(totalBytes - freeBytes),
-      freeMb: bytesToMb(freeBytes),
+      totalMb: bytesToMb(fsTotalBytes),
+      usedMb: bytesToMb(fsTotalBytes - fsFreeBytes),
+      freeMb: bytesToMb(fsFreeBytes),
     };
   } catch {
     return null;
@@ -416,13 +489,7 @@ function getIdentity() {
 
   const version = APP_VERSION;
 
-  let createdAt: string | undefined;
-  try {
-    const stats = statSync(identityPath);
-    createdAt = stats.birthtime.toISOString();
-  } catch {
-    // ignore
-  }
+  const createdAt = resolveIdentityCreatedAt(identityPath);
 
   return {
     name: fields.name ?? "",
@@ -435,10 +502,18 @@ function getIdentity() {
   };
 }
 
+function resolveIdentityCreatedAt(identityPath: string): string | undefined {
+  return resolveHatchedAtReadOnly(identityPath);
+}
+
 function getIdentityIntro() {
-  const soulIntro = readSoulIdentityIntro();
-  if (soulIntro) {
-    return { text: soulIntro };
+  const identityPath = getWorkspacePromptPath("IDENTITY.md");
+  if (existsSync(identityPath)) {
+    const content = readFileSync(identityPath, "utf-8");
+    const fields = parseIdentityFields(content);
+    if (fields.name) {
+      return { text: `Hi, I'm ${fields.name}!` };
+    }
   }
 
   const cached = getCachedIntro();
@@ -448,37 +523,6 @@ function getIdentityIntro() {
   return { text: cached.text };
 }
 
-// ---------------------------------------------------------------------------
-// Identity intro cache
-// ---------------------------------------------------------------------------
-
-/**
- * Parse the `## Identity Intro` section from SOUL.md.
- * Returns the first non-empty line under that heading, or null.
- */
-function readSoulIdentityIntro(): string | null {
-  try {
-    const soulPath = getWorkspacePromptPath("SOUL.md");
-    if (!existsSync(soulPath)) return null;
-    const content = readFileSync(soulPath, "utf-8");
-
-    let inSection = false;
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (/^#+\s/.test(trimmed)) {
-        inSection = trimmed.toLowerCase().includes("identity intro");
-        continue;
-      }
-      if (inSection && trimmed.length > 0) {
-        return trimmed;
-      }
-    }
-  } catch {
-    // Fall through to cache/fallback
-  }
-  return null;
-}
-
 // ---------------------------------------------------------------------------
 // Zod schemas for profiler health metadata
 // ---------------------------------------------------------------------------
@@ -575,7 +619,7 @@ export const ROUTES: RouteDefinition[] = [
     handler: getIdentityIntro,
     summary: "Get identity intro text",
     description:
-      "Returns the cached identity intro string, preferring SOUL.md over LLM-generated cache.",
+      "Returns a deterministic greeting derived from the assistant name in IDENTITY.md, falling back to LLM-generated cache.",
     tags: ["identity"],
     responseBody: z.object({
       text: z.string(),