@vellumai/cli 0.7.0 → 0.7.2

package/src/commands/backup.ts

@@ -1,14 +1,20 @@
 import { mkdirSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 
-import { findAssistantByName } from "../lib/assistant-config";
+import type { AssistantEntry } from "../lib/assistant-config.js";
+import { findAssistantByName } from "../lib/assistant-config.js";
 import { getBackupsDir, formatSize } from "../lib/backup-ops.js";
 import { loadGuardianToken, leaseGuardianToken } from "../lib/guardian-token";
+import { pollJobUntilDone } from "../lib/job-polling.js";
 import {
+  MigrationInProgressError,
+  localRuntimeExportToGcs,
+  localRuntimeIdentity,
+  localRuntimePollJobStatus,
+} from "../lib/local-runtime-client.js";
+import {
+  platformRequestSignedUrl,
   readPlatformToken,
-  platformInitiateExport,
-  platformPollExportStatus,
-  platformDownloadExport,
 } from "../lib/platform-client.js";
 
 export async function backup(): Promise<void> {
@@ -73,7 +79,7 @@ export async function backup(): Promise<void> {
   }
 
   if (cloud === "vellum") {
-    await backupPlatform(name, outputArg, entry.runtimeUrl);
+    await backupPlatform(entry, name, outputArg);
     return;
   }
 
@@ -188,39 +194,87 @@ export async function backup(): Promise<void> {
 }
 
 // ---------------------------------------------------------------------------
-// Platform (Vellum-hosted) backup via Django async migration export
+// Platform-managed (cloud="vellum") backup over GCS.
+//
+// The runtime exports the bundle straight to a platform-issued signed GCS
+// URL; the CLI then downloads from GCS to local disk. Bytes never flow
+// through Django. Same architectural shape as the platform-source half of
+// `vellum teleport`. Output format and success log lines match mode 1
+// (runtime-direct local backup) so users see one consistent UX.
+//
+// Lifecycle: the GCS bucket has a 1-day TTL on `uploads/<org>/*` objects
+// (see `vellum-assistant-platform/django/app/assistant/migration/views.py`
+// and `migration/services.py`). Backup is single-shot with no import to
+// trigger best-effort cleanup, so the bundle sits in GCS up to 24h before
+// TTL deletion. No explicit cleanup endpoint exists; relying on TTL is
+// intentional.
 // ---------------------------------------------------------------------------
-
 async function backupPlatform(
+  entry: AssistantEntry,
   name: string,
   outputArg?: string,
-  runtimeUrl?: string,
 ): Promise<void> {
-  // Step 1 — Authenticate
-  const token = readPlatformToken();
-  if (!token) {
-    console.error("Not logged in. Run 'vellum login' first.");
+  const platformToken = readPlatformToken();
+  if (!platformToken) {
+    console.error(
+      "Not logged in. Run 'vellum login' first (required for platform-managed backup).",
+    );
+    process.exit(1);
+  }
+  // Pin upload, download, and runtime requests to the same platform instance
+  // the assistant lives on. Using `getPlatformUrl()` instead would target
+  // whatever the lockfile / env-var resolves to, which may differ from
+  // `entry.runtimeUrl` for staging/dev assistants and end up signing URLs
+  // for the wrong GCS bucket. Mirrors the teleport bundlePlatformUrl
+  // threading at `cli/src/commands/teleport.ts:1311-1312`.
+  const platformUrl = entry.runtimeUrl;
+  // Track the working platform token across kickoff/poll/download so a
+  // 401-driven refresh during polling stays consistent through the final
+  // signed-download request.
+  let exportPlatformToken = platformToken;
+
+  // Step 0 — Ask the source runtime which version it's running. The bundle
+  // is produced by the daemon (not the CLI), and the CLI version can drift
+  // from the daemon version, so the daemon's version is the authoritative
+  // value to record as the bundle's `min_runtime_version`. Stamping with
+  // `cliPkg.version` here would record an inaccurate compatibility band on
+  // the signed-URL request.
+  let runtimeIdentity: { version: string };
+  try {
+    runtimeIdentity = await localRuntimeIdentity(entry, exportPlatformToken);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(
+      `Error: Could not fetch runtime identity from '${name}': ${msg}`,
+    );
     process.exit(1);
   }
 
-  // Step 2 — Initiate export job
+  // Step 1 — Request a signed upload URL.
+  const { url: uploadUrl, bundleKey } = await platformRequestSignedUrl(
+    {
+      operation: "upload",
+      minRuntimeVersion: runtimeIdentity.version,
+      maxRuntimeVersion: null,
+    },
+    exportPlatformToken,
+    platformUrl,
+  );
+
+  // Step 2 — Kick off runtime export-to-GCS through the platform's
+  // wildcard runtime proxy. `localRuntimeExportToGcs` builds the
+  // `/v1/assistants/<id>/migrations/export-to-gcs` URL for cloud="vellum"
+  // and uses platform-token auth (no guardian-token bootstrap).
   let jobId: string;
   try {
-    const result = await platformInitiateExport(
-      token,
-      "CLI backup",
-      runtimeUrl,
-    );
-    jobId = result.jobId;
+    ({ jobId } = await localRuntimeExportToGcs(entry, exportPlatformToken, {
+      uploadUrl,
+      description: "CLI backup",
+    }));
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("401") || msg.includes("403")) {
-      console.error("Authentication failed. Run 'vellum login' to refresh.");
-      process.exit(1);
-    }
-    if (msg.includes("429")) {
+    if (err instanceof MigrationInProgressError) {
       console.error(
-        "Too many export requests. Please wait before trying again.",
+        `Error: Another backup or teleport export is already in progress on '${entry.assistantId}' (job ${err.existingJobId}). Wait for it to finish, then re-run.`,
       );
       process.exit(1);
     }
@@ -229,65 +283,90 @@ async function backupPlatform(
 
   console.log(`Export started (job ${jobId})...`);
 
-  // Step 3 — Poll for completion
-  const POLL_INTERVAL_MS = 2_000;
-  const TIMEOUT_MS = 5 * 60 * 1_000; // 5 minutes
-  const deadline = Date.now() + TIMEOUT_MS;
-  let downloadUrl: string | undefined;
-
-  while (Date.now() < deadline) {
-    let status: { status: string; downloadUrl?: string; error?: string };
-    try {
-      status = await platformPollExportStatus(jobId, token, runtimeUrl);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      // Let non-transient errors (e.g. 404 "job not found") propagate immediately
-      if (msg.includes("not found")) {
-        throw err;
+  // Step 3 — Poll the job through the wildcard proxy. The dedicated
+  // `/v1/migrations/jobs/{id}/` endpoint queries platform-side ImportJob
+  // records and would 404 on runtime-created job IDs.
+  const terminal = await pollJobUntilDone({
+    label: "platform export",
+    poll: () => localRuntimePollJobStatus(entry, exportPlatformToken, jobId),
+    refreshOn401: async () => {
+      const refreshed = readPlatformToken();
+      if (!refreshed) {
+        throw new Error(
+          "Platform auth expired during export and no credential was found on disk. Run 'vellum login' and retry.",
+        );
       }
-      console.warn(`Polling failed, retrying... (${msg})`);
-      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-      continue;
-    }
+      exportPlatformToken = refreshed;
+    },
+  });
 
-    if (status.status === "complete") {
-      downloadUrl = status.downloadUrl;
-      break;
-    }
-
-    if (status.status === "failed") {
-      console.error(`Export failed: ${status.error ?? "unknown error"}`);
-      process.exit(1);
-    }
-
-    // Still in progress — wait and retry
-    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  if (terminal.status === "failed") {
+    console.error(`Error: Export failed: ${terminal.error}`);
+    process.exit(1);
   }
 
-  if (!downloadUrl) {
-    console.error("Export timed out after 5 minutes.");
+  // Step 4 — Request a signed download URL for the same bundle and fetch
+  // it from GCS directly. No auth on signed URLs.
+  // Use `exportPlatformToken` (not the original `platformToken`) so a
+  // poll-loop 401 refresh doesn't get clobbered here — otherwise a long
+  // export that recovered mid-poll via re-auth would still 401 on the
+  // download-URL request and abort an otherwise successful run.
+  //
+  // We deliberately do NOT send `targetRuntimeVersion` here. This flow
+  // saves the bundle to disk for offline storage; there is no target
+  // runtime to gate against, and the user can later restore the file
+  // into any compatible runtime. Sending the CLI's version would
+  // incorrectly block older CLIs from backing up newer assistants.
+  // The platform treats `target_runtime_version` as optional and skips
+  // the version check when it's omitted.
+  const { url: bundleUrl } = await platformRequestSignedUrl(
+    {
+      operation: "download",
+      bundleKey,
+    },
+    exportPlatformToken,
+    platformUrl,
+  );
+
+  let downloadResponse: Response;
+  try {
+    downloadResponse = await fetch(bundleUrl);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error: Failed to fetch bundle from GCS: ${msg}`);
+    process.exit(1);
+  }
+  if (!downloadResponse.ok) {
+    const body = await downloadResponse.text().catch(() => "");
+    console.error(
+      `Error: Failed to fetch bundle from GCS (${downloadResponse.status}): ${body}`,
+    );
     process.exit(1);
   }
 
-  // Step 4 — Download bundle
+  const arrayBuffer = await downloadResponse.arrayBuffer();
+  const data = new Uint8Array(arrayBuffer);
+
+  // Step 5 — Write to disk using the same path resolution mode 1 uses.
   const isoTimestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const outputPath =
     outputArg || join(getBackupsDir(), `${name}-${isoTimestamp}.vbundle`);
-
   mkdirSync(dirname(outputPath), { recursive: true });
-
-  const response = await platformDownloadExport(downloadUrl);
-  const arrayBuffer = await response.arrayBuffer();
-  const data = new Uint8Array(arrayBuffer);
-
   writeFileSync(outputPath, data);
 
-  // Step 5 — Print success
+  // Step 6 — Print success. Manifest SHA is included only if the runtime
+  // surfaced it via the unified job result; the export-to-gcs runtime
+  // route does not set the legacy `X-Vbundle-Manifest-Sha256` response
+  // header.
   console.log(`Backup saved to ${outputPath}`);
   console.log(`Size: ${formatSize(data.byteLength)}`);
-
-  const manifestSha = response.headers.get("X-Vbundle-Manifest-Sha256");
-  if (manifestSha) {
+  const manifestSha =
+    terminal.status === "complete" &&
+    terminal.result &&
+    typeof terminal.result === "object"
+      ? (terminal.result as Record<string, unknown>).manifest_sha256
+      : undefined;
+  if (typeof manifestSha === "string") {
     console.log(`Manifest SHA-256: ${manifestSha}`);
   }
 }

package/src/commands/client.ts

@@ -3,7 +3,7 @@ import { hostname } from "os";
 import {
   findAssistantByName,
   getActiveAssistant,
-  loadLatestAssistant,
+  resolveAssistant,
 } from "../lib/assistant-config";
 import {
   DAEMON_INTERNAL_ASSISTANT_ID,
@@ -11,7 +11,12 @@ import {
   type Species,
 } from "../lib/constants";
 import { loadGuardianToken } from "../lib/guardian-token";
-import { getLocalLanIPv4, getMacLocalHostname } from "../lib/local";
+import { getLocalLanIPv4 } from "../lib/local";
+import {
+  fetchOrganizationId,
+  readPlatformToken,
+} from "../lib/platform-client";
+import { tuiLog } from "../lib/tui-log";
 
 const ANSI = {
   reset: "\x1b[0m",
@@ -25,6 +30,11 @@ interface ParsedArgs {
   runtimeUrl: string;
   assistantId: string;
   species: Species;
+  /** "vellum" for platform-hosted assistants, undefined for local. */
+  cloud?: string;
+  /** Platform session token (X-Session-Token), set when cloud === "vellum". */
+  platformToken?: string;
+  /** Guardian JWT (Authorization: Bearer), set for local assistants. */
   bearerToken?: string;
   project?: string;
   zone?: string;
@@ -76,8 +86,8 @@ function parseArgs(): ParsedArgs {
       }
     }
     if (!entry && hasExplicitUrl) {
-      // URL provided but active assistant missing or unset — use latest for remaining defaults
-      entry = loadLatestAssistant();
+      // URL provided but active assistant missing or unset — resolve for remaining defaults
+      entry = resolveAssistant();
     } else if (!entry) {
       console.error(
         "No active assistant set. Set one with 'vellum use <name>' or specify a name: 'vellum client <name>'.",
@@ -88,10 +98,17 @@ function parseArgs(): ParsedArgs {
 
   let runtimeUrl = entry?.localUrl || entry?.runtimeUrl || FALLBACK_RUNTIME_URL;
   let assistantId = entry?.assistantId || DAEMON_INTERNAL_ASSISTANT_ID;
-  const bearerToken =
-    loadGuardianToken(entry?.assistantId ?? "")?.accessToken ?? undefined;
+  const cloud = entry?.cloud;
   const species: Species = (entry?.species as Species) ?? "vellum";
 
+  // Platform-hosted assistants use a session token; local assistants use a guardian JWT.
+  const platformToken =
+    cloud === "vellum" ? (readPlatformToken() ?? undefined) : undefined;
+  const bearerToken =
+    cloud === "vellum"
+      ? undefined
+      : (loadGuardianToken(entry?.assistantId ?? "")?.accessToken ?? undefined);
+
   for (let i = 0; i < flagArgs.length; i++) {
     const flag = flagArgs[i];
     if ((flag === "--url" || flag === "-u") && flagArgs[i + 1]) {
@@ -108,6 +125,8 @@ function parseArgs(): ParsedArgs {
     runtimeUrl: maybeSwapToLocalhost(runtimeUrl.replace(/\/+$/, "")),
     assistantId,
     species,
+    cloud,
+    platformToken,
     bearerToken,
     project: entry?.project,
     zone: entry?.zone,
@@ -140,11 +159,6 @@ function maybeSwapToLocalhost(url: string): string {
     }
   }
 
-  const macHost = getMacLocalHostname();
-  if (macHost) {
-    localNames.push(macHost.toLowerCase());
-  }
-
   const lanIp = getLocalLanIPv4();
   if (lanIp) {
     localNames.push(lanIp);
@@ -185,8 +199,34 @@ ${ANSI.bold}EXAMPLES:${ANSI.reset}
 }
 
 export async function client(): Promise<void> {
-  const { runtimeUrl, assistantId, species, bearerToken, project, zone } =
-    parseArgs();
+  const {
+    runtimeUrl,
+    assistantId,
+    species,
+    cloud,
+    platformToken,
+    bearerToken,
+    project,
+    zone,
+  } = parseArgs();
+
+  tuiLog.init();
+  tuiLog.info("session start", { runtimeUrl, assistantId, species, cloud });
+
+  // Build pre-constructed auth headers so all fetch sites share a single object.
+  let auth: Record<string, string> | undefined;
+  if (cloud === "vellum" && platformToken) {
+    const orgId = await fetchOrganizationId(platformToken).catch((err) => {
+      tuiLog.warn("failed to fetch organization id", { err: String(err) });
+      return undefined;
+    });
+    auth = {
+      "X-Session-Token": platformToken,
+      ...(orgId ? { "Vellum-Organization-Id": orgId } : {}),
+    };
+  } else if (bearerToken) {
+    auth = { Authorization: `Bearer ${bearerToken}` };
+  }
 
   const { renderChatApp } = await import("../components/DefaultMainScreen");
 
@@ -197,11 +237,13 @@ export async function client(): Promise<void> {
     assistantId,
     species,
     () => {
+      tuiLog.info("session end (user disconnect)");
+      tuiLog.close();
       app.unmount();
       process.stdout.write("\x1b[2J\x1b[H");
       console.log(`${ANSI.dim}Disconnected.${ANSI.reset}`);
       process.exit(0);
     },
-    { bearerToken, project, zone },
+    { auth, project, zone },
   );
 }

package/src/commands/events.ts

@@ -139,6 +139,9 @@ export async function events(): Promise<void> {
     query,
     headers: getClientRegistrationHeaders(),
   })) {
+    if (!event.message) {
+      continue;
+    }
     if (jsonOutput) {
       console.log(JSON.stringify(event));
     } else {

package/src/commands/exec.ts

@@ -1,10 +1,6 @@
 import { spawn } from "child_process";
 
-import {
-  findAssistantByName,
-  loadLatestAssistant,
-  resolveCloud,
-} from "../lib/assistant-config";
+import { resolveAssistant, resolveCloud } from "../lib/assistant-config";
 import { dockerResourceNames } from "../lib/docker";
 import type { ServiceName } from "../lib/docker";
 import { execAppleContainer } from "../lib/exec-apple-container";
@@ -84,6 +80,9 @@ export async function exec(): Promise<void> {
     console.log(
       "  -it                 Interactive mode with TTY (like docker exec -it)",
     );
+    console.log(
+      "  --timeout <secs>    Timeout in seconds (default: 30, 0 = no timeout)",
+    );
     console.log(
       "  --verbose           Show debug output (SSE events, sentinel parsing)",
     );
@@ -120,12 +119,20 @@ export async function exec(): Promise<void> {
   let serviceRaw = "assistant";
   let interactive = false;
   let verbose = false;
+  let timeoutMs = 30_000;
 
   for (let i = 0; i < preArgs.length; i++) {
     if (preArgs[i] === "--service" && preArgs[i + 1]) {
       serviceRaw = preArgs[++i];
     } else if (preArgs[i] === "-it" || preArgs[i] === "-ti") {
       interactive = true;
+    } else if (preArgs[i] === "--timeout" && preArgs[i + 1]) {
+      const secs = Number(preArgs[++i]);
+      if (!Number.isFinite(secs) || secs < 0) {
+        console.error("Error: --timeout must be a non-negative number.");
+        process.exit(1);
+      }
+      timeoutMs = secs === 0 ? 0 : secs * 1000;
     } else if (preArgs[i] === "--verbose") {
       verbose = true;
     } else if (!preArgs[i].startsWith("-")) {
@@ -135,7 +142,7 @@ export async function exec(): Promise<void> {
 
   const service = normalizeService(serviceRaw);
 
-  const entry = nameArg ? findAssistantByName(nameArg) : loadLatestAssistant();
+  const entry = resolveAssistant(nameArg);
 
   if (!entry) {
     if (nameArg) {
@@ -149,10 +156,19 @@ export async function exec(): Promise<void> {
   const cloud = resolveCloud(entry);
 
   if (cloud === "local") {
-    console.error(
-      "Cannot exec into a local assistant — it runs directly on this machine.",
-    );
-    process.exit(1);
+    const child = spawn(command[0], command.slice(1), { stdio: "inherit" });
+    await new Promise<void>((resolve) => {
+      child.on("close", (code) => {
+        process.exitCode = code ?? 0;
+        resolve();
+      });
+      child.on("error", (err) => {
+        console.error(`Error: ${err.message}`);
+        process.exitCode = 1;
+        resolve();
+      });
+    });
+    return;
   }
 
   if (cloud === "apple-container") {
@@ -200,14 +216,20 @@ export async function exec(): Promise<void> {
       platformUrl: getPlatformUrl(),
     };
 
+    const serviceParam = service === "assistant" ? undefined : service;
+
     if (interactive) {
       // Interactive mode: shell-escape argv and delegate to full terminal
-      await interactiveSession(assistant, shellEscapeArgs(command));
+      await interactiveSession(assistant, shellEscapeArgs(command), serviceParam);
       return;
     }
 
     // Non-interactive: sentinel-based output capture with exit code
-    await nonInteractiveExec(assistant, command, { verbose });
+    await nonInteractiveExec(assistant, command, {
+      verbose,
+      timeoutMs,
+      service: serviceParam,
+    });
     return;
   }
 

package/src/commands/hatch.ts

@@ -15,7 +15,7 @@ import {
   VALID_SPECIES,
 } from "../lib/constants";
 import type { RemoteHost, Species } from "../lib/constants";
-import { buildInitialConfig } from "../lib/config-utils";
+import { buildNestedConfig } from "../lib/config-utils";
 import { hatchDocker } from "../lib/docker";
 import { hatchGcp } from "../lib/gcp";
 import type { PollResult, WatchHatchingResult } from "../lib/gcp";
@@ -32,7 +32,7 @@ export type { PollResult, WatchHatchingResult } from "../lib/gcp";
 const INSTALL_SCRIPT_REMOTE_PATH = "/tmp/vellum-install.sh";
 
 const HATCH_TIMEOUT_MS: Record<Species, number> = {
-  vellum: 2 * 60 * 1000,
+  vellum: 5 * 60 * 1000,
   openclaw: 10 * 60 * 1000,
 };
 const DEFAULT_SPECIES: Species = "vellum";
@@ -123,11 +123,7 @@ export async function buildStartupScript(
   // and export the env var so the daemon reads it on first boot.
   let configWriteBlock = "";
   if (Object.keys(configValues).length > 0) {
-    const configJson = JSON.stringify(
-      buildInitialConfig(configValues),
-      null,
-      2,
-    );
+    const configJson = JSON.stringify(buildNestedConfig(configValues), null, 2);
     configWriteBlock = `
 echo "Writing default workspace config..."
 VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH="/tmp/vellum-initial-config-$$.json"

package/src/commands/login.ts

@@ -3,12 +3,10 @@ import { spawn } from "child_process";
 import { randomBytes } from "crypto";
 
 import {
-  findAssistantByName,
   getActiveAssistant,
-  loadLatestAssistant,
+  resolveAssistant,
   loadAllAssistants,
   removeAssistantEntry,
-  saveAssistantEntry,
   setActiveAssistant,
 } from "../lib/assistant-config";
 import { computeDeviceId } from "../lib/guardian-token";
@@ -26,6 +24,7 @@ import {
   reprovisionAssistantApiKey,
   savePlatformToken,
 } from "../lib/platform-client";
+import { syncCloudAssistants } from "../lib/sync-cloud-assistants";
 
 const LOGIN_TIMEOUT_MS = 120_000; // 2 minutes
 
@@ -205,10 +204,7 @@ export async function login(): Promise<void> {
     // Register the local assistant with the platform (non-fatal).
     // Mirrors the desktop app's LocalAssistantBootstrapService flow.
     try {
-      const activeName = getActiveAssistant();
-      const entry = activeName
-        ? findAssistantByName(activeName)
-        : loadLatestAssistant();
+      const entry = resolveAssistant();
 
       // Skip managed ("vellum") assistants — they are handled by the platform.
       if (entry && entry.cloud !== "vellum") {
@@ -282,36 +278,22 @@ export async function login(): Promise<void> {
     // This ensures `vellum ps` shows managed assistants immediately
     // after login (e.g. after a retire-and-rehatch cycle).
     try {
-      const platformAssistants = await fetchPlatformAssistants(token);
-      const existingIds = new Set(
-        loadAllAssistants()
-          .filter((a) => a.cloud === "vellum")
-          .map((a) => a.assistantId),
-      );
-
-      let synced = 0;
-      for (const pa of platformAssistants) {
-        if (!existingIds.has(pa.id)) {
-          saveAssistantEntry({
-            assistantId: pa.id,
-            runtimeUrl: getPlatformUrl(),
-            cloud: "vellum",
-            species: "vellum",
-            hatchedAt: new Date().toISOString(),
-          });
-          synced++;
+      const result = await syncCloudAssistants();
+      if (result) {
+        const total = result.added + result.removed;
+        if (total > 0) {
+          console.log(
+            `Synced cloud assistants (${result.added} added, ${result.removed} removed).`,
+          );
         }
       }
 
-      if (synced > 0) {
-        console.log(
-          `Synced ${synced} cloud assistant${synced > 1 ? "s" : ""} to local lockfile.`,
-        );
-      }
-
       // If no active assistant is set, activate the first cloud one.
-      if (!getActiveAssistant() && platformAssistants.length > 0) {
-        setActiveAssistant(platformAssistants[0].id);
+      if (!getActiveAssistant()) {
+        const platformAssistants = await fetchPlatformAssistants(token);
+        if (platformAssistants.length > 0) {
+          setActiveAssistant(platformAssistants[0].id);
+        }
       }
     } catch {
       // Non-fatal — login succeeded even if sync fails

package/src/commands/logs.ts

@@ -4,10 +4,7 @@ import { createInterface } from "readline";
 import { watch } from "fs";
 import { join } from "path";
 
-import {
-  findAssistantByName,
-  loadLatestAssistant,
-} from "../lib/assistant-config";
+import { resolveAssistant } from "../lib/assistant-config";
 import type { AssistantEntry } from "../lib/assistant-config";
 import { dockerResourceNames } from "../lib/docker";
 import { getLogDir } from "../lib/xdg-log";
@@ -593,9 +590,7 @@ async function showAwsLogs(
 export async function logs(): Promise<void> {
   const opts = parseArgs();
 
-  const entry = opts.name
-    ? findAssistantByName(opts.name)
-    : loadLatestAssistant();
+  const entry = resolveAssistant(opts.name);
 
   if (!entry) {
     if (opts.name) {