@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/daemon/app-source-watcher.ts

@@ -1,218 +0,0 @@
-/**
- * Filesystem watcher for app source directories.
- *
- * Watches the apps root directory recursively using fs.watch (FSEvents on
- * macOS). When a source file changes, debounces per app ID and calls the
- * provided callback so the server can recompile + refresh surfaces.
- *
- * This catches ALL modification sources (file_edit, file_write, bash, etc.)
- * without relying on individual tool hooks.
- */
-
-import { existsSync, type FSWatcher, watch } from "node:fs";
-
-import {
-  getApp,
-  getAppDirPath,
-  getAppsDir,
-  resolveAppIdByDirName,
-} from "../apps/app-store.js";
-import { compileApp } from "../bundler/app-compiler.js";
-import { broadcastMessage } from "../runtime/assistant-event-hub.js";
-import { publishAppsChanged } from "../runtime/sync/resource-sync-events.js";
-import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
-import { DebouncerMap } from "../util/debounce.js";
-import { attachFsWatcherErrorHandler } from "../util/fs-watcher-error.js";
-import { getLogger } from "../util/logger.js";
-import { allConversations } from "./conversation-registry.js";
-import { refreshSurfacesForApp } from "./conversation-surfaces.js";
-
-const log = getLogger("app-source-watcher");
-
-const APP_REFRESH_DEBOUNCE_MS = 500;
-
-export type AppSourceChangeCallback = (appId: string) => void;
-
-/** Process-level singleton; created by {@link startAppSourceWatcher}. */
-let instance: AppSourceWatcher | null = null;
-
-/**
- * Ensure the watcher is running. Called by tool-side-effects after the apps
- * directory may have been created (e.g. on first app_create), since the
- * watcher is skipped at startup when the directory doesn't exist yet.
- */
-export function ensureAppSourceWatcher(): void {
-  instance?.ensureStarted();
-}
-
-/**
- * Resolve app ID from a relative path within the apps directory.
- * Returns null if the path is not an app source file (e.g. dist/, records/).
- */
-function resolveAppIdFromRelPath(relPath: string): string | null {
-  const slashIdx = relPath.indexOf("/");
-  if (slashIdx === -1) {
-    return null;
-  } // file directly in apps/ (e.g. .json definition)
-
-  const dirName = relPath.slice(0, slashIdx);
-  const innerPath = relPath.slice(slashIdx + 1);
-
-  // Skip a git repo at the root of the apps directory. Older installs may
-  // still carry a legacy .git there; its objects/index/refs churn constantly,
-  // and each event would otherwise hit resolveAppIdByDirName -> existsSync,
-  // which is needless work on a path that can never be an app.
-  if (dirName === ".git") {
-    return null;
-  }
-
-  // Skip non-source directories (include bare directory names for fs.watch events)
-  if (
-    innerPath === "records" ||
-    innerPath.startsWith("records/") ||
-    innerPath === "dist" ||
-    innerPath.startsWith("dist/")
-  ) {
-    return null;
-  }
-
-  return resolveAppIdByDirName(dirName);
-}
-
-export class AppSourceWatcher {
-  private watcher: FSWatcher | null = null;
-  private onChange: AppSourceChangeCallback | null = null;
-  private debouncer = new DebouncerMap({
-    defaultDelayMs: APP_REFRESH_DEBOUNCE_MS,
-    maxEntries: 50,
-  });
-
-  start(onChange: AppSourceChangeCallback): void {
-    this.onChange = onChange;
-    this.tryWatch();
-  }
-
-  /**
-   * Ensure the watcher is running. Call after app creation so the watcher
-   * starts if the apps directory was created after daemon startup.
-   */
-  ensureStarted(): void {
-    if (this.watcher || !this.onChange) {
-      return;
-    }
-    this.tryWatch();
-  }
-
-  private tryWatch(): void {
-    if (this.watcher) {
-      return;
-    }
-
-    let appsDir: string;
-    try {
-      appsDir = getAppsDir();
-    } catch {
-      log.warn(
-        "Could not resolve apps directory; app source watching disabled",
-      );
-      return;
-    }
-
-    if (!existsSync(appsDir)) {
-      log.info("Apps directory does not exist yet; skipping source watcher");
-      return;
-    }
-
-    const onChange = this.onChange;
-    if (!onChange) {
-      return;
-    }
-
-    try {
-      this.watcher = watch(
-        appsDir,
-        { recursive: true },
-        (_eventType, filename) => {
-          if (!filename) {
-            return;
-          }
-
-          const appId = resolveAppIdFromRelPath(filename);
-          if (!appId) {
-            return;
-          }
-
-          this.debouncer.schedule(`app:${appId}`, () => {
-            onChange(appId);
-          });
-        },
-      );
-      // Recursive watches over app trees (incl. node_modules) can exhaust the
-      // inotify watch limit and emit ENOSPC asynchronously. Without an 'error'
-      // listener that unhandled emitter error crashes the daemon.
-      attachFsWatcherErrorHandler(this.watcher, log, appsDir);
-      log.info("App source watcher started");
-    } catch (err) {
-      log.warn(
-        { err },
-        "Failed to watch apps directory; source watching disabled",
-      );
-    }
-  }
-
-  stop(): void {
-    this.debouncer.cancelAll();
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
-    }
-  }
-}
-
-/**
- * Handle a detected app source file change. Recompiles the app and refreshes
- * surfaces across ALL conversations.
- */
-function handleAppSourceChange(appId: string): void {
-  const app = getApp(appId);
-  if (!app) {
-    return;
-  }
-
-  const doRefresh = () => {
-    for (const conversation of allConversations()) {
-      refreshSurfacesForApp(conversation, appId, { fileChange: true });
-    }
-    broadcastMessage({ type: "app_files_changed", appId });
-    publishAppsChanged();
-    void updatePublishedAppDeployment(appId);
-  };
-
-  const appDir = getAppDirPath(appId);
-  void compileApp(appDir)
-    .then((result) => {
-      if (!result.ok) {
-        log.warn(
-          { appId, errors: result.errors },
-          "Recompile failed on app source change",
-        );
-      }
-      doRefresh();
-    })
-    .catch((err) => {
-      log.warn({ appId, err }, "Recompile threw on app source change");
-      doRefresh();
-    });
-}
-
-/** Start watching app source directories for the life of the daemon. */
-export function startAppSourceWatcher(): void {
-  instance = new AppSourceWatcher();
-  instance.start(handleAppSourceChange);
-}
-
-/** Stop the app source watcher during daemon shutdown. */
-export function stopAppSourceWatcher(): void {
-  instance?.stop();
-  instance = null;
-}

package/src/messaging/providers/whatsapp/client.ts

@@ -1,29 +0,0 @@
-/**
- * Low-level WhatsApp operations.
- *
- * Calls the Meta Cloud API directly via ./api.ts — no gateway proxy hop.
- */
-
-import { sendWhatsAppTextMessage } from "./api.js";
-
-/** Result returned by sendMessage. */
-export interface WhatsAppSendResult {
-  ok: boolean;
-  /**
-   * The id the Cloud API assigned to the message (`messages[0].id`). Meta
-   * returns it on every accepted send, so this is absent only when the API
-   * answered with an unexpected shape.
-   */
-  messageId?: string;
-}
-
-/**
- * Send a WhatsApp text message via the Meta Cloud API.
- */
-export async function sendMessage(
-  to: string,
-  text: string,
-): Promise<WhatsAppSendResult> {
-  const result = await sendWhatsAppTextMessage(to, text);
-  return { ok: true, messageId: result.messages?.[0]?.id };
-}

package/src/runtime/routes/debug-bash-routes.ts

@@ -1,173 +0,0 @@
-/**
- * IPC route for executing shell commands through the assistant process.
- *
- * The CLI sends the command over the IPC socket and receives a single
- * response containing stdout, stderr, and the exit code.
- *
- * **Security**: Gated behind VELLUM_DEBUG=1. When debug mode is off (the
- * default), the handler returns an error immediately so the CLI surfaces a
- * clear rejection instead of hanging. The assistant must be restarted with
- * VELLUM_DEBUG=1 for this route to execute commands.
- */
-
-import { spawn } from "node:child_process";
-
-import { z } from "zod";
-
-import { getIsContainerized } from "../../config/env-registry.js";
-import { buildSanitizedEnv } from "../../tools/terminal/safe-env.js";
-import { getWorkspaceDir } from "../../util/platform.js";
-import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
-import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
-
-const DEFAULT_TIMEOUT_MS = 30_000;
-
-function isDebugMode(): boolean {
-  return (
-    process.env.VELLUM_DEBUG === "1" || process.env.VELLUM_DEBUG === "true"
-  );
-}
-
-interface DebugBashResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number | null;
-  timedOut: boolean;
-  error?: string;
-}
-
-function handleDebugBash({ body }: RouteHandlerArgs): Promise<DebugBashResult> {
-  if (getIsContainerized()) {
-    return Promise.resolve({
-      stdout: "",
-      stderr: "",
-      exitCode: null,
-      timedOut: false,
-      error: "debug bash is not available in containerized environments",
-    });
-  }
-
-  if (!isDebugMode()) {
-    return Promise.resolve({
-      stdout: "",
-      stderr: "",
-      exitCode: null,
-      timedOut: false,
-      error:
-        "Bash debug execution is disabled. The running assistant process must have been started with VELLUM_DEBUG=1 (setting it on the CLI command alone is not enough). Restart the assistant with: vellum sleep && VELLUM_DEBUG=1 vellum wake",
-    });
-  }
-
-  const { command, timeoutMs } = body as {
-    command?: string;
-    timeoutMs?: number;
-  };
-
-  if (!command || typeof command !== "string") {
-    return Promise.resolve({
-      stdout: "",
-      stderr: "",
-      exitCode: null,
-      timedOut: false,
-      error: "command is required",
-    });
-  }
-
-  const effectiveTimeout =
-    typeof timeoutMs === "number" && timeoutMs > 0
-      ? timeoutMs
-      : DEFAULT_TIMEOUT_MS;
-
-  return new Promise<DebugBashResult>((resolve) => {
-    const stdoutChunks: Buffer[] = [];
-    const stderrChunks: Buffer[] = [];
-    let timedOut = false;
-    let settled = false;
-
-    const finish = (result: DebugBashResult) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      resolve(result);
-    };
-
-    const child = spawn("bash", ["-c", command], {
-      cwd: getWorkspaceDir(),
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: true,
-      env: buildSanitizedEnv(),
-      windowsHide: true,
-    });
-
-    const timer = setTimeout(() => {
-      timedOut = true;
-      try {
-        process.kill(-child.pid!, "SIGKILL");
-      } catch {
-        // Process group may have already exited.
-      }
-    }, effectiveTimeout);
-
-    child.stdout.on("data", (data: Buffer) => {
-      stdoutChunks.push(data);
-    });
-
-    child.stderr.on("data", (data: Buffer) => {
-      stderrChunks.push(data);
-    });
-
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      finish({
-        stdout: Buffer.concat(stdoutChunks).toString(),
-        stderr: Buffer.concat(stderrChunks).toString(),
-        exitCode: code,
-        timedOut,
-      });
-    });
-
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      finish({
-        stdout: "",
-        stderr: "",
-        exitCode: null,
-        timedOut: false,
-        error: err.message,
-      });
-    });
-  });
-}
-
-export const ROUTES: RouteDefinition[] = [
-  {
-    operationId: "debug_bash",
-    endpoint: "debug/bash",
-    method: "POST",
-    policy: {
-      requiredScopes: ["settings.write"],
-      allowedPrincipalTypes: ACTOR_PRINCIPALS,
-    },
-    requireGuardian: false,
-    summary: "Execute a shell command in the assistant process",
-    description:
-      "Developer debugging tool. Requires the assistant to be running with VELLUM_DEBUG=1.",
-    tags: ["debug"],
-    requestBody: z.object({
-      command: z.string().describe("Shell command to execute via bash -c"),
-      timeoutMs: z
-        .number()
-        .optional()
-        .describe("Execution timeout in milliseconds (default: 30000)"),
-    }),
-    responseBody: z.object({
-      stdout: z.string(),
-      stderr: z.string(),
-      exitCode: z.number().nullable(),
-      timedOut: z.boolean(),
-      error: z.string().optional(),
-    }),
-    handler: handleDebugBash,
-  },
-];

package/src/util/fs-watcher-error.ts

@@ -1,36 +0,0 @@
-/**
- * Shared `'error'`-event handler for `fs.watch()` FSWatchers.
- *
- * An `FSWatcher` is an EventEmitter. When the underlying inotify/FSEvents
- * backend fails *after* the watch was established — e.g. ENOSPC when the
- * kernel's `fs.inotify.max_user_watches` limit is exhausted while walking a
- * recursive watch into a large subtree (a plugin's `node_modules`), or ENXIO
- * when a Unix socket file appears in a watched directory — the failure is
- * delivered asynchronously as an `'error'` event rather than a synchronous
- * throw from `watch()`. An emitter with no `'error'` listener rethrows, which
- * surfaces as an `uncaughtException` and takes the whole daemon down (→
- * CrashLoopBackOff).
- *
- * Attaching this handler degrades the failure to "this watcher stops
- * delivering events", in line with the daemon startup philosophy: a subsystem
- * failure must never crash the process.
- */
-
-import type { FSWatcher } from "node:fs";
-
-import type { Logger } from "pino";
-
-/**
- * Attach a resilient `'error'` listener so async FSWatcher failures are logged
- * instead of crashing the process. Pass the owning module's logger and the
- * watched directory for diagnostic context.
- */
-export function attachFsWatcherErrorHandler(
-  watcher: FSWatcher,
-  log: Logger,
-  dir: string,
-): void {
-  watcher.on("error", (err) => {
-    log.warn({ err, dir }, "FSWatcher error (non-fatal, continuing)");
-  });
-}