@vellumai/assistant 0.6.4 → 0.6.6

package/src/prompts/update-bulletin.ts

@@ -1,139 +0,0 @@
-import {
-  existsSync,
-  lstatSync,
-  readFileSync,
-  realpathSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-
-import { getConfig } from "../config/loader.js";
-import { getWorkspacePromptPath } from "../util/platform.js";
-import { stripCommentLines } from "../util/strip-comment-lines.js";
-import { APP_VERSION } from "../version.js";
-import {
-  appendReleaseBlock,
-  filterNewContentBlocks,
-  hasReleaseBlock,
-} from "./update-bulletin-format.js";
-import {
-  addActiveRelease,
-  getActiveReleases,
-  isReleaseCompleted,
-  markReleasesCompleted,
-  setActiveReleases,
-} from "./update-bulletin-state.js";
-import { getTemplatePath } from "./update-bulletin-template-path.js";
-
-/**
- * Writes content to a file via a temp-file + rename to prevent partial/truncated
- * writes if the process crashes mid-write.
- */
-function atomicWriteFileSync(filePath: string, content: string): void {
-  const tmpPath = `${filePath}.tmp.${process.pid}`;
-  try {
-    writeFileSync(tmpPath, content, "utf-8");
-    // Resolve symlinks so we rename to the real target, preserving the link.
-    // If the symlink is dangling (target doesn't exist), fall back to writing
-    // through the symlink path directly — realpathSync throws ENOENT for dangling links.
-    let targetPath = filePath;
-    try {
-      if (lstatSync(filePath, { throwIfNoEntry: false })?.isSymbolicLink()) {
-        targetPath = realpathSync(filePath);
-      }
-    } catch (err: unknown) {
-      // Dangling symlink — fall back to writing through the symlink path.
-      // Only swallow ENOENT (dangling target); re-throw ELOOP, EACCES, I/O faults, etc.
-      if (
-        err instanceof Error &&
-        "code" in err &&
-        (err as NodeJS.ErrnoException).code !== "ENOENT"
-      ) {
-        throw err;
-      }
-    }
-    renameSync(tmpPath, targetPath);
-  } catch (err) {
-    try {
-      unlinkSync(tmpPath);
-    } catch {
-      /* ignore cleanup errors */
-    }
-    throw err;
-  }
-}
-
-/**
- * Materializes the current release's update bulletin on startup.
- *
- * First checks for dismissal: if the workspace UPDATES.md was deleted or
- * emptied after we'd previously materialized it, that's an explicit signal
- * (from the user or the assistant) that the current release has been handled.
- * Mark any active releases plus the current release as completed and return
- * without recreating the file.
- *
- * Otherwise reads the bundled UPDATES.md template, strips comment lines, and
- * appends a release block to the workspace UPDATES.md if one doesn't already
- * exist for this version. Skips completed releases entirely.
- */
-export function syncUpdateBulletinOnStartup(): void {
-  if (!getConfig().updates.enabled) return;
-
-  const currentReleaseId = APP_VERSION;
-  const workspacePath = getWorkspacePromptPath("UPDATES.md");
-
-  // --- Dismissal detection ---
-  // If UPDATES.md is missing or empty AND the CURRENT release has been
-  // materialized before (i.e. it's in the active set, or already marked
-  // completed), treat it as a dismissal: mark the active set plus the
-  // current release completed and stop. Scoping to the current release is
-  // critical — a prior release having been completed must NOT cause a new
-  // version's bulletin to be suppressed as "already dismissed". It also
-  // preserves fresh-install semantics: on a brand-new DB we want to create
-  // the file, not treat its absence as dismissal.
-  const activeReleases = getActiveReleases();
-  const fileMissing = !existsSync(workspacePath);
-  const fileEmpty =
-    !fileMissing && readFileSync(workspacePath, "utf-8").trim().length === 0;
-  const currentReleaseMaterialized =
-    activeReleases.includes(currentReleaseId) ||
-    isReleaseCompleted(currentReleaseId);
-
-  if ((fileMissing || fileEmpty) && currentReleaseMaterialized) {
-    markReleasesCompleted([...activeReleases, currentReleaseId]);
-    setActiveReleases([]);
-    return;
-  }
-
-  // --- Template materialization ---
-  const templatePath = getTemplatePath();
-  if (!existsSync(templatePath)) return;
-
-  const rawTemplate = readFileSync(templatePath, "utf-8");
-  const templateContent = stripCommentLines(rawTemplate);
-
-  if (!templateContent || templateContent.trim().length === 0) return;
-
-  if (isReleaseCompleted(currentReleaseId)) return;
-
-  if (!existsSync(workspacePath)) {
-    const content = appendReleaseBlock("", currentReleaseId, templateContent);
-    atomicWriteFileSync(workspacePath, content);
-  } else {
-    const existing = readFileSync(workspacePath, "utf-8");
-    if (!hasReleaseBlock(existing, currentReleaseId)) {
-      const contentToAppend = filterNewContentBlocks(templateContent, existing);
-      if (contentToAppend.length > 0) {
-        const updated = appendReleaseBlock(
-          existing,
-          currentReleaseId,
-          contentToAppend,
-        );
-        atomicWriteFileSync(workspacePath, updated);
-      }
-    }
-  }
-
-  addActiveRelease(currentReleaseId);
-}

package/src/runtime/gateway-internal-client.ts

@@ -1,94 +0,0 @@
-import { getGatewayInternalBaseUrl } from "../config/env.js";
-import { mintEdgeRelayToken } from "./auth/token-service.js";
-
-export class GatewayRequestError extends Error {
-  statusCode: number;
-  gatewayError: string | undefined;
-
-  constructor(
-    message: string,
-    statusCode: number,
-    gatewayError: string | undefined,
-  ) {
-    super(message);
-    this.name = "GatewayRequestError";
-    this.statusCode = statusCode;
-    this.gatewayError = gatewayError;
-  }
-}
-
-/**
- * Parse a non-ok gateway response into a human-readable error message.
- * Matches the existing pattern in contact tools: try JSON parse, extract
- * `.error` string, fall back to raw body text, fall back to status code.
- */
-async function parseErrorResponse(
-  resp: Response,
-): Promise<GatewayRequestError> {
-  const body = await resp.text();
-  let gatewayError: string | undefined;
-  let message = `Gateway request failed (${resp.status})`;
-
-  try {
-    const parsed = JSON.parse(body) as {
-      error?: string | { code?: string; message?: string };
-    };
-    if (parsed.error) {
-      // Runtime httpError() returns { error: { code, message } } while
-      // gateway returns { error: "string" }. Handle both formats.
-      const errStr =
-        typeof parsed.error === "string"
-          ? parsed.error
-          : (parsed.error.message ?? JSON.stringify(parsed.error));
-      gatewayError = errStr;
-      message = errStr;
-    }
-  } catch {
-    if (body) message = body;
-  }
-
-  return new GatewayRequestError(message, resp.status, gatewayError);
-}
-
-export async function gatewayGet<T>(path: string): Promise<T> {
-  const baseUrl = getGatewayInternalBaseUrl();
-  const token = mintEdgeRelayToken();
-
-  const resp = await fetch(`${baseUrl}${path}`, {
-    method: "GET",
-    headers: {
-      Accept: "application/json",
-      Authorization: `Bearer ${token}`,
-    },
-  });
-
-  if (!resp.ok) {
-    throw await parseErrorResponse(resp);
-  }
-
-  return (await resp.json()) as T;
-}
-
-export async function gatewayPost<T>(
-  path: string,
-  body: unknown,
-): Promise<{ status: number; data: T }> {
-  const baseUrl = getGatewayInternalBaseUrl();
-  const token = mintEdgeRelayToken();
-
-  const resp = await fetch(`${baseUrl}${path}`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`,
-    },
-    body: JSON.stringify(body),
-  });
-
-  if (!resp.ok) {
-    throw await parseErrorResponse(resp);
-  }
-
-  const data = (await resp.json()) as T;
-  return { status: resp.status, data };
-}

package/src/runtime/routes/watch-routes.ts

@@ -1,156 +0,0 @@
-/**
- * HTTP route handler for watch (ambient observation) functionality.
- *
- * Decoupled from computer-use routes so that the watch endpoint has
- * zero dependency on CU session state.
- */
-
-import { z } from "zod";
-
-import { getLogger } from "../../util/logger.js";
-import { httpError } from "../http-errors.js";
-import type { RouteDefinition } from "../http-router.js";
-
-const log = getLogger("watch-routes");
-
-// ---------------------------------------------------------------------------
-// Dependency injection interface
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal interface for watch observation handling.
- * The daemon wires a concrete implementation at startup.
- */
-export interface WatchDeps {
-  /** Handle a watch observation. */
-  handleWatchObservation: (params: {
-    watchId: string;
-    conversationId: string;
-    ocrText: string;
-    appName?: string;
-    windowTitle?: string;
-    bundleIdentifier?: string;
-    timestamp: number;
-    captureIndex: number;
-    totalExpected: number;
-  }) => Promise<void>;
-}
-
-// ---------------------------------------------------------------------------
-// Route handler
-// ---------------------------------------------------------------------------
-
-/**
- * POST /v1/computer-use/watch — send a watch observation.
- *
- * Body: { watchId, conversationId, ocrText, appName?, windowTitle?,
- *         bundleIdentifier?, timestamp, captureIndex, totalExpected }
- */
-async function handleWatchObservationRoute(
-  req: Request,
-  deps: WatchDeps,
-): Promise<Response> {
-  const body = (await req.json()) as {
-    watchId?: string;
-    conversationId?: string;
-    ocrText?: string;
-    appName?: string;
-    windowTitle?: string;
-    bundleIdentifier?: string;
-    timestamp?: number;
-    captureIndex?: number;
-    totalExpected?: number;
-  };
-
-  if (!body.watchId || typeof body.watchId !== "string") {
-    return httpError("BAD_REQUEST", "watchId is required", 400);
-  }
-  if (!body.conversationId || typeof body.conversationId !== "string") {
-    return httpError("BAD_REQUEST", "conversationId is required", 400);
-  }
-  if (!body.ocrText || typeof body.ocrText !== "string") {
-    return httpError("BAD_REQUEST", "ocrText is required", 400);
-  }
-  if (typeof body.timestamp !== "number") {
-    return httpError("BAD_REQUEST", "timestamp is required", 400);
-  }
-  if (typeof body.captureIndex !== "number") {
-    return httpError("BAD_REQUEST", "captureIndex is required", 400);
-  }
-  if (typeof body.totalExpected !== "number") {
-    return httpError("BAD_REQUEST", "totalExpected is required", 400);
-  }
-
-  try {
-    await deps.handleWatchObservation({
-      watchId: body.watchId,
-      conversationId: body.conversationId,
-      ocrText: body.ocrText,
-      appName: body.appName,
-      windowTitle: body.windowTitle,
-      bundleIdentifier: body.bundleIdentifier,
-      timestamp: body.timestamp,
-      captureIndex: body.captureIndex,
-      totalExpected: body.totalExpected,
-    });
-
-    return Response.json({ ok: true });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error(
-      { err, watchId: body.watchId },
-      "Failed to handle watch observation via HTTP",
-    );
-    return httpError("INTERNAL_ERROR", message, 500);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Route definitions
-// ---------------------------------------------------------------------------
-
-export function watchRouteDefinitions(deps: {
-  getWatchDeps?: () => WatchDeps;
-}): RouteDefinition[] {
-  const getDeps = (): WatchDeps => {
-    if (!deps.getWatchDeps) {
-      throw new Error("Watch deps not available");
-    }
-    return deps.getWatchDeps();
-  };
-
-  return [
-    {
-      endpoint: "computer-use/watch",
-      method: "POST",
-      policyKey: "computer-use/watch",
-      summary: "Submit watch observation",
-      description: "Send a screen observation from ambient watch mode.",
-      tags: ["computer-use"],
-      handler: async ({ req }) => handleWatchObservationRoute(req, getDeps()),
-      requestBody: z.object({
-        watchId: z.string().describe("Watch session ID"),
-        conversationId: z.string().describe("Conversation to associate with"),
-        ocrText: z.string().describe("OCR text from screen capture"),
-        appName: z.string().describe("Active application name").optional(),
-        windowTitle: z.string().describe("Active window title").optional(),
-        bundleIdentifier: z
-          .string()
-          .describe("Application bundle identifier")
-          .optional(),
-        timestamp: z.number().describe("Capture timestamp (epoch ms)"),
-        captureIndex: z
-          .number()
-          .int()
-          .describe("Index of this capture in the batch"),
-        totalExpected: z
-          .number()
-          .int()
-          .describe("Total captures expected in the batch"),
-      }),
-      responseBody: z.object({
-        ok: z.boolean(),
-      }),
-    },
-  ];
-}

package/src/shared/provider-env-vars.ts

@@ -1,19 +0,0 @@
-/**
- * Provider API key environment variable names, keyed by provider ID.
- *
- * Keep in sync with:
- *   - cli/src/shared/provider-env-vars.ts
- *   - meta/provider-env-vars.json  (consumed by the macOS client build)
- *
- * Once a consolidated shared package exists in packages/, all three
- * copies can be replaced by a single import.
- */
-export const PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
-  anthropic: "ANTHROPIC_API_KEY",
-  openai: "OPENAI_API_KEY",
-  gemini: "GEMINI_API_KEY",
-  fireworks: "FIREWORKS_API_KEY",
-  openrouter: "OPENROUTER_API_KEY",
-  brave: "BRAVE_API_KEY",
-  perplexity: "PERPLEXITY_API_KEY",
-};

package/src/signals/shotgun.ts

@@ -1,203 +0,0 @@
-/**
- * Handle shotgun (screen-watch) signals delivered via signal files from the CLI.
- *
- * Each invocation writes JSON to a unique `signals/shotgun.<requestId>` file.
- * ConfigWatcher detects the new file and invokes {@link handleShotgunSignal},
- * which reads the payload, creates or queries a watch session, and writes
- * the result to `signals/shotgun.<requestId>.result` for the CLI to pick up.
- *
- * Supports two actions:
- * - `start`: Create a new watch session and return the watchId/conversationId.
- * - `status`: Query the status of an existing watch session by watchId.
- */
-
-import crypto from "node:crypto";
-import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { getIsContainerized } from "../config/env-registry.js";
-import {
-  fireWatchCompletionNotifier,
-  fireWatchStartNotifier,
-  type WatchSession,
-  watchSessions,
-} from "../tools/watch/watch-state.js";
-import { getLogger } from "../util/logger.js";
-import { getSignalsDir } from "../util/platform.js";
-
-const log = getLogger("signal:shotgun");
-
-const SHORT_HASH_LENGTH = 8;
-
-interface ShotgunResult {
-  requestId: string;
-  ok: boolean;
-  error?: string;
-  watchId?: string;
-  conversationId?: string;
-  status?: string;
-}
-
-function writeResult(requestId: string, result: ShotgunResult): void {
-  try {
-    writeFileSync(
-      join(getSignalsDir(), `shotgun.${requestId}.result`),
-      JSON.stringify(result),
-    );
-  } catch (err) {
-    log.error({ err, requestId }, "Failed to write shotgun signal result");
-  }
-}
-
-/**
- * Read a `signals/shotgun.<requestId>` file, process the action, and write
- * the result to `signals/shotgun.<requestId>.result`. Called by ConfigWatcher
- * when a matching signal file is created or modified.
- */
-export function handleShotgunSignal(filename: string): void {
-  if (getIsContainerized()) return;
-
-  const signalPath = join(getSignalsDir(), filename);
-  let raw: string;
-  try {
-    raw = readFileSync(signalPath, "utf-8");
-  } catch {
-    return;
-  }
-
-  try {
-    unlinkSync(signalPath);
-  } catch {
-    // Best-effort cleanup.
-  }
-
-  let payload: {
-    requestId?: string;
-    action?: string;
-    durationSeconds?: number;
-    intervalSeconds?: number;
-    focusArea?: string;
-    watchId?: string;
-  };
-  try {
-    payload = JSON.parse(raw) as typeof payload;
-  } catch (err) {
-    log.error({ err, filename }, "Failed to parse shotgun signal file");
-    return;
-  }
-
-  const { requestId } = payload;
-  if (!requestId || typeof requestId !== "string") {
-    log.warn("Shotgun signal missing requestId");
-    return;
-  }
-
-  const { action } = payload;
-
-  if (action === "start") {
-    handleStart(requestId, payload);
-  } else if (action === "status") {
-    handleStatus(requestId, payload);
-  } else {
-    writeResult(requestId, {
-      requestId,
-      ok: false,
-      error: `Unknown action: ${String(action)}`,
-    });
-  }
-}
-
-function handleStart(
-  requestId: string,
-  payload: {
-    durationSeconds?: number;
-    intervalSeconds?: number;
-    focusArea?: string;
-  },
-): void {
-  const durationSeconds =
-    typeof payload.durationSeconds === "number" && payload.durationSeconds > 0
-      ? payload.durationSeconds
-      : 300;
-
-  const intervalSeconds =
-    typeof payload.intervalSeconds === "number" && payload.intervalSeconds > 0
-      ? payload.intervalSeconds
-      : 5;
-
-  const focusArea =
-    typeof payload.focusArea === "string" && payload.focusArea.length > 0
-      ? payload.focusArea
-      : "general observation";
-
-  const watchId = crypto.randomUUID().slice(0, SHORT_HASH_LENGTH);
-  const conversationId = `shotgun-${watchId}`;
-  const now = Date.now();
-
-  const session: WatchSession = {
-    watchId,
-    conversationId,
-    focusArea,
-    durationSeconds,
-    intervalSeconds,
-    observations: [],
-    commentaryCount: 0,
-    status: "active",
-    startedAt: now,
-  };
-
-  watchSessions.set(watchId, session);
-  fireWatchStartNotifier(conversationId, session);
-
-  session.timeoutHandle = setTimeout(() => {
-    session.status = "completing";
-    session.timeoutHandle = undefined;
-    log.info(
-      { watchId, focusArea },
-      "Shotgun session duration expired, marking as completing",
-    );
-    fireWatchCompletionNotifier(conversationId, session);
-  }, durationSeconds * 1000);
-
-  log.info(
-    { watchId, conversationId, focusArea, durationSeconds, intervalSeconds },
-    "Shotgun watch session started via signal",
-  );
-
-  writeResult(requestId, {
-    requestId,
-    ok: true,
-    watchId,
-    conversationId,
-  });
-}
-
-function handleStatus(requestId: string, payload: { watchId?: string }): void {
-  const { watchId } = payload;
-  if (!watchId || typeof watchId !== "string") {
-    writeResult(requestId, {
-      requestId,
-      ok: false,
-      error: "Missing watchId for status query",
-    });
-    return;
-  }
-
-  const session = watchSessions.get(watchId);
-  if (!session) {
-    writeResult(requestId, {
-      requestId,
-      ok: false,
-      error: `No watch session found for watchId: ${watchId}`,
-    });
-    return;
-  }
-
-  writeResult(requestId, {
-    requestId,
-    ok: true,
-    watchId,
-    conversationId: session.conversationId,
-    status: session.status,
-  });
-}