@vellumai/assistant 0.5.16 → 0.6.1

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

@@ -11,6 +11,8 @@
  * results with is_valid flag and detailed error descriptions.
  */
 
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
 import { Database } from "bun:sqlite";
 
 import { z } from "zod";
@@ -27,7 +29,7 @@ import {
 } from "../../util/platform.js";
 import { httpError } from "../http-errors.js";
 import type { RouteDefinition } from "../http-router.js";
-import { buildExportVBundle } from "../migrations/vbundle-builder.js";
+import { streamExportVBundle } from "../migrations/vbundle-builder.js";
 import {
   analyzeImport,
   DefaultPathResolver,
@@ -141,8 +143,10 @@ export async function handleMigrationExport(req: Request): Promise<Response> {
     }
   }
 
+  let cleanup: (() => Promise<void>) | undefined;
+
   try {
-    const { archive, manifest } = buildExportVBundle({
+    const result = await streamExportVBundle({
       // hooksDir is intentionally omitted — hooks now live under workspace/hooks/
       // and are included in the workspace walk. Passing hooksDir separately would
       // export them twice (once as workspace/hooks/... and again as hooks/...).
@@ -170,25 +174,32 @@ export async function handleMigrationExport(req: Request): Promise<Response> {
       },
     });
 
+    cleanup = result.cleanup;
+    const { tempPath, size, manifest } = result;
+
     const timestamp = manifest.created_at.replace(/[:.]/g, "-");
     const filename = `export-${timestamp}.vbundle`;
 
-    const body = archive.buffer.slice(
-      archive.byteOffset,
-      archive.byteOffset + archive.byteLength,
-    ) as ArrayBuffer;
+    const fileStream = createReadStream(tempPath);
+    fileStream.on("close", () => {
+      cleanup?.();
+      cleanup = undefined;
+    });
+
+    const body = Readable.toWeb(fileStream) as unknown as ReadableStream;
 
     return new Response(body, {
       status: 200,
       headers: {
         "Content-Type": "application/octet-stream",
         "Content-Disposition": `attachment; filename="${filename}"`,
-        "Content-Length": String(archive.length),
+        "Content-Length": String(size),
         "X-Vbundle-Schema-Version": manifest.schema_version,
         "X-Vbundle-Manifest-Sha256": manifest.manifest_sha256,
       },
     });
   } catch (err) {
+    await cleanup?.();
     log.error({ err }, "Failed to build export bundle");
     return httpError(
       "INTERNAL_ERROR",

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

@@ -0,0 +1,350 @@
+/**
+ * HTTP route handlers for managed profiler run management.
+ *
+ * Control-plane callers (proxied via vembda) can enumerate, inspect, export,
+ * and delete completed profiler runs without opening a shell on the assistant
+ * pod.
+ *
+ * Routes:
+ *   GET    /v1/profiler/runs              — list all profiler runs
+ *   GET    /v1/profiler/runs/:runId       — detail for a single run
+ *   POST   /v1/profiler/runs/:runId/export — tar.gz export of a single run
+ *   DELETE /v1/profiler/runs/:runId       — delete a completed run
+ */
+
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { z } from "zod";
+
+import {
+  getProfilerMaxBytes,
+  getProfilerRunId,
+} from "../../config/env-registry.js";
+import {
+  rescanRuns,
+  runProfilerSweep,
+} from "../../daemon/profiler-run-store.js";
+import { getLogger } from "../../util/logger.js";
+import { getProfilerRunDir } from "../../util/platform.js";
+import { httpError } from "../http-errors.js";
+import type { RouteDefinition } from "../http-router.js";
+import { createTarGz, MAX_ARCHIVE_BYTES } from "./archive-utils.js";
+
+const log = getLogger("profiler-routes");
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+/**
+ * Read the Bun-generated profiler markdown summary from a run directory.
+ * Bun writes CPU profile summaries as `.md` files; we look for the first
+ * markdown file in the run directory.
+ */
+function readProfileSummary(runDir: string): string | undefined {
+  try {
+    const entries = readdirSync(runDir);
+    const mdFile = entries.find((e) => e.endsWith(".md"));
+    if (!mdFile) return undefined;
+    return readFileSync(join(runDir, mdFile), "utf-8");
+  } catch {
+    return undefined;
+  }
+}
+
+// ── Route handlers ─────────────────────────────────────────────────────
+
+/**
+ * GET /v1/profiler/runs — list all profiler runs with manifest metadata.
+ */
+function handleListRuns(): Response {
+  const manifests = rescanRuns({ readOnly: true });
+
+  // Sort newest-first for the listing
+  manifests.sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+  );
+
+  return Response.json({
+    runs: manifests,
+    totalRuns: manifests.length,
+    activeRunId: getProfilerRunId() ?? null,
+  });
+}
+
+/** Default max total bytes across all completed runs: 500 MB */
+const DEFAULT_MAX_BYTES = 500 * 1024 * 1024;
+
+/**
+ * GET /v1/profiler/runs/:runId — detail view with manifest + markdown summary
+ * plus current budget/retention state.
+ */
+function handleGetRun(runId: string): Response {
+  if (runId.includes("..") || runId.includes("/") || runId.includes("\\")) {
+    return httpError("BAD_REQUEST", "Invalid run ID", 400);
+  }
+
+  // Rescan all runs first to get freshly computed totalBytes for every run,
+  // then find the target run in the results. This avoids using a stale
+  // manifest from the last write-through rescan.
+  const allManifests = rescanRuns({ readOnly: true });
+  const manifest = allManifests.find((m) => m.runId === runId);
+  if (!manifest) {
+    return httpError("NOT_FOUND", `Profiler run '${runId}' not found`, 404);
+  }
+
+  const runDir = getProfilerRunDir(runId);
+  const summary = readProfileSummary(runDir);
+  const activeRunId = getProfilerRunId();
+
+  // Compute budget state from all runs
+  const maxBytes = getProfilerMaxBytes() ?? DEFAULT_MAX_BYTES;
+  const totalBytesAllRuns = allManifests.reduce(
+    (sum, m) => sum + m.totalBytes,
+    0,
+  );
+  const remainingBytes = Math.max(0, maxBytes - totalBytesAllRuns);
+  const overBudget = totalBytesAllRuns > maxBytes;
+
+  return Response.json({
+    ...manifest,
+    summary: summary ?? null,
+    isActive: runId === activeRunId,
+    budget: {
+      maxBytes,
+      totalBytesAllRuns,
+      remainingBytes,
+      overBudget,
+    },
+  });
+}
+
+/**
+ * POST /v1/profiler/runs/:runId/export — package a single run as tar.gz.
+ */
+function handleExportRun(runId: string): Response {
+  if (runId.includes("..") || runId.includes("/") || runId.includes("\\")) {
+    return httpError("BAD_REQUEST", "Invalid run ID", 400);
+  }
+
+  const runDir = getProfilerRunDir(runId);
+  if (!existsSync(runDir)) {
+    return httpError("NOT_FOUND", `Profiler run '${runId}' not found`, 404);
+  }
+
+  // Stage the run directory contents into a temp directory to avoid
+  // including parent path structure in the archive.
+  const staging = mkdtempSync(join(tmpdir(), "vellum-profiler-export-"));
+
+  try {
+    // Copy run directory contents into the staging area
+    copyDirContents(runDir, staging);
+
+    const archiveBytes = createTarGz(staging);
+    if (!archiveBytes) {
+      log.error(
+        { runId },
+        "Profiler run archive exceeds size limit or tar failed",
+      );
+      return httpError(
+        "INTERNAL_ERROR",
+        `Profiler run '${runId}' exceeds the maximum archive size of ${MAX_ARCHIVE_BYTES} bytes`,
+        500,
+      );
+    }
+
+    return new Response(archiveBytes, {
+      status: 200,
+      headers: {
+        "Content-Type": "application/gzip",
+        "Content-Disposition": `attachment; filename="profiler-${runId}.tar.gz"`,
+        "Content-Length": String(archiveBytes.byteLength),
+      },
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err, runId }, "Failed to export profiler run");
+    return httpError(
+      "INTERNAL_ERROR",
+      `Failed to export profiler run: ${message}`,
+      500,
+    );
+  } finally {
+    try {
+      rmSync(staging, { recursive: true, force: true });
+    } catch {
+      // Best-effort cleanup
+    }
+  }
+}
+
+/**
+ * DELETE /v1/profiler/runs/:runId — delete a completed run and recalculate
+ * disk-budget state.
+ */
+function handleDeleteRun(runId: string): Response {
+  if (runId.includes("..") || runId.includes("/") || runId.includes("\\")) {
+    return httpError("BAD_REQUEST", "Invalid run ID", 400);
+  }
+
+  const activeRunId = getProfilerRunId();
+  if (runId === activeRunId) {
+    return httpError(
+      "CONFLICT",
+      `Cannot delete the currently active profiler run '${runId}'`,
+      409,
+    );
+  }
+
+  const runDir = getProfilerRunDir(runId);
+  if (!existsSync(runDir)) {
+    return httpError("NOT_FOUND", `Profiler run '${runId}' not found`, 404);
+  }
+
+  try {
+    rmSync(runDir, { recursive: true, force: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err, runId }, "Failed to delete profiler run directory");
+    return httpError(
+      "INTERNAL_ERROR",
+      `Failed to delete profiler run: ${message}`,
+      500,
+    );
+  }
+
+  // Re-run the sweep to recompute disk-budget state after deletion
+  const sweepResult = runProfilerSweep();
+
+  log.info(
+    { runId, remainingRuns: sweepResult.remainingRuns },
+    "Profiler run deleted",
+  );
+
+  return Response.json({
+    deleted: true,
+    runId,
+    remainingRuns: sweepResult.remainingRuns,
+    activeRunOverBudget: sweepResult.activeRunOverBudget,
+  });
+}
+
+// ── File copying helper ────────────────────────────────────────────────
+
+/**
+ * Recursively copy all files and directories from `src` into `dest`.
+ */
+function copyDirContents(src: string, dest: string): void {
+  const entries = readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    try {
+      const stat = lstatSync(srcPath);
+      // Skip symlinks for defense-in-depth — a symlink inside a run
+      // directory could point outside the run and exfiltrate files.
+      if (stat.isSymbolicLink()) continue;
+      if (stat.isDirectory()) {
+        mkdirSync(destPath, { recursive: true });
+        copyDirContents(srcPath, destPath);
+      } else if (stat.isFile()) {
+        const content = readFileSync(srcPath);
+        writeFileSync(destPath, content);
+      }
+    } catch {
+      // Skip unreadable entries
+    }
+  }
+}
+
+// ── Route definitions ──────────────────────────────────────────────────
+
+export function profilerRouteDefinitions(): RouteDefinition[] {
+  return [
+    {
+      endpoint: "profiler/runs",
+      method: "GET",
+      policyKey: "profiler/runs",
+      summary: "List profiler runs",
+      description:
+        "Enumerate all profiler run directories with manifest metadata, sorted newest-first.",
+      tags: ["profiler"],
+      responseBody: z.object({
+        runs: z.array(
+          z.object({
+            runId: z.string(),
+            status: z.enum(["active", "completed"]),
+            createdAt: z.string(),
+            updatedAt: z.string(),
+            totalBytes: z.number(),
+            completedAt: z.string().optional(),
+          }),
+        ),
+        totalRuns: z.number(),
+        activeRunId: z.string().nullable(),
+      }),
+      handler: () => handleListRuns(),
+    },
+    {
+      endpoint: "profiler/runs/:runId",
+      method: "GET",
+      policyKey: "profiler/runs",
+      summary: "Get profiler run detail",
+      description:
+        "Return manifest metadata, Bun-generated markdown summary, and current retention state for a single profiler run.",
+      tags: ["profiler"],
+      responseBody: z.object({
+        runId: z.string(),
+        status: z.enum(["active", "completed"]),
+        createdAt: z.string(),
+        updatedAt: z.string(),
+        totalBytes: z.number(),
+        completedAt: z.string().optional(),
+        summary: z.string().nullable(),
+        isActive: z.boolean(),
+        budget: z.object({
+          maxBytes: z.number(),
+          totalBytesAllRuns: z.number(),
+          remainingBytes: z.number(),
+          overBudget: z.boolean(),
+        }),
+      }),
+      handler: ({ params }) => handleGetRun(params.runId),
+    },
+    {
+      endpoint: "profiler/runs/:runId/export",
+      method: "POST",
+      policyKey: "profiler/runs/export",
+      summary: "Export profiler run",
+      description:
+        "Package a single profiler run directory as a tar.gz bundle, subject to the same archive size limits used by runtime log exports.",
+      tags: ["profiler"],
+      handler: ({ params }) => handleExportRun(params.runId),
+    },
+    {
+      endpoint: "profiler/runs/:runId",
+      method: "DELETE",
+      policyKey: "profiler/runs",
+      summary: "Delete profiler run",
+      description:
+        "Delete a completed profiler run and recalculate disk-budget state. Rejects deletion of the currently active run.",
+      tags: ["profiler"],
+      responseBody: z.object({
+        deleted: z.boolean(),
+        runId: z.string(),
+        remainingRuns: z.number(),
+        activeRunOverBudget: z.boolean(),
+      }),
+      handler: ({ params }) => handleDeleteRun(params.runId),
+    },
+  ];
+}

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

@@ -7,12 +7,14 @@
 import { z } from "zod";
 
 import { bootstrapConversation } from "../../memory/conversation-bootstrap.js";
+import { getConversation } from "../../memory/conversation-crud.js";
 import {
   cancelSchedule,
   completeScheduleRun,
   createScheduleRun,
   deleteSchedule,
   describeCronExpression,
+  getLastScheduleConversationId,
   getSchedule,
   listSchedules,
   updateSchedule,
@@ -50,6 +52,7 @@ function handleListSchedules(): Response {
       mode: j.mode,
       status: j.status,
       routingIntent: j.routingIntent,
+      reuseConversation: j.reuseConversation,
       isOneShot: j.cronExpression == null,
     })),
   });
@@ -145,6 +148,7 @@ function handleUpdateSchedule(
     "mode",
     "routingIntent",
     "quiet",
+    "reuseConversation",
   ] as const) {
     if (key in body) {
       updates[key] = body[key];
@@ -229,6 +233,7 @@ async function handleRunScheduleNow(
       );
       const fallbackConversation = bootstrapConversation({
         source: "schedule",
+        groupId: "system:scheduled",
         origin: "schedule",
         systemHint: `Schedule (manual): ${schedule.name}`,
       });
@@ -238,29 +243,40 @@ async function handleRunScheduleNow(
     return handleListSchedules();
   }
 
-  // Regular message-based schedule
-  const conversation = bootstrapConversation({
-    source: "schedule",
-    origin: "schedule",
-    systemHint: `Schedule (manual): ${schedule.name}`,
-  });
-  const runId = createScheduleRun(schedule.id, conversation.id);
+  // Regular message-based schedule — respect reuseConversation flag
+  const isRecurring = schedule.expression != null;
+  let conversationId: string | null = null;
+  if (schedule.reuseConversation && isRecurring) {
+    const lastId = getLastScheduleConversationId(schedule.id);
+    if (lastId && getConversation(lastId)) {
+      conversationId = lastId;
+    }
+  }
+  if (!conversationId) {
+    const conversation = bootstrapConversation({
+      source: "schedule",
+      groupId: "system:scheduled",
+      origin: "schedule",
+      systemHint: `Schedule (manual): ${schedule.name}`,
+    });
+    conversationId = conversation.id;
+  }
+  const runId = createScheduleRun(schedule.id, conversationId);
 
   try {
     log.info(
       {
         jobId: schedule.id,
         name: schedule.name,
-        conversationId: conversation.id,
+        conversationId,
       },
       "Executing schedule manually via HTTP (run now)",
     );
     if (!sendMessageDeps) {
       throw new Error("sendMessageDeps not available for schedule execution");
     }
-    const activeConversation = await sendMessageDeps.getOrCreateConversation(
-      conversation.id,
-    );
+    const activeConversation =
+      await sendMessageDeps.getOrCreateConversation(conversationId);
     await activeConversation.processMessage(
       schedule.message,
       [],
@@ -352,6 +368,7 @@ export function scheduleRouteDefinitions(deps: {
           .string()
           .describe("single_channel, multi_channel, or all_channels"),
         quiet: z.boolean(),
+        reuseConversation: z.boolean(),
       }),
       responseBody: z.object({
         schedules: z.array(z.unknown()).describe("Updated schedule list"),

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

@@ -12,11 +12,16 @@ import { join } from "node:path";
 
 import { z } from "zod";
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import {
   getPlatformBaseUrl,
   setIngressPublicBaseUrl,
 } from "../../config/env.js";
-import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
+import {
+  getConfig,
+  loadRawConfig,
+  saveRawConfig,
+} from "../../config/loader.js";
 import { loadSkillCatalog } from "../../config/skills.js";
 import {
   computeGatewayTarget,
@@ -36,6 +41,12 @@ import {
   generateAllowlistOptions,
   generateScopeOptions,
 } from "../../permissions/checker.js";
+import {
+  getMode,
+  onModeChanged,
+  setAskBeforeActing,
+  setHostAccess,
+} from "../../permissions/permission-mode-store.js";
 import { getSecureKeyAsync } from "../../security/secure-keys.js";
 import { parseToolManifestFile } from "../../skills/tool-manifest.js";
 import {
@@ -51,7 +62,7 @@ import { isSideEffectTool } from "../../tools/side-effects.js";
 import { generateAndSaveAvatar } from "../../tools/system/avatar-generator.js";
 import { pathExists } from "../../util/fs.js";
 import { getLogger } from "../../util/logger.js";
-import { getWorkspaceDir } from "../../util/platform.js";
+import { getAvatarImagePath, getWorkspaceDir } from "../../util/platform.js";
 import { buildAssistantEvent } from "../assistant-event.js";
 import { assistantEventHub } from "../assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
@@ -61,6 +72,24 @@ import { resolveWorkspacePath } from "./workspace-utils.js";
 
 const log = getLogger("settings-routes");
 
+// ---------------------------------------------------------------------------
+// Permission mode SSE broadcast
+// ---------------------------------------------------------------------------
+
+onModeChanged((mode) => {
+  assistantEventHub
+    .publish(
+      buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+        type: "permission_mode_update",
+        askBeforeActing: mode.askBeforeActing,
+        hostAccess: mode.hostAccess,
+      }),
+    )
+    .catch((err) => {
+      log.warn({ err }, "Failed to publish permission_mode_update event");
+    });
+});
+
 // ---------------------------------------------------------------------------
 // Voice config
 // ---------------------------------------------------------------------------
@@ -94,12 +123,7 @@ async function handleGenerateAvatar(description: string): Promise<Response> {
       return httpError("INTERNAL_ERROR", result.content, 500);
     }
 
-    const avatarPath = join(
-      getWorkspaceDir(),
-      "data",
-      "avatar",
-      "avatar-image.png",
-    );
+    const avatarPath = getAvatarImagePath();
 
     // Notify all connected SSE clients so every macOS/iOS instance
     // reloads the avatar image immediately.
@@ -897,5 +921,68 @@ export function settingsRouteDefinitions(): RouteDefinition[] {
         }
       },
     },
+
+    // Permission mode (GET always available; PUT gated on feature flag)
+    {
+      endpoint: "permission-mode",
+      method: "GET",
+      policyKey: "permission-mode:GET",
+      summary: "Get permission mode",
+      description:
+        "Return the current two-axis permission mode (askBeforeActing, hostAccess).",
+      tags: ["settings"],
+      responseBody: z.object({
+        askBeforeActing: z.boolean(),
+        hostAccess: z.boolean(),
+      }),
+      handler: () => {
+        const mode = getMode();
+        return Response.json({
+          askBeforeActing: mode.askBeforeActing,
+          hostAccess: mode.hostAccess,
+        });
+      },
+    },
+    {
+      endpoint: "permission-mode",
+      method: "PUT",
+      policyKey: "permission-mode",
+      summary: "Update permission mode",
+      description:
+        "Update the two-axis permission mode. Requires the permission-controls-v2 feature flag.",
+      tags: ["settings"],
+      requestBody: z.object({
+        askBeforeActing: z.boolean().optional(),
+        hostAccess: z.boolean().optional(),
+      }),
+      responseBody: z.object({
+        askBeforeActing: z.boolean(),
+        hostAccess: z.boolean(),
+      }),
+      handler: async ({ req }) => {
+        const config = getConfig();
+        if (!isAssistantFeatureFlagEnabled("permission-controls-v2", config)) {
+          return httpError("NOT_FOUND", "Not found", 404);
+        }
+
+        const body = (await req.json()) as {
+          askBeforeActing?: boolean;
+          hostAccess?: boolean;
+        };
+
+        if (typeof body.askBeforeActing === "boolean") {
+          setAskBeforeActing(body.askBeforeActing);
+        }
+        if (typeof body.hostAccess === "boolean") {
+          setHostAccess(body.hostAccess);
+        }
+
+        const mode = getMode();
+        return Response.json({
+          askBeforeActing: mode.askBeforeActing,
+          hostAccess: mode.hostAccess,
+        });
+      },
+    },
   ];
 }