@vellumai/assistant 0.6.2 → 0.6.4

package/src/permissions/permission-mode-store.ts

@@ -1,180 +0,0 @@
-/**
- * Singleton runtime store for the two-axis permission mode.
- *
- * Reads initial state from the `permissions` section of config.json on
- * initialization and persists mutations back to the config file via the
- * raw-config read/write helpers so env-var–derived keys are never leaked
- * to disk.
- *
- * Downstream consumers (e.g. SSE broadcast) register change listeners
- * via `onModeChanged()`.
- */
-
-import {
-  invalidateConfigCache,
-  loadConfig,
-  loadRawConfig,
-  saveRawConfig,
-} from "../config/loader.js";
-import { getLogger } from "../util/logger.js";
-import type { PermissionMode } from "./permission-mode.js";
-import { DEFAULT_PERMISSION_MODE } from "./permission-mode.js";
-
-const log = getLogger("permission-mode-store");
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type ModeChangeListener = (mode: PermissionMode) => void;
-
-// ---------------------------------------------------------------------------
-// Module-level state
-// ---------------------------------------------------------------------------
-
-let currentMode: PermissionMode = { ...DEFAULT_PERMISSION_MODE };
-let initialized = false;
-const listeners: ModeChangeListener[] = [];
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-function notifyListeners(): void {
-  const snapshot = { ...currentMode };
-  for (const listener of listeners) {
-    try {
-      listener(snapshot);
-    } catch (err) {
-      log.error({ err }, "Error in permission mode change listener");
-    }
-  }
-}
-
-/**
- * Persist the current in-memory permission mode to config.json.
- *
- * Uses the raw-config pattern (loadRawConfig → mutate → saveRawConfig) so
- * that env-var–derived fields (API keys, dataDir) are never written to disk.
- */
-function persistToConfig(): void {
-  try {
-    const raw = loadRawConfig();
-
-    // Ensure the permissions object exists
-    if (
-      raw.permissions == null ||
-      typeof raw.permissions !== "object" ||
-      Array.isArray(raw.permissions)
-    ) {
-      raw.permissions = {};
-    }
-
-    const permissions = raw.permissions as Record<string, unknown>;
-    permissions.askBeforeActing = currentMode.askBeforeActing;
-    permissions.hostAccess = currentMode.hostAccess;
-
-    saveRawConfig(raw);
-
-    // Invalidate the cached config so the next loadConfig() picks up the
-    // persisted values rather than returning stale in-memory state.
-    invalidateConfigCache();
-  } catch (err) {
-    log.error({ err }, "Failed to persist permission mode to config");
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Initialize the store from the current config. Safe to call multiple times;
- * subsequent calls are no-ops unless `resetForTesting()` has been called.
- */
-export function initPermissionModeStore(): void {
-  if (initialized) return;
-
-  try {
-    const config = loadConfig();
-    currentMode = {
-      askBeforeActing: config.permissions.askBeforeActing,
-      hostAccess: config.permissions.hostAccess,
-    };
-  } catch (err) {
-    log.warn(
-      { err },
-      "Failed to load permission mode from config; using defaults",
-    );
-    currentMode = { ...DEFAULT_PERMISSION_MODE };
-  }
-
-  initialized = true;
-}
-
-/**
- * Return the current permission mode. Initializes from config on first call
- * if `initPermissionModeStore()` hasn't been called yet.
- */
-export function getMode(): PermissionMode {
-  if (!initialized) {
-    initPermissionModeStore();
-  }
-  return { ...currentMode };
-}
-
-/**
- * Update the `askBeforeActing` axis. Persists to config.json and notifies
- * change listeners.
- */
-export function setAskBeforeActing(value: boolean): void {
-  if (!initialized) {
-    initPermissionModeStore();
-  }
-
-  if (currentMode.askBeforeActing === value) return;
-
-  currentMode.askBeforeActing = value;
-  persistToConfig();
-  notifyListeners();
-}
-
-/**
- * Update the `hostAccess` axis. Persists to config.json and notifies
- * change listeners.
- */
-export function setHostAccess(value: boolean): void {
-  if (!initialized) {
-    initPermissionModeStore();
-  }
-
-  if (currentMode.hostAccess === value) return;
-
-  currentMode.hostAccess = value;
-  persistToConfig();
-  notifyListeners();
-}
-
-/**
- * Register a callback that fires whenever the permission mode changes.
- * Returns an unsubscribe function.
- */
-export function onModeChanged(callback: ModeChangeListener): () => void {
-  listeners.push(callback);
-  return () => {
-    const idx = listeners.indexOf(callback);
-    if (idx >= 0) {
-      listeners.splice(idx, 1);
-    }
-  };
-}
-
-/**
- * Reset the store to uninitialized state. **Test-only** — production code
- * should never call this.
- */
-export function resetForTesting(): void {
-  currentMode = { ...DEFAULT_PERMISSION_MODE };
-  initialized = false;
-  listeners.length = 0;
-}

package/src/prompts/templates/USER.md

@@ -1,13 +0,0 @@
-_ Lines starting with _ are comments - they won't appear in the system prompt
-
-# USER.md
-
-Store details about your user here. Edit freely - build this over time as you learn about them. Don't be pushy about seeking details, but when you learn something, write it down. More context makes you more useful.
-
-- Preferred name/reference:
-- Pronouns:
-- Locale:
-- Work role:
-- Goals:
-- Hobbies/fun:
-- Daily tools:

package/src/providers/speech-to-text/types.ts

@@ -1,17 +0,0 @@
-export interface SpeechToTextResult {
-  text: string;
-}
-
-export interface SpeechToTextProvider {
-  /**
-   * Transcribe audio from a Buffer.
-   * @param audio - Raw audio data (WAV, OGG, MP3, etc.)
-   * @param mimeType - MIME type of the audio data
-   * @param signal - Optional abort signal for cancellation
-   */
-  transcribe(
-    audio: Buffer,
-    mimeType: string,
-    signal?: AbortSignal,
-  ): Promise<SpeechToTextResult>;
-}

package/src/tools/browser/chrome-cdp.ts

@@ -1,239 +0,0 @@
-/**
- * Shared Chrome CDP session management.
- *
- * Consolidates the duplicated launch / readiness / window-management logic
- * that was previously copy-pasted across the Amazon and DoorDash CLIs.
- * Callers get back a {@link CdpSession} with structured metadata so they can
- * make cleanup decisions (e.g. only kill Chrome if *we* launched it).
- */
-
-import { execSync, spawn as spawnChild } from "node:child_process";
-import { homedir } from "node:os";
-import { join as pathJoin } from "node:path";
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const DEFAULT_CDP_PORT = 9222;
-const DEFAULT_CDP_BASE = `http://localhost:${DEFAULT_CDP_PORT}`;
-const DEFAULT_USER_DATA_DIR = pathJoin(
-  homedir(),
-  "Library/Application Support/Google/Chrome-CDP",
-);
-const CHROME_APP_PATH =
-  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface CdpSession {
-  /** Base URL for the CDP HTTP endpoints (e.g. `http://localhost:9222`). */
-  baseUrl: string;
-  /** Whether this helper launched Chrome (true) or it was already running (false). */
-  launchedByUs: boolean;
-  /** The `--user-data-dir` used for the Chrome instance. */
-  userDataDir: string;
-}
-
-export interface EnsureChromeOptions {
-  /** CDP port. Defaults to `9222`. */
-  port?: number;
-  /** User data directory for Chrome. Defaults to `~/Library/Application Support/Google/Chrome-CDP`. */
-  userDataDir?: string;
-  /** Initial URL to open when launching Chrome. */
-  startUrl?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Readiness check
-// ---------------------------------------------------------------------------
-
-/**
- * Returns `true` when a CDP endpoint is responding at the given base URL
- * and has at least one open page tab. A CDP endpoint with zero tabs is
- * stale and unusable - callers should treat it as not ready.
- */
-export async function isCdpReady(
-  cdpBase: string = DEFAULT_CDP_BASE,
-): Promise<boolean> {
-  try {
-    const res = await fetch(`${cdpBase}/json/version`);
-    if (!res.ok) return false;
-
-    // Verify there's at least one page tab - a CDP endpoint with no tabs
-    // is a stale Chrome process that should be relaunched.
-    const listRes = await fetch(`${cdpBase}/json/list`);
-    if (!listRes.ok) return false;
-    const targets = (await listRes.json()) as Array<{ type: string }>;
-    return targets.some((t) => t.type === "page");
-  } catch {
-    return false;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Launch / ensure
-// ---------------------------------------------------------------------------
-
-/**
- * Ensure a Chrome instance with CDP is available. If one is already listening
- * on the target port, returns immediately. Otherwise spawns a new detached
- * Chrome process and waits for the CDP endpoint to become ready.
- *
- * Returns a {@link CdpSession} with metadata about the running instance.
- */
-export async function ensureChromeWithCdp(
-  options: EnsureChromeOptions = {},
-): Promise<CdpSession> {
-  const port = options.port ?? DEFAULT_CDP_PORT;
-  const baseUrl = `http://localhost:${port}`;
-  const userDataDir = options.userDataDir ?? DEFAULT_USER_DATA_DIR;
-
-  if (await isCdpReady(baseUrl)) {
-    return { baseUrl, launchedByUs: false, userDataDir };
-  }
-
-  // If CDP is responding but has no tabs (stale), kill the process holding the port.
-  try {
-    const versionRes = await fetch(`${baseUrl}/json/version`);
-    if (versionRes.ok) {
-      // Stale Chrome - CDP up but no tabs. Kill it so we can relaunch.
-      try {
-        execSync(`lsof -ti :${port} | xargs kill -9 2>/dev/null`, {
-          stdio: "ignore",
-        });
-      } catch {
-        // Ignore - process may have already exited.
-      }
-      // Brief wait for port to clear.
-      await new Promise((r) => setTimeout(r, 500));
-    }
-  } catch {
-    // CDP not responding at all - port is free, proceed to launch.
-  }
-
-  const args = [
-    `--remote-debugging-port=${port}`,
-    `--force-renderer-accessibility`,
-    `--user-data-dir=${userDataDir}`,
-  ];
-  if (options.startUrl) {
-    args.push(options.startUrl);
-  }
-
-  spawnChild(CHROME_APP_PATH, args, {
-    detached: true,
-    stdio: "ignore",
-  }).unref();
-
-  // Poll until CDP responds (up to 15 s)
-  for (let i = 0; i < 30; i++) {
-    await new Promise((r) => setTimeout(r, 500));
-    if (await isCdpReady(baseUrl)) {
-      return { baseUrl, launchedByUs: true, userDataDir };
-    }
-  }
-
-  throw new Error("Chrome started but CDP endpoint not responding after 15s");
-}
-
-// ---------------------------------------------------------------------------
-// Window management helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Look up the first page target and return its WebSocket debugger URL.
- */
-async function findPageTarget(cdpBase: string): Promise<string | null> {
-  const res = await fetch(`${cdpBase}/json/list`);
-  const targets = (await res.json()) as Array<{
-    type: string;
-    webSocketDebuggerUrl: string;
-  }>;
-  const page = targets.find((t) => t.type === "page");
-  return page?.webSocketDebuggerUrl ?? null;
-}
-
-/**
- * Set the window state of the Chrome window owning the first page target.
- * Used by both minimize and restore.
- */
-async function setWindowState(
-  cdpBase: string,
-  windowState: "minimized" | "normal",
-): Promise<void> {
-  const wsUrl = await findPageTarget(cdpBase);
-  if (!wsUrl) return;
-
-  const ws = new WebSocket(wsUrl);
-
-  await new Promise<void>((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      ws.close();
-      reject(new Error(`CDP ${windowState} timed out`));
-    }, 5000);
-
-    ws.addEventListener("open", () => {
-      ws.send(JSON.stringify({ id: 1, method: "Browser.getWindowForTarget" }));
-    });
-
-    ws.addEventListener("message", (event) => {
-      const msg = JSON.parse(String(event.data)) as {
-        id: number;
-        result?: { windowId: number };
-        error?: { message: string };
-      };
-      if (msg.id === 1 && msg.result) {
-        ws.send(
-          JSON.stringify({
-            id: 2,
-            method: "Browser.setWindowBounds",
-            params: {
-              windowId: msg.result.windowId,
-              bounds: { windowState },
-            },
-          }),
-        );
-      } else if (msg.id === 1) {
-        clearTimeout(timeout);
-        ws.close();
-        reject(new Error("Browser.getWindowForTarget failed"));
-      } else if (msg.id === 2) {
-        clearTimeout(timeout);
-        ws.close();
-        if (msg.error) {
-          reject(
-            new Error(`Browser.setWindowBounds failed: ${msg.error.message}`),
-          );
-        } else {
-          resolve();
-        }
-      }
-    });
-
-    ws.addEventListener("error", (err) => {
-      clearTimeout(timeout);
-      reject(err);
-    });
-  });
-}
-
-/**
- * Minimize the Chrome window associated with the CDP session.
- */
-export async function minimizeChromeWindow(
-  cdpBase: string = DEFAULT_CDP_BASE,
-): Promise<void> {
-  await setWindowState(cdpBase, "minimized");
-}
-
-/**
- * Restore (un-minimize) the Chrome window associated with the CDP session.
- */
-export async function restoreChromeWindow(
-  cdpBase: string = DEFAULT_CDP_BASE,
-): Promise<void> {
-  await setWindowState(cdpBase, "normal");
-}

package/src/tools/system/set-permission-mode.ts

@@ -1,103 +0,0 @@
-/**
- * System tool: set_permission_mode
- *
- * Allows the LLM to deterministically switch permission mode axes via the
- * PermissionModeStore rather than relying on model-generated text.
- *
- * This tool is always available (no permission check required) when the
- * `permission-controls-v2` feature flag is enabled — it IS the permission
- * mechanism.
- */
-
-import {
-  getMode,
-  setAskBeforeActing,
-  setHostAccess,
-} from "../../permissions/permission-mode-store.js";
-import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
-import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
-
-class SetPermissionModeTool implements Tool {
-  name = "set_permission_mode";
-  description =
-    "Change the assistant's permission mode. Supports partial updates — " +
-    "only the provided fields are changed. Use this to toggle whether the " +
-    "assistant asks before acting or whether host access is enabled.";
-  category = "system";
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: "object",
-        properties: {
-          askBeforeActing: {
-            type: "boolean",
-            description:
-              "When true, the assistant checks in with the user before taking actions.",
-          },
-          hostAccess: {
-            type: "boolean",
-            description:
-              "When true, the assistant can execute commands on the host machine without prompting.",
-          },
-        },
-      },
-    };
-  }
-
-  async execute(
-    input: Record<string, unknown>,
-    _context: ToolContext,
-  ): Promise<ToolExecutionResult> {
-    const { askBeforeActing, hostAccess } = input;
-
-    // Validate that at least one field is provided
-    if (askBeforeActing === undefined && hostAccess === undefined) {
-      return {
-        content:
-          "Error: at least one of askBeforeActing or hostAccess must be provided.",
-        isError: true,
-      };
-    }
-
-    // Validate types of provided fields
-    if (askBeforeActing !== undefined && typeof askBeforeActing !== "boolean") {
-      return {
-        content: `Error: askBeforeActing must be a boolean, got ${typeof askBeforeActing}.`,
-        isError: true,
-      };
-    }
-    if (hostAccess !== undefined && typeof hostAccess !== "boolean") {
-      return {
-        content: `Error: hostAccess must be a boolean, got ${typeof hostAccess}.`,
-        isError: true,
-      };
-    }
-
-    // Apply changes for provided fields
-    if (typeof askBeforeActing === "boolean") {
-      setAskBeforeActing(askBeforeActing);
-    }
-
-    if (typeof hostAccess === "boolean") {
-      setHostAccess(hostAccess);
-    }
-
-    // Return confirmation with the new state
-    const mode = getMode();
-    return {
-      content: [
-        "Permission mode updated.",
-        `  askBeforeActing: ${mode.askBeforeActing}`,
-        `  hostAccess: ${mode.hostAccess}`,
-      ].join("\n"),
-      isError: false,
-    };
-  }
-}
-
-export const setPermissionModeTool = new SetPermissionModeTool();