@vellumai/assistant 0.3.0

package/src/daemon/handlers/identity.ts

@@ -0,0 +1,127 @@
+import * as net from 'node:net';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getWorkspacePromptPath } from '../../util/platform.js';
+import { log, defineHandlers, type HandlerContext } from './shared.js';
+
+function handleIdentityGet(socket: net.Socket, ctx: HandlerContext): void {
+  const identityPath = getWorkspacePromptPath('IDENTITY.md');
+
+  if (!existsSync(identityPath)) {
+    ctx.send(socket, {
+      type: 'identity_get_response',
+      found: false,
+      name: '',
+      role: '',
+      personality: '',
+      emoji: '',
+      home: '',
+    });
+    return;
+  }
+
+  try {
+    const content = readFileSync(identityPath, 'utf-8');
+    const fields: Record<string, string> = {};
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      const lower = trimmed.toLowerCase();
+      const extract = (prefix: string): string | null => {
+        if (!lower.startsWith(prefix)) return null;
+        return trimmed.split(':**').pop()?.trim() ?? null;
+      };
+
+      const name = extract('- **name:**');
+      if (name) { fields.name = name; continue; }
+      const role = extract('- **role:**');
+      if (role) { fields.role = role; continue; }
+      const personality = extract('- **personality:**') ?? extract('- **vibe:**');
+      if (personality) { fields.personality = personality; continue; }
+      const emoji = extract('- **emoji:**');
+      if (emoji) { fields.emoji = emoji; continue; }
+      const home = extract('- **home:**');
+      if (home) { fields.home = home; continue; }
+    }
+
+    // Read version from package.json
+    let version: string | undefined;
+    try {
+      const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '../../../package.json');
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      version = pkg.version;
+    } catch {
+      // ignore
+    }
+
+    // Read createdAt from IDENTITY.md file birthtime
+    let createdAt: string | undefined;
+    try {
+      const stats = statSync(identityPath);
+      createdAt = stats.birthtime.toISOString();
+    } catch {
+      // ignore
+    }
+
+    // Read lockfile for assistantId, cloud, and originSystem
+    let assistantId: string | undefined;
+    let cloud: string | undefined;
+    let originSystem: string | undefined;
+    try {
+      const homedir = process.env.HOME ?? process.env.USERPROFILE ?? '';
+      const lockfilePaths = [
+        join(homedir, '.vellum.lock.json'),
+        join(homedir, '.vellum.lockfile.json'),
+      ];
+      for (const lockPath of lockfilePaths) {
+        if (!existsSync(lockPath)) continue;
+        const lockData = JSON.parse(readFileSync(lockPath, 'utf-8'));
+        const assistants = lockData.assistants as Array<Record<string, unknown>> | undefined;
+        if (assistants && assistants.length > 0) {
+          // Use the most recently hatched assistant
+          const sorted = [...assistants].sort((a, b) => {
+            const dateA = new Date(a.hatchedAt as string || 0).getTime();
+            const dateB = new Date(b.hatchedAt as string || 0).getTime();
+            return dateB - dateA;
+          });
+          const latest = sorted[0];
+          assistantId = latest.assistantId as string | undefined;
+          cloud = latest.cloud as string | undefined;
+          originSystem = cloud === 'local' ? 'local' : cloud;
+        }
+        break;
+      }
+    } catch {
+      // ignore — lockfile may not exist
+    }
+
+    ctx.send(socket, {
+      type: 'identity_get_response',
+      found: true,
+      name: fields.name ?? '',
+      role: fields.role ?? '',
+      personality: fields.personality ?? '',
+      emoji: fields.emoji ?? '',
+      home: fields.home ?? '',
+      version,
+      assistantId,
+      createdAt,
+      originSystem,
+    });
+  } catch (err) {
+    log.error({ err }, 'Failed to read identity');
+    ctx.send(socket, {
+      type: 'identity_get_response',
+      found: false,
+      name: '',
+      role: '',
+      personality: '',
+      emoji: '',
+      home: '',
+    });
+  }
+}
+
+export const identityHandlers = defineHandlers({
+  identity_get: (_msg, socket, ctx) => handleIdentityGet(socket, ctx),
+});

package/src/daemon/handlers/index.ts

@@ -0,0 +1,129 @@
+import * as net from 'node:net';
+import type { ClientMessage } from '../ipc-protocol.js';
+import { handleRideShotgunStart, handleRideShotgunStop } from '../ride-shotgun-handler.js';
+import { handleWatchObservation } from '../watch-handler.js';
+import { handleOpenBundle } from './open-bundle-handler.js';
+import { log, defineHandlers, type HandlerContext, type DispatchMap } from './shared.js';
+
+import { sessionHandlers } from './sessions.js';
+import { skillHandlers } from './skills.js';
+import { appHandlers } from './apps.js';
+import { configHandlers } from './config.js';
+import { computerUseHandlers } from './computer-use.js';
+import { publishHandlers } from './publish.js';
+import { homeBaseHandlers } from './home-base.js';
+import { diagnosticsHandlers } from './diagnostics.js';
+import { miscHandlers } from './misc.js';
+import { documentHandlers } from './documents.js';
+import { workItemHandlers } from './work-items.js';
+import { subagentHandlers } from './subagents.js';
+import { browserHandlers } from './browser.js';
+import { signingHandlers } from './signing.js';
+import { twitterAuthHandlers } from './twitter-auth.js';
+import { workspaceFileHandlers } from './workspace-files.js';
+import { identityHandlers } from './identity.js';
+
+// Re-export types and utilities for backwards compatibility
+export type {
+  HandlerContext,
+  SessionCreateOptions,
+  HistoryToolCall,
+  HistorySurface,
+  RenderedHistoryContent,
+  ParsedHistoryMessage,
+} from './shared.js';
+
+export {
+  renderHistoryContent,
+  mergeToolResults,
+} from './shared.js';
+
+// ─── Typed dispatch ──────────────────────────────────────────────────────────
+
+// Inline handlers for messages not owned by any feature group
+const inlineHandlers = defineHandlers({
+  ride_shotgun_start: handleRideShotgunStart,
+  ride_shotgun_stop: handleRideShotgunStop,
+  watch_observation: handleWatchObservation,
+  open_bundle: handleOpenBundle,
+
+  ui_surface_action: (msg, _socket, ctx) => {
+    const cuSession = ctx.cuSessions.get(msg.sessionId);
+    if (cuSession) {
+      cuSession.handleSurfaceAction(msg.surfaceId, msg.actionId, msg.data);
+      return;
+    }
+    const session = ctx.sessions.get(msg.sessionId);
+    if (session) {
+      ctx.touchSession(msg.sessionId);
+      session.handleSurfaceAction(msg.surfaceId, msg.actionId, msg.data);
+      return;
+    }
+    log.warn({ sessionId: msg.sessionId, surfaceId: msg.surfaceId }, 'No session found for surface action');
+  },
+  ui_surface_undo: (msg, _socket, ctx) => {
+    const session = ctx.sessions.get(msg.sessionId);
+    if (session) {
+      ctx.touchSession(msg.sessionId);
+      session.handleSurfaceUndo(msg.surfaceId);
+      return;
+    }
+    log.warn({ sessionId: msg.sessionId, surfaceId: msg.surfaceId }, 'No session found for surface undo');
+  },
+
+  // Stub handlers: the integration registry was removed but the Swift client
+  // still sends these messages. Return safe no-op responses so the client
+  // doesn't hang waiting for a reply.
+  integration_list: (_msg, socket, ctx) => {
+    ctx.send(socket, { type: 'integration_list_response', integrations: [] });
+  },
+  integration_connect: (msg, socket, ctx) => {
+    ctx.send(socket, {
+      type: 'integration_connect_result',
+      integrationId: msg.integrationId,
+      success: false,
+      error: 'Please use chat to connect integrations.',
+    });
+  },
+  integration_disconnect: () => { /* no-op — integration registry removed */ },
+
+});
+
+const handlers = {
+  ...sessionHandlers,
+  ...skillHandlers,
+  ...appHandlers,
+  ...configHandlers,
+  ...computerUseHandlers,
+  ...publishHandlers,
+  ...homeBaseHandlers,
+  ...diagnosticsHandlers,
+  ...miscHandlers,
+  ...documentHandlers,
+  ...workItemHandlers,
+  ...subagentHandlers,
+  ...browserHandlers,
+  ...signingHandlers,
+  ...twitterAuthHandlers,
+  ...workspaceFileHandlers,
+  ...identityHandlers,
+  ...inlineHandlers,
+} satisfies DispatchMap;
+
+export function handleMessage(
+  msg: ClientMessage,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  // 'auth' is handled at the transport layer and should never reach dispatch.
+  if (msg.type === 'auth') return;
+
+  const handler = handlers[msg.type] as
+    | ((msg: ClientMessage, socket: net.Socket, ctx: HandlerContext) => void)
+    | undefined;
+  if (!handler) {
+    log.warn({ type: msg.type }, 'Unknown message type, ignoring');
+    return;
+  }
+  handler(msg, socket, ctx);
+}

package/src/daemon/handlers/misc.ts

@@ -0,0 +1,331 @@
+import * as net from 'node:net';
+import { v4 as uuid } from 'uuid';
+import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import * as conversationStore from '../../memory/conversation-store.js';
+import { getConfig } from '../../config/loader.js';
+import { getFailoverProvider, listProviders } from '../../providers/registry.js';
+import type { Provider } from '../../providers/types.js';
+import { classifyInteraction } from '../classifier.js';
+import { checkIngressForSecrets } from '../../security/secret-ingress.js';
+import { parseSlashCandidate } from '../../skills/slash-commands.js';
+import { classifySessionError, buildSessionErrorMessage } from '../session-error.js';
+import { resolveBlobPath, deleteBlob, isValidBlobId } from '../ipc-blob-store.js';
+import type {
+  TaskSubmit,
+  SuggestionRequest,
+  LinkOpenRequest,
+  IpcBlobProbe,
+  CuSessionCreate,
+} from '../ipc-protocol.js';
+import { log, wireEscalationHandler, renderHistoryContent, defineHandlers, type HandlerContext } from './shared.js';
+import { handleCuSessionCreate } from './computer-use.js';
+
+// ─── Task submit handler ────────────────────────────────────────────────────
+
+export async function handleTaskSubmit(
+  msg: TaskSubmit,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  const requestId = uuid();
+  const rlog = log.child({ requestId });
+
+  try {
+    // Block inbound tasks that contain secrets and redirect to secure prompt
+    const taskIngressCheck = checkIngressForSecrets(msg.task);
+    if (taskIngressCheck.blocked) {
+      rlog.warn({ detectedTypes: taskIngressCheck.detectedTypes }, 'Blocked task_submit containing secrets');
+      ctx.send(socket, {
+        type: 'error',
+        message: taskIngressCheck.userNotice!,
+      });
+      // Create an ephemeral session so the secret_response lifecycle works
+      // end-to-end. The conversation is deleted after the prompt resolves
+      // to avoid accumulating placeholder entries in session history.
+      const conversation = conversationStore.createConversation('(blocked — secret detected)');
+      ctx.socketToSession.set(socket, conversation.id);
+      const session = await ctx.getOrCreateSession(conversation.id, socket, true);
+      session.redirectToSecurePrompt(taskIngressCheck.detectedTypes, () => {
+        conversationStore.deleteConversation(conversation.id);
+        // Clean up in-memory session and socket binding so the ephemeral
+        // session doesn't accumulate in the daemon's session map.
+        const s = ctx.sessions.get(conversation.id);
+        if (s) {
+          s.dispose();
+          ctx.sessions.delete(conversation.id);
+        }
+        // Only unbind if the socket still points to this ephemeral conversation;
+        // a new task_submit may have already rebound it to a real session.
+        if (ctx.socketToSession.get(socket) === conversation.id) {
+          ctx.socketToSession.delete(socket);
+        }
+      });
+      return;
+    }
+
+    // Slash candidates always route to text_qa — bypass classifier
+    const slashCandidate = parseSlashCandidate(msg.task);
+    const interactionType = slashCandidate.kind === 'candidate'
+      ? 'text_qa' as const
+      : await classifyInteraction(msg.task, msg.source);
+    rlog.info({ interactionType, slashBypass: slashCandidate.kind === 'candidate', taskLength: msg.task.length }, 'Task classified');
+
+    if (interactionType === 'computer_use') {
+      // Create CU session (reuse handleCuSessionCreate logic)
+      const sessionId = uuid();
+      const cuMsg: CuSessionCreate = {
+        type: 'cu_session_create',
+        sessionId,
+        task: msg.task,
+        screenWidth: msg.screenWidth,
+        screenHeight: msg.screenHeight,
+        attachments: msg.attachments,
+        interactionType: 'computer_use',
+      };
+      handleCuSessionCreate(cuMsg, socket, ctx);
+
+      ctx.send(socket, {
+        type: 'task_routed',
+        sessionId,
+        interactionType: 'computer_use',
+      });
+    } else {
+      // Create text QA session and immediately start processing
+      const conversation = conversationStore.createConversation(msg.task);
+      ctx.socketToSession.set(socket, conversation.id);
+      const session = await ctx.getOrCreateSession(conversation.id, socket, true);
+
+      // Wire escalation handler so the agent can call computer_use_request_control
+      wireEscalationHandler(session, socket, ctx, msg.screenWidth, msg.screenHeight);
+
+      ctx.send(socket, {
+        type: 'task_routed',
+        sessionId: conversation.id,
+        interactionType: 'text_qa',
+      });
+
+      // Start streaming immediately — client doesn't need to send user_message
+      session.processMessage(msg.task, msg.attachments ?? [], (event) => {
+        ctx.send(socket, event);
+      }, requestId).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        rlog.error({ err }, 'Error processing task_submit text QA');
+        ctx.send(socket, { type: 'error', message: `Failed to process message: ${message}` });
+        const classified = classifySessionError(err, { phase: 'agent_loop' });
+        ctx.send(socket, buildSessionErrorMessage(conversation.id, classified));
+      });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    rlog.error({ err }, 'Error handling task_submit');
+    ctx.send(socket, { type: 'error', message: `Failed to route task: ${message}` });
+  }
+}
+
+// ─── Suggestion handler ─────────────────────────────────────────────────────
+
+const SUGGESTION_CACHE_MAX = 100;
+const suggestionCache = new Map<string, string>();
+const suggestionInFlight = new Map<string, Promise<string | null>>();
+
+export async function handleSuggestionRequest(
+  msg: SuggestionRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  const noSuggestion = () => {
+    ctx.send(socket, {
+      type: 'suggestion_response',
+      requestId: msg.requestId,
+      suggestion: null,
+      source: 'none' as const,
+    });
+  };
+
+  const rawMessages = conversationStore.getMessages(msg.sessionId);
+  if (rawMessages.length === 0) { noSuggestion(); return; }
+
+  // Find the most recent assistant message — only use it if it has text content.
+  // Do NOT fall back to older turns; if the latest assistant message is tool-only,
+  // return no suggestion rather than reusing stale text from a previous turn.
+  for (let i = rawMessages.length - 1; i >= 0; i--) {
+    const m = rawMessages[i];
+    if (m.role !== 'assistant') continue;
+
+    let content: unknown;
+    try { content = JSON.parse(m.content); } catch { content = m.content; }
+    const rendered = renderHistoryContent(content);
+    const text = rendered.text.trim();
+    if (!text) { noSuggestion(); return; }
+
+    // Return cached suggestion
+    const cached = suggestionCache.get(m.id);
+    if (cached !== undefined) {
+      ctx.send(socket, {
+        type: 'suggestion_response',
+        requestId: msg.requestId,
+        suggestion: cached,
+        source: 'llm' as const,
+      });
+      return;
+    }
+
+    // Try LLM suggestion using the configured provider
+    const config = getConfig();
+    if (listProviders().includes(config.provider)) {
+      try {
+        const provider = getFailoverProvider(config.provider, config.providerOrder);
+        let promise = suggestionInFlight.get(m.id);
+        if (!promise) {
+          promise = generateSuggestion(provider, text);
+          suggestionInFlight.set(m.id, promise);
+        }
+        const llmSuggestion = await promise;
+        suggestionInFlight.delete(m.id);
+
+        if (llmSuggestion) {
+          if (suggestionCache.size >= SUGGESTION_CACHE_MAX) {
+            const oldest = suggestionCache.keys().next().value!;
+            suggestionCache.delete(oldest);
+          }
+          suggestionCache.set(m.id, llmSuggestion);
+
+          ctx.send(socket, {
+            type: 'suggestion_response',
+            requestId: msg.requestId,
+            suggestion: llmSuggestion,
+            source: 'llm' as const,
+          });
+          return;
+        }
+      } catch (err) {
+        suggestionInFlight.delete(m.id);
+        log.warn({ err }, 'LLM suggestion failed');
+      }
+    }
+
+    noSuggestion();
+    return;
+  }
+
+  noSuggestion();
+}
+
+async function generateSuggestion(provider: Provider, assistantText: string): Promise<string | null> {
+  const truncated = assistantText.length > 2000
+    ? assistantText.slice(-2000)
+    : assistantText;
+
+  const prompt = `Given this assistant message, write a very short tab-complete suggestion (max 50 chars) the user could send next to keep the conversation going. Be casual, curious, or actionable — like a quick reply, not a formal request. Reply with ONLY the suggestion text.\n\nAssistant's message:\n${truncated}`;
+  const response = await provider.sendMessage(
+    [{ role: 'user', content: [{ type: 'text', text: prompt }] }],
+    [], // no tools
+    undefined, // no system prompt
+    { config: { max_tokens: 30 } },
+  );
+
+  const textBlock = response.content.find((b) => b.type === 'text');
+  const raw = textBlock && 'text' in textBlock ? textBlock.text.trim() : '';
+  if (!raw || raw.length > 50) return null;
+
+  const firstLine = raw.split('\n')[0].trim();
+  return firstLine || null;
+}
+
+// ─── Link open handler ──────────────────────────────────────────────────────
+
+export function handleLinkOpenRequest(
+  msg: LinkOpenRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    const parsed = new URL(msg.url);
+    if (!['http:', 'https:'].includes(parsed.protocol)) {
+      log.warn({ url: msg.url }, 'link_open_request: blocked non-http URL');
+      return;
+    }
+  } catch {
+    log.warn({ url: msg.url }, 'link_open_request: invalid URL');
+    return;
+  }
+  // V1: passthrough. Future: affiliate param injection based on metadata
+  const finalUrl = msg.url;
+  ctx.send(socket, { type: 'open_url', url: finalUrl });
+}
+
+// ─── IPC blob probe handler ─────────────────────────────────────────────────
+
+export function handleIpcBlobProbe(
+  msg: IpcBlobProbe,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  if (!isValidBlobId(msg.probeId)) {
+    ctx.send(socket, {
+      type: 'ipc_blob_probe_result',
+      probeId: msg.probeId,
+      ok: false,
+      reason: 'invalid_probe_id',
+    });
+    return;
+  }
+
+  let filePath: string;
+  try {
+    filePath = resolveBlobPath(msg.probeId);
+  } catch {
+    ctx.send(socket, {
+      type: 'ipc_blob_probe_result',
+      probeId: msg.probeId,
+      ok: false,
+      reason: 'invalid_probe_id',
+    });
+    return;
+  }
+
+  let content: Buffer;
+  try {
+    content = readFileSync(filePath);
+  } catch {
+    ctx.send(socket, {
+      type: 'ipc_blob_probe_result',
+      probeId: msg.probeId,
+      ok: false,
+      reason: 'missing_probe_file',
+    });
+    return;
+  }
+
+  const observedHash = createHash('sha256').update(content).digest('hex');
+
+  // Best-effort cleanup regardless of match outcome
+  deleteBlob(msg.probeId);
+
+  if (observedHash !== msg.nonceSha256) {
+    ctx.send(socket, {
+      type: 'ipc_blob_probe_result',
+      probeId: msg.probeId,
+      ok: false,
+      observedNonceSha256: observedHash,
+      reason: 'hash_mismatch',
+    });
+    return;
+  }
+
+  ctx.send(socket, {
+    type: 'ipc_blob_probe_result',
+    probeId: msg.probeId,
+    ok: true,
+    observedNonceSha256: observedHash,
+  });
+}
+
+export const miscHandlers = defineHandlers({
+  task_submit: handleTaskSubmit,
+  suggestion_request: handleSuggestionRequest,
+  link_open_request: handleLinkOpenRequest,
+  ipc_blob_probe: handleIpcBlobProbe,
+  ping: (_msg, socket, ctx) => { ctx.send(socket, { type: 'pong' }); },
+});

package/src/daemon/handlers/open-bundle-handler.ts

@@ -0,0 +1,80 @@
+import * as net from 'node:net';
+import { stat } from 'node:fs/promises';
+import { scanBundle } from '../../bundler/bundle-scanner.js';
+import { verifyBundleSignature } from '../../bundler/signature-verifier.js';
+import { getLogger } from '../../util/logger.js';
+import type { OpenBundleRequest, OpenBundleResponse } from '../ipc-protocol.js';
+import type { HandlerContext } from './shared.js';
+
+const log = getLogger('open-bundle-handler');
+
+export async function handleOpenBundle(
+  msg: OpenBundleRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): Promise<void> {
+  try {
+    const fileStat = await stat(msg.filePath);
+    const bundleSizeBytes = fileStat.size;
+
+    // Run scanner and signature verifier in parallel
+    const [scanResult, signatureResult] = await Promise.all([
+      scanBundle(msg.filePath),
+      verifyBundleSignature(msg.filePath),
+    ]);
+
+    // Extract manifest from the zip for the response
+    const JSZip = (await import('jszip')).default;
+    const fileData = await Bun.file(msg.filePath).arrayBuffer();
+    const zip = await JSZip.loadAsync(fileData);
+    const manifestFile = zip.file('manifest.json');
+    let manifest: OpenBundleResponse['manifest'];
+    if (manifestFile) {
+      const manifestText = await manifestFile.async('text');
+      manifest = JSON.parse(manifestText) as OpenBundleResponse['manifest'];
+    } else {
+      manifest = {
+        format_version: 0,
+        name: 'Unknown',
+        created_at: '',
+        created_by: '',
+        entry: '',
+        capabilities: [],
+      };
+    }
+
+    const blocked = scanResult.findings
+      .filter((f) => f.level === 'block')
+      .map((f) => f.message);
+    const warnings = scanResult.findings
+      .filter((f) => f.level === 'warn')
+      .map((f) => f.message);
+
+    const response: OpenBundleResponse = {
+      type: 'open_bundle_response',
+      manifest,
+      scanResult: {
+        passed: scanResult.passed,
+        blocked,
+        warnings,
+      },
+      signatureResult: {
+        trustTier: signatureResult.trustTier,
+        signerKeyId: signatureResult.signerKeyId,
+        signerDisplayName: signatureResult.signerDisplayName,
+        signerAccount: signatureResult.signerAccount,
+      },
+      bundleSizeBytes,
+    };
+
+    ctx.send(socket, response);
+    log.info(
+      { filePath: msg.filePath, passed: scanResult.passed, trustTier: signatureResult.trustTier },
+      'Bundle opened and scanned',
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err, filePath: msg.filePath }, 'Failed to open bundle');
+    ctx.send(socket, { type: 'error', message: `Failed to open bundle: ${message}` });
+  }
+}