@vellumai/cli 0.10.12-dev.202607250047.75b9ec6 → 0.10.12-staging.1

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/local-hatch-lock.ts

@@ -1,322 +0,0 @@
-import { execFileSync } from "child_process";
-import { createHash, randomUUID } from "crypto";
-import {
-  closeSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  statSync,
-  unlinkSync,
-  utimesSync,
-  writeFileSync,
-} from "fs";
-import { hostname, userInfo } from "os";
-import { dirname, join } from "path";
-
-const DEFAULT_TIMEOUT_MS = 240_000;
-const DEFAULT_RETRY_MS = 100;
-const MAX_LOCK_AGE_MS = DEFAULT_TIMEOUT_MS - 60_000;
-const HEARTBEAT_INTERVAL_MS = 30_000;
-const LIVE_OWNER_RECOVERY_GRACE_MS = 10_000;
-
-interface LocalHatchLockOptions {
-  lockPath?: string;
-  liveOwnerRecoveryGraceMs?: number;
-  timeoutMs?: number;
-  retryMs?: number;
-}
-
-interface LockOwner {
-  pid: number;
-  processStartedAt?: string;
-  token: string;
-}
-
-interface LockSnapshot {
-  owner?: LockOwner;
-  signature: string;
-}
-
-export function resolveLocalHatchLockPath(): string {
-  const machineKey = createHash("sha256")
-    .update(hostname())
-    .digest("hex")
-    .slice(0, 12);
-  return join(
-    userInfo().homedir,
-    ".cache",
-    "vellum",
-    "runtime",
-    machineKey,
-    "local-hatch.lock",
-  );
-}
-
-function processIsAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return (error as NodeJS.ErrnoException).code === "EPERM";
-  }
-}
-
-function processStartedAt(pid: number): string | undefined {
-  try {
-    const value = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-      timeout: 1_000,
-    }).trim();
-    return value || undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function parseOwner(raw: string): LockOwner | undefined {
-  try {
-    const parsed = JSON.parse(raw) as {
-      pid?: unknown;
-      processStartedAt?: unknown;
-      token?: unknown;
-    };
-    if (
-      typeof parsed.pid === "number" &&
-      Number.isInteger(parsed.pid) &&
-      parsed.pid > 0 &&
-      typeof parsed.token === "string" &&
-      parsed.token.length > 0
-    ) {
-      return {
-        pid: parsed.pid,
-        processStartedAt:
-          typeof parsed.processStartedAt === "string" &&
-          parsed.processStartedAt.length > 0
-            ? parsed.processStartedAt
-            : undefined,
-        token: parsed.token,
-      };
-    }
-  } catch {}
-  return undefined;
-}
-
-function readSnapshot(path: string): LockSnapshot | undefined {
-  try {
-    const raw = readFileSync(path, "utf-8");
-    return {
-      owner: parseOwner(raw),
-      signature: createHash("sha256").update(raw).digest("hex"),
-    };
-  } catch {
-    return undefined;
-  }
-}
-
-function readOwner(path: string): LockOwner | undefined {
-  return readSnapshot(path)?.owner;
-}
-
-function fileAgeMs(path: string): number | undefined {
-  try {
-    return Date.now() - statSync(path).mtimeMs;
-  } catch {
-    return undefined;
-  }
-}
-
-const expiredLiveOwners = new Map<string, number>();
-
-function ownerIsActive(
-  path: string,
-  owner: LockOwner | undefined,
-  liveOwnerRecoveryGraceMs: number,
-): boolean {
-  const ageMs = fileAgeMs(path);
-  if (!owner) {
-    return ageMs !== undefined && ageMs < MAX_LOCK_AGE_MS;
-  }
-  if (!processIsAlive(owner.pid)) {
-    return false;
-  }
-  if (owner.processStartedAt) {
-    const currentStartedAt = processStartedAt(owner.pid);
-    if (currentStartedAt) {
-      expiredLiveOwners.delete(owner.token);
-      return currentStartedAt === owner.processStartedAt;
-    }
-  }
-  if (ageMs !== undefined && ageMs < MAX_LOCK_AGE_MS) {
-    expiredLiveOwners.delete(owner.token);
-    return true;
-  }
-
-  const firstExpiredAt = expiredLiveOwners.get(owner.token) ?? Date.now();
-  expiredLiveOwners.set(owner.token, firstExpiredAt);
-  if (Date.now() - firstExpiredAt < liveOwnerRecoveryGraceMs) {
-    return true;
-  }
-  return false;
-}
-
-function writeOwnerFile(path: string, owner: LockOwner): void {
-  const fd = openSync(path, "wx", 0o600);
-  try {
-    writeFileSync(fd, JSON.stringify(owner) + "\n");
-  } finally {
-    closeSync(fd);
-  }
-}
-
-function acquireRecoveryClaim(
-  lockPath: string,
-  staleSignature: string,
-  owner: LockOwner,
-  liveOwnerRecoveryGraceMs: number,
-): (() => void) | undefined {
-  const recoveryKey = staleSignature.slice(0, 16);
-  for (let generation = 0; generation < 100; generation++) {
-    const claimPath = `${lockPath}.recovery-${recoveryKey}-${generation}`;
-    try {
-      writeOwnerFile(claimPath, owner);
-      return () => releaseLock(claimPath, owner.token);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "EEXIST") {
-        throw error;
-      }
-      if (
-        ownerIsActive(claimPath, readOwner(claimPath), liveOwnerRecoveryGraceMs)
-      ) {
-        return undefined;
-      }
-    }
-  }
-  return undefined;
-}
-
-function removeStaleLock(
-  lockPath: string,
-  recoveryOwner: LockOwner,
-  liveOwnerRecoveryGraceMs: number,
-): boolean {
-  const staleSnapshot = readSnapshot(lockPath);
-  if (!staleSnapshot) {
-    return true;
-  }
-  if (ownerIsActive(lockPath, staleSnapshot.owner, liveOwnerRecoveryGraceMs)) {
-    return false;
-  }
-
-  const releaseRecoveryClaim = acquireRecoveryClaim(
-    lockPath,
-    staleSnapshot.signature,
-    recoveryOwner,
-    liveOwnerRecoveryGraceMs,
-  );
-  if (!releaseRecoveryClaim) {
-    return false;
-  }
-
-  try {
-    const currentSnapshot = readSnapshot(lockPath);
-    if (!currentSnapshot) {
-      return true;
-    }
-    if (currentSnapshot.signature !== staleSnapshot.signature) {
-      return false;
-    }
-    if (
-      ownerIsActive(lockPath, currentSnapshot.owner, liveOwnerRecoveryGraceMs)
-    ) {
-      return false;
-    }
-    try {
-      unlinkSync(lockPath);
-      return true;
-    } catch (error) {
-      return (error as NodeJS.ErrnoException).code === "ENOENT";
-    }
-  } finally {
-    releaseRecoveryClaim();
-  }
-}
-
-function releaseLock(lockPath: string, token: string): void {
-  if (readOwner(lockPath)?.token !== token) {
-    return;
-  }
-  try {
-    unlinkSync(lockPath);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-      throw error;
-    }
-  }
-}
-
-function refreshLock(lockPath: string, token: string): void {
-  if (readOwner(lockPath)?.token !== token) {
-    return;
-  }
-  try {
-    const now = new Date();
-    utimesSync(lockPath, now, now);
-  } catch {}
-}
-
-/**
- * Serialize local assistant startup across CLI processes. Port availability is
- * machine-wide even when callers use different lockfile or XDG directories,
- * so allocation must remain exclusive until the new services have bound their
- * ports and the assistant entry has been persisted.
- */
-export async function withLocalHatchLock<T>(
-  action: () => Promise<T>,
-  options: LocalHatchLockOptions = {},
-): Promise<T> {
-  const lockPath = options.lockPath ?? resolveLocalHatchLockPath();
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const retryMs = options.retryMs ?? DEFAULT_RETRY_MS;
-  const liveOwnerRecoveryGraceMs =
-    options.liveOwnerRecoveryGraceMs ?? LIVE_OWNER_RECOVERY_GRACE_MS;
-  const deadline = Date.now() + timeoutMs;
-  const owner: LockOwner = {
-    pid: process.pid,
-    processStartedAt: processStartedAt(process.pid),
-    token: `${process.pid}-${randomUUID()}`,
-  };
-
-  mkdirSync(dirname(lockPath), { recursive: true, mode: 0o700 });
-
-  while (true) {
-    try {
-      writeOwnerFile(lockPath, owner);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "EEXIST") {
-        throw error;
-      }
-      if (removeStaleLock(lockPath, owner, liveOwnerRecoveryGraceMs)) {
-        continue;
-      }
-      if (Date.now() >= deadline) {
-        throw new Error(
-          `Timed out waiting for another local assistant to finish starting (${lockPath})`,
-        );
-      }
-      await new Promise((resolve) => setTimeout(resolve, retryMs));
-      continue;
-    }
-
-    const heartbeat = setInterval(
-      () => refreshLock(lockPath, owner.token),
-      HEARTBEAT_INTERVAL_MS,
-    );
-    try {
-      return await action();
-    } finally {
-      clearInterval(heartbeat);
-      releaseLock(lockPath, owner.token);
-    }
-  }
-}

package/src/lib/stale-cli-hint.ts

@@ -1,11 +0,0 @@
-/**
- * Shared tail for errors where this CLI doesn't recognize an option or provider
- * the user named. The name may be valid in a newer release, so point the user
- * at the self-update path before they conclude the feature doesn't exist.
- *
- * `bun install -g vellum@latest` refreshes the `vellum` binary directly — the
- * mechanism the installer and the CLI's own self-update use. (`vellum upgrade`
- * targets the assistant runtime, not the CLI binary, for local assistants.)
- */
-export const STALE_CLI_UPDATE_HINT =
-  "your CLI may be out of date — update it with `bun install -g vellum@latest` and retry.";