@vellumai/assistant 0.12.0 → 0.12.1-staging.1

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/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)");
-  });
-}