@vellumai/assistant 0.6.0 → 0.6.2

package/src/cli/commands/memory.ts

@@ -7,7 +7,6 @@ import {
   getMemorySystemStatus,
   queryMemory,
   requestMemoryBackfill,
-  requestMemoryCleanup,
   requestMemoryRebuildIndex,
   requestReextract,
 } from "../../memory/admin.js";
@@ -106,38 +105,6 @@ Examples:
       log.info(`Queued backfill job: ${jobId}`);
     });
 
-  memory
-    .command("cleanup")
-    .description("Queue cleanup jobs for stale superseded items")
-    .option(
-      "--retention-ms <ms>",
-      "Optional retention threshold in milliseconds"
-    )
-    .addHelpText(
-      "after",
-      `
-Queues a background cleanup job to remove memory items that have been
-superseded by newer, corrected facts past the retention threshold.
-
-The optional --retention-ms flag sets the minimum age (in milliseconds) a
-record must have before it is eligible for cleanup. If omitted, the system
-default retention period is used.
-
-Examples:
-  $ assistant memory cleanup
-  $ assistant memory cleanup --retention-ms 86400000`
-    )
-    .action((opts: { retentionMs?: string }) => {
-      initializeDb();
-      const retentionMs = opts.retentionMs
-        ? Number.parseInt(opts.retentionMs, 10)
-        : undefined;
-      requestMemoryCleanup(
-        Number.isFinite(retentionMs) ? retentionMs : undefined
-      );
-      log.info("Memory cleanup requested (legacy items table dropped)");
-    });
-
   memory
     .command("cleanup-segments")
     .description("Remove short segments that waste retrieval budget")
@@ -270,7 +237,7 @@ extraction prompt. This is useful after updating the extraction prompt
 (e.g. importance scoring rework) to re-score and re-extract memories
 from historically important conversations.
 
-The command resets extraction checkpoints so the batch extraction handler
+The command resets extraction checkpoints so the graph extraction handler
 re-processes all messages. Existing memories are provided as supersession
 context — the new extraction can supersede old flat-fact memories with
 richer, properly-scored replacements.

package/src/cli/commands/notifications.ts

@@ -10,6 +10,10 @@ import {
   NOTIFICATION_SOURCE_EVENT_NAMES,
 } from "../../notifications/signal.js";
 import type { NotificationChannel } from "../../notifications/types.js";
+import {
+  initAuthSigningKey,
+  resolveSigningKey,
+} from "../../runtime/auth/token-service.js";
 import { initializeDb } from "../db.js";
 import { log } from "../logger.js";
 import { shouldOutputJson, writeOutput } from "../output.js";
@@ -159,7 +163,7 @@ Examples:
           visibleInSourceNow: boolean;
           deadlineAt?: string;
           preferredChannels?: string;
-          conversationId?: string;
+          sessionId?: string;
           dedupeKey?: string;
         },
         cmd: Command,
@@ -251,8 +255,9 @@ Examples:
           }
 
           initializeDb();
+          initAuthSigningKey(resolveSigningKey());
 
-          const sourceContextId = opts.conversationId ?? `cli-${Date.now()}`;
+          const sourceContextId = opts.sessionId ?? `cli-${Date.now()}`;
 
           const result = await emitNotificationSignal({
             sourceEventName: opts.sourceEventName,

package/src/cli/commands/oauth/__tests__/connect.test.ts

@@ -668,6 +668,33 @@ describe("assistant oauth connect", () => {
     expect(parsed.error).toContain("apps upsert");
   });
 
+  // -------------------------------------------------------------------------
+  // Manual-token providers (slack_channel, telegram)
+  // -------------------------------------------------------------------------
+
+  test("manual-token provider returns error directing to credentials command", async () => {
+    mockGetProvider = () => ({
+      providerKey: "slack_channel",
+      authUrl: "urn:manual-token",
+      tokenUrl: "urn:manual-token",
+      managedServiceConfigKey: null,
+    });
+    mockIsManagedMode = () => false;
+
+    const { exitCode, stdout } = await runCommand([
+      "connect",
+      "slack_channel",
+      "--json",
+    ]);
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("manual token configuration");
+    expect(parsed.error).toContain("assistant credentials set");
+    expect(parsed.error).toContain("--service");
+    expect(parsed.error).toContain("--field");
+  });
+
   // -------------------------------------------------------------------------
   // Orchestrator error propagation
   // -------------------------------------------------------------------------

package/src/cli/commands/oauth/connect.ts

@@ -2,6 +2,7 @@ import { createServer, type Server } from "node:http";
 
 import type { Command } from "commander";
 
+import { getIsContainerized } from "../../../config/env-registry.js";
 import { orchestrateOAuthConnect } from "../../../oauth/connect-orchestrator.js";
 import {
   getAppByProviderAndClientId,
@@ -178,15 +179,23 @@ Examples:
 
             // When opening the browser, start a local server to show a nice
             // completion page instead of redirecting to the platform website.
+            //
+            // In containerized mode the loopback server is unreachable from
+            // the host browser, so redirect to the platform's own completion
+            // page instead.
             let redirectServer:
               | { redirectUrl: string; cleanup: () => void }
               | undefined;
             if (opts.browser !== false) {
-              try {
-                redirectServer = await startManagedRedirectServer(provider);
-                body.redirect_after_connect = redirectServer.redirectUrl;
-              } catch {
-                // Non-fatal — fall back to platform default redirect
+              if (getIsContainerized()) {
+                body.redirect_after_connect = "/account/oauth/desktop-complete";
+              } else {
+                try {
+                  redirectServer = await startManagedRedirectServer(provider);
+                  body.redirect_after_connect = redirectServer.redirectUrl;
+                } catch {
+                  // Non-fatal — fall back to platform default redirect
+                }
               }
             }
 
@@ -327,6 +336,17 @@ Examples:
             // BYO PATH
             // =============================================================
 
+            // Manual-token providers (slack_channel, telegram) don't use
+            // OAuth2 browser flows — credentials are configured via
+            // `assistant credentials` or chat setup instead.
+            if (providerRow.authUrl === "urn:manual-token") {
+              writeError(
+                `"${provider}" uses manual token configuration, not an OAuth browser flow. ` +
+                  `Set the token with: assistant credentials set <token_value> --service ${provider} --field <field_name>`,
+              );
+              return;
+            }
+
             // a. Resolve client credentials from the DB
             const dbApp = opts.clientId
               ? getAppByProviderAndClientId(provider, opts.clientId)

package/src/cli/commands/platform/__tests__/connect.test.ts

@@ -109,7 +109,7 @@ async function runCommand(
   process.exitCode = 0;
 
   try {
-    const program = buildCliProgram();
+    const program = await buildCliProgram();
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {},

package/src/cli/commands/platform/__tests__/disconnect.test.ts

@@ -130,7 +130,7 @@ async function runCommand(
   process.exitCode = 0;
 
   try {
-    const program = buildCliProgram();
+    const program = await buildCliProgram();
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {},

package/src/cli/commands/platform/__tests__/status.test.ts

@@ -110,7 +110,7 @@ async function runCommand(
   process.exitCode = 0;
 
   try {
-    const program = buildCliProgram();
+    const program = await buildCliProgram();
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {},

package/src/cli/commands/routes.ts

@@ -0,0 +1,396 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+
+import type { Command } from "commander";
+
+import { getConfig } from "../../config/loader.js";
+import { getPublicBaseUrl } from "../../inbound/public-ingress-urls.js";
+import { getWorkspaceRoutesDir } from "../../util/platform.js";
+import { log } from "../logger.js";
+
+/** HTTP methods that can be exported from a handler module. */
+const HTTP_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+] as const;
+
+type HttpMethod = (typeof HTTP_METHODS)[number];
+
+/** Supported file extensions for handler modules. */
+const HANDLER_EXTENSIONS = [".ts", ".js"] as const;
+
+type HandlerExtension = (typeof HANDLER_EXTENSIONS)[number];
+
+interface DiscoveredRoute {
+  /** Route path relative to /x/ prefix (e.g. "my-app/status"). */
+  routePath: string;
+  /** Absolute path to the handler file. */
+  filePath: string;
+  /** HTTP methods exported by the handler module. */
+  methods: HttpMethod[];
+  /** Optional description exported by the handler module. */
+  description?: string;
+  /** File size in bytes. */
+  fileSize: number;
+  /** Last modified time as ISO string. */
+  modifiedAt: string;
+}
+
+/**
+ * Load a handler module and extract its exported HTTP methods and description.
+ */
+async function inspectModule(
+  filePath: string,
+): Promise<{ methods: HttpMethod[]; description?: string }> {
+  const stat = statSync(filePath);
+  const mod = (await import(`${filePath}?t=${stat.mtimeMs}`)) as Record<
+    string,
+    unknown
+  >;
+
+  const methods: HttpMethod[] = [];
+  for (const method of HTTP_METHODS) {
+    if (typeof mod[method] === "function") {
+      methods.push(method);
+    }
+  }
+
+  const description =
+    typeof mod.description === "string" ? mod.description : undefined;
+
+  return { methods, description };
+}
+
+/**
+ * Recursively scan the routes directory for handler files (.ts, .js).
+ * Returns discovered routes sorted alphabetically by route path.
+ */
+async function discoverRoutes(routesDir: string): Promise<DiscoveredRoute[]> {
+  if (!existsSync(routesDir)) {
+    return [];
+  }
+
+  const routes: DiscoveredRoute[] = [];
+
+  function scanDir(dir: string): void {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scanDir(fullPath);
+      } else if (entry.isFile()) {
+        const ext = HANDLER_EXTENSIONS.find((e) => entry.name.endsWith(e)) as
+          | HandlerExtension
+          | undefined;
+        if (!ext) continue;
+
+        const relativePath = relative(routesDir, fullPath);
+        const withoutExt = relativePath.slice(0, -ext.length);
+
+        // Convert filesystem path to route path:
+        // - Strip /index suffix for index file convention
+        // - Replace backslashes with forward slashes (Windows compat)
+        let routePath = withoutExt.replace(/\\/g, "/");
+        if (routePath.endsWith("/index")) {
+          routePath = routePath.slice(0, -"/index".length);
+        } else if (routePath === "index") {
+          routePath = "";
+        }
+
+        routes.push({
+          routePath,
+          filePath: fullPath,
+          methods: [],
+          description: undefined,
+          fileSize: 0,
+          modifiedAt: "",
+        });
+      }
+    }
+  }
+
+  scanDir(routesDir);
+
+  // Load each module to detect exported methods and description
+  for (const route of routes) {
+    try {
+      const stat = statSync(route.filePath);
+      route.fileSize = stat.size;
+      route.modifiedAt = stat.mtime.toISOString();
+
+      const { methods, description } = await inspectModule(route.filePath);
+      route.methods = methods;
+      route.description = description;
+    } catch {
+      // If a module fails to load, keep it in the list with empty methods
+    }
+  }
+
+  return routes.sort((a, b) => a.routePath.localeCompare(b.routePath));
+}
+
+/**
+ * Try to resolve the public base URL for building full endpoint URLs.
+ * Returns null if no public URL is configured (non-fatal for CLI display).
+ */
+function tryGetPublicBaseUrl(): string | null {
+  try {
+    const config = getConfig();
+    return getPublicBaseUrl(config);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format a list of HTTP methods for display, abbreviating DELETE to DEL.
+ */
+function formatMethods(methods: HttpMethod[]): string {
+  return methods.map((m) => (m === "DELETE" ? "DEL" : m)).join(",");
+}
+
+export function registerRoutesCommand(program: Command): void {
+  const routes = program
+    .command("routes")
+    .description("Manage user-defined HTTP route handlers under /x/*");
+
+  routes.addHelpText(
+    "after",
+    `
+User-defined routes let you expose custom HTTP endpoints by dropping handler
+files into /workspace/routes/. Each file exports named HTTP method functions
+(GET, POST, etc.) and becomes reachable at /x/<path>.
+
+Routes are managed by creating and deleting files — no add/remove commands
+needed.
+
+Examples:
+  $ assistant routes list
+  $ assistant routes list --json
+  $ assistant routes inspect my-dashboard-api/submit`,
+  );
+
+  routes
+    .command("list")
+    .description("List all user-defined route handlers and their public URLs")
+    .option("--json", "Machine-readable JSON output")
+    .addHelpText(
+      "after",
+      `
+Scans /workspace/routes/ for handler files (.ts, .js) and displays the route
+path, exported HTTP methods, optional description, and file location.
+
+Examples:
+  $ assistant routes list
+  $ assistant routes list --json`,
+    )
+    .action(async (opts: { json?: boolean }) => {
+      try {
+        const routesDir = getWorkspaceRoutesDir();
+        const discovered = await discoverRoutes(routesDir);
+
+        if (opts.json) {
+          const publicBase = tryGetPublicBaseUrl();
+          const items = discovered.map((r) => ({
+            routePath: `/x/${r.routePath}`,
+            methods: r.methods,
+            description: r.description ?? null,
+            filePath: relative(routesDir, r.filePath),
+            publicUrl: publicBase ? `${publicBase}/x/${r.routePath}` : null,
+          }));
+          console.log(JSON.stringify({ ok: true, routes: items }));
+          return;
+        }
+
+        if (discovered.length === 0) {
+          log.info("No route handlers found in /workspace/routes/.");
+          log.info(
+            "Create a .ts or .js file exporting named HTTP method functions (GET, POST, etc.).",
+          );
+          return;
+        }
+
+        const publicBase = tryGetPublicBaseUrl();
+
+        log.info("");
+        // Table header
+        const routeCol = "ROUTE PATH";
+        const methodsCol = "METHODS";
+        const descCol = "DESCRIPTION";
+        const fileCol = "FILE";
+
+        // Calculate column widths
+        const routeWidth = Math.max(
+          routeCol.length,
+          ...discovered.map((r) => `/x/${r.routePath}`.length),
+        );
+        const methodsWidth = Math.max(
+          methodsCol.length,
+          ...discovered.map((r) => formatMethods(r.methods).length),
+        );
+        const descWidth = Math.max(
+          descCol.length,
+          ...discovered.map((r) => (r.description ?? "").length),
+        );
+
+        const header = [
+          routeCol.padEnd(routeWidth),
+          methodsCol.padEnd(methodsWidth),
+          descCol.padEnd(descWidth),
+          fileCol,
+        ].join("    ");
+
+        log.info(`  ${header}`);
+
+        for (const route of discovered) {
+          const cols = [
+            `/x/${route.routePath}`.padEnd(routeWidth),
+            formatMethods(route.methods).padEnd(methodsWidth),
+            (route.description ?? "").padEnd(descWidth),
+            `routes/${relative(routesDir, route.filePath)}`,
+          ].join("    ");
+          log.info(`  ${cols}`);
+        }
+
+        log.info("");
+        const countLabel = discovered.length === 1 ? "route" : "routes";
+        const summary = `${discovered.length} ${countLabel}`;
+        if (publicBase) {
+          log.info(`  ${summary} • Public base: ${publicBase}`);
+        } else {
+          log.info(`  ${summary}`);
+        }
+        log.info("");
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (opts.json) {
+          console.log(JSON.stringify({ ok: false, error: msg }));
+        } else {
+          log.error(`Error: ${msg}`);
+        }
+        process.exitCode = 1;
+      }
+    });
+
+  routes
+    .command("inspect <path>")
+    .description("Show details of a specific user-defined route handler")
+    .option("--json", "Machine-readable JSON output")
+    .addHelpText(
+      "after",
+      `
+Arguments:
+  path   Route path relative to /x/ (e.g. "my-dashboard-api/submit").
+         Do not include the /x/ prefix.
+
+Loads the handler file and displays exported methods, description, file path,
+public URL, file size, and last modified time.
+
+Examples:
+  $ assistant routes inspect my-dashboard-api/submit
+  $ assistant routes inspect items --json`,
+    )
+    .action(async (routePath: string, opts: { json?: boolean }) => {
+      try {
+        const routesDir = getWorkspaceRoutesDir();
+        const filePath = resolveHandlerFile(routesDir, routePath);
+
+        if (!filePath) {
+          const msg = `No handler file found for route path "${routePath}"`;
+          if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: msg }));
+          } else {
+            log.error(msg);
+            log.info("Expected file at one of:");
+            for (const ext of HANDLER_EXTENSIONS) {
+              log.info(`  ${join(routesDir, `${routePath}${ext}`)}`);
+              log.info(`  ${join(routesDir, routePath, `index${ext}`)}`);
+            }
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const stat = statSync(filePath);
+        const { methods, description } = await inspectModule(filePath);
+        const publicBase = tryGetPublicBaseUrl();
+        const publicUrl = publicBase ? `${publicBase}/x/${routePath}` : null;
+
+        if (opts.json) {
+          console.log(
+            JSON.stringify({
+              ok: true,
+              route: {
+                routePath: `/x/${routePath}`,
+                methods,
+                description: description ?? null,
+                filePath,
+                publicUrl,
+                fileSize: stat.size,
+                modifiedAt: stat.mtime.toISOString(),
+              },
+            }),
+          );
+          return;
+        }
+
+        log.info("");
+        log.info(`  Route:       /x/${routePath}`);
+        log.info(
+          `  Methods:     ${methods.join(", ") || "(none)"}  (detected from named exports)`,
+        );
+        if (description) {
+          log.info(`  Description: ${description}`);
+        }
+        log.info(`  File:        ${filePath}`);
+        if (publicUrl) {
+          log.info(`  Public URL:  ${publicUrl}`);
+        }
+        log.info(`  File Size:   ${stat.size} bytes`);
+        log.info(`  Modified:    ${stat.mtime.toISOString()}`);
+        log.info("");
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (opts.json) {
+          console.log(JSON.stringify({ ok: false, error: msg }));
+        } else {
+          log.error(`Error: ${msg}`);
+        }
+        process.exitCode = 1;
+      }
+    });
+}
+
+/**
+ * Resolve a route path to a handler file on disk.
+ * Mirrors the resolution logic from UserRouteDispatcher.
+ */
+function resolveHandlerFile(
+  routesDir: string,
+  routePath: string,
+): string | null {
+  const basePath = join(routesDir, routePath);
+
+  // Direct file match
+  for (const ext of HANDLER_EXTENSIONS) {
+    const candidate = `${basePath}${ext}`;
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  // Index file convention
+  for (const ext of HANDLER_EXTENSIONS) {
+    const candidate = join(basePath, `index${ext}`);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}