@vellumai/assistant 0.11.2 → 0.11.3-staging.1

package/src/__tests__/tool-side-effects-slack-dm.test.ts

@@ -1,357 +0,0 @@
-/**
- * Tests for the bash post-execution hook that dispatches Slack DMs
- * for channel verification sessions. Validates that the hook only
- * delivers when an active session exists with a matching destination.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mocks — must be set up before importing the module under test
-// ---------------------------------------------------------------------------
-
-const mockFindActiveSession = mock((): unknown => null);
-mock.module("../channels/gateway-verification-sessions.js", () => ({
-  findActiveSession: async () => mockFindActiveSession(),
-}));
-
-const mockDeliverVerificationSlack = mock(() => {});
-mock.module("../runtime/verification-outbound-actions.js", () => ({
-  deliverVerificationSlack: mockDeliverVerificationSlack,
-}));
-
-// Stub out transitive dependencies to prevent import errors
-mock.module("../bundler/app-compiler.js", () => ({
-  compileApp: mock(() => Promise.resolve({ ok: true })),
-}));
-mock.module("../media/app-icon-generator.js", () => ({
-  generateAppIcon: mock(() => Promise.resolve()),
-}));
-mock.module("../apps/app-store.js", () => ({
-  getApp: mock(() => null),
-  getAppDirPath: mock(() => ""),
-  getAppsDir: mock(() => ""),
-  resolveAppIdFromPath: mock(() => null),
-  resolveAppIdByDirName: mock(() => null),
-  resolveAppDir: mock(() => ({ dirName: "", dirPath: "" })),
-  slugify: mock((s: string) => s),
-  validateDirName: mock(() => {}),
-  generateAppDirName: mock(() => ""),
-  listApps: mock(() => []),
-  createApp: mock(() => ({})),
-  updateApp: mock(() => {}),
-  deleteApp: mock(() => {}),
-  getAppPreview: mock(() => null),
-  createAppRecord: mock(() => ({})),
-  getAppRecord: mock(() => null),
-  queryAppRecords: mock(() => []),
-  updateAppRecord: mock(() => {}),
-  deleteAppRecord: mock(() => {}),
-  listAppFiles: mock(() => []),
-  appFileExists: mock(() => false),
-  readAppFile: mock(() => ""),
-  writeAppFile: mock(() => {}),
-  editAppFile: mock(() => ({})),
-  inlineDistAssets: mock((_, html: string) => html),
-  addAppConversationId: mock(() => false),
-  linkAppToConversationLineage: mock(() => {}),
-}));
-mock.module("../services/published-app-updater.js", () => ({
-  updatePublishedAppDeployment: mock(() => Promise.resolve()),
-}));
-mock.module("../daemon/conversation-surfaces.js", () => ({
-  refreshSurfacesForApp: mock(() => {}),
-}));
-const mockIsDoordashCommand = mock(() => false);
-const mockUpdateDoordashProgress = mock(() => {});
-mock.module("../daemon/doordash-steps.js", () => ({
-  isDoordashCommand: mockIsDoordashCommand,
-  updateDoordashProgress: mockUpdateDoordashProgress,
-}));
-
-const mockLogWarn = mock((_obj: unknown, _msg: string) => {});
-const mockLogInfo = mock((_obj: unknown, _msg: string) => {});
-const mockLogError = mock((_obj: unknown, _msg: string) => {});
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    warn: mockLogWarn,
-    info: mockLogInfo,
-    error: mockLogError,
-    debug: () => {},
-    trace: () => {},
-  }),
-}));
-
-// ---------------------------------------------------------------------------
-// Import after mocks — dynamic import ensures mock.module() calls above
-// are registered before tool-side-effects.ts evaluates its top-level
-// `const log = getLogger(...)`.
-// ---------------------------------------------------------------------------
-
-import type { SideEffectContext } from "../daemon/tool-side-effects.js";
-
-const { runPostExecutionSideEffects } =
-  await import("../daemon/tool-side-effects.js");
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const dummySideEffectCtx = {
-  ctx: {} as SideEffectContext["ctx"],
-} satisfies SideEffectContext;
-
-async function callWithBashHook(
-  command: string,
-  content: string,
-  isError = false,
-): Promise<void> {
-  await runPostExecutionSideEffects(
-    "bash",
-    { command },
-    { content, isError },
-    dummySideEffectCtx,
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("bash hook — Slack DM dispatch with session validation", () => {
-  beforeEach(() => {
-    mockFindActiveSession.mockReset();
-    mockDeliverVerificationSlack.mockReset();
-    mockLogWarn.mockReset();
-    mockLogInfo.mockReset();
-    mockLogError.mockReset();
-  });
-
-  test("legitimate verification dispatches DM", async () => {
-    mockFindActiveSession.mockReturnValue({
-      destinationAddress: "U123",
-      status: "awaiting_response",
-    });
-
-    const output = JSON.stringify({
-      _pendingSlackDm: {
-        userId: "U123",
-        text: "code",
-        assistantId: "aid",
-      },
-    });
-
-    await callWithBashHook(
-      "assistant channel-verification-sessions create ...",
-      output,
-    );
-
-    expect(mockDeliverVerificationSlack).toHaveBeenCalledTimes(1);
-    expect(mockDeliverVerificationSlack).toHaveBeenCalledWith(
-      "U123",
-      "code",
-      "aid",
-    );
-  });
-
-  test("no active session — DM not dispatched", async () => {
-    mockFindActiveSession.mockReturnValue(null);
-
-    const output = JSON.stringify({
-      _pendingSlackDm: {
-        userId: "U123",
-        text: "code",
-        assistantId: "aid",
-      },
-    });
-
-    await callWithBashHook(
-      "assistant channel-verification-sessions create ...",
-      output,
-    );
-
-    expect(mockDeliverVerificationSlack).not.toHaveBeenCalled();
-    expect(mockLogWarn).toHaveBeenCalledWith(
-      expect.objectContaining({ userId: "U123" }),
-      expect.stringContaining("no active Slack verification session"),
-    );
-  });
-
-  test("userId mismatch — DM not dispatched", async () => {
-    mockFindActiveSession.mockReturnValue({
-      destinationAddress: "U999",
-      status: "awaiting_response",
-    });
-
-    const output = JSON.stringify({
-      _pendingSlackDm: {
-        userId: "U_ATTACKER",
-        text: "code",
-        assistantId: "aid",
-      },
-    });
-
-    await callWithBashHook(
-      "assistant channel-verification-sessions create ...",
-      output,
-    );
-
-    expect(mockDeliverVerificationSlack).not.toHaveBeenCalled();
-    expect(mockLogWarn).toHaveBeenCalledWith(
-      expect.objectContaining({ userId: "U_ATTACKER", expected: "U999" }),
-      expect.stringContaining("does not match active session destination"),
-    );
-  });
-
-  test("gateway session lookup failure — DM not dispatched (fail closed)", async () => {
-    mockFindActiveSession.mockImplementation(() => {
-      throw new Error("gateway unreachable");
-    });
-
-    const output = JSON.stringify({
-      _pendingSlackDm: {
-        userId: "U123",
-        text: "code",
-        assistantId: "aid",
-      },
-    });
-
-    await callWithBashHook(
-      "assistant channel-verification-sessions create ...",
-      output,
-    );
-
-    expect(mockDeliverVerificationSlack).not.toHaveBeenCalled();
-    expect(mockLogWarn).toHaveBeenCalledWith(
-      expect.objectContaining({ userId: "U123" }),
-      expect.stringContaining("gateway session lookup failed"),
-    );
-  });
-
-  test("command without verification substring — hook is no-op", async () => {
-    mockFindActiveSession.mockReturnValue({
-      destinationAddress: "U123",
-      status: "awaiting_response",
-    });
-
-    const output = JSON.stringify({
-      _pendingSlackDm: {
-        userId: "U123",
-        text: "code",
-        assistantId: "aid",
-      },
-    });
-
-    await callWithBashHook("echo hello", output);
-
-    expect(mockDeliverVerificationSlack).not.toHaveBeenCalled();
-  });
-
-  test("output without _pendingSlackDm — hook is no-op", async () => {
-    mockFindActiveSession.mockReturnValue({
-      destinationAddress: "U123",
-      status: "awaiting_response",
-    });
-
-    await callWithBashHook(
-      "assistant channel-verification-sessions create ...",
-      JSON.stringify({ success: true, sessionId: "s1" }),
-    );
-
-    expect(mockDeliverVerificationSlack).not.toHaveBeenCalled();
-  });
-
-  test("multi-line JSON output — dispatches from correct line", async () => {
-    mockFindActiveSession.mockReturnValue({
-      destinationAddress: "U123",
-      status: "awaiting_response",
-    });
-
-    const cancelResult = JSON.stringify({ success: true, cancelled: true });
-    const createResult = JSON.stringify({
-      _pendingSlackDm: {
-        userId: "U123",
-        text: "verify-code",
-        assistantId: "aid2",
-      },
-    });
-    const multiLineOutput = `${cancelResult}\n${createResult}`;
-
-    await callWithBashHook(
-      "assistant channel-verification-sessions create ...",
-      multiLineOutput,
-    );
-
-    expect(mockDeliverVerificationSlack).toHaveBeenCalledTimes(1);
-    expect(mockDeliverVerificationSlack).toHaveBeenCalledWith(
-      "U123",
-      "verify-code",
-      "aid2",
-    );
-  });
-
-  test("multi-line — rejected first line does not block valid second line", async () => {
-    mockFindActiveSession.mockReturnValue({
-      destinationAddress: "U200",
-      status: "awaiting_response",
-    });
-
-    const staleResult = JSON.stringify({
-      _pendingSlackDm: {
-        userId: "U100",
-        text: "stale-code",
-        assistantId: "aid",
-      },
-    });
-    const validResult = JSON.stringify({
-      _pendingSlackDm: {
-        userId: "U200",
-        text: "valid-code",
-        assistantId: "aid2",
-      },
-    });
-    const multiLineOutput = `${staleResult}\n${validResult}`;
-
-    await callWithBashHook(
-      "assistant channel-verification-sessions create ...",
-      multiLineOutput,
-    );
-
-    expect(mockDeliverVerificationSlack).toHaveBeenCalledTimes(1);
-    expect(mockDeliverVerificationSlack).toHaveBeenCalledWith(
-      "U200",
-      "valid-code",
-      "aid2",
-    );
-  });
-});
-
-describe("doordash progress side effect", () => {
-  beforeEach(() => {
-    mockIsDoordashCommand.mockReset();
-    mockUpdateDoordashProgress.mockReset();
-    mockLogError.mockReset();
-  });
-
-  test("throwing updateDoordashProgress is swallowed and logged", async () => {
-    mockIsDoordashCommand.mockReturnValue(true);
-    mockUpdateDoordashProgress.mockImplementation(() => {
-      throw new Error("doordash boom");
-    });
-
-    await expect(
-      runPostExecutionSideEffects(
-        "bash",
-        { command: "order food" },
-        { content: "{}", isError: false },
-        dummySideEffectCtx,
-      ),
-    ).resolves.toBeUndefined();
-
-    expect(mockUpdateDoordashProgress).toHaveBeenCalledTimes(1);
-    expect(mockLogError).toHaveBeenCalledWith(
-      expect.objectContaining({ toolName: "bash" }),
-      expect.stringContaining("DoorDash progress update failed"),
-    );
-  });
-});

package/src/daemon/install-symlink.ts

@@ -1,207 +0,0 @@
-import { execFileSync } from "node:child_process";
-import {
-  appendFileSync,
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readFileSync,
-  readlinkSync,
-  symlinkSync,
-  unlinkSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-import { getLogger } from "../util/logger.js";
-
-const log = getLogger("install-symlink");
-
-/**
- * Resolves the path to the `vellum-assistant` binary that should be symlinked
- * as `assistant`.
- *
- * - **Bundled (desktop app):** The daemon runs from a compiled binary inside
- *   `Vellum.app/Contents/MacOS/`. `process.execPath` is the daemon binary
- *   itself — the `vellum-assistant` CLI binary lives alongside it in the same
- *   directory.
- *
- * - **Dev (bun):** `process.execPath` is the bun runtime. We resolve the
- *   assistant entrypoint relative to this file's location in the source tree
- *   and return a wrapper script path that would need bun to run — so we skip
- *   symlinking in dev mode since developers manage their own PATH.
- */
-function resolveAssistantBinary(): string | null {
-  const execPath = process.execPath;
-  // Detect the bundled desktop app case by checking for the app bundle path.
-  const isBundled = execPath.includes("/Contents/MacOS/");
-
-  if (isBundled) {
-    // The assistant CLI binary is a sibling of the daemon binary in
-    // Contents/MacOS/.
-    const macosDir = dirname(execPath);
-    const assistantBinary = join(macosDir, "vellum-assistant");
-    if (existsSync(assistantBinary)) {
-      return assistantBinary;
-    }
-    log.warn(
-      { expected: assistantBinary },
-      "Bundled vellum-assistant binary not found alongside daemon",
-    );
-    return null;
-  }
-
-  // Dev mode: resolve the assistant entrypoint from the source tree.
-  // The daemon entry is at assistant/src/daemon/main.ts and the assistant
-  // CLI entry is at assistant/src/index.ts.
-  const assistantEntry = join(dirname(__filename), "..", "index.ts");
-  if (existsSync(assistantEntry)) {
-    return assistantEntry;
-  }
-  return null;
-}
-
-/**
- * Attempts to place a symlink at `symlinkPath` pointing to `target`.
- * Returns true if the symlink was created or already points to the target.
- */
-function trySymlink(target: string, symlinkPath: string): boolean {
-  try {
-    try {
-      const stats = lstatSync(symlinkPath);
-      if (!stats.isSymbolicLink()) {
-        // Real file — don't overwrite (could be a developer's local install)
-        return false;
-      }
-      const dest = readlinkSync(symlinkPath);
-      if (dest === target) {
-        return true;
-      }
-      // Stale or dangling symlink — remove before creating new one
-      unlinkSync(symlinkPath);
-    } catch (e) {
-      if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") {
-        return false;
-      }
-      // Path doesn't exist — proceed to create symlink
-    }
-
-    const dir = dirname(symlinkPath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    symlinkSync(target, symlinkPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Ensures ~/.local/bin is present in the user's shell profile so that
- * symlinks placed there are on PATH in new terminal sessions.
- */
-function ensureLocalBinInShellProfile(localBinDir: string): void {
-  const shell = process.env.SHELL ?? "";
-  const home = homedir();
-  const profilePath = shell.endsWith("/zsh")
-    ? join(home, ".zshrc")
-    : shell.endsWith("/bash")
-      ? join(home, ".bash_profile")
-      : null;
-  if (!profilePath) {
-    return;
-  }
-
-  try {
-    const contents = existsSync(profilePath)
-      ? readFileSync(profilePath, "utf-8")
-      : "";
-    if (contents.includes(localBinDir)) {
-      return;
-    }
-    const line = `\nexport PATH="${localBinDir}:$PATH"\n`;
-    appendFileSync(profilePath, line);
-    log.info(
-      { profilePath, localBinDir },
-      "Added ~/.local/bin to shell profile",
-    );
-  } catch {
-    // Not critical — user can add it manually
-  }
-}
-
-/**
- * Checks whether `assistant` already resolves on PATH to something other than
- * our candidate symlink locations. If so, we skip symlinking to avoid
- * overwriting a developer's local build.
- */
-function commandResolvesElsewhere(
-  commandName: string,
-  candidatePaths: Set<string>,
-): boolean {
-  try {
-    const resolved = execFileSync("/usr/bin/which", [commandName], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    return resolved !== "" && !candidatePaths.has(resolved);
-  } catch {
-    // `which` exited non-zero — command not found, safe to proceed
-    return false;
-  }
-}
-
-/**
- * Idempotent: installs (or verifies) a symlink for the `assistant` command.
- *
- * Called on every daemon startup. Handles two runtime modes:
- * - **Bundled binary** (desktop app): symlinks to the compiled
- *   `vellum-assistant` binary in the app bundle.
- * - **Bun dev mode**: symlinks to a small wrapper script that invokes
- *   `bun run` on the assistant entrypoint.
- *
- * Tries `/usr/local/bin/assistant` first, then falls back to
- * `~/.local/bin/assistant` (and patches the shell profile if needed).
- *
- * Skipped when VELLUM_DEV=1 (developers manage their own PATH).
- */
-export function installAssistantSymlink(): void {
-  if (process.env.VELLUM_DEV === "1") {
-    return;
-  }
-
-  const target = resolveAssistantBinary();
-  if (!target) {
-    return;
-  }
-
-  const localBinDir = join(homedir(), ".local", "bin");
-  const candidateDirs = ["/usr/local/bin", localBinDir];
-  const candidatePaths = new Set(
-    candidateDirs.map((dir) => `${dir}/assistant`),
-  );
-
-  if (commandResolvesElsewhere("assistant", candidatePaths)) {
-    log.info(
-      "`assistant` already resolves to a non-managed path — skipping symlink",
-    );
-    return;
-  }
-
-  for (const dir of candidateDirs) {
-    const symlinkPath = join(dir, "assistant");
-    if (trySymlink(target, symlinkPath)) {
-      log.info({ symlinkPath, target }, "Installed assistant symlink");
-      if (dir === localBinDir) {
-        ensureLocalBinInShellProfile(localBinDir);
-      }
-      return;
-    }
-    log.info(
-      { symlinkPath },
-      "Could not install assistant symlink at candidate — trying next",
-    );
-  }
-
-  log.warn("Could not install assistant symlink in any candidate directory");
-}

package/src/notifications/deferred-emit.ts

@@ -1,147 +0,0 @@
-/**
- * Per-conversation notification buffer used to keep a background job's
- * "success" notification from racing the runner's `activity.failed` when
- * the job times out after the model already invoked `notifications send`.
- *
- * `registerDeferredConversation` arms the buffer before the LLM turn.
- * `bufferIfDeferred` is called from the IPC route handler — it buffers when
- * armed, swallows when tombstoned (post-discard grace window), and returns
- * null otherwise so the route emits normally.
- * `commitDeferredConversation` flushes on success; `discardDeferredConversation`
- * drops on failure and tombstones briefly to catch late tool calls that
- * arrive after `processMessage` keeps running past the runner's timeout.
- */
-
-import { v4 as uuid } from "uuid";
-
-import { getLogger } from "../util/logger.js";
-import {
-  emitNotificationSignal,
-  type EmitSignalParams,
-  type EmitSignalResult,
-} from "./emit-signal.js";
-
-const log = getLogger("notifications-deferred-emit");
-
-// How long after the last observed late notification we keep the tombstone
-// alive. `work` in `runBackgroundJob` is not cancelled on timeout — it can
-// continue running and emit skill calls indefinitely. We refresh the timer
-// on every late arrival, so the tombstone persists as long as the turn is
-// still draining and only expires once the conversation has been quiet for
-// this long.
-const TOMBSTONE_TTL_MS = 5 * 60 * 1000;
-
-type BufferEntry =
-  | { state: "buffered"; items: EmitSignalParams<string>[] }
-  | { state: "tombstoned"; timer: ReturnType<typeof setTimeout> };
-
-const buffers = new Map<string, BufferEntry>();
-
-function scheduleTombstoneEviction(
-  conversationId: string,
-): ReturnType<typeof setTimeout> {
-  const timer = setTimeout(() => {
-    const cur = buffers.get(conversationId);
-    if (cur?.state === "tombstoned") {
-      buffers.delete(conversationId);
-    }
-  }, TOMBSTONE_TTL_MS);
-  timer.unref?.();
-  return timer;
-}
-
-export function registerDeferredConversation(conversationId: string): void {
-  buffers.set(conversationId, { state: "buffered", items: [] });
-}
-
-/**
- * Buffer the signal when the originating conversation is armed, swallow it
- * when tombstoned, otherwise return null so the caller emits normally.
- */
-export function bufferIfDeferred(
-  originatingConversationId: string | undefined,
-  params: EmitSignalParams<string>,
-): EmitSignalResult | null {
-  if (!originatingConversationId) {
-    return null;
-  }
-  const entry = buffers.get(originatingConversationId);
-  if (!entry) {
-    return null;
-  }
-  if (entry.state === "tombstoned") {
-    // Refresh the eviction timer so the tombstone outlives any continuing
-    // turn activity. Otherwise a long-running orphan `processMessage` could
-    // emit a `notifications send` after the fixed TTL elapsed and bypass
-    // buffering, recreating the "success + activity.failed" contradiction.
-    clearTimeout(entry.timer);
-    entry.timer = scheduleTombstoneEviction(originatingConversationId);
-    return {
-      signalId: uuid(),
-      deduplicated: false,
-      dispatched: false,
-      reason: "Notification dropped: background job did not complete",
-      deliveryResults: [],
-    };
-  }
-  entry.items.push(params);
-  return {
-    signalId: uuid(),
-    deduplicated: false,
-    dispatched: false,
-    reason: "Notification deferred until background job completes",
-    deliveryResults: [],
-  };
-}
-
-export async function commitDeferredConversation(
-  conversationId: string,
-): Promise<void> {
-  const entry = buffers.get(conversationId);
-  if (!entry || entry.state !== "buffered") {
-    return;
-  }
-  buffers.delete(conversationId);
-  for (const params of entry.items) {
-    try {
-      await emitNotificationSignal(params);
-    } catch (err) {
-      log.warn(
-        { err, conversationId },
-        "Buffered notification failed to emit on commit",
-      );
-    }
-  }
-}
-
-/**
- * Drop any buffered signals and tombstone the conversation. The tombstone
- * persists until the turn has been quiet for `TOMBSTONE_TTL_MS`; each late
- * notification observed via `bufferIfDeferred` refreshes the timer.
- */
-export function discardDeferredConversation(conversationId: string): number {
-  const entry = buffers.get(conversationId);
-  if (!entry) {
-    return 0;
-  }
-  const droppedCount = entry.state === "buffered" ? entry.items.length : 0;
-  if (entry.state === "tombstoned") {
-    clearTimeout(entry.timer);
-  }
-  buffers.set(conversationId, {
-    state: "tombstoned",
-    timer: scheduleTombstoneEviction(conversationId),
-  });
-  if (droppedCount > 0) {
-    log.info(
-      { conversationId, droppedCount },
-      "Discarded buffered notifications for failed background job",
-    );
-  }
-  return droppedCount;
-}
-
-/** @internal Test-only reset hook. */
-export function resetDeferredForTest(): void {
-  buffers.clear();
-}