@vellumai/assistant 0.6.5 → 0.6.6

package/src/oauth/scope-policy.ts

@@ -1,89 +0,0 @@
-/**
- * Scope resolution and policy enforcement for OAuth providers.
- *
- * Pure module (no side effects, no I/O) that resolves the final set of
- * scopes for an OAuth flow based on the provider profile's scope policy.
- */
-
-import type { OAuthScopePolicy } from "./connect-types.js";
-
-// ---------------------------------------------------------------------------
-// Result types
-// ---------------------------------------------------------------------------
-
-export type ScopeResolutionResult =
-  | { ok: true; scopes: string[] }
-  | { ok: false; error: string; allowedScopes?: string[] };
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve the final set of scopes for an OAuth flow.
- *
- * - If `requestedScopes` is undefined or empty, returns the provider's
- *   `defaultScopes`.
- * - Otherwise, starts with `defaultScopes` and validates each additional
- *   requested scope against the provider's `scopePolicy`.
- * - Returns a deduplicated union of default + approved requested scopes.
- */
-/** Minimal shape needed by the scope resolver. */
-export interface ScopeResolverInput {
-  service: string;
-  defaultScopes: string[];
-  scopePolicy: OAuthScopePolicy;
-}
-
-export function resolveScopes(
-  profile: ScopeResolverInput,
-  requestedScopes?: string[],
-): ScopeResolutionResult {
-  const { defaultScopes, scopePolicy, service } = profile;
-
-  // No requested scopes — use defaults
-  if (!requestedScopes || requestedScopes.length === 0) {
-    return { ok: true, scopes: [...defaultScopes] };
-  }
-
-  const defaultSet = new Set(defaultScopes);
-  const finalScopes = new Set(defaultScopes);
-
-  for (const scope of requestedScopes) {
-    // Already in defaults — no policy check needed
-    if (defaultSet.has(scope)) {
-      continue;
-    }
-
-    // Check forbidden list first
-    if (scopePolicy.forbiddenScopes.includes(scope)) {
-      return {
-        ok: false,
-        error: `Scope '${scope}' is forbidden for ${service}`,
-      };
-    }
-
-    // Additional scopes not allowed at all
-    if (!scopePolicy.allowAdditionalScopes) {
-      return {
-        ok: false,
-        error: `Additional scopes are not allowed for ${service}. Only the default scopes may be used.`,
-        allowedScopes: [...defaultScopes],
-      };
-    }
-
-    // Additional scopes allowed, but this one isn't in the optional list
-    if (!scopePolicy.allowedOptionalScopes.includes(scope)) {
-      return {
-        ok: false,
-        error: `Scope '${scope}' is not in the allowed optional scopes for ${service}`,
-        allowedScopes: [...defaultScopes, ...scopePolicy.allowedOptionalScopes],
-      };
-    }
-
-    // Passed all checks — include it
-    finalScopes.add(scope);
-  }
-
-  return { ok: true, scopes: [...finalScopes] };
-}

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

package/src/tools/watch/screen-watch.ts

@@ -1,144 +0,0 @@
-import crypto from "node:crypto";
-
-import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
-import { getLogger } from "../../util/logger.js";
-import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
-import type { WatchSession } from "./watch-state.js";
-import {
-  fireWatchCompletionNotifier,
-  fireWatchStartNotifier,
-  getActiveWatchSession,
-  watchSessions,
-} from "./watch-state.js";
-
-const log = getLogger("screen-watch");
-
-const SHORT_HASH_LENGTH = 8;
-
-class ScreenWatchTool implements Tool {
-  name = "start_screen_watch";
-  description =
-    "Start observing the screen at regular intervals for a specified duration. Captures OCR text from the active window and provides periodic commentary.";
-  category = "observation";
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: "object",
-        properties: {
-          duration_minutes: {
-            type: "number",
-            description: "How long to watch in minutes (1-15, default 5)",
-          },
-          interval_seconds: {
-            type: "number",
-            description: "Seconds between screen captures (5-30, default 10)",
-          },
-          focus_area: {
-            type: "string",
-            description: "What to focus on observing",
-          },
-        },
-        required: ["focus_area"],
-      },
-    };
-  }
-
-  async execute(
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolExecutionResult> {
-    const { conversationId } = context;
-
-    // Validate focus_area
-    const focusArea =
-      typeof input.focus_area === "string" && input.focus_area.length > 0
-        ? input.focus_area
-        : undefined;
-
-    if (!focusArea) {
-      return {
-        content: "Error: focus_area is required and must be a non-empty string",
-        isError: true,
-      };
-    }
-
-    // Clamp duration to 1-15 minutes
-    let durationMinutes =
-      typeof input.duration_minutes === "number" ? input.duration_minutes : 5;
-    durationMinutes = Math.max(1, Math.min(15, durationMinutes));
-
-    // Clamp interval to 5-30 seconds
-    let intervalSeconds =
-      typeof input.interval_seconds === "number" ? input.interval_seconds : 10;
-    intervalSeconds = Math.max(5, Math.min(30, intervalSeconds));
-
-    // Check for existing active session
-    const existing = getActiveWatchSession(conversationId);
-    if (existing) {
-      return {
-        content: `Error: An active watch session already exists for this conversation (watchId: ${existing.watchId}, focus: "${existing.focusArea}"). Cancel or wait for it to complete before starting a new one.`,
-        isError: true,
-      };
-    }
-
-    // Generate watchId
-    const watchId = crypto.randomUUID().slice(0, SHORT_HASH_LENGTH);
-    const now = Date.now();
-    const durationSeconds = durationMinutes * 60;
-
-    // Create session
-    const session: WatchSession = {
-      watchId,
-      conversationId,
-      focusArea,
-      durationSeconds,
-      intervalSeconds,
-      observations: [],
-      commentaryCount: 0,
-      status: "active",
-      startedAt: now,
-    };
-
-    // Store in sessions map
-    watchSessions.set(watchId, session);
-
-    // Fire start notifier
-    fireWatchStartNotifier(conversationId, session);
-
-    // Set timeout for duration expiry
-    session.timeoutHandle = setTimeout(() => {
-      session.status = "completing";
-      session.timeoutHandle = undefined;
-      log.info(
-        { watchId, focusArea },
-        "Watch session duration expired, marking as completing",
-      );
-      fireWatchCompletionNotifier(conversationId, session);
-    }, durationSeconds * 1000);
-
-    log.info(
-      { watchId, conversationId, focusArea, durationMinutes, intervalSeconds },
-      "Screen watch session started",
-    );
-
-    const expectedCaptures = Math.floor(durationSeconds / intervalSeconds);
-    const content = [
-      `Screen watch started (watchId: ${watchId})`,
-      `Focus: ${focusArea}`,
-      `Duration: ${durationMinutes} minute${durationMinutes !== 1 ? "s" : ""}`,
-      `Interval: every ${intervalSeconds} seconds`,
-      `Expected captures: ~${expectedCaptures}`,
-      `Started at: ${new Date(now).toISOString()}`,
-      `Expected end: ${new Date(now + durationSeconds * 1000).toISOString()}`,
-    ].join("\n");
-
-    return { content, isError: false };
-  }
-}
-
-export const screenWatchTool = new ScreenWatchTool();