vellum 0.2.13 → 0.3.2

package/src/tools/apps/registry.ts

@@ -1,16 +0,0 @@
-/**
- * Registers app proxy tools with the daemon's tool registry.
- *
- * Called once at daemon startup via initializeTools(). Only proxy tools
- * (e.g. app_open) are registered here — non-proxy data tools are now
- * provided by the app-builder skill via its TOOLS.json manifest.
- */
-
-import { registerTool } from '../registry.js';
-import { coreAppProxyTools } from './definitions.js';
-
-export function registerAppTools(): void {
-  for (const tool of coreAppProxyTools) {
-    registerTool(tool);
-  }
-}

package/src/tools/assets/materialize.ts

@@ -1,218 +0,0 @@
-/**
- * asset_materialize — write a stored attachment to a sandbox file path.
- *
- * Accepts an attachment ID (from asset_search) and a destination path
- * within the sandbox working directory. Decodes the base64 content and
- * writes it to disk so scripts and other tools can consume it as a
- * regular file.
- */
-
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { eq } from 'drizzle-orm';
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
-import { getDb } from '../../memory/db.js';
-import { attachments } from '../../memory/schema.js';
-import { sandboxPolicy } from '../shared/filesystem/path-policy.js';
-import { isAttachmentVisible, type AttachmentContext } from '../../daemon/media-visibility-policy.js';
-import { getConversationThreadType } from '../../memory/conversation-store.js';
-import { getAttachmentSourceConversations } from './search.js';
-
-// ---------------------------------------------------------------------------
-// Size limit — prevent materializing excessively large attachments
-// ---------------------------------------------------------------------------
-
-/** 50 MB ceiling for materialized files. */
-export const MAX_MATERIALIZE_BYTES = 50 * 1024 * 1024;
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function formatBytes(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
-/**
- * Load an attachment row (including base64 data) by its primary key.
- *
- * Not scoped by assistantId because ToolContext doesn't carry it.
- * Cross-thread isolation is enforced by the visibility check in execute().
- */
-function loadAttachmentById(
-  attachmentId: string,
-): { id: string; originalFilename: string; mimeType: string; sizeBytes: number; dataBase64: string } | null {
-  const db = getDb();
-  const row = db
-    .select({
-      id: attachments.id,
-      originalFilename: attachments.originalFilename,
-      mimeType: attachments.mimeType,
-      sizeBytes: attachments.sizeBytes,
-      dataBase64: attachments.dataBase64,
-    })
-    .from(attachments)
-    .where(eq(attachments.id, attachmentId))
-    .get();
-
-  return row ?? null;
-}
-
-// ---------------------------------------------------------------------------
-// Tool definition
-// ---------------------------------------------------------------------------
-
-const definition: ToolDefinition = {
-  name: 'asset_materialize',
-  description:
-    'Copy a stored attachment to a file on disk inside the sandbox directory. ' +
-    'Use attachment IDs from asset_search results. The file can then be used ' +
-    'as input to scripts, tools, or other processing.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      attachment_id: {
-        type: 'string',
-        description: 'The ID of the attachment to materialize (from asset_search results).',
-      },
-      destination_path: {
-        type: 'string',
-        description:
-          'Path where the file should be written, relative to (or inside) the sandbox working directory.',
-      },
-    },
-    required: ['attachment_id', 'destination_path'],
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Tool class
-// ---------------------------------------------------------------------------
-
-class AssetMaterializeTool implements Tool {
-  name = 'asset_materialize';
-  description = definition.description;
-  category = 'assets';
-  defaultRiskLevel = RiskLevel.Medium;
-
-  getDefinition(): ToolDefinition {
-    return definition;
-  }
-
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const attachmentId = input.attachment_id as string | undefined;
-    const destinationPath = input.destination_path as string | undefined;
-
-    // --- Input validation ---------------------------------------------------
-
-    if (!attachmentId || typeof attachmentId !== 'string') {
-      return {
-        content: 'Error: attachment_id is required and must be a string.',
-        isError: true,
-      };
-    }
-
-    if (!destinationPath || typeof destinationPath !== 'string') {
-      return {
-        content: 'Error: destination_path is required and must be a string.',
-        isError: true,
-      };
-    }
-
-    // --- Sandbox path enforcement -------------------------------------------
-
-    const pathCheck = sandboxPolicy(destinationPath, context.workingDir, { mustExist: false });
-    if (!pathCheck.ok) {
-      return {
-        content: `Error: ${pathCheck.error}`,
-        isError: true,
-      };
-    }
-
-    const resolvedPath = pathCheck.resolved;
-
-    // --- Load attachment ----------------------------------------------------
-
-    const attachment = loadAttachmentById(attachmentId);
-    if (!attachment) {
-      return {
-        content: `Error: Attachment "${attachmentId}" not found.`,
-        isError: true,
-      };
-    }
-
-    // --- Visibility check ---------------------------------------------------
-    // Reject materialization of attachments from private threads the caller
-    // does not belong to. This prevents cross-thread data leakage.
-
-    const currentThreadType = getConversationThreadType(context.conversationId);
-    const currentContext: AttachmentContext = {
-      conversationId: context.conversationId,
-      isPrivate: currentThreadType === 'private',
-    };
-
-    const sources = getAttachmentSourceConversations(attachmentId);
-    if (sources.length > 0) {
-      const hasStandard = sources.some((s) => s.threadType !== 'private');
-      if (!hasStandard) {
-        // All sources are private — check if the caller is in any of those threads
-        const callerInSourceThread = sources.some(
-          (s) => isAttachmentVisible(
-            { conversationId: s.conversationId, isPrivate: true },
-            currentContext,
-          ),
-        );
-        if (!callerInSourceThread) {
-          return {
-            content:
-              `Error: Attachment "${attachment.originalFilename}" is from a private thread ` +
-              `and cannot be accessed from this context. You can only access this ` +
-              `attachment from within the private thread where it was shared.`,
-            isError: true,
-          };
-        }
-      }
-    }
-
-    // --- Size check ---------------------------------------------------------
-
-    if (attachment.sizeBytes > MAX_MATERIALIZE_BYTES) {
-      return {
-        content:
-          `Error: Attachment "${attachment.originalFilename}" is ${formatBytes(attachment.sizeBytes)}, ` +
-          `which exceeds the ${formatBytes(MAX_MATERIALIZE_BYTES)} materialization limit.`,
-        isError: true,
-      };
-    }
-
-    // --- Decode and write ---------------------------------------------------
-
-    try {
-      const buffer = Buffer.from(attachment.dataBase64, 'base64');
-
-      // Ensure parent directories exist
-      mkdirSync(dirname(resolvedPath), { recursive: true });
-
-      writeFileSync(resolvedPath, buffer);
-
-      return {
-        content:
-          `Materialized "${attachment.originalFilename}" (${attachment.mimeType}, ` +
-          `${formatBytes(attachment.sizeBytes)}) to ${resolvedPath}`,
-        isError: false,
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Error writing file: ${msg}`, isError: true };
-    }
-  }
-}
-
-export const assetMaterializeTool = new AssetMaterializeTool();
-
-registerTool(assetMaterializeTool);

package/src/tools/assets/search.ts

@@ -1,361 +0,0 @@
-/**
- * asset_search — cross-thread attachment metadata search.
- *
- * Queries the attachments store for matching assets by MIME type,
- * filename, recency, or conversation scope. Returns metadata and
- * attachment IDs only — never base64 payloads. The IDs can be
- * passed to asset_materialize (PR 35) to retrieve actual content.
- */
-
-import { and, eq, like, gte, desc } from 'drizzle-orm';
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
-import { getDb } from '../../memory/db.js';
-import { attachments, messageAttachments, messages, conversations } from '../../memory/schema.js';
-import type { StoredAttachment } from '../../memory/attachments-store.js';
-import { isAttachmentVisible, type AttachmentContext } from '../../daemon/media-visibility-policy.js';
-import { getConversationThreadType } from '../../memory/conversation-store.js';
-import { escapeLikeWildcards } from '../../memory/search/lexical.js';
-
-// ---------------------------------------------------------------------------
-// Recency presets — map human-readable labels to epoch-ms cutoff offsets
-// ---------------------------------------------------------------------------
-
-const RECENCY_MS: Record<string, number> = {
-  last_hour: 60 * 60 * 1000,
-  last_24_hours: 24 * 60 * 60 * 1000,
-  last_7_days: 7 * 24 * 60 * 60 * 1000,
-  last_30_days: 30 * 24 * 60 * 60 * 1000,
-  last_90_days: 90 * 24 * 60 * 60 * 1000,
-};
-
-const VALID_RECENCY_VALUES = Object.keys(RECENCY_MS);
-
-// ---------------------------------------------------------------------------
-// Result formatting
-// ---------------------------------------------------------------------------
-
-function formatBytes(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
-function formatAttachment(a: StoredAttachment): string {
-  const date = new Date(a.createdAt).toISOString();
-  return [
-    `- **${a.originalFilename}** (ID: ${a.id})`,
-    `  Type: ${a.mimeType} | Kind: ${a.kind} | Size: ${formatBytes(a.sizeBytes)}`,
-    `  Created: ${date}`,
-  ].join('\n');
-}
-
-// ---------------------------------------------------------------------------
-// Attachment source conversation lookup
-// ---------------------------------------------------------------------------
-
-/**
- * Look up which conversations an attachment belongs to, along with each
- * conversation's thread type. An attachment can be linked to multiple
- * messages across multiple conversations.
- */
-export function getAttachmentSourceConversations(
-  attachmentId: string,
-): Array<{ conversationId: string; threadType: string }> {
-  const db = getDb();
-  return db
-    .select({
-      conversationId: messages.conversationId,
-      threadType: conversations.threadType,
-    })
-    .from(messageAttachments)
-    .innerJoin(messages, eq(messages.id, messageAttachments.messageId))
-    .innerJoin(conversations, eq(conversations.id, messages.conversationId))
-    .where(eq(messageAttachments.attachmentId, attachmentId))
-    .all();
-}
-
-/**
- * Check whether an attachment is visible from the given context.
- * Returns true if visible, false if hidden.
- *
- * - Orphan attachments (no message linkage) are universally visible.
- * - Attachments with any standard-thread source are universally visible.
- * - All-private attachments are visible only if the caller is in one of
- *   the source private threads.
- */
-function isAttachmentVisibleFromContext(attachmentId: string, currentContext: AttachmentContext): boolean {
-  const sources = getAttachmentSourceConversations(attachmentId);
-  if (sources.length === 0) {
-    return true;
-  }
-
-  const hasStandard = sources.some((s) => s.threadType !== 'private');
-  if (hasStandard) {
-    return true;
-  }
-
-  // All sources are private — visible only if the caller is in one of those threads
-  return sources.some(
-    (s) => isAttachmentVisible({ conversationId: s.conversationId, isPrivate: true }, currentContext),
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Search logic
-// ---------------------------------------------------------------------------
-
-export interface AssetSearchParams {
-  mime_type?: string;
-  filename?: string;
-  recency?: string;
-  conversation_id?: string;
-  limit?: number;
-}
-
-const MAX_RESULTS = 100;
-const DEFAULT_LIMIT = 20;
-
-export function searchAttachments(params: AssetSearchParams): StoredAttachment[] {
-  const db = getDb();
-  const conditions = [];
-
-  // MIME type filter — supports wildcards like 'image/*' via LIKE
-  if (params.mime_type) {
-    const mimePattern = params.mime_type.replace(/\*/g, '%');
-    conditions.push(like(attachments.mimeType, mimePattern));
-  }
-
-  // Filename filter — case-insensitive substring match (escape LIKE wildcards)
-  if (params.filename) {
-    conditions.push(like(attachments.originalFilename, `%${escapeLikeWildcards(params.filename)}%`));
-  }
-
-  // Recency filter — computed cutoff timestamp
-  if (params.recency) {
-    const offsetMs = RECENCY_MS[params.recency];
-    if (offsetMs) {
-      const cutoff = Date.now() - offsetMs;
-      conditions.push(gte(attachments.createdAt, cutoff));
-    }
-  }
-
-  // Conversation scope — join through message_attachments + messages
-  if (params.conversation_id) {
-    const linkedIds = db
-      .select({ attachmentId: messageAttachments.attachmentId })
-      .from(messageAttachments)
-      .innerJoin(messages, eq(messages.id, messageAttachments.messageId))
-      .where(eq(messages.conversationId, params.conversation_id))
-      .all()
-      .map((r) => r.attachmentId)
-      .filter((id): id is string => id !== null);
-
-    if (linkedIds.length === 0) {
-      return [];
-    }
-
-    // Use raw SQL IN clause for the attachment ID set
-    const raw = (db as unknown as { $client: import('bun:sqlite').Database }).$client;
-    const placeholders = linkedIds.map(() => '?').join(', ');
-
-    // Build WHERE clauses for raw query
-    const whereParts: string[] = [`a.id IN (${placeholders})`];
-    const bindValues: (string | number)[] = [...linkedIds];
-
-    if (params.mime_type) {
-      const mimePattern = params.mime_type.replace(/\*/g, '%');
-      whereParts.push(`a.mime_type LIKE ?`);
-      bindValues.push(mimePattern);
-    }
-    if (params.filename) {
-      whereParts.push(`a.original_filename LIKE ?`);
-      bindValues.push(`%${escapeLikeWildcards(params.filename)}%`);
-    }
-    if (params.recency) {
-      const offsetMs = RECENCY_MS[params.recency];
-      if (offsetMs) {
-        whereParts.push(`a.created_at >= ?`);
-        bindValues.push(Date.now() - offsetMs);
-      }
-    }
-    const limit = Math.min(params.limit ?? DEFAULT_LIMIT, MAX_RESULTS);
-    const stmt = raw.prepare(
-      `SELECT a.id, a.original_filename, a.mime_type, a.size_bytes, a.kind, a.thumbnail_base64, a.created_at
-       FROM attachments a
-       WHERE ${whereParts.join(' AND ')}
-       ORDER BY a.created_at DESC
-       LIMIT ?`,
-    );
-
-    const rows = stmt.all(...bindValues, limit) as Array<{
-      id: string;
-      original_filename: string;
-      mime_type: string;
-      size_bytes: number;
-      kind: string;
-      thumbnail_base64: string | null;
-      created_at: number;
-    }>;
-
-    return rows.map((r) => ({
-      id: r.id,
-      originalFilename: r.original_filename,
-      mimeType: r.mime_type,
-      sizeBytes: r.size_bytes,
-      kind: r.kind,
-      thumbnailBase64: r.thumbnail_base64,
-      createdAt: r.created_at,
-    }));
-  }
-
-  // No conversation constraint — query attachments table directly
-  const limit = Math.min(params.limit ?? DEFAULT_LIMIT, MAX_RESULTS);
-  const where = conditions.length > 0 ? and(...conditions) : undefined;
-
-  const query = db
-    .select({
-      id: attachments.id,
-      originalFilename: attachments.originalFilename,
-      mimeType: attachments.mimeType,
-      sizeBytes: attachments.sizeBytes,
-      kind: attachments.kind,
-      thumbnailBase64: attachments.thumbnailBase64,
-      createdAt: attachments.createdAt,
-    })
-    .from(attachments)
-    .orderBy(desc(attachments.createdAt))
-    .limit(limit);
-
-  if (where) {
-    return query.where(where).all();
-  }
-  return query.all();
-}
-
-// ---------------------------------------------------------------------------
-// Tool definition
-// ---------------------------------------------------------------------------
-
-const definition: ToolDefinition = {
-  name: 'asset_search',
-  description:
-    'Search for previously uploaded media assets (images, documents, etc.) by metadata. ' +
-    'Returns attachment IDs and metadata — not file content. Use the returned IDs with ' +
-    'asset_materialize to retrieve actual file data.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      mime_type: {
-        type: 'string',
-        description:
-          'Filter by MIME type. Supports wildcards: "image/*" matches all images, ' +
-          '"application/pdf" matches PDFs exactly.',
-      },
-      filename: {
-        type: 'string',
-        description: 'Search by original filename (case-insensitive substring match).',
-      },
-      recency: {
-        type: 'string',
-        enum: VALID_RECENCY_VALUES,
-        description:
-          'Filter by recency. One of: last_hour, last_24_hours, last_7_days, last_30_days, last_90_days.',
-      },
-      conversation_id: {
-        type: 'string',
-        description:
-          'Constrain results to attachments linked to messages in a specific conversation.',
-      },
-      limit: {
-        type: 'number',
-        description: `Maximum results to return (default ${DEFAULT_LIMIT}, max ${MAX_RESULTS}).`,
-      },
-    },
-    required: [],
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Tool class
-// ---------------------------------------------------------------------------
-
-class AssetSearchTool implements Tool {
-  name = 'asset_search';
-  description = definition.description;
-  category = 'assets';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return definition;
-  }
-
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const mimeType = input.mime_type as string | undefined;
-    const filename = input.filename as string | undefined;
-    const recency = input.recency as string | undefined;
-    const conversationId = input.conversation_id as string | undefined;
-    const limit = input.limit as number | undefined;
-
-    // Validate recency if provided
-    if (recency && !RECENCY_MS[recency]) {
-      return {
-        content: `Error: Invalid recency value "${recency}". Valid values: ${VALID_RECENCY_VALUES.join(', ')}`,
-        isError: true,
-      };
-    }
-
-    // Validate limit if provided
-    if (limit !== undefined && (typeof limit !== 'number' || limit < 1)) {
-      return {
-        content: 'Error: limit must be a positive number.',
-        isError: true,
-      };
-    }
-
-    try {
-      // Over-fetch with MAX_RESULTS so visibility filtering doesn't
-      // under-fill the caller's requested limit.
-      const results = searchAttachments({
-        mime_type: mimeType,
-        filename,
-        recency,
-        conversation_id: conversationId,
-        limit: MAX_RESULTS,
-      });
-
-      // Enforce private-thread visibility: filter out attachments that
-      // belong exclusively to private threads the caller cannot access.
-      const currentThreadType = getConversationThreadType(context.conversationId);
-      const currentContext: AttachmentContext = {
-        conversationId: context.conversationId,
-        isPrivate: currentThreadType === 'private',
-      };
-
-      const effectiveLimit = Math.min(limit ?? DEFAULT_LIMIT, MAX_RESULTS);
-      const visible = results
-        .filter((attachment) => isAttachmentVisibleFromContext(attachment.id, currentContext))
-        .slice(0, effectiveLimit);
-
-      if (visible.length === 0) {
-        return { content: 'No assets found matching the search criteria.', isError: false };
-      }
-
-      const lines = [`Found ${visible.length} asset(s):\n`];
-      for (const attachment of visible) {
-        lines.push(formatAttachment(attachment));
-      }
-
-      return { content: lines.join('\n'), isError: false };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Error: ${msg}`, isError: true };
-    }
-  }
-}
-
-export const assetSearchTool = new AssetSearchTool();
-
-registerTool(assetSearchTool);