@vellumai/cli 0.11.6 → 0.11.7-staging.2

package/src/lib/provider-secrets.ts

@@ -73,10 +73,31 @@ const PROVIDER_LABELS: Record<LlmProviderId, string> = {
   minimax: "MiniMax",
   atlascloud: "Atlas Cloud",
   together: "Together AI",
+  litellm: "LiteLLM",
+  opencode: "OpenCode",
   baseten: "Baseten",
   poolside: "Poolside",
 };
 
+// litellm and opencode are deliberately excluded: they have no fixed default
+// model (endpoint-supplied catalogs), so they cannot back llm.defaultProvider
+// (see DEFAULT_PROVIDER_CHOICES in assistant/src/config/schemas/llm.ts).
+// Picking them here would collect a key the assistant then never uses, since
+// resolveHatchDefaultProvider falls back to anthropic instead.
+export const HATCH_PROVIDER_CHOICES: readonly LlmProviderId[] = [
+  "anthropic",
+  "openai",
+  "gemini",
+  "openrouter",
+  "vercel-ai-gateway",
+  "fireworks",
+  "together",
+  "minimax",
+  "atlascloud",
+  "baseten",
+  "poolside",
+];
+
 export function formatProviderName(provider: LlmProviderId): string {
   return PROVIDER_LABELS[provider];
 }
@@ -107,6 +128,32 @@ export function resolveHatchProvider(
   return provider;
 }
 
+// Distinguishes an explicit `--config` provider from resolveHatchProvider's
+// silent fallback to Anthropic, without duplicating its resolution order.
+export function hasExplicitHatchProvider(
+  configValues: Record<string, string | undefined>,
+): boolean {
+  return resolveConfiguredMainAgentProvider(configValues) !== undefined;
+}
+
+export interface ShouldPromptForHatchProviderOptions {
+  configValues: Record<string, string | undefined>;
+  setupProviderCredentials: boolean;
+  hasProviderApiKey: boolean;
+  stdinIsTTY: boolean | undefined;
+}
+
+export function shouldPromptForHatchProvider(
+  options: ShouldPromptForHatchProviderOptions,
+): boolean {
+  return (
+    options.setupProviderCredentials &&
+    !options.hasProviderApiKey &&
+    !hasExplicitHatchProvider(options.configValues) &&
+    !!options.stdinIsTTY
+  );
+}
+
 function resolveConfiguredMainAgentProvider(
   configValues: Record<string, string | undefined>,
 ): string | undefined {
@@ -423,6 +470,154 @@ export async function promptSecret(
   });
 }
 
+// Unlike promptSecret, never enables raw mode: a numbered choice needs no
+// masking, so canonical-mode line editing (backspace, etc.) comes free.
+//
+// Reads via a shared line buffer rather than a one-off listener so that
+// pasted or piped input containing multiple lines isn't lost: any lines
+// beyond the first stay queued for the next readLine() call on the same
+// reader (see promptProviderChoice, which reuses one reader across retries).
+function createLineReader(input: NodeJS.ReadStream): {
+  readLine(): Promise<string>;
+  dispose(): void;
+} {
+  let buffered = "";
+  const queuedLines: string[] = [];
+  let waitingResolve: ((line: string) => void) | null = null;
+  // Ctrl-D (EOF) fires "end" with no trailing newline, so a pending read
+  // would otherwise wait forever. Treat EOF as a blank line: any read
+  // already waiting, and every read requested afterward, resolves to "".
+  let ended = false;
+
+  const onData = (chunk: Buffer | string): void => {
+    buffered += chunk.toString();
+    let newlineIndex: number;
+    while ((newlineIndex = buffered.search(/[\r\n]/)) !== -1) {
+      const terminatorLength =
+        buffered[newlineIndex] === "\r" && buffered[newlineIndex + 1] === "\n"
+          ? 2
+          : 1;
+      const line = buffered.slice(0, newlineIndex);
+      buffered = buffered.slice(newlineIndex + terminatorLength);
+
+      if (waitingResolve) {
+        const resolve = waitingResolve;
+        waitingResolve = null;
+        resolve(line);
+      } else {
+        queuedLines.push(line);
+      }
+    }
+  };
+
+  const onEnd = (): void => {
+    ended = true;
+    if (waitingResolve) {
+      const resolve = waitingResolve;
+      waitingResolve = null;
+      resolve("");
+    }
+  };
+
+  input.resume();
+  input.on("data", onData);
+  input.on("end", onEnd);
+
+  return {
+    readLine(): Promise<string> {
+      const queued = queuedLines.shift();
+      if (queued !== undefined) {
+        return Promise.resolve(queued);
+      }
+      if (ended) {
+        return Promise.resolve("");
+      }
+      return new Promise((resolve) => {
+        waitingResolve = resolve;
+      });
+    },
+    dispose(): void {
+      input.removeListener("data", onData);
+      input.removeListener("end", onEnd);
+      input.pause();
+    },
+  };
+}
+
+export async function promptLine(
+  prompt: string,
+  streams: {
+    input?: NodeJS.ReadStream;
+    output?: NodeJS.WriteStream;
+  } = {},
+): Promise<string> {
+  const input = streams.input ?? process.stdin;
+  const output = streams.output ?? process.stdout;
+
+  output.write(prompt);
+
+  const reader = createLineReader(input);
+  try {
+    return await reader.readLine();
+  } finally {
+    reader.dispose();
+  }
+}
+
+export interface PromptProviderChoiceOptions {
+  input?: NodeJS.ReadStream;
+  output?: NodeJS.WriteStream;
+  choices?: readonly LlmProviderId[];
+}
+
+// Resolves null on blank input: the caller's signal to keep whatever
+// resolveHatchProvider already picked.
+export async function promptProviderChoice(
+  options: PromptProviderChoiceOptions = {},
+): Promise<LlmProviderId | null> {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const choices = options.choices ?? HATCH_PROVIDER_CHOICES;
+
+  output.write(
+    "No LLM provider API key was found in your environment.\n" +
+      "Choose a provider to use for this assistant:\n\n",
+  );
+  choices.forEach((provider, index) => {
+    const suffix = index === 0 ? " (default)" : "";
+    output.write(`  ${index + 1}) ${formatProviderName(provider)}${suffix}\n`);
+  });
+  output.write("\n");
+
+  const defaultLabel = formatProviderName(choices[0]);
+  const reader = createLineReader(input);
+  try {
+    for (;;) {
+      output.write(
+        `Enter a number (1-${choices.length}), or press Enter to keep the default (${defaultLabel}): `,
+      );
+      const answer = (await reader.readLine()).trim();
+
+      if (answer === "") {
+        return null;
+      }
+
+      if (/^\d+$/.test(answer)) {
+        const index = Number(answer);
+        if (index >= 1 && index <= choices.length) {
+          return choices[index - 1];
+        }
+      }
+
+      output.write(
+        `Please enter a number between 1 and ${choices.length}, or press Enter to skip.\n`,
+      );
+    }
+  } finally {
+    reader.dispose();
+  }
+}
+
 export async function ensureProviderApiKey(
   options: EnsureProviderApiKeyOptions,
 ): Promise<EnsureProviderApiKeyResult> {

package/src/lib/shell-arg.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+
+import { shellArg } from "./shell-arg.js";
+
+describe("shellArg", () => {
+  test("leaves plainly inert values alone", () => {
+    for (const value of ["jarvis", "assistant-1", "jarvis-2.0_beta"]) {
+      expect(shellArg(value)).toBe(value);
+    }
+  });
+
+  test("quotes values a shell would otherwise interpret", () => {
+    // Assistant names and ids are only checked for path separators, so all of
+    // these can reach a printed command.
+    expect(shellArg("My Assistant")).toBe("'My Assistant'");
+    expect(shellArg("Bob&Alice")).toBe("'Bob&Alice'");
+    expect(shellArg("My $team")).toBe("'My $team'");
+    expect(shellArg("a`whoami`")).toBe("'a`whoami`'");
+  });
+
+  test("closes, escapes, and reopens around an embedded single quote", () => {
+    expect(shellArg("Bob's box")).toBe(`'Bob'\\''s box'`);
+  });
+});

package/src/lib/shell-arg.ts

@@ -0,0 +1,17 @@
+/** Names that survive a shell verbatim; everything else has to be quoted. */
+const SHELL_SAFE_ARG = /^[A-Za-z0-9._-]+$/;
+
+/**
+ * One free-form value as a single shell word, for commands printed for the
+ * user to paste. Assistant names and ids are only checked for path separators
+ * when they are created, so `Bob&Alice` and `My $team` both reach here.
+ *
+ * Single quotes are the only ones that also neutralize `$`, backticks and
+ * backslashes, and an embedded one closes the quote, escapes itself, and
+ * reopens.
+ */
+export function shellArg(value: string): string {
+  return SHELL_SAFE_ARG.test(value)
+    ? value
+    : `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/src/lib/tunnel-edge.ts

@@ -1,5 +1,7 @@
 import type { ChildProcess } from "child_process";
 
+import { selectRestartTunnelRecord } from "@vellumai/service-contracts/ingress";
+
 import {
   loadAllAssistants,
   loadAllAssistantsAcrossEnvs,
@@ -21,6 +23,7 @@ import {
 } from "./nginx-ingress.js";
 import { waitForDaemonReady } from "./http-client.js";
 import { hasWebhookIntegrations, maybeStartNgrokTunnel } from "./ngrok.js";
+import { shellArg } from "./shell-arg.js";
 
 /** Matches the Docker hatch path's service-readiness allowance. */
 export const DOCKER_GATEWAY_READY_TIMEOUT_MS = 5 * 60_000;
@@ -54,6 +57,32 @@ function wantsTunnelEdge(workspaceDir: string): boolean {
   }
 }
 
+/**
+ * The `vellum tunnel` invocation that rebuilds this assistant's edge. That
+ * command requires `--provider`, and a `<provider>` placeholder would be shell
+ * redirection rather than something to paste, so name the provider recorded
+ * here; with none recorded, point at the help that lists them.
+ *
+ * The assistant is named too: an unqualified run targets the active assistant,
+ * which on a computer running several is not the one being restored.
+ */
+function tunnelRestartCommand(
+  workspaceDir: string,
+  assistantId: string,
+): string {
+  try {
+    const record = selectRestartTunnelRecord(
+      loadRawConfig(workspaceDir).ingress,
+    );
+    if (record) {
+      return `vellum tunnel ${shellArg(assistantId)} --provider ${record.provider}`;
+    }
+  } catch {
+    // An unreadable config names no provider; the help pointer still holds.
+  }
+  return "vellum tunnel --help";
+}
+
 /**
  * Listen port of an SPA edge still serving in front of `gatewayPort`, or null
  * when nothing verifiably fronts that gateway (an unrecorded upstream port is
@@ -123,7 +152,7 @@ export async function restoreTunnelEdge(
           ? "Webhooks still work, but the web app is not being served."
           : "The web app and webhook delivery are unavailable until it is rebuilt.";
     console.warn(
-      `   Could not restore the tunnel edge: ${detail} ${impact} Run \`vellum tunnel\` to rebuild the edge.`,
+      `   Could not restore the tunnel edge: ${detail} ${impact} Run \`${tunnelRestartCommand(workspaceDir, assistantId)}\` to rebuild the edge.`,
     );
     return survivingPort;
   }
@@ -226,7 +255,7 @@ export async function restoreContainerTunnelEdge(
     !(await waitForDaemonReady(gatewayPort, gatewayReadyTimeoutMs))
   ) {
     console.warn(
-      `   Gateway on 127.0.0.1:${gatewayPort} did not come up, so the tunnel edge was not restored. Run \`vellum tunnel\` once it is running.`,
+      `   Gateway on 127.0.0.1:${gatewayPort} did not come up, so the tunnel edge was not restored. Run \`${tunnelRestartCommand(workspaceDir, entry.assistantId)}\` once it is running.`,
     );
     return;
   }

package/src/shared/provider-env-vars.ts

@@ -31,6 +31,7 @@ export const LLM_PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
   atlascloud: "ATLASCLOUD_API_KEY",
   together: "TOGETHER_API_KEY",
   litellm: "LITELLM_API_KEY",
+  opencode: "OPENCODE_API_KEY",
   baseten: "BASETEN_API_KEY",
   poolside: "POOLSIDE_API_KEY",
 };