vellum 0.0.16 → 0.2.0

package/src/daemon/handlers/work-items.ts

@@ -0,0 +1,176 @@
+import * as net from 'node:net';
+import type {
+  WorkItemsListRequest,
+  WorkItemGetRequest,
+  WorkItemCreateRequest,
+  WorkItemUpdateRequest,
+  WorkItemCompleteRequest,
+  WorkItemRunTaskRequest,
+} from '../ipc-protocol.js';
+import { log, type HandlerContext } from './shared.js';
+import {
+  createWorkItem,
+  getWorkItem,
+  listWorkItems,
+  updateWorkItem,
+  type WorkItemStatus,
+} from '../../work-items/work-item-store.js';
+import { getTask } from '../../tasks/task-store.js';
+import { runTask } from '../../tasks/task-runner.js';
+
+export function handleWorkItemsList(
+  msg: WorkItemsListRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  const items = listWorkItems(msg.status ? { status: msg.status as WorkItemStatus } : undefined);
+  ctx.send(socket, { type: 'work_items_list_response', items });
+}
+
+export function handleWorkItemGet(
+  msg: WorkItemGetRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  const item = getWorkItem(msg.id) ?? null;
+  ctx.send(socket, { type: 'work_item_get_response', item });
+}
+
+export function handleWorkItemCreate(
+  msg: WorkItemCreateRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  const task = getTask(msg.taskId);
+  if (!task) {
+    ctx.send(socket, { type: 'error', message: `Task not found: ${msg.taskId}` });
+    return;
+  }
+  const item = createWorkItem({
+    taskId: msg.taskId,
+    title: msg.title ?? task.title,
+    notes: msg.notes,
+    priorityTier: msg.priorityTier,
+    sortIndex: msg.sortIndex,
+  });
+  ctx.send(socket, { type: 'work_item_create_response', item });
+
+  // Notify all connected clients so open Task Queue views refresh immediately
+  broadcastWorkItemStatus(ctx, item.id);
+}
+
+export function handleWorkItemUpdate(
+  msg: WorkItemUpdateRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  const updates: Record<string, unknown> = {};
+  if (msg.title !== undefined) updates.title = msg.title;
+  if (msg.notes !== undefined) updates.notes = msg.notes;
+  if (msg.status !== undefined) updates.status = msg.status;
+  if (msg.priorityTier !== undefined) updates.priorityTier = msg.priorityTier;
+  if (msg.sortIndex !== undefined) updates.sortIndex = msg.sortIndex;
+
+  const item = updateWorkItem(msg.id, updates as Parameters<typeof updateWorkItem>[1]) ?? null;
+  ctx.send(socket, { type: 'work_item_update_response', item });
+
+  // Broadcast to all clients so other open task views stay in sync
+  // (e.g. priority/sort changes made by one client are reflected everywhere)
+  if (item) {
+    broadcastWorkItemStatus(ctx, item.id);
+  }
+}
+
+export function handleWorkItemComplete(
+  msg: WorkItemCompleteRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  const item = updateWorkItem(msg.id, { status: 'done' }) ?? null;
+  ctx.send(socket, { type: 'work_item_update_response', item });
+  if (item) {
+    ctx.broadcast({
+      type: 'work_item_status_changed',
+      item: {
+        id: item.id,
+        taskId: item.taskId,
+        title: item.title,
+        status: item.status,
+        lastRunId: item.lastRunId,
+        lastRunConversationId: item.lastRunConversationId,
+        lastRunStatus: item.lastRunStatus,
+        updatedAt: item.updatedAt,
+      },
+    });
+  }
+}
+
+function broadcastWorkItemStatus(ctx: HandlerContext, id: string): void {
+  const item = getWorkItem(id);
+  if (item) {
+    ctx.broadcast({
+      type: 'work_item_status_changed',
+      item: {
+        id: item.id,
+        taskId: item.taskId,
+        title: item.title,
+        status: item.status,
+        lastRunId: item.lastRunId,
+        lastRunConversationId: item.lastRunConversationId,
+        lastRunStatus: item.lastRunStatus,
+        updatedAt: item.updatedAt,
+      },
+    });
+  }
+}
+
+export async function handleWorkItemRunTask(
+  msg: WorkItemRunTaskRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  const workItem = getWorkItem(msg.id);
+  if (!workItem) {
+    ctx.send(socket, { type: 'work_item_run_task_response', id: msg.id, lastRunId: '', success: false, error: 'Work item not found' });
+    return;
+  }
+
+  // Set status to running
+  updateWorkItem(msg.id, { status: 'running' });
+
+  // Return immediately with acknowledgment
+  ctx.send(socket, { type: 'work_item_run_task_response', id: msg.id, lastRunId: '', success: true });
+
+  // Broadcast the running state
+  broadcastWorkItemStatus(ctx, msg.id);
+
+  // Execute task asynchronously — create a session and wire processMessage
+  try {
+    const session = await ctx.getOrCreateSession(crypto.randomUUID());
+    const result = await runTask(
+      { taskId: workItem.taskId, workingDir: process.cwd() },
+      async (_conversationId, message) => {
+        await session.processMessage(message, [], (event) => {
+          ctx.broadcast(event);
+        });
+      },
+    );
+
+    const finalStatus: WorkItemStatus = result.status === 'completed' ? 'awaiting_review' : 'failed';
+    updateWorkItem(msg.id, {
+      status: finalStatus,
+      lastRunId: result.taskRunId,
+      lastRunConversationId: result.conversationId,
+      lastRunStatus: result.status,
+    });
+
+    broadcastWorkItemStatus(ctx, msg.id);
+  } catch (err) {
+    log.error({ err, workItemId: msg.id }, 'work_item_run_task failed');
+    updateWorkItem(msg.id, {
+      status: 'failed',
+      lastRunStatus: 'failed',
+    });
+    broadcastWorkItemStatus(ctx, msg.id);
+  }
+}

package/src/daemon/handlers.ts

@@ -0,0 +1,17 @@
+// Re-export everything from the decomposed handler modules.
+// This file exists for backwards compatibility — all imports from
+// './handlers.js' continue to work without changes.
+export {
+  handleMessage,
+  renderHistoryContent,
+  mergeToolResults,
+} from './handlers/index.js';
+
+export type {
+  HandlerContext,
+  SessionCreateOptions,
+  HistoryToolCall,
+  HistorySurface,
+  RenderedHistoryContent,
+  ParsedHistoryMessage,
+} from './handlers/index.js';

package/src/daemon/history-repair.ts

@@ -0,0 +1,214 @@
+import type {
+  Message,
+  ContentBlock,
+  ToolUseContent,
+  ToolResultContent,
+} from '../providers/types.js';
+
+export interface RepairStats {
+  assistantToolResultsMigrated: number;
+  missingToolResultsInserted: number;
+  orphanToolResultsDowngraded: number;
+  consecutiveSameRoleMerged: number;
+}
+
+export interface RepairResult {
+  messages: Message[];
+  stats: RepairStats;
+}
+
+const SYNTHETIC_RESULT = '<synthesized_result>tool result missing from history</synthesized_result>';
+
+export function repairHistory(messages: Message[]): RepairResult {
+  const stats: RepairStats = {
+    assistantToolResultsMigrated: 0,
+    missingToolResultsInserted: 0,
+    orphanToolResultsDowngraded: 0,
+    consecutiveSameRoleMerged: 0,
+  };
+
+  const result: Message[] = [];
+  let pendingToolUseIds = new Set<string>();
+  // tool_result blocks stripped from assistant messages, keyed by tool_use_id
+  let recoveredResults = new Map<string, ToolResultContent>();
+
+  for (const msg of messages) {
+    if (msg.role === 'assistant') {
+      // If previous assistant had unfulfilled tool_use, inject user message
+      // using recovered results where available, synthetic for the rest
+      if (pendingToolUseIds.size > 0) {
+        result.push(
+          buildResultMessage(pendingToolUseIds, recoveredResults, stats),
+        );
+        pendingToolUseIds = new Set();
+        recoveredResults = new Map();
+      }
+
+      // Strip tool_result blocks from assistant messages, preserving them
+      // so they can be migrated to the correct user message position
+      const cleanedContent: ContentBlock[] = [];
+      const newRecovered = new Map<string, ToolResultContent>();
+      for (const block of msg.content) {
+        if (block.type === 'tool_result') {
+          const tr = block as ToolResultContent;
+          newRecovered.set(tr.tool_use_id, tr);
+          stats.assistantToolResultsMigrated++;
+        } else {
+          cleanedContent.push(block);
+        }
+      }
+
+      result.push({ role: 'assistant', content: cleanedContent });
+
+      // Collect tool_use IDs from this assistant message
+      pendingToolUseIds = new Set(
+        cleanedContent
+          .filter((b): b is ToolUseContent => b.type === 'tool_use')
+          .map((b) => b.id),
+      );
+      recoveredResults = newRecovered;
+    } else {
+      // User message
+      if (pendingToolUseIds.size > 0) {
+        const matchedIds = new Set<string>();
+        const newContent: ContentBlock[] = [];
+
+        for (const block of msg.content) {
+          if (block.type === 'tool_result') {
+            const tr = block as ToolResultContent;
+            if (pendingToolUseIds.has(tr.tool_use_id)) {
+              matchedIds.add(tr.tool_use_id);
+              newContent.push(block);
+            } else {
+              stats.orphanToolResultsDowngraded++;
+              newContent.push(downgradeToolResult(tr));
+            }
+          } else {
+            newContent.push(block);
+          }
+        }
+
+        // Fill unmatched IDs: use recovered results if available, otherwise synthesize
+        for (const id of pendingToolUseIds) {
+          if (!matchedIds.has(id)) {
+            const recovered = recoveredResults.get(id);
+            if (recovered) {
+              newContent.push(recovered);
+              // Already counted in assistantToolResultsMigrated
+            } else {
+              stats.missingToolResultsInserted++;
+              newContent.push({
+                type: 'tool_result',
+                tool_use_id: id,
+                content: SYNTHETIC_RESULT,
+                is_error: true,
+              });
+            }
+          }
+        }
+
+        result.push({ role: 'user', content: newContent });
+        pendingToolUseIds = new Set();
+        recoveredResults = new Map();
+      } else {
+        // No pending tool_use — any tool_result here is orphaned
+        const newContent: ContentBlock[] = msg.content.map((block) => {
+          if (block.type === 'tool_result') {
+            stats.orphanToolResultsDowngraded++;
+            return downgradeToolResult(block as ToolResultContent);
+          }
+          return block;
+        });
+
+        result.push({ role: 'user', content: newContent });
+      }
+    }
+  }
+
+  // Trailing unfulfilled tool_use at end of history
+  if (pendingToolUseIds.size > 0) {
+    result.push(buildResultMessage(pendingToolUseIds, recoveredResults, stats));
+  }
+
+  // Merge consecutive same-role messages. This can occur after a checkpoint
+  // handoff where a user(tool_result) message is followed by a user(new_message),
+  // or from other history reconstruction artifacts. The Anthropic API requires
+  // strict user/assistant alternation, so consecutive same-role messages must
+  // always be merged. Undo semantics for mixed tool_result+text messages are
+  // handled by isUndoableUserMessage in session.ts.
+  const merged: Message[] = [];
+  for (const msg of result) {
+    const prev = merged[merged.length - 1];
+    if (prev && prev.role === msg.role) {
+      prev.content = [...prev.content, ...msg.content];
+      stats.consecutiveSameRoleMerged++;
+    } else {
+      merged.push({ role: msg.role, content: [...msg.content] });
+    }
+  }
+
+  return { messages: merged, stats };
+}
+
+function buildResultMessage(
+  ids: Set<string>,
+  recovered: Map<string, ToolResultContent>,
+  stats: RepairStats,
+): Message {
+  return {
+    role: 'user',
+    content: Array.from(ids).map((id) => {
+      const rec = recovered.get(id);
+      if (rec) {
+        // Already counted in assistantToolResultsMigrated
+        return rec;
+      }
+      stats.missingToolResultsInserted++;
+      return {
+        type: 'tool_result' as const,
+        tool_use_id: id,
+        content: SYNTHETIC_RESULT,
+        is_error: true,
+      };
+    }),
+  };
+}
+
+/**
+ * Aggressive repair pass that handles edge cases beyond repairHistory:
+ * - Removes empty messages
+ * - Ensures the first message is from the user
+ * - Merges consecutive same-role messages (before tool-use/result repair)
+ * Then applies the standard repairHistory on top (which also merges any
+ * consecutive same-role messages introduced by tool-use/result repair).
+ */
+export function deepRepairHistory(messages: Message[]): RepairResult {
+  // 1. Remove messages with no content blocks
+  let cleaned = messages.filter((m) => m.content.length > 0);
+
+  // 2. Strip leading assistant messages (provider requires user-first)
+  while (cleaned.length > 0 && cleaned[0].role === 'assistant') {
+    cleaned = cleaned.slice(1);
+  }
+
+  // 3. Merge consecutive same-role messages
+  const merged: Message[] = [];
+  for (const msg of cleaned) {
+    const prev = merged[merged.length - 1];
+    if (prev && prev.role === msg.role) {
+      prev.content = [...prev.content, ...msg.content];
+    } else {
+      merged.push({ role: msg.role, content: [...msg.content] });
+    }
+  }
+
+  // 4. Apply standard tool-use/tool-result repair on top
+  return repairHistory(merged);
+}
+
+function downgradeToolResult(tr: ToolResultContent): ContentBlock {
+  return {
+    type: 'text',
+    text: `[orphaned tool_result for ${tr.tool_use_id}]: ${tr.content}`,
+  };
+}

package/src/daemon/ipc-blob-store.ts

@@ -0,0 +1,231 @@
+import { getIpcBlobDir } from '../util/platform.js';
+import { getLogger } from '../util/logger.js';
+import type { IpcBlobRef } from './ipc-contract.js';
+import {
+  mkdirSync,
+  existsSync,
+  unlinkSync,
+  lstatSync,
+  realpathSync,
+} from 'node:fs';
+import { readFile, readdir, lstat, realpath, unlink } from 'node:fs/promises';
+import { join, resolve, relative, sep } from 'node:path';
+import { createHash } from 'node:crypto';
+
+const log = getLogger('ipc-blob-store');
+
+const BLOB_ID_REGEX = /^[0-9a-fA-F-]{36}$/;
+const MAX_SCREENSHOT_BLOB_SIZE = 10 * 1024 * 1024; // 10 MB
+const MAX_AX_BLOB_SIZE = 2 * 1024 * 1024; // 2 MB
+const BLOB_EXTENSION = '.blob';
+
+/** Ensure the blob directory exists. Call at daemon startup. */
+export function ensureBlobDir(): void {
+  const dir = getIpcBlobDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+/** Validate a blob ID matches UUID format. */
+export function isValidBlobId(id: string): boolean {
+  return BLOB_ID_REGEX.test(id);
+}
+
+/**
+ * Resolve a blob ID to its absolute file path.
+ * Throws if the ID is invalid or the resolved path escapes the blob directory.
+ */
+export function resolveBlobPath(id: string): string {
+  if (!isValidBlobId(id)) {
+    throw new Error(`Invalid blob ID: ${id}`);
+  }
+  const blobDir = getIpcBlobDir();
+  const candidate = resolve(join(blobDir, `${id}${BLOB_EXTENSION}`));
+
+  // Symlink protection: verify the resolved path stays within the blob dir.
+  // Use relative() for separator-agnostic containment check.
+  const normalizedBlobDir = resolve(blobDir);
+  const rel = relative(normalizedBlobDir, candidate);
+  if (rel.startsWith('..') || rel.startsWith(sep + sep) || rel === '') {
+    throw new Error(`Blob path escapes blob directory: ${id}`);
+  }
+
+  return candidate;
+}
+
+/**
+ * Verify that a blob file at the given path is a regular file (not a symlink)
+ * and that its realpath stays within the blob directory.
+ * Throws if the file is a symlink or escapes the blob directory.
+ */
+async function assertRegularFileInBlobDir(filePath: string): Promise<void> {
+  const fileLstat = await lstat(filePath);
+  if (fileLstat.isSymbolicLink()) {
+    throw new Error(`Blob file is a symlink: ${filePath}`);
+  }
+  const real = await realpath(filePath);
+  // Realpath both the file and the blob dir so macOS /var → /private/var is handled
+  const realBlobDir = await realpath(getIpcBlobDir());
+  const realRel = relative(realBlobDir, real);
+  if (realRel.startsWith('..') || realRel.startsWith(sep + sep) || realRel === '') {
+    throw new Error(`Blob realpath escapes blob directory: ${real}`);
+  }
+}
+
+/**
+ * Synchronous variant for use in deleteBlob.
+ */
+function assertRegularFileInBlobDirSync(filePath: string): void {
+  const fileLstat = lstatSync(filePath);
+  if (fileLstat.isSymbolicLink()) {
+    throw new Error(`Blob file is a symlink: ${filePath}`);
+  }
+  const real = realpathSync(filePath);
+  const realBlobDir = realpathSync(getIpcBlobDir());
+  const realRel = relative(realBlobDir, real);
+  if (realRel.startsWith('..') || realRel.startsWith(sep + sep) || realRel === '') {
+    throw new Error(`Blob realpath escapes blob directory: ${real}`);
+  }
+}
+
+/** Expected kind and encoding for each blob field. */
+export const EXPECTED_BLOB_FIELD_METADATA = {
+  axTreeBlob: { kind: 'ax_tree' as const, encoding: 'utf8' as const },
+  screenshotBlob: { kind: 'screenshot_jpeg' as const, encoding: 'binary' as const },
+};
+
+/**
+ * Validate that a blob ref's kind and encoding match expectations for a given field.
+ * Throws with a descriptive message if they don't match.
+ */
+export function validateBlobKindEncoding(
+  ref: IpcBlobRef,
+  field: keyof typeof EXPECTED_BLOB_FIELD_METADATA,
+): void {
+  const expected = EXPECTED_BLOB_FIELD_METADATA[field];
+  if (ref.kind !== expected.kind) {
+    throw new Error(
+      `Blob kind mismatch for ${field}: expected "${expected.kind}", got "${ref.kind}"`,
+    );
+  }
+  if (ref.encoding !== expected.encoding) {
+    throw new Error(
+      `Blob encoding mismatch for ${field}: expected "${expected.encoding}", got "${ref.encoding}"`,
+    );
+  }
+}
+
+/**
+ * Read a blob file and validate it against the ref metadata.
+ * Verifies the file is a regular file (not a symlink) and its realpath
+ * stays within the blob directory before reading.
+ * Returns the raw bytes.
+ */
+export async function readBlob(ref: IpcBlobRef): Promise<Buffer> {
+  const filePath = resolveBlobPath(ref.id);
+
+  // Enforce hard size limits by kind against declared byteLength before any I/O
+  const maxSize = ref.kind === 'screenshot_jpeg' ? MAX_SCREENSHOT_BLOB_SIZE : MAX_AX_BLOB_SIZE;
+  if (ref.byteLength > maxSize) {
+    throw new Error(
+      `Blob ${ref.id} declared size exceeds limit for kind "${ref.kind}": ${ref.byteLength} > ${maxSize}`,
+    );
+  }
+
+  // Symlink-safe: verify the file is a regular file with realpath inside blob dir.
+  // assertRegularFileInBlobDir also lstat()s, giving us symlink detection.
+  await assertRegularFileInBlobDir(filePath);
+
+  const buf = await readFile(filePath);
+
+  // Validate actual size matches declared byteLength
+  if (buf.byteLength !== ref.byteLength) {
+    throw new Error(
+      `Blob size mismatch for ${ref.id}: expected ${ref.byteLength} bytes, got ${buf.byteLength}`,
+    );
+  }
+
+  // Double-check actual size against limit (in case byteLength was spoofed to be small)
+  if (buf.byteLength > maxSize) {
+    throw new Error(
+      `Blob ${ref.id} exceeds size limit for kind "${ref.kind}": ${buf.byteLength} > ${maxSize}`,
+    );
+  }
+
+  // Verify SHA-256 if provided
+  if (ref.sha256) {
+    const hash = createHash('sha256').update(buf).digest('hex');
+    if (hash !== ref.sha256) {
+      throw new Error(
+        `Blob SHA-256 mismatch for ${ref.id}: expected ${ref.sha256}, got ${hash}`,
+      );
+    }
+  }
+
+  return buf;
+}
+
+/** Delete a blob file by ID. Best-effort, logs warning on failure. */
+export function deleteBlob(id: string): void {
+  try {
+    const filePath = resolveBlobPath(id);
+    // Symlink-safe: verify the file is a regular file before deleting
+    assertRegularFileInBlobDirSync(filePath);
+    unlinkSync(filePath);
+  } catch (err) {
+    // ENOENT is expected when the blob was already cleaned up
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+      log.warn({ err, blobId: id }, 'Failed to delete blob');
+    }
+  }
+}
+
+/** Sweep stale blob files older than maxAgeMs. Returns count of deleted files. */
+export async function sweepStaleBlobs(maxAgeMs: number): Promise<number> {
+  const blobDir = getIpcBlobDir();
+  let entries: string[];
+  try {
+    entries = await readdir(blobDir);
+  } catch (err) {
+    // Directory may not exist yet if no blobs have been written
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return 0;
+    }
+    log.warn({ err }, 'Failed to read blob directory for sweep');
+    return 0;
+  }
+
+  const now = Date.now();
+  let deleted = 0;
+
+  for (const entry of entries) {
+    if (!entry.endsWith(BLOB_EXTENSION)) continue;
+
+    const filePath = join(blobDir, entry);
+    try {
+      // Use lstat (not stat) to detect symlinks without following them
+      const fileLstat = await lstat(filePath);
+      if (fileLstat.isSymbolicLink()) {
+        log.warn({ filePath }, 'Skipping symlink during blob sweep');
+        continue;
+      }
+      const ageMs = now - fileLstat.mtimeMs;
+      if (ageMs > maxAgeMs) {
+        await unlink(filePath);
+        deleted++;
+      }
+    } catch (err) {
+      // File may have been deleted between readdir and stat/unlink
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+        log.warn({ err, filePath }, 'Failed to stat/delete blob during sweep');
+      }
+    }
+  }
+
+  if (deleted > 0) {
+    log.info({ deleted, total: entries.length }, 'Swept stale blobs');
+  }
+
+  return deleted;
+}