@vellumai/cli 0.8.4 → 0.8.6

package/src/commands/roadmap.ts

@@ -0,0 +1,449 @@
+import { readPlatformToken, getWebUrl } from "../lib/platform-client.js";
+
+function printUsage(): void {
+  console.log("Usage: vellum roadmap <subcommand>");
+  console.log("");
+  console.log("Manage roadmap items.");
+  console.log("");
+  console.log("Subcommands:");
+  console.log(
+    "  list     [--query <q>] [--status <s>] [--tag <slug>] [--sort upvotes|created] [--limit <n>]",
+  );
+  console.log("  get      <slug>");
+  console.log(
+    "  create   --title <title> [--description <desc>] [--tag <slug>...]",
+  );
+  console.log(
+    "  update   <slug> [--title <title>] [--description <desc>] [--status <s>] [--tag <slug>...]",
+  );
+  console.log("  delete   <slug>");
+  console.log("  upvote   <slug>");
+  console.log("  unvote   <slug>");
+  console.log("");
+  console.log("Examples:");
+  console.log('  $ vellum roadmap list --query "dark mode"');
+  console.log("  $ vellum roadmap list --status planned --sort upvotes");
+  console.log("  $ vellum roadmap get my-feature-slug");
+  console.log('  $ vellum roadmap create --title "Add dark mode"');
+  console.log(
+    '  $ vellum roadmap update my-feature --status planned --tag integrations',
+  );
+  console.log("  $ vellum roadmap upvote my-feature-slug");
+}
+
+function consumeValue(args: string[], i: number, flag: string): string {
+  const next = args[i + 1];
+  if (next === undefined || next.startsWith("--")) {
+    console.error(`Error: ${flag} requires a value.`);
+    process.exit(1);
+  }
+  return next;
+}
+
+function requireAuth(): string {
+  const token = readPlatformToken();
+  if (!token) {
+    console.error("Not logged in. Run `vellum login` first.");
+    process.exit(1);
+  }
+  return token;
+}
+
+function requireSlug(args: string[], command: string): string {
+  const slug = args[0];
+  if (!slug || slug.startsWith("--")) {
+    console.error(`Usage: vellum roadmap ${command} <slug>`);
+    process.exit(1);
+  }
+  return slug;
+}
+
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /[\x00-\x08\x0b-\x1f\x7f]|\x1b(?:\[[0-9;]*[A-Za-z]|\].*?(?:\x07|\x1b\\))/g;
+function sanitize(text: string): string {
+  return text.replace(ANSI_RE, "");
+}
+
+function makeLink(url: string): string {
+  return `\x1b]8;;${url}\x1b\\${url}\x1b]8;;\x1b\\`;
+}
+
+async function apiFetch(
+  path: string,
+  options: {
+    method?: string;
+    token?: string;
+    body?: Record<string, unknown>;
+    params?: Record<string, string>;
+  } = {},
+): Promise<Response> {
+  const webUrl = getWebUrl();
+  let url = `${webUrl}/api/marketing${path}`;
+  if (options.params) {
+    const qs = new URLSearchParams(options.params).toString();
+    if (qs) url += `?${qs}`;
+  }
+
+  const headers: Record<string, string> = {};
+  if (options.token) headers["X-Session-Token"] = options.token;
+  if (options.body) headers["Content-Type"] = "application/json";
+
+  return fetch(url, {
+    method: options.method ?? "GET",
+    headers,
+    body: options.body ? JSON.stringify(options.body) : undefined,
+  });
+}
+
+async function handleError(
+  response: Response,
+  action: string,
+): Promise<never> {
+  const text = await response.text().catch(() => "");
+  console.error(`Failed to ${action} (${response.status}): ${text}`);
+  process.exit(1);
+}
+
+// ── list ──
+
+interface ListItem {
+  slug: string;
+  title: string;
+  status: string;
+  upvote_count: number;
+  comment_count: number;
+  tags: { slug: string; name: string }[];
+  viewer_upvoted: boolean | null;
+}
+
+async function roadmapList(args: string[]): Promise<void> {
+  const params: Record<string, string> = {};
+  const token = readPlatformToken() ?? undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--query":
+      case "-q":
+        params.q = consumeValue(args, i, "--query");
+        i++;
+        break;
+      case "--status":
+        params.status = consumeValue(args, i, "--status");
+        i++;
+        break;
+      case "--tag":
+        params.tag = consumeValue(args, i, "--tag");
+        i++;
+        break;
+      case "--sort":
+        params.sort = consumeValue(args, i, "--sort");
+        i++;
+        break;
+      case "--limit":
+        params.limit = consumeValue(args, i, "--limit");
+        i++;
+        break;
+      case "--offset":
+        params.offset = consumeValue(args, i, "--offset");
+        i++;
+        break;
+    }
+  }
+
+  const response = await apiFetch("/v1/roadmap", { params, token });
+  if (!response.ok) return handleError(response, "list roadmap items");
+
+  const data = (await response.json()) as {
+    items: ListItem[];
+    total: number;
+  };
+
+  if (data.items.length === 0) {
+    console.log("No roadmap items found.");
+    return;
+  }
+
+  const webUrl = getWebUrl();
+  console.log(`Showing ${data.items.length} of ${data.total} items:\n`);
+
+  for (const item of data.items) {
+    const upvoted = item.viewer_upvoted ? " (upvoted)" : "";
+    const tags = item.tags.length > 0
+      ? ` [${item.tags.map((t) => sanitize(t.slug)).join(", ")}]`
+      : "";
+    console.log(
+      `  ${sanitize(item.title)}  ▲${item.upvote_count}${upvoted}  💬${item.comment_count}  ${item.status}${tags}`,
+    );
+    console.log(`    ${makeLink(`${webUrl}/roadmap/${item.slug}`)}`);
+  }
+}
+
+// ── get ──
+
+async function roadmapGet(args: string[]): Promise<void> {
+  const slug = requireSlug(args, "get");
+  const token = readPlatformToken() ?? undefined;
+  const response = await apiFetch(`/v1/roadmap/${slug}`, { token });
+  if (!response.ok) return handleError(response, "get roadmap item");
+
+  const item = (await response.json()) as {
+    slug: string;
+    title: string;
+    description: string;
+    status: string;
+    upvote_count: number;
+    comment_count: number;
+    tags: { slug: string; name: string }[];
+    viewer_upvoted: boolean | null;
+    creator_username: string;
+    created: string;
+    comments: {
+      id: string;
+      author_username: string;
+      author_is_staff: boolean;
+      body: string;
+      created: string;
+    }[];
+  };
+
+  const webUrl = getWebUrl();
+  const upvoted = item.viewer_upvoted ? " (upvoted)" : "";
+  const tags =
+    item.tags.length > 0
+      ? item.tags.map((t) => sanitize(t.slug)).join(", ")
+      : "none";
+
+  console.log(sanitize(item.title));
+  console.log(`  slug:     ${item.slug}`);
+  console.log(`  status:   ${item.status}`);
+  console.log(`  upvotes:  ${item.upvote_count}${upvoted}`);
+  console.log(`  tags:     ${tags}`);
+  console.log(`  by:       ${sanitize(item.creator_username)}`);
+  console.log(`  created:  ${item.created}`);
+  console.log(`  url:      ${makeLink(`${webUrl}/roadmap/${item.slug}`)}`);
+  if (item.description) {
+    console.log(`\n${sanitize(item.description)}`);
+  }
+
+  if (item.comments.length > 0) {
+    console.log(`\nComments (${item.comments.length}):`);
+    for (const c of item.comments) {
+      const staff = c.author_is_staff ? " [staff]" : "";
+      console.log(`  ${sanitize(c.author_username)}${staff} (${c.created}):`);
+      console.log(`    ${sanitize(c.body)}`);
+    }
+  }
+}
+
+// ── create ──
+
+async function roadmapCreate(args: string[]): Promise<void> {
+  let title: string | undefined;
+  let description: string | undefined;
+  const tags: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--title":
+        title = consumeValue(args, i, "--title");
+        i++;
+        break;
+      case "--description":
+        description = consumeValue(args, i, "--description");
+        i++;
+        break;
+      case "--tag":
+        tags.push(consumeValue(args, i, "--tag"));
+        i++;
+        break;
+    }
+  }
+
+  if (!title) {
+    console.error("Error: --title is required.");
+    console.error('Usage: vellum roadmap create --title "My feature request"');
+    process.exitCode = 1;
+    return;
+  }
+
+  const token = requireAuth();
+  const body: Record<string, unknown> = { title };
+  if (description) body.description = description;
+  if (tags.length > 0) body.tags = tags;
+
+  const response = await apiFetch("/v1/roadmap", {
+    method: "POST",
+    token,
+    body,
+  });
+  if (!response.ok) return handleError(response, "create roadmap item");
+
+  const item = (await response.json()) as {
+    slug: string;
+    title: string;
+    status: string;
+  };
+
+  const webUrl = getWebUrl();
+  console.log(`Created roadmap item: ${sanitize(item.title)}`);
+  console.log(`  slug:   ${item.slug}`);
+  console.log(`  status: ${item.status}`);
+  console.log(`  url:    ${makeLink(`${webUrl}/roadmap/${item.slug}`)}`);
+}
+
+// ── update ──
+
+async function roadmapUpdate(args: string[]): Promise<void> {
+  const slug = requireSlug(args, "update");
+
+  let title: string | undefined;
+  let description: string | undefined;
+  let status: string | undefined;
+  const tags: string[] = [];
+
+  for (let i = 1; i < args.length; i++) {
+    switch (args[i]) {
+      case "--title":
+        title = consumeValue(args, i, "--title");
+        i++;
+        break;
+      case "--description":
+        description = consumeValue(args, i, "--description");
+        i++;
+        break;
+      case "--status":
+        status = consumeValue(args, i, "--status");
+        i++;
+        break;
+      case "--tag":
+        tags.push(consumeValue(args, i, "--tag"));
+        i++;
+        break;
+    }
+  }
+
+  const body: Record<string, unknown> = {};
+  if (title !== undefined) body.title = title;
+  if (description !== undefined) body.description = description;
+  if (status !== undefined) body.status = status;
+  if (tags.length > 0) body.tags = tags;
+
+  if (Object.keys(body).length === 0) {
+    console.error("Error: at least one field to update is required.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const token = requireAuth();
+  const response = await apiFetch(`/v1/roadmap/${slug}`, {
+    method: "PATCH",
+    token,
+    body,
+  });
+  if (!response.ok) return handleError(response, "update roadmap item");
+
+  const item = (await response.json()) as {
+    slug: string;
+    title: string;
+    status: string;
+  };
+
+  const webUrl = getWebUrl();
+  console.log(`Updated roadmap item: ${sanitize(item.title)}`);
+  console.log(`  slug:   ${item.slug}`);
+  console.log(`  status: ${item.status}`);
+  console.log(`  url:    ${makeLink(`${webUrl}/roadmap/${item.slug}`)}`);
+}
+
+// ── delete ──
+
+async function roadmapDelete(args: string[]): Promise<void> {
+  const slug = requireSlug(args, "delete");
+  const token = requireAuth();
+  const response = await apiFetch(`/v1/roadmap/${slug}`, {
+    method: "DELETE",
+    token,
+  });
+  if (!response.ok) return handleError(response, "delete roadmap item");
+
+  console.log(`Deleted roadmap item: ${slug}`);
+}
+
+// ── upvote / unvote ──
+
+async function roadmapUpvote(args: string[]): Promise<void> {
+  const slug = requireSlug(args, "upvote");
+  const token = requireAuth();
+  const response = await apiFetch(`/v1/roadmap/${slug}/upvote`, {
+    method: "POST",
+    token,
+  });
+  if (!response.ok) return handleError(response, "upvote roadmap item");
+
+  const data = (await response.json()) as {
+    slug: string;
+    upvote_count: number;
+  };
+
+  console.log(`Upvoted: ${data.slug} (${data.upvote_count} total)`);
+}
+
+async function roadmapUnvote(args: string[]): Promise<void> {
+  const slug = requireSlug(args, "unvote");
+  const token = requireAuth();
+  const response = await apiFetch(`/v1/roadmap/${slug}/upvote`, {
+    method: "DELETE",
+    token,
+  });
+  if (!response.ok) return handleError(response, "remove upvote");
+
+  const data = (await response.json()) as {
+    slug: string;
+    upvote_count: number;
+  };
+
+  console.log(`Removed upvote: ${data.slug} (${data.upvote_count} total)`);
+}
+
+// ── main ──
+
+export async function roadmap(): Promise<void> {
+  const args = process.argv.slice(3);
+  const sub = args[0];
+
+  if (!sub || sub === "--help" || sub === "-h") {
+    printUsage();
+    return;
+  }
+
+  switch (sub) {
+    case "list":
+    case "ls":
+      await roadmapList(args.slice(1));
+      break;
+    case "get":
+    case "show":
+      await roadmapGet(args.slice(1));
+      break;
+    case "create":
+      await roadmapCreate(args.slice(1));
+      break;
+    case "update":
+      await roadmapUpdate(args.slice(1));
+      break;
+    case "delete":
+    case "rm":
+      await roadmapDelete(args.slice(1));
+      break;
+    case "upvote":
+      await roadmapUpvote(args.slice(1));
+      break;
+    case "unvote":
+      await roadmapUnvote(args.slice(1));
+      break;
+    default:
+      console.error(`Unknown subcommand: ${sub}`);
+      printUsage();
+      process.exitCode = 1;
+  }
+}

package/src/commands/rollback.ts

@@ -4,9 +4,10 @@ import {
   findAssistantByName,
   getActiveAssistant,
   loadAllAssistants,
+  resolveCloud,
   saveAssistantEntry,
+  type AssistantEntry,
 } from "../lib/assistant-config";
-import type { AssistantEntry } from "../lib/assistant-config";
 import {
   captureImageRefs,
   GATEWAY_INTERNAL_PORT,
@@ -90,19 +91,6 @@ function parseArgs(): { name: string | null; version: string | null } {
   return { name, version };
 }
 
-function resolveCloud(entry: AssistantEntry): string {
-  if (entry.cloud) {
-    return entry.cloud;
-  }
-  if (entry.project) {
-    return "gcp";
-  }
-  if (entry.sshUser) {
-    return "custom";
-  }
-  return "local";
-}
-
 /**
  * Resolve which assistant to target for the rollback command. Priority:
  * 1. Explicit name argument

package/src/commands/ssh.ts

@@ -1,7 +1,10 @@
 import { spawn } from "child_process";
 
-import { resolveAssistant } from "../lib/assistant-config";
-import type { AssistantEntry } from "../lib/assistant-config";
+import {
+  extractHostFromUrl,
+  resolveAssistant,
+  resolveCloud,
+} from "../lib/assistant-config";
 import { dockerResourceNames } from "../lib/docker";
 import { getPlatformUrl, readPlatformToken } from "../lib/platform-client";
 import { sshAppleContainer } from "../lib/ssh-apple-container";
@@ -18,28 +21,6 @@ const SSH_OPTS = [
   "LogLevel=ERROR",
 ];
 
-function resolveCloud(entry: AssistantEntry): string {
-  if (entry.cloud) {
-    return entry.cloud;
-  }
-  if (entry.project) {
-    return "gcp";
-  }
-  if (entry.sshUser) {
-    return "custom";
-  }
-  return "local";
-}
-
-function extractHostFromUrl(url: string): string {
-  try {
-    const parsed = new URL(url);
-    return parsed.hostname;
-  } catch {
-    return url.replace(/^https?:\/\//, "").split(":")[0];
-  }
-}
-
 export async function ssh(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {

package/src/commands/teleport.ts

@@ -3,10 +3,11 @@ import {
   loadAllAssistants,
   getDaemonPidPath,
   removeAssistantEntry,
+  resolveCloud,
   saveAssistantEntry,
   setActiveAssistant,
+  type AssistantEntry,
 } from "../lib/assistant-config.js";
-import type { AssistantEntry } from "../lib/assistant-config.js";
 import {
   loadGuardianToken,
   leaseGuardianToken,
@@ -214,12 +215,6 @@ export function parseArgs(argv: string[]): {
   return { from, to, targetEnv, targetName, keepSource, dryRun, help };
 }
 
-function resolveCloud(entry: AssistantEntry): string {
-  return (
-    entry.cloud || (entry.project ? "gcp" : entry.sshUser ? "custom" : "local")
-  );
-}
-
 // ---------------------------------------------------------------------------
 // Auth helper — same pattern as restore.ts
 // ---------------------------------------------------------------------------
@@ -228,7 +223,7 @@ async function getAccessToken(
   runtimeUrl: string,
   assistantId: string,
   displayName: string,
-  options?: { forceRefresh?: boolean },
+  options?: { forceRefresh?: boolean; bootstrapSecret?: string },
 ): Promise<string> {
   // When forceRefresh is set (e.g. after a runtime 401 on the cached token)
   // we skip the cache and lease a brand-new token from the gateway, so a
@@ -242,7 +237,11 @@ async function getAccessToken(
   }
 
   try {
-    const freshToken = await leaseGuardianToken(runtimeUrl, assistantId);
+    const freshToken = await leaseGuardianToken(
+      runtimeUrl,
+      assistantId,
+      options?.bootstrapSecret,
+    );
     return freshToken.accessToken;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -281,11 +280,15 @@ function isRuntime401(err: unknown): boolean {
  * — propagates to the caller.
  */
 async function callRuntimeWithAuthRetry<T>(
-  runtimeUrl: string,
-  assistantId: string,
+  entry: AssistantEntry,
   fn: (token: string) => Promise<T>,
 ): Promise<T> {
-  const firstToken = await getAccessToken(runtimeUrl, assistantId, assistantId);
+  const firstToken = await getAccessToken(
+    entry.runtimeUrl,
+    entry.assistantId,
+    entry.assistantId,
+    { bootstrapSecret: entry.guardianBootstrapSecret },
+  );
   try {
     return await fn(firstToken);
   } catch (err) {
@@ -293,10 +296,13 @@ async function callRuntimeWithAuthRetry<T>(
       throw err;
     }
     const refreshedToken = await getAccessToken(
-      runtimeUrl,
-      assistantId,
-      assistantId,
-      { forceRefresh: true },
+      entry.runtimeUrl,
+      entry.assistantId,
+      entry.assistantId,
+      {
+        forceRefresh: true,
+        bootstrapSecret: entry.guardianBootstrapSecret,
+      },
     );
     return await fn(refreshedToken);
   }
@@ -386,8 +392,7 @@ async function exportFromAssistant(
     let sourceRuntimeVersion: string;
     try {
       const identity = await callRuntimeWithAuthRetry(
-        entry.runtimeUrl,
-        entry.assistantId,
+        entry,
         async (token) => localRuntimeIdentity(entry, token),
       );
       sourceRuntimeVersion = identity.version;
@@ -423,8 +428,7 @@ async function exportFromAssistant(
     let accessToken: string;
     try {
       const result = await callRuntimeWithAuthRetry(
-        entry.runtimeUrl,
-        entry.assistantId,
+        entry,
         async (token) => {
           const r = await localRuntimeExportToGcs(entry, token, {
             uploadUrl,
@@ -462,7 +466,10 @@ async function exportFromAssistant(
           entry.runtimeUrl,
           entry.assistantId,
           entry.assistantId,
-          { forceRefresh: true },
+          {
+            forceRefresh: true,
+            bootstrapSecret: entry.guardianBootstrapSecret,
+          },
         );
       },
     });
@@ -728,8 +735,7 @@ async function importToAssistant(
     let targetRuntimeVersion: string;
     try {
       const identity = await callRuntimeWithAuthRetry(
-        entry.runtimeUrl,
-        entry.assistantId,
+        entry,
         (token) => localRuntimeIdentity(entry, token),
       );
       targetRuntimeVersion = identity.version;
@@ -774,8 +780,7 @@ async function importToAssistant(
     let accessToken: string;
     try {
       const result = await callRuntimeWithAuthRetry(
-        entry.runtimeUrl,
-        entry.assistantId,
+        entry,
         async (token) => {
           const r = await localRuntimeImportFromGcs(entry, token, {
             bundleUrl,
@@ -806,7 +811,10 @@ async function importToAssistant(
           entry.runtimeUrl,
           entry.assistantId,
           entry.assistantId,
-          { forceRefresh: true },
+          {
+            forceRefresh: true,
+            bootstrapSecret: entry.guardianBootstrapSecret,
+          },
         );
       },
     });