@vellumai/cli 0.10.11-dev.202607242127.a6bf2b2 → 0.10.11-staging.2

package/src/__tests__/tailscale-tunnel.test.ts

@@ -1,229 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  normalizeDnsName,
-  resolveServeHostname,
-  shouldClearIngressUrl,
-  startTailscaleServe,
-  stopTailscaleServe,
-  type TailscaleCommandResult,
-  type TailscaleDeps,
-} from "../lib/tailscale-tunnel.js";
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-const tempDirs: string[] = [];
-
-function makeWorkspace(): string {
-  const dir = mkdtempSync(join(tmpdir(), "vellum-tailscale-test-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-const RUNNING_STATUS = JSON.stringify({
-  BackendState: "Running",
-  Self: { DNSName: "my-host.tail-scale.ts.net.", Online: true },
-});
-
-const ok = (stdout = "", stderr = ""): TailscaleCommandResult => ({
-  status: 0,
-  stdout,
-  stderr,
-});
-
-/**
- * Build a fake {@link TailscaleDeps}. `binary` defaults to a present binary;
- * pass `null` to simulate a missing install. `responses` is keyed by the
- * space-joined args; unmatched calls return an empty success result.
- */
-function makeDeps(opts: {
-  binary?: string | null;
-  responses?: Record<string, TailscaleCommandResult>;
-}): { deps: TailscaleDeps; calls: string[][] } {
-  const calls: string[][] = [];
-  const binary = opts.binary === undefined ? "tailscale" : opts.binary;
-  const deps: TailscaleDeps = {
-    findBinary: () => binary,
-    run: (_bin, args) => {
-      calls.push(args);
-      return opts.responses?.[args.join(" ")] ?? ok();
-    },
-  };
-  return { deps, calls };
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// ── normalizeDnsName ────────────────────────────────────────────────────────
-
-describe("normalizeDnsName", () => {
-  test("trims the trailing MagicDNS dot", () => {
-    expect(normalizeDnsName("host.tailnet.ts.net.")).toBe(
-      "host.tailnet.ts.net",
-    );
-  });
-
-  test("leaves a name without a trailing dot unchanged", () => {
-    expect(normalizeDnsName("host.tailnet.ts.net")).toBe("host.tailnet.ts.net");
-  });
-});
-
-// ── resolveServeHostname ──────────────────────────────────────────────────────
-
-describe("resolveServeHostname", () => {
-  test("returns the trimmed Self.DNSName for a running node", () => {
-    expect(resolveServeHostname(RUNNING_STATUS)).toBe(
-      "my-host.tail-scale.ts.net",
-    );
-  });
-
-  test("throws a login hint when logged out", () => {
-    const json = JSON.stringify({ BackendState: "NeedsLogin", Self: {} });
-    expect(() => resolveServeHostname(json)).toThrow("not logged in");
-  });
-
-  test("throws when the backend is not running", () => {
-    const json = JSON.stringify({
-      BackendState: "Stopped",
-      Self: { DNSName: "host.ts.net." },
-    });
-    expect(() => resolveServeHostname(json)).toThrow("not ready");
-  });
-
-  test("throws when the DNS name is missing", () => {
-    const json = JSON.stringify({ BackendState: "Running", Self: {} });
-    expect(() => resolveServeHostname(json)).toThrow("DNS name");
-  });
-
-  test("throws on unparseable JSON", () => {
-    expect(() => resolveServeHostname("not json")).toThrow("Could not parse");
-  });
-});
-
-// ── startTailscaleServe ───────────────────────────────────────────────────────
-
-describe("startTailscaleServe", () => {
-  test("throws install guidance when the binary is missing", async () => {
-    const { deps, calls } = makeDeps({ binary: null });
-    await expect(
-      startTailscaleServe({ port: 7840, workspaceDir: makeWorkspace() }, deps),
-    ).rejects.toThrow("Tailscale is not installed");
-    expect(calls).toHaveLength(0);
-  });
-
-  test("throws a login hint when logged out and never calls serve", async () => {
-    const { deps, calls } = makeDeps({
-      responses: {
-        "status --json": ok(
-          JSON.stringify({ BackendState: "NeedsLogin", Self: {} }),
-        ),
-      },
-    });
-    await expect(
-      startTailscaleServe({ port: 7840, workspaceDir: makeWorkspace() }, deps),
-    ).rejects.toThrow("not logged in");
-    expect(calls).not.toContainEqual(["serve", "--bg", "7840"]);
-  });
-
-  test("throws when the status query fails (daemon down)", async () => {
-    const { deps } = makeDeps({
-      responses: {
-        "status --json": {
-          status: 1,
-          stdout: "",
-          stderr: "failed to connect to local tailscaled",
-        },
-      },
-    });
-    await expect(
-      startTailscaleServe({ port: 7840, workspaceDir: makeWorkspace() }, deps),
-    ).rejects.toThrow("Could not query Tailscale");
-  });
-
-  test("serves the target port and persists the ingress URL on success", async () => {
-    const workspaceDir = makeWorkspace();
-    const { deps, calls } = makeDeps({
-      responses: {
-        "status --json": ok(RUNNING_STATUS),
-        "serve --bg 7840": ok(),
-      },
-    });
-
-    const info = await startTailscaleServe({ port: 7840, workspaceDir }, deps);
-
-    expect(info.publicUrl).toBe("https://my-host.tail-scale.ts.net");
-    expect(info.port).toBe(7840);
-    expect(info.viaIngress).toBe(false);
-    expect(calls).toContainEqual(["serve", "--bg", "7840"]);
-
-    const config = JSON.parse(
-      readFileSync(join(workspaceDir, "config.json"), "utf-8"),
-    );
-    expect(config.ingress.publicBaseUrl).toBe(
-      "https://my-host.tail-scale.ts.net",
-    );
-    expect(config.ingress.enabled).toBe(true);
-  });
-
-  test("surfaces tailscale's enable-URL guidance when serve is not enabled", async () => {
-    const workspaceDir = makeWorkspace();
-    const enableUrl = "https://login.tailscale.com/f/serve?node=abc123";
-    const { deps } = makeDeps({
-      responses: {
-        "status --json": ok(RUNNING_STATUS),
-        "serve --bg 7840": {
-          status: 1,
-          stdout: "",
-          stderr: `error: Serve is not enabled on your tailnet.\n\nTo enable, visit:\n  ${enableUrl}`,
-        },
-      },
-    });
-
-    await expect(
-      startTailscaleServe({ port: 7840, workspaceDir }, deps),
-    ).rejects.toThrow(enableUrl);
-
-    // A failed serve must not persist an ingress URL.
-    expect(existsSync(join(workspaceDir, "config.json"))).toBe(false);
-  });
-});
-
-// ── stopTailscaleServe ────────────────────────────────────────────────────────
-
-describe("stopTailscaleServe", () => {
-  test("turns off the HTTPS:443 serve (narrow off form)", () => {
-    const { deps, calls } = makeDeps({
-      responses: { "serve --https=443 off": ok() },
-    });
-    const result = stopTailscaleServe("tailscale", deps);
-    expect(result.status).toBe(0);
-    expect(calls).toContainEqual(["serve", "--https=443", "off"]);
-  });
-});
-
-// ── shouldClearIngressUrl ─────────────────────────────────────────────────────
-
-describe("shouldClearIngressUrl", () => {
-  test("clears only after a confirmed successful stop", () => {
-    expect(shouldClearIngressUrl({ status: 0, stdout: "", stderr: "" })).toBe(
-      true,
-    );
-  });
-
-  test("keeps the URL when the stop command fails", () => {
-    expect(
-      shouldClearIngressUrl({ status: 1, stdout: "", stderr: "boom" }),
-    ).toBe(false);
-  });
-
-  test("keeps the URL when the stop command threw before running", () => {
-    expect(shouldClearIngressUrl(null)).toBe(false);
-  });
-});

package/src/lib/environments/__tests__/detect.test.ts

@@ -1,101 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  crossEnvironmentAssistantHint,
-  detectOtherEnvironmentAssistants,
-} from "../detect.js";
-import { getSeed } from "../resolve.js";
-
-const prod = getSeed("production")!;
-
-/** Create `<XDG_DATA_HOME>/vellum-<env>/assistants/<id>/` for a non-prod env. */
-function seedAssistantDir(dataHome: string, envName: string, id: string): void {
-  mkdirSync(join(dataHome, `vellum-${envName}`, "assistants", id), {
-    recursive: true,
-  });
-}
-
-describe("cross-environment assistant detection", () => {
-  let dataHome: string;
-  let prevXdg: string | undefined;
-  let prevEnv: string | undefined;
-
-  beforeEach(() => {
-    prevXdg = process.env.XDG_DATA_HOME;
-    prevEnv = process.env.VELLUM_ENVIRONMENT;
-    dataHome = mkdtempSync(join(tmpdir(), "cli-detect-xdg-"));
-    process.env.XDG_DATA_HOME = dataHome;
-    // Pin the current env so the hint's "this CLI targets '<env>'" copy and
-    // the current-env skip are deterministic regardless of machine config.
-    process.env.VELLUM_ENVIRONMENT = "production";
-  });
-
-  afterEach(() => {
-    if (prevXdg === undefined) {
-      delete process.env.XDG_DATA_HOME;
-    } else {
-      process.env.XDG_DATA_HOME = prevXdg;
-    }
-    if (prevEnv === undefined) {
-      delete process.env.VELLUM_ENVIRONMENT;
-    } else {
-      process.env.VELLUM_ENVIRONMENT = prevEnv;
-    }
-    rmSync(dataHome, { recursive: true, force: true });
-  });
-
-  test("finds an env whose data dir holds an assistant subdirectory", () => {
-    seedAssistantDir(dataHome, "dev", "dev-bot");
-    expect(detectOtherEnvironmentAssistants(prod)).toContain("dev");
-  });
-
-  test("reports every other env that holds assistants", () => {
-    seedAssistantDir(dataHome, "dev", "dev-bot");
-    seedAssistantDir(dataHome, "staging", "staging-bot");
-    const others = detectOtherEnvironmentAssistants(prod);
-    expect(others).toContain("dev");
-    expect(others).toContain("staging");
-  });
-
-  test("skips the current environment even when it holds assistants", () => {
-    // production's own multi-instance dir (no env suffix).
-    mkdirSync(join(dataHome, "vellum", "assistants", "prod-bot"), {
-      recursive: true,
-    });
-    expect(detectOtherEnvironmentAssistants(prod)).toEqual([]);
-  });
-
-  test("ignores an env dir that holds no assistant subdirectory", () => {
-    mkdirSync(join(dataHome, "vellum-dev", "assistants"), { recursive: true });
-    expect(detectOtherEnvironmentAssistants(prod)).toEqual([]);
-  });
-
-  test("returns empty when no env data dirs exist", () => {
-    expect(detectOtherEnvironmentAssistants(prod)).toEqual([]);
-  });
-
-  test("swallows fs errors (data root is a file, not a dir) and returns empty", () => {
-    const filePath = join(dataHome, "not-a-dir");
-    writeFileSync(filePath, "x");
-    process.env.XDG_DATA_HOME = filePath;
-    expect(detectOtherEnvironmentAssistants(prod)).toEqual([]);
-    expect(crossEnvironmentAssistantHint()).toBeNull();
-  });
-
-  test("hint names the env, the current env, and both fixes", () => {
-    seedAssistantDir(dataHome, "dev", "dev-bot");
-    const hint = crossEnvironmentAssistantHint();
-    expect(hint).not.toBeNull();
-    expect(hint).toContain("'dev'");
-    expect(hint).toContain("This CLI targets 'production'");
-    expect(hint).toContain("Install vellum Command");
-    expect(hint).toContain("VELLUM_ENVIRONMENT=dev");
-  });
-
-  test("hint is null when no other env has assistants", () => {
-    expect(crossEnvironmentAssistantHint()).toBeNull();
-  });
-});

package/src/lib/environments/detect.ts

@@ -1,79 +0,0 @@
-import { readdirSync } from "fs";
-
-import { SEEDS, type EnvironmentDefinition } from "@vellumai/environments";
-
-import { getMultiInstanceDir } from "./paths.js";
-import { getCurrentEnvironment } from "./resolve.js";
-
-/**
- * Names of OTHER environments (every seed except `currentEnv`) whose
- * multi-instance data dir exists and holds at least one assistant
- * subdirectory.
- *
- * Each environment has its own on-host data layout — see
- * {@link getMultiInstanceDir}. A user who hatched via a dev/staging desktop
- * app but runs the production npm CLI (or vice versa) targets a different
- * layout than the app did, so the assistant the app created is invisible to
- * this CLI. This cheap filesystem scan surfaces that split so callers can
- * point the user at the environment that actually holds their assistants.
- *
- * Never throws: a missing or unreadable dir just means that environment has no
- * discoverable assistants, so it is skipped. Returns an empty array on any
- * error.
- */
-export function detectOtherEnvironmentAssistants(
-  currentEnv: EnvironmentDefinition,
-): string[] {
-  const found: string[] = [];
-  for (const env of Object.values(SEEDS)) {
-    if (env.name === currentEnv.name) {
-      continue;
-    }
-    try {
-      const hasAssistant = readdirSync(getMultiInstanceDir(env), {
-        withFileTypes: true,
-      }).some((dirent) => dirent.isDirectory());
-      if (hasAssistant) {
-        found.push(env.name);
-      }
-    } catch {
-      // Missing or unreadable dir — this environment has no discoverable
-      // assistants. Skip it.
-    }
-  }
-  return found;
-}
-
-/**
- * One-line hint appended to "no assistant found" and "gateway unreachable"
- * errors when another environment's data dir holds assistants. A first-time
- * user who hatched via a dev/staging desktop app while running the production
- * npm CLI otherwise gets a bare failure with no clue the two tools target
- * different environments.
- *
- * Returns null when nothing is found so callers can append unconditionally:
- * `message + (crossEnvironmentAssistantHint() ?? "")`. Detection failure never
- * propagates — the caller's original error must survive intact.
- */
-export function crossEnvironmentAssistantHint(): string | null {
-  let currentEnv: EnvironmentDefinition;
-  let others: string[];
-  try {
-    currentEnv = getCurrentEnvironment();
-    others = detectOtherEnvironmentAssistants(currentEnv);
-  } catch {
-    return null;
-  }
-  if (others.length === 0) {
-    return null;
-  }
-
-  const quoted = others.map((name) => `'${name}'`).join(", ");
-  const noun = others.length > 1 ? "environments" : "environment";
-  return (
-    `\n\nFound assistants in the ${quoted} ${noun} (managed by a dev/staging ` +
-    `desktop app). This CLI targets '${currentEnv.name}'. Use the desktop ` +
-    `app's 'Install vellum Command…' menu item to get a matching CLI, or ` +
-    `set VELLUM_ENVIRONMENT=${others[0]}.`
-  );
-}

package/src/lib/ingress-config.ts

@@ -1,101 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-import {
-  lookupAssistantByIdentifier,
-  saveAssistantEntry,
-} from "./assistant-config.js";
-
-/**
- * Shared workspace-config helpers for tunnel providers (ngrok, cloudflare,
- * tailscale) and the nginx ingress proxy. Each provider fronts the local edge
- * and records the resulting public URL under `ingress.publicBaseUrl` so webhook
- * integrations can reach the assistant. The workspace config is the
- * gateway-facing contract; when an `assistantId` is supplied, the URL is also
- * mirrored onto the lockfile entry (`ingressUrl`) — the CLI-owned contract
- * that CLI features (e.g. remote-web pairing defaults) read, per the
- * no-`.vellum/`-reads boundary in cli/AGENTS.md.
- */
-
-/** Default workspace dir: `$VELLUM_WORKSPACE_DIR` or `~/.vellum/workspace`. */
-export function getDefaultWorkspaceDir(): string {
-  return (
-    process.env.VELLUM_WORKSPACE_DIR?.trim() ||
-    join(homedir(), ".vellum", "workspace")
-  );
-}
-
-function getConfigPath(workspaceDir: string): string {
-  return join(workspaceDir, "config.json");
-}
-
-/** Read the workspace `config.json`, or an empty object when it is absent. */
-export function loadRawConfig(workspaceDir: string): Record<string, unknown> {
-  const configPath = getConfigPath(workspaceDir);
-  if (!existsSync(configPath)) return {};
-  return JSON.parse(readFileSync(configPath, "utf-8")) as Record<
-    string,
-    unknown
-  >;
-}
-
-/** Write the workspace `config.json`, creating parent directories as needed. */
-export function saveRawConfig(
-  workspaceDir: string,
-  config: Record<string, unknown>,
-): void {
-  const configPath = getConfigPath(workspaceDir);
-  mkdirSync(dirname(configPath), { recursive: true });
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-}
-
-/** Mirror the ingress URL onto the lockfile entry; null removes it. */
-function stampLockfileIngressUrl(
-  assistantId: string,
-  publicUrl: string | null,
-): void {
-  const result = lookupAssistantByIdentifier(assistantId);
-  if (result.status !== "found") {
-    return;
-  }
-  const entry = result.entry;
-  if (publicUrl) {
-    entry.ingressUrl = publicUrl;
-  } else {
-    delete entry.ingressUrl;
-  }
-  saveAssistantEntry(entry);
-}
-
-/** Persist a public ingress URL to the workspace config and enable ingress. */
-export function saveIngressUrl(
-  workspaceDir: string,
-  publicUrl: string,
-  assistantId?: string,
-): void {
-  const config = loadRawConfig(workspaceDir);
-  const ingress = (config.ingress ?? {}) as Record<string, unknown>;
-  ingress.publicBaseUrl = publicUrl;
-  ingress.enabled = true;
-  config.ingress = ingress;
-  saveRawConfig(workspaceDir, config);
-  if (assistantId) {
-    stampLockfileIngressUrl(assistantId, publicUrl);
-  }
-}
-
-/** Clear the ingress public base URL from the workspace config. */
-export function clearIngressUrl(
-  workspaceDir: string,
-  assistantId?: string,
-): void {
-  const config = loadRawConfig(workspaceDir);
-  const ingress = (config.ingress ?? {}) as Record<string, unknown>;
-  delete ingress.publicBaseUrl;
-  config.ingress = ingress;
-  saveRawConfig(workspaceDir, config);
-  if (assistantId) {
-    stampLockfileIngressUrl(assistantId, null);
-  }
-}