@vellumai/assistant 0.6.5 → 0.6.6

package/src/hooks/config.ts

@@ -1,100 +0,0 @@
-import { writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-import { ensureDir, readTextFileSync } from "../util/fs.js";
-import { getLogger } from "../util/logger.js";
-import { getWorkspaceHooksDir } from "../util/platform.js";
-import type { HookConfig, HookConfigEntry, HookManifest } from "./types.js";
-
-const log = getLogger("hooks-config");
-
-const HOOKS_CONFIG_VERSION = 1;
-
-function getConfigPath(): string {
-  return join(getWorkspaceHooksDir(), "config.json");
-}
-
-export function loadHooksConfig(): HookConfig {
-  const configPath = getConfigPath();
-  const raw = readTextFileSync(configPath);
-  if (raw == null) {
-    return { version: HOOKS_CONFIG_VERSION, hooks: {} };
-  }
-
-  try {
-    const parsed = JSON.parse(raw) as HookConfig;
-    if (
-      typeof parsed.version !== "number" ||
-      typeof parsed.hooks !== "object" ||
-      parsed.hooks == null
-    ) {
-      log.warn({ configPath }, "Invalid hooks config, using defaults");
-      return { version: HOOKS_CONFIG_VERSION, hooks: {} };
-    }
-    return parsed;
-  } catch (err) {
-    log.warn(
-      { err, configPath },
-      "Failed to read hooks config, using defaults",
-    );
-    return { version: HOOKS_CONFIG_VERSION, hooks: {} };
-  }
-}
-
-export function saveHooksConfig(config: HookConfig): void {
-  const configPath = getConfigPath();
-  ensureDir(dirname(configPath));
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-}
-
-export function isHookEnabled(hookName: string): boolean {
-  const config = loadHooksConfig();
-  return config.hooks[hookName]?.enabled ?? false;
-}
-
-export function setHookEnabled(hookName: string, enabled: boolean): void {
-  const config = loadHooksConfig();
-  config.hooks[hookName] = { ...config.hooks[hookName], enabled };
-  saveHooksConfig(config);
-}
-
-export function ensureHookInConfig(
-  hookName: string,
-  entry: HookConfigEntry,
-): void {
-  const config = loadHooksConfig();
-  if (hookName in config.hooks) return;
-  config.hooks[hookName] = entry;
-  saveHooksConfig(config);
-}
-
-export function removeHook(hookName: string): void {
-  const config = loadHooksConfig();
-  delete config.hooks[hookName];
-  saveHooksConfig(config);
-}
-
-/**
- * Get merged settings for a hook. Manifest defaults are used as the base,
- * then user overrides from config.json are applied on top.
- */
-export function getHookSettings(
-  hookName: string,
-  manifest: HookManifest,
-): Record<string, unknown> {
-  // Start with defaults from manifest schema
-  const defaults: Record<string, unknown> = {};
-  if (manifest.settingsSchema) {
-    for (const [key, schema] of Object.entries(manifest.settingsSchema)) {
-      if (schema.default !== undefined) {
-        defaults[key] = schema.default;
-      }
-    }
-  }
-
-  // Merge user overrides from config
-  const config = loadHooksConfig();
-  const userSettings = config.hooks[hookName]?.settings ?? {};
-
-  return { ...defaults, ...userSettings };
-}

package/src/hooks/discovery.ts

@@ -1,135 +0,0 @@
-import { type Dirent, readdirSync, readFileSync } from "node:fs";
-import { join, relative, resolve } from "node:path";
-
-import { pathExists } from "../util/fs.js";
-import { getLogger } from "../util/logger.js";
-import { getWorkspaceHooksDir } from "../util/platform.js";
-import { loadHooksConfig } from "./config.js";
-import type { DiscoveredHook, HookManifest } from "./types.js";
-
-const log = getLogger("hooks-discovery");
-
-const VALID_EVENTS = new Set<string>([
-  "daemon-start",
-  "daemon-stop",
-  "conversation-start",
-  "conversation-end",
-  // Legacy aliases — existing user hooks may still reference the old names.
-  "session-start",
-  "session-end",
-  "pre-llm-call",
-  "post-llm-call",
-  "pre-tool-execute",
-  "post-tool-execute",
-  "permission-request",
-  "permission-resolve",
-  "pre-message",
-  "post-message",
-  "on-error",
-]);
-
-/**
- * Validates the core manifest fields required for discovery.
- * `description` and `version` are optional here so that legacy hook manifests
- * (created before those fields were added) continue to be discovered.
- */
-export function isValidManifest(manifest: unknown): manifest is HookManifest {
-  if (typeof manifest !== "object" || manifest == null) return false;
-  const m = manifest as Record<string, unknown>;
-  if (typeof m.name !== "string" || !m.name) return false;
-  if (typeof m.script !== "string" || !m.script) return false;
-  if (!Array.isArray(m.events) || m.events.length === 0) return false;
-  for (const e of m.events) {
-    if (typeof e !== "string" || !VALID_EVENTS.has(e)) return false;
-  }
-  // Optional fields: allow if present but must be strings
-  if (m.description !== undefined && typeof m.description !== "string")
-    return false;
-  if (m.version !== undefined && typeof m.version !== "string") return false;
-  return true;
-}
-
-/**
- * Stricter validation for installing new hooks.
- * Requires `description` and `version` in addition to the core fields.
- */
-export function isValidInstallManifest(
-  manifest: unknown,
-): manifest is HookManifest & { description: string; version: string } {
-  if (!isValidManifest(manifest)) return false;
-  if (typeof manifest.description !== "string" || !manifest.description)
-    return false;
-  if (typeof manifest.version !== "string" || !manifest.version) return false;
-  return true;
-}
-
-export function discoverHooks(hooksDir?: string): DiscoveredHook[] {
-  const dir = hooksDir ?? getWorkspaceHooksDir();
-  if (!pathExists(dir)) return [];
-
-  const config = loadHooksConfig();
-  const hooks: DiscoveredHook[] = [];
-
-  let entries: Dirent[];
-  try {
-    entries = readdirSync(dir, { withFileTypes: true }) as Dirent[];
-  } catch (err) {
-    log.warn({ err, dir }, "Failed to read hooks directory");
-    return [];
-  }
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-
-    const hookDir = join(dir, entry.name);
-    const manifestPath = join(hookDir, "hook.json");
-    if (!pathExists(manifestPath)) continue;
-
-    let manifest: unknown;
-    try {
-      manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-    } catch (err) {
-      log.warn({ err, hookDir }, "Failed to parse hook manifest");
-      continue;
-    }
-
-    if (!isValidManifest(manifest)) {
-      log.warn({ hookDir }, "Invalid hook manifest, skipping");
-      continue;
-    }
-
-    const scriptPath = resolve(hookDir, manifest.script);
-    const rel = relative(hookDir, scriptPath);
-    // Normalize backslashes so Windows-style traversal (e.g. `..\\..\\evil.js`) is
-    // also caught. This project targets macOS, but we check for defense in depth.
-    const normalizedRel = rel.replaceAll("\\", "/");
-    if (
-      normalizedRel.startsWith("../") ||
-      normalizedRel === ".." ||
-      resolve(hookDir, rel) !== scriptPath
-    ) {
-      log.warn(
-        { hookDir, script: manifest.script },
-        "Hook script path traversal detected, skipping",
-      );
-      continue;
-    }
-    if (!pathExists(scriptPath)) {
-      log.warn(
-        { hookDir, script: manifest.script },
-        "Hook script not found, skipping",
-      );
-      continue;
-    }
-
-    hooks.push({
-      name: entry.name,
-      dir: hookDir,
-      manifest,
-      scriptPath,
-      enabled: config.hooks[entry.name]?.enabled ?? false,
-    });
-  }
-
-  return hooks.sort((a, b) => a.name.localeCompare(b.name));
-}

package/src/hooks/manager.ts

@@ -1,179 +0,0 @@
-import { type FSWatcher, watch } from "node:fs";
-
-import { getIsContainerized } from "../config/env-registry.js";
-import { Debouncer } from "../util/debounce.js";
-import { pathExists } from "../util/fs.js";
-import { getLogger } from "../util/logger.js";
-import { getWorkspaceHooksDir } from "../util/platform.js";
-import { discoverHooks } from "./discovery.js";
-import { runHookScript } from "./runner.js";
-import type {
-  DiscoveredHook,
-  HookEventData,
-  HookEventName,
-  HookTriggerResult,
-} from "./types.js";
-
-const log = getLogger("hooks-manager");
-
-/**
- * Legacy event name aliases so existing user hooks that reference the old
- * session-based names still fire when the corresponding conversation event
- * is triggered.
- */
-const LEGACY_EVENT_ALIASES: Partial<Record<HookEventName, HookEventName[]>> = {
-  "conversation-start": ["session-start"],
-  "conversation-end": ["session-end"],
-};
-
-export class HookManager {
-  private hooks: DiscoveredHook[] = [];
-  private eventIndex = new Map<HookEventName, DiscoveredHook[]>();
-  private watcher: FSWatcher | null = null;
-  private readonly debouncer = new Debouncer(500);
-
-  initialize(): void {
-    if (getIsContainerized()) {
-      log.info("Hooks disabled in containerized mode");
-      return;
-    }
-    this.hooks = discoverHooks();
-    this.buildEventIndex();
-    const enabled = this.hooks.filter((h) => h.enabled).length;
-    if (this.hooks.length > 0) {
-      log.info({ enabled, total: this.hooks.length }, "Hooks discovered");
-    }
-  }
-
-  private buildEventIndex(): void {
-    this.eventIndex.clear();
-    for (const hook of this.hooks) {
-      if (!hook.enabled) continue;
-      for (const event of hook.manifest.events) {
-        const list = this.eventIndex.get(event) ?? [];
-        list.push(hook);
-        this.eventIndex.set(event, list);
-      }
-    }
-    // Sort alphabetically by name for deterministic ordering
-    for (const [, list] of this.eventIndex) {
-      list.sort((a, b) => a.name.localeCompare(b.name));
-    }
-  }
-
-  async trigger(
-    event: HookEventName,
-    data: Record<string, unknown>,
-  ): Promise<HookTriggerResult> {
-    // Collect hooks registered under the canonical event name and any
-    // legacy aliases (e.g. session-start -> conversation-start).
-    const primaryHooks = this.eventIndex.get(event) ?? [];
-    const legacyAliases = LEGACY_EVENT_ALIASES[event] ?? [];
-    const aliasHooks = legacyAliases.flatMap(
-      (alias) => this.eventIndex.get(alias) ?? [],
-    );
-    // Deduplicate in case a hook subscribes to both old and new names.
-    const seen = new Set<string>();
-    const hooks: DiscoveredHook[] = [];
-    for (const h of [...primaryHooks, ...aliasHooks]) {
-      if (!seen.has(h.name)) {
-        seen.add(h.name);
-        hooks.push(h);
-      }
-    }
-    if (hooks.length === 0) return { blocked: false };
-
-    const isPreEvent = event.startsWith("pre-");
-    const eventData: HookEventData = { ...data, event };
-
-    for (const hook of hooks) {
-      try {
-        const result = await runHookScript(hook, eventData);
-        if (result.exitCode != null && result.exitCode !== 0) {
-          // Blocking hooks on pre-* events cancel the action
-          if (isPreEvent && hook.manifest.blocking) {
-            log.info(
-              { hook: hook.name, event, exitCode: result.exitCode },
-              "Blocking hook rejected action",
-            );
-            return { blocked: true, blockedBy: hook.name };
-          }
-          log.warn(
-            { hook: hook.name, event, exitCode: result.exitCode },
-            "Hook exited with non-zero code",
-          );
-        }
-      } catch (err) {
-        log.warn({ err, hook: hook.name, event }, "Hook execution failed");
-      }
-    }
-
-    return { blocked: false };
-  }
-
-  reload(): void {
-    if (getIsContainerized()) return;
-    this.hooks = discoverHooks();
-    this.buildEventIndex();
-    const enabled = this.hooks.filter((h) => h.enabled).length;
-    log.info({ enabled, total: this.hooks.length }, "Hooks reloaded");
-  }
-
-  watch(): void {
-    if (getIsContainerized()) return;
-    const hooksDir = getWorkspaceHooksDir();
-    if (!pathExists(hooksDir)) return;
-
-    this.stopWatching();
-
-    try {
-      this.watcher = watch(
-        hooksDir,
-        { recursive: true },
-        (_eventType, filename) => {
-          this.debouncer.schedule(() => {
-            log.info(
-              { filename: String(filename ?? "") },
-              "Hooks directory changed, reloading",
-            );
-            this.reload();
-          });
-        },
-      );
-      log.info({ dir: hooksDir }, "Watching hooks directory for changes");
-    } catch (err) {
-      log.warn(
-        { err, dir: hooksDir },
-        "Failed to watch hooks directory. Hot-reload will be unavailable.",
-      );
-    }
-  }
-
-  stopWatching(): void {
-    this.debouncer.cancel();
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
-    }
-  }
-
-  getDiscoveredHooks(): DiscoveredHook[] {
-    return [...this.hooks];
-  }
-}
-
-let instance: HookManager | null = null;
-
-export function getHookManager(): HookManager {
-  if (!instance) {
-    instance = new HookManager();
-    instance.initialize();
-  }
-  return instance;
-}
-
-/** Reset the singleton (for testing) */
-export function resetHookManager(): void {
-  instance?.stopWatching();
-  instance = null;
-}

package/src/hooks/runner.ts

@@ -1,117 +0,0 @@
-import { spawn } from "node:child_process";
-import { homedir } from "node:os";
-import { extname, join } from "node:path";
-
-import { ensureBun } from "../util/bun-runtime.js";
-import { getWorkspaceDir } from "../util/platform.js";
-import { getHookSettings } from "./config.js";
-import type { DiscoveredHook, HookEventData } from "./types.js";
-
-async function getSpawnArgs(
-  scriptPath: string,
-): Promise<{ command: string; args: string[] }> {
-  const ext = extname(scriptPath);
-  if (ext === ".ts") {
-    const bunPath = await ensureBun();
-    return { command: bunPath, args: ["run", scriptPath] };
-  }
-  return { command: scriptPath, args: [] };
-}
-
-export interface HookRunResult {
-  exitCode: number | null;
-  stdout: string;
-  stderr: string;
-}
-
-export async function runHookScript(
-  hook: DiscoveredHook,
-  eventData: HookEventData,
-  options?: { timeoutMs?: number },
-): Promise<HookRunResult> {
-  const timeoutMs = options?.timeoutMs ?? 5000;
-
-  let spawnResult: { command: string; args: string[] };
-  try {
-    spawnResult = await getSpawnArgs(hook.scriptPath);
-  } catch (err) {
-    return { exitCode: null, stdout: "", stderr: (err as Error).message };
-  }
-  const { command, args } = spawnResult;
-
-  return new Promise<HookRunResult>((resolve) => {
-    const child = spawn(command, args, {
-      cwd: hook.dir,
-      env: {
-        ...process.env,
-        VELLUM_HOOK_EVENT: eventData.event,
-        VELLUM_HOOK_NAME: hook.name,
-        // @deprecated — usage of VELLUM_ROOT_DIR by hook scripts is deprecated.
-        // Removing this requires an LLM-based migration or declarative migration
-        // file to update existing user-authored hooks to use VELLUM_WORKSPACE_DIR.
-        //
-        // VELLUM_ROOT_DIR is kept at the legacy `~/.vellum` value even when
-        // vellumRoot() resolves per-instance via BASE_DATA_DIR. User hook
-        // scripts written against this env var expected the legacy path;
-        // changing it would be a silent contract break. Hooks that need the
-        // per-instance root should read BASE_DATA_DIR themselves or use the
-        // new env vars the environment-layout plan adds.
-        VELLUM_ROOT_DIR: join(homedir(), ".vellum"),
-        VELLUM_WORKSPACE_DIR: getWorkspaceDir(),
-        VELLUM_HOOK_SETTINGS: JSON.stringify(
-          getHookSettings(hook.name, hook.manifest),
-        ),
-      },
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-
-    child.stdout.on("data", (chunk: Buffer) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk: Buffer) => {
-      stderr += chunk.toString();
-    });
-
-    const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      child.kill("SIGTERM");
-      // Give the process a short grace period to exit after SIGTERM, then SIGKILL
-      const killTimer = setTimeout(() => {
-        child.kill("SIGKILL");
-      }, 2000);
-      child.once("close", () => {
-        clearTimeout(killTimer);
-        resolve({
-          exitCode: null,
-          stdout,
-          stderr: stderr + "\nHook timed out",
-        });
-      });
-    }, timeoutMs);
-
-    child.on("close", (code) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve({ exitCode: code, stdout, stderr });
-    });
-
-    child.on("error", (err) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve({ exitCode: null, stdout, stderr: stderr + "\n" + err.message });
-    });
-
-    // Suppress unhandled EPIPE errors if the child exits before we finish writing
-    child.stdin.on("error", () => {});
-    // Write event data to stdin and close
-    child.stdin.write(JSON.stringify(eventData));
-    child.stdin.end();
-  });
-}

package/src/hooks/templates.ts

@@ -1,77 +0,0 @@
-import {
-  chmodSync,
-  cpSync,
-  type Dirent,
-  readdirSync,
-  readFileSync,
-  rmSync,
-} from "node:fs";
-import { join } from "node:path";
-
-import { resolveBundledDir } from "../util/bundled-asset.js";
-import { pathExists } from "../util/fs.js";
-import { getLogger } from "../util/logger.js";
-import { getWorkspaceHooksDir } from "../util/platform.js";
-import { ensureHookInConfig } from "./config.js";
-
-const log = getLogger("hooks-templates");
-
-/**
- * Install bundled hook templates into the user's hooks directory.
- * Templates are copied from `assistant/hook-templates/` to `~/.vellum/hooks/`.
- * - Never overwrites existing hooks (user modifications are preserved).
- * - Newly installed hooks are disabled by default.
- */
-export function installTemplates(): void {
-  const templatesDir = resolveBundledDir(
-    import.meta.dirname ?? __dirname,
-    "../../hook-templates",
-    "hook-templates",
-  );
-  if (!pathExists(templatesDir)) return;
-
-  const hooksDir = getWorkspaceHooksDir();
-  const entries = readdirSync(templatesDir, {
-    withFileTypes: true,
-  }) as Dirent[];
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-
-    const targetDir = join(hooksDir, entry.name);
-    if (pathExists(targetDir)) continue; // Never overwrite user hooks
-
-    try {
-      // Copy template directory
-      cpSync(join(templatesDir, entry.name), targetDir, { recursive: true });
-
-      // Make script executable
-      const manifestPath = join(targetDir, "hook.json");
-      if (pathExists(manifestPath)) {
-        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-        if (manifest.script) {
-          chmodSync(join(targetDir, manifest.script), 0o755);
-        }
-      }
-
-      // Add to config (disabled by default)
-      ensureHookInConfig(entry.name, { enabled: false });
-
-      log.info(
-        { hook: entry.name },
-        "Installed hook template (disabled by default)",
-      );
-    } catch (err) {
-      // Clean up partially-copied directory so the next restart can retry
-      try {
-        rmSync(targetDir, { recursive: true, force: true });
-      } catch (e) {
-        log.debug(
-          { err: e },
-          "Cleanup of partial hook template directory failed",
-        );
-      }
-      log.warn({ err, hook: entry.name }, "Failed to install hook template");
-    }
-  }
-}

package/src/hooks/types.ts

@@ -1,75 +0,0 @@
-export type HookEventName =
-  // Daemon lifecycle
-  | "daemon-start"
-  | "daemon-stop"
-  // Conversation lifecycle
-  | "conversation-start"
-  | "conversation-end"
-  // Legacy aliases (backwards compat for existing user hooks)
-  | "session-start"
-  | "session-end"
-  // LLM call lifecycle
-  | "pre-llm-call"
-  | "post-llm-call"
-  // Tool execution lifecycle
-  | "pre-tool-execute"
-  | "post-tool-execute"
-  // Permission lifecycle
-  | "permission-request"
-  | "permission-resolve"
-  // Message lifecycle
-  | "pre-message"
-  | "post-message"
-  // Error
-  | "on-error";
-
-export interface HookSettingsSchemaEntry {
-  type: string;
-  default?: unknown;
-  description?: string;
-}
-
-export interface HookManifest {
-  name: string;
-  description?: string;
-  version?: string;
-  events: HookEventName[];
-  script: string;
-  /** When true, non-zero exit from this hook cancels pre-* actions. Default false. */
-  blocking?: boolean;
-  /** Schema for per-hook settings with defaults and descriptions. */
-  settingsSchema?: Record<string, HookSettingsSchemaEntry>;
-}
-
-export interface HookConfigEntry {
-  enabled: boolean;
-  /** Per-hook user settings that override manifest defaults. */
-  settings?: Record<string, unknown>;
-}
-
-export interface HookConfig {
-  version: number;
-  hooks: Record<string, HookConfigEntry>;
-}
-
-export interface DiscoveredHook {
-  name: string;
-  /** Absolute path to hook directory */
-  dir: string;
-  manifest: HookManifest;
-  /** Absolute path to the script */
-  scriptPath: string;
-  enabled: boolean;
-}
-
-export interface HookEventData {
-  event: HookEventName;
-  [key: string]: unknown;
-}
-
-export interface HookTriggerResult {
-  /** True if a blocking hook rejected the action (non-zero exit). */
-  blocked: boolean;
-  /** Name of the hook that blocked, if any. */
-  blockedBy?: string;
-}