@vellumai/assistant 0.6.4 → 0.6.6

package/src/cli/commands/doctor.ts

@@ -1,341 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync, readFileSync, statSync } from "node:fs";
-
-import type { Command } from "commander";
-
-import { getRuntimeHttpPort } from "../../config/env.js";
-import { loadRawConfig } from "../../config/loader.js";
-import { shouldAutoStartDaemon } from "../../daemon/connection-policy.js";
-import { isHttpHealthy } from "../../daemon/daemon-control.js";
-import {
-  getDataDir,
-  getDbPath,
-  getLogPath,
-  getProtectedDir,
-  getWorkspaceDir,
-  getWorkspaceHooksDir,
-  getWorkspaceSkillsDir,
-} from "../../util/platform.js";
-import { getProviderKeyViaDaemon } from "../lib/daemon-credential-client.js";
-import { log } from "../logger.js";
-
-export function registerDoctorCommand(program: Command): void {
-  program
-    .command("doctor")
-    .description("Run diagnostic checks")
-    .addHelpText(
-      "after",
-      `
-Runs a series of diagnostic checks against the local assistant environment
-and prints pass/fail results. Use this to verify that the assistant is
-correctly installed and configured before starting a session.
-
-Output symbols:
-  ✓   Check passed
-  ✗   Check failed (detail message follows the label)
-
-Diagnostic checks performed:
-  1.  Bun is installed           Verifies bun is available in PATH
-  2.  API key configured         Checks for a valid provider API key in secure storage
-  3.  Assistant reachable         HTTP health check against the assistant server
-  4.  Database exists/readable   Opens the SQLite database and runs a test query
-  5.  Directory structure        Verifies required workspace directories exist
-  6.  Disk space                 Ensures at least 100MB free on the data partition
-  7.  Log file size              Warns if the log file exceeds 50MB
-  8.  Database integrity         Runs SQLite PRAGMA integrity_check
-  9.  Trust rule syntax          Validates trust.json structure and rule fields
-  10. WASM files                 Checks that tree-sitter WASM binaries are present
-  11. Browser runtime            Verifies Playwright and Chromium availability
-  12. Sandbox diagnostics        Reports sandbox backend status and configuration
-
-Examples:
-  $ assistant doctor`,
-    )
-    .action(async () => {
-      const pass = (label: string) => log.info(`  \u2713 ${label}`);
-      const fail = (label: string, detail?: string) =>
-        log.info(`  \u2717 ${label}${detail ? ` — ${detail}` : ""}`);
-
-      log.info("Vellum Doctor\n");
-
-      // 0. Connection policy info
-      const httpUrl = `http://127.0.0.1:${getRuntimeHttpPort()}`;
-      const autostart = shouldAutoStartDaemon();
-      log.info(`  HTTP:      ${httpUrl}`);
-      log.info(`  Autostart: ${autostart ? "enabled" : "disabled"}\n`);
-
-      // 1. Bun installed
-      try {
-        execSync("bun --version", { stdio: "pipe" });
-        pass("Bun is installed");
-      } catch {
-        fail("Bun is installed", "bun not found in PATH");
-      }
-
-      // 2. Provider/API key configured
-      const raw = loadRawConfig();
-      const rawServices = raw.services as
-        | Record<string, Record<string, unknown>>
-        | undefined;
-      const rawInferenceProvider = rawServices?.inference?.provider;
-      const provider =
-        typeof rawInferenceProvider === "string"
-          ? rawInferenceProvider
-          : "anthropic";
-      const configKey = await getProviderKeyViaDaemon(provider);
-
-      if (provider === "ollama") {
-        pass("Provider configured (Ollama; API key optional)");
-      } else if (configKey) {
-        pass("API key configured");
-      } else {
-        fail("API key configured", `run: assistant keys set ${provider} <key>`);
-      }
-
-      // 3. Daemon reachable (HTTP health check)
-      try {
-        const healthy = await isHttpHealthy();
-        if (healthy) {
-          pass("Assistant reachable");
-        } else {
-          fail(
-            "Assistant reachable",
-            "HTTP health check failed (is the assistant running?)",
-          );
-        }
-      } catch {
-        fail(
-          "Assistant reachable",
-          "could not connect to assistant HTTP server",
-        );
-      }
-
-      // 4. DB exists and readable
-      const dbPath = getDbPath();
-      if (existsSync(dbPath)) {
-        try {
-          const { Database } = await import("bun:sqlite");
-          const db = new Database(dbPath, { readonly: true });
-          db.query("SELECT 1").get();
-          db.close();
-          pass("Database exists and readable");
-        } catch {
-          fail(
-            "Database exists and readable",
-            "file exists but cannot be read",
-          );
-        }
-      } else {
-        fail("Database exists and readable", `not found at ${dbPath}`);
-      }
-
-      // 5. Workspace directory structure
-      const protectedDir = getProtectedDir();
-      const dataDir = getDataDir();
-      const workspaceDir = getWorkspaceDir();
-      const requiredDirs = [
-        workspaceDir,
-        dataDir,
-        `${dataDir}/db`,
-        `${dataDir}/logs`,
-        getWorkspaceSkillsDir(),
-        getWorkspaceHooksDir(),
-        protectedDir,
-      ];
-      const missing = requiredDirs.filter((d) => !existsSync(d));
-      if (missing.length === 0) {
-        pass("Directory structure exists");
-      } else {
-        fail("Directory structure exists", `missing: ${missing.join(", ")}`);
-      }
-
-      // 6. Disk space
-      try {
-        const output = execSync(`df -k "${workspaceDir}"`, {
-          stdio: "pipe",
-          encoding: "utf-8",
-        });
-        const lines = output.trim().split("\n");
-        if (lines.length >= 2) {
-          const cols = lines[1].trim().split(/\s+/);
-          const availKB = parseInt(cols[3], 10);
-          if (isNaN(availKB)) {
-            fail("Disk space", "could not parse available space");
-          } else if (availKB < 100 * 1024) {
-            fail(
-              "Disk space",
-              `only ${Math.round(availKB / 1024)}MB free (< 100MB)`,
-            );
-          } else {
-            pass(`Disk space (${Math.round(availKB / 1024)}MB free)`);
-          }
-        } else {
-          fail("Disk space", "unexpected df output");
-        }
-      } catch {
-        fail("Disk space", "could not check disk space");
-      }
-
-      // 7. Log file size
-      const logPath = getLogPath();
-      if (existsSync(logPath)) {
-        try {
-          const logStat = statSync(logPath);
-          const logSizeMB = logStat.size / (1024 * 1024);
-          if (logSizeMB > 50) {
-            fail("Log file size", `${logSizeMB.toFixed(1)}MB (> 50MB)`);
-          } else {
-            pass(`Log file size (${logSizeMB.toFixed(1)}MB)`);
-          }
-        } catch {
-          fail("Log file size", "could not stat log file");
-        }
-      } else {
-        pass("Log file size (no log file yet)");
-      }
-
-      // 8. DB integrity check
-      if (existsSync(dbPath)) {
-        try {
-          const { Database } = await import("bun:sqlite");
-          const db = new Database(dbPath, { readonly: true });
-          const result = db.query("PRAGMA integrity_check").get() as {
-            integrity_check: string;
-          } | null;
-          db.close();
-          if (result?.integrity_check === "ok") {
-            pass("Database integrity check");
-          } else {
-            fail(
-              "Database integrity check",
-              result?.integrity_check ?? "unknown result",
-            );
-          }
-        } catch (err) {
-          fail(
-            "Database integrity check",
-            err instanceof Error ? err.message : "unknown error",
-          );
-        }
-      } else {
-        fail("Database integrity check", "database file not found");
-      }
-
-      // 9. Trust rule syntax
-      const trustPath = `${protectedDir}/trust.json`;
-      if (existsSync(trustPath)) {
-        try {
-          const rawTrust = readFileSync(trustPath, "utf-8");
-          const data = JSON.parse(rawTrust);
-          if (typeof data !== "object" || data == null) {
-            fail("Trust rule syntax", "trust.json is not a JSON object");
-          } else if (typeof data.version !== "number") {
-            fail("Trust rule syntax", 'missing or invalid "version" field');
-          } else if (!Array.isArray(data.rules)) {
-            fail("Trust rule syntax", 'missing or invalid "rules" array');
-          } else {
-            const invalid = data.rules.filter(
-              (r: unknown) =>
-                typeof r !== "object" ||
-                r == null ||
-                typeof (r as Record<string, unknown>).tool !== "string" ||
-                typeof (r as Record<string, unknown>).pattern !== "string" ||
-                typeof (r as Record<string, unknown>).scope !== "string",
-            );
-            if (invalid.length > 0) {
-              fail(
-                "Trust rule syntax",
-                `${invalid.length} rule(s) have invalid structure`,
-              );
-            } else {
-              pass(`Trust rule syntax (${data.rules.length} rule(s))`);
-            }
-          }
-        } catch (err) {
-          fail(
-            "Trust rule syntax",
-            err instanceof Error ? err.message : "could not parse",
-          );
-        }
-      } else {
-        pass("Trust rule syntax (no trust.json yet)");
-      }
-
-      // 10. WASM files
-      const wasmFiles = [
-        { pkg: "web-tree-sitter", file: "web-tree-sitter.wasm" },
-        { pkg: "tree-sitter-bash", file: "tree-sitter-bash.wasm" },
-      ];
-      let wasmOk = true;
-      const missingWasm: string[] = [];
-      for (const wasm of wasmFiles) {
-        const dir = import.meta.dirname ?? __dirname;
-        let fullPath = `${dir}/../../../node_modules/${wasm.pkg}/${wasm.file}`;
-        // In compiled binaries, fall back to Resources/ or next to the binary
-        if (!existsSync(fullPath) && dir.startsWith("/$bunfs/")) {
-          const { dirname: pathDirname, join: pathJoin } =
-            await import("node:path");
-          const execDir = pathDirname(process.execPath);
-          const resourcesPath = pathJoin(execDir, "..", "Resources", wasm.file);
-          fullPath = existsSync(resourcesPath)
-            ? resourcesPath
-            : pathJoin(execDir, wasm.file);
-        }
-        if (!existsSync(fullPath)) {
-          missingWasm.push(wasm.file);
-          wasmOk = false;
-        } else {
-          try {
-            const wasmStat = statSync(fullPath);
-            if (wasmStat.size === 0) {
-              missingWasm.push(`${wasm.file} (empty)`);
-              wasmOk = false;
-            }
-          } catch {
-            missingWasm.push(`${wasm.file} (unreadable)`);
-            wasmOk = false;
-          }
-        }
-      }
-      if (wasmOk) {
-        pass("WASM files present and non-empty");
-      } else {
-        fail("WASM files", missingWasm.join(", "));
-      }
-
-      // 11. Browser runtime (Playwright + Chromium)
-      const { checkBrowserRuntime } =
-        await import("../../tools/browser/runtime-check.js");
-      const browserStatus = await checkBrowserRuntime();
-      if (
-        browserStatus.playwrightAvailable &&
-        browserStatus.chromiumInstalled
-      ) {
-        pass("Browser runtime (Playwright + Chromium)");
-      } else if (!browserStatus.playwrightAvailable) {
-        fail("Browser runtime", "playwright not available");
-      } else {
-        fail(
-          "Browser runtime",
-          browserStatus.error ?? "Chromium not installed",
-        );
-      }
-
-      // 12. Sandbox backend diagnostics
-      const { runSandboxDiagnostics } =
-        await import("../../tools/terminal/sandbox-diagnostics.js");
-      const sandbox = runSandboxDiagnostics();
-      log.info(
-        `\n  Sandbox:   ${sandbox.config.enabled ? "enabled" : "disabled"}`,
-      );
-      log.info(`  Reason:    ${sandbox.activeBackendReason}`);
-      log.info("");
-      for (const check of sandbox.checks) {
-        if (check.ok) {
-          pass(check.label);
-        } else {
-          fail(check.label, check.detail);
-        }
-      }
-    });
-}

package/src/cli/commands/shotgun.ts

@@ -1,266 +0,0 @@
-import { randomUUID } from "node:crypto";
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-
-import type { Command } from "commander";
-
-import { getSignalsDir } from "../../util/platform.js";
-import { log } from "../logger.js";
-
-const POLL_INTERVAL_MS = 100;
-const DEFAULT_TIMEOUT_MS = 30_000;
-
-interface ShotgunResult {
-  requestId: string;
-  ok: boolean;
-  error?: string;
-  watchId?: string;
-  conversationId?: string;
-  status?: string;
-}
-
-function writeShotgunSignal(
-  requestId: string,
-  payload: Record<string, unknown>,
-): { signalPath: string; resultPath: string } | null {
-  const signalsDir = getSignalsDir();
-  try {
-    mkdirSync(signalsDir, { recursive: true });
-  } catch {
-    log.error("Failed to create signals directory.");
-    return null;
-  }
-
-  const signalPath = join(signalsDir, `shotgun.${requestId}`);
-  const resultPath = join(signalsDir, `shotgun.${requestId}.result`);
-
-  try {
-    writeFileSync(signalPath, JSON.stringify({ requestId, ...payload }));
-  } catch {
-    log.error("Failed to write shotgun signal file.");
-    return null;
-  }
-
-  return { signalPath, resultPath };
-}
-
-function pollForResult(
-  requestId: string,
-  resultPath: string,
-  signalPath: string,
-  timeoutMs: number,
-  callback: (result: ShotgunResult) => void,
-): void {
-  const deadline = Date.now() + timeoutMs + 5_000;
-
-  const poll = setInterval(() => {
-    if (Date.now() > deadline) {
-      clearInterval(poll);
-      cleanup(signalPath, resultPath);
-      log.error("Timed out waiting for response. Is the assistant running?");
-      process.exitCode = 1;
-      return;
-    }
-
-    if (!existsSync(resultPath)) return;
-
-    let result: ShotgunResult;
-    try {
-      const content = readFileSync(resultPath, "utf-8");
-      result = JSON.parse(content) as ShotgunResult;
-    } catch {
-      return;
-    }
-
-    if (result.requestId !== requestId) return;
-
-    clearInterval(poll);
-    cleanup(signalPath, resultPath);
-    callback(result);
-  }, POLL_INTERVAL_MS);
-}
-
-function cleanup(...paths: string[]): void {
-  for (const p of paths) {
-    try {
-      unlinkSync(p);
-    } catch {
-      // Best-effort cleanup.
-    }
-  }
-}
-
-export function registerShotgunCommand(program: Command): void {
-  const shotgun = program
-    .command("shotgun")
-    .description("Start and monitor screen-watch (shotgun) sessions via IPC");
-
-  shotgun.addHelpText(
-    "after",
-    `
-Screen-watch sessions capture periodic screenshots and feed them to the
-assistant for observation. The CLI communicates with the running assistant
-via IPC signal files — the assistant must be running for these commands
-to work.
-
-Examples:
-  $ assistant shotgun start --duration 600 --focus "browsing workflow"
-  $ assistant shotgun status <watchId>`,
-  );
-
-  shotgun
-    .command("start")
-    .description("Start a new screen-watch session")
-    .option(
-      "-d, --duration <seconds>",
-      "Duration in seconds for the watch session",
-      "300",
-    )
-    .option("-i, --interval <seconds>", "Seconds between screen captures", "5")
-    .option(
-      "-f, --focus <area>",
-      "What to focus on observing",
-      "general observation",
-    )
-    .option(
-      "-t, --timeout <ms>",
-      "Timeout in milliseconds waiting for the assistant to respond",
-      String(DEFAULT_TIMEOUT_MS),
-    )
-    .addHelpText(
-      "after",
-      `
-Starts a screen-watch session via IPC signal files. The assistant
-creates a watch session and begins accepting screen observations from the
-desktop client.
-
-The CLI writes the request to signals/shotgun.<requestId> and polls
-signals/shotgun.<requestId>.result for the response. The assistant must
-be running for this to work.
-
-Output (JSON): { ok, watchId, conversationId }
-
-Examples:
-  $ assistant shotgun start
-  $ assistant shotgun start --duration 600 --interval 10 --focus "doordash.com"
-  $ assistant shotgun start -d 300 -i 5 -f "browsing workflow"`,
-    )
-    .action(
-      (opts: {
-        duration: string;
-        interval: string;
-        focus: string;
-        timeout: string;
-      }) => {
-        const durationSeconds = parseInt(opts.duration, 10);
-        if (!Number.isFinite(durationSeconds) || durationSeconds < 1) {
-          log.error("Invalid duration. Must be a positive integer.");
-          process.exitCode = 1;
-          return;
-        }
-
-        const intervalSeconds = parseInt(opts.interval, 10);
-        if (!Number.isFinite(intervalSeconds) || intervalSeconds < 1) {
-          log.error("Invalid interval. Must be a positive integer.");
-          process.exitCode = 1;
-          return;
-        }
-
-        const timeoutMs = parseInt(opts.timeout, 10);
-        if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
-          log.error("Invalid timeout. Must be a positive integer.");
-          process.exitCode = 1;
-          return;
-        }
-
-        const requestId = randomUUID();
-        const paths = writeShotgunSignal(requestId, {
-          action: "start",
-          durationSeconds,
-          intervalSeconds,
-          focusArea: opts.focus,
-        });
-        if (!paths) {
-          process.exitCode = 1;
-          return;
-        }
-
-        pollForResult(
-          requestId,
-          paths.resultPath,
-          paths.signalPath,
-          timeoutMs,
-          (result) => {
-            if (!result.ok) {
-              process.stdout.write(JSON.stringify(result) + "\n");
-              process.exitCode = 1;
-              return;
-            }
-            process.stdout.write(JSON.stringify(result) + "\n");
-          },
-        );
-      },
-    );
-
-  shotgun
-    .command("status <watchId>")
-    .description("Check the status of an active screen-watch session")
-    .option(
-      "-t, --timeout <ms>",
-      "Timeout in milliseconds waiting for the assistant to respond",
-      String(DEFAULT_TIMEOUT_MS),
-    )
-    .addHelpText(
-      "after",
-      `
-Arguments:
-  watchId   The watch session ID returned by 'assistant shotgun start'.
-
-Queries the status of an existing screen-watch session by watchId.
-
-Output (JSON): { ok, watchId, conversationId, status }
-
-The status field is one of: "active", "completing", "completed", "cancelled".
-
-Examples:
-  $ assistant shotgun status abc12345
-  $ assistant shotgun status abc12345 --timeout 5000`,
-    )
-    .action((watchId: string, opts: { timeout: string }) => {
-      const timeoutMs = parseInt(opts.timeout, 10);
-      if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
-        log.error("Invalid timeout. Must be a positive integer.");
-        process.exitCode = 1;
-        return;
-      }
-
-      const requestId = randomUUID();
-      const paths = writeShotgunSignal(requestId, {
-        action: "status",
-        watchId,
-      });
-      if (!paths) {
-        process.exitCode = 1;
-        return;
-      }
-
-      pollForResult(
-        requestId,
-        paths.resultPath,
-        paths.signalPath,
-        timeoutMs,
-        (result) => {
-          process.stdout.write(JSON.stringify(result) + "\n");
-          if (!result.ok) {
-            process.exitCode = 1;
-          }
-        },
-      );
-    });
-}

package/src/config/bundled-skills/browser/SKILL.md

@@ -1,88 +0,0 @@
----
-name: browser
-description: Navigate and interact with web pages using a headless browser
-compatibility: "Designed for Vellum personal assistants"
-metadata:
-  emoji: "🌐"
-  vellum:
-    display-name: "Browser"
-    feature-flag: "browser"
-    activation-hints:
-      - "Load first if you need browser_* tools (navigating, clicking, extracting web content)"
----
-
-Use this skill to browse the web. After loading this skill, the following browser tools become available:
-
-- `browser_attach` - Attach the Chrome debugger to the active tab
-- `browser_navigate` - Navigate to a URL
-- `browser_snapshot` - List interactive elements on the current page
-- `browser_screenshot` - Take a visual screenshot
-- `browser_close` - Close the browser page
-- `browser_detach` - Detach the Chrome debugger from the active tab
-- `browser_click` - Click an element
-- `browser_type` - Type text into an input
-- `browser_press_key` - Press a keyboard key
-- `browser_scroll` - Scroll the page or a specific element
-- `browser_select_option` - Select an option from a native `<select>` element
-- `browser_hover` - Hover over an element to reveal menus/tooltips
-- `browser_wait_for` - Wait for a condition
-- `browser_extract` - Extract page text content
-- `browser_wait_for_download` - Wait for a file download to complete
-- `browser_fill_credential` - Fill a stored credential into a form field
-- `browser_status` - Diagnose browser backend readiness and setup steps
-
-## Capabilities
-
-This browser runs **full Chromium with JavaScript enabled**. It can handle SPAs, React/Vue/Angular apps, dynamic content, date pickers, booking systems, reservation flows, and any JavaScript-heavy interactive site. Never tell the user you "can't handle interactive JavaScript" - you can.
-
-## Browser Mode
-
-Every browser tool accepts an optional `browser_mode` parameter that controls which backend executes the command:
-
-| Value | Backend | Description |
-|---|---|---|
-| `auto` | Automatic | Default. The assistant picks the best available backend based on context (extension > cdp-inspect > local). |
-| `extension` | Chrome extension | Routes through the user's Chrome browser via the extension debugger. |
-| `cdp-inspect` | CDP inspect | Connects to an already-running Chrome instance via the DevTools protocol. Alias: `cdp-debugger`. |
-| `local` | Playwright | Drives a dedicated Playwright-managed Chromium instance. Alias: `playwright`. |
-
-**When to use `auto`**: Prefer `auto` (or omit `browser_mode` entirely) unless you have a specific reason to pin. The automatic backend selection handles extension availability, fallback, and session reuse.
-
-**When to pin a mode**: Pin explicitly when:
-- The user requests interaction with their own browser (use `extension` or `cdp-inspect`).
-- A tool only works on a specific backend (e.g. `browser_wait_for_download` requires `local`).
-- You want to avoid fallback behavior for diagnostic clarity.
-
-**Unsupported mode errors**: Some tools restrict which modes they support. For example, `browser_wait_for_download` only supports `auto` and `local` because file downloads require the Playwright backend. Passing an unsupported mode returns a clear error with the accepted alternatives.
-
-## Typical Workflow
-
-1. (Optional) `browser_status` to diagnose backend availability and remediation when setup is unclear
-2. `browser_attach` to establish the debugger session (extension path; optional on other backends)
-3. `browser_navigate` to load a page
-4. `browser_snapshot` to discover interactive elements
-5. Use `browser_click`, `browser_type`, `browser_press_key`, `browser_scroll`, `browser_select_option`, or `browser_hover` to interact
-6. `browser_extract` or `browser_screenshot` to capture results
-7. `browser_detach` to end the debugger session, or `browser_close` to close the page entirely
-
-## Interaction Strategies
-
-**Date pickers / calendars:** Click the date input to open the picker, re-snapshot to see calendar controls, click month navigation arrows to reach the target month, then click the target date. For `<input type="date">`, use `browser_type` with `YYYY-MM-DD` format.
-
-**Native `<select>` elements:** Use `browser_select_option` with `value`, `label`, or `index`. Do not try to click individual `<option>` elements.
-
-**ARIA / custom dropdowns:** Click to open, take a new `browser_snapshot`, then click the desired option by `element_id`.
-
-**Autocomplete inputs:** Type the search text, wait 500–1000ms (`browser_wait_for` with duration), re-snapshot for suggestions, then click the suggestion or use ArrowDown + Enter.
-
-**Multi-step forms:** Complete each step, wait for the next section to load, re-snapshot to discover new elements, then proceed.
-
-**Dynamic content:** After interactions that change the page, use `browser_wait_for` (selector or text) or re-snapshot to see updated elements before continuing.
-
-**Scrolling:** Use `browser_scroll` to reveal below-the-fold content before snapshotting. Long pages may require multiple scrolls.
-
-**Hover menus / tooltips:** Use `browser_hover` to reveal hidden menus or tooltips, then re-snapshot to see newly revealed elements.
-
-## Verification
-
-Use `browser_screenshot` after critical actions (form submission, booking confirmation, checkout) to visually verify results before reporting success to the user.