vellum 0.2.0 → 0.2.2

package/src/daemon/handlers/config.ts

@@ -5,11 +5,12 @@ import { addRule, removeRule, updateRule, getAllRules, acceptStarterBundle } fro
 import { listSchedules, updateSchedule, deleteSchedule, describeCronExpression } from '../../schedule/schedule-store.js';
 import { listReminders, cancelReminder } from '../../tools/reminder/reminder-store.js';
 import { getSecureKey, setSecureKey, deleteSecureKey } from '../../security/secure-keys.js';
-import { upsertCredentialMetadata, deleteCredentialMetadata } from '../../tools/credentials/metadata-store.js';
+import { upsertCredentialMetadata, deleteCredentialMetadata, getCredentialMetadata } from '../../tools/credentials/metadata-store.js';
 import { postToSlackWebhook } from '../../slack/slack-webhook.js';
 import { getApp } from '../../memory/app-store.js';
 import type {
   ModelSetRequest,
+  ImageGenModelSetRequest,
   AddTrustRule,
   RemoveTrustRule,
   UpdateTrustRule,
@@ -19,8 +20,9 @@ import type {
   ShareToSlackRequest,
   SlackWebhookConfigRequest,
   VercelApiConfigRequest,
+  TwitterIntegrationConfigRequest,
 } from '../ipc-protocol.js';
-import { log, type HandlerContext } from './shared.js';
+import { log, CONFIG_RELOAD_DEBOUNCE_MS, defineHandlers, type HandlerContext } from './shared.js';
 import { MODEL_TO_PROVIDER } from '../session-slash.js';
 
 export function handleModelGet(socket: net.Socket, ctx: HandlerContext): void {
@@ -95,7 +97,7 @@ export function handleModelSet(
     }
     const existingSuppressTimer = ctx.debounceTimers.get('__suppress_reset__');
     if (existingSuppressTimer) clearTimeout(existingSuppressTimer);
-    const resetTimer = setTimeout(() => { ctx.setSuppressConfigReload(false); }, 300);
+    const resetTimer = setTimeout(() => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
     ctx.debounceTimers.set('__suppress_reset__', resetTimer);
 
     // Re-initialize provider with the new model so LLM calls use it
@@ -126,6 +128,35 @@ export function handleModelSet(
   }
 }
 
+export function handleImageGenModelSet(
+  msg: ImageGenModelSetRequest,
+  _socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    const raw = loadRawConfig();
+    raw.imageGenModel = msg.model;
+
+    ctx.setSuppressConfigReload(true);
+    try {
+      saveRawConfig(raw);
+    } catch (err) {
+      ctx.setSuppressConfigReload(false);
+      throw err;
+    }
+    const existingSuppressTimer = ctx.debounceTimers.get('__suppress_reset__');
+    if (existingSuppressTimer) clearTimeout(existingSuppressTimer);
+    const resetTimer = setTimeout(() => { ctx.setSuppressConfigReload(false); }, CONFIG_RELOAD_DEBOUNCE_MS);
+    ctx.debounceTimers.set('__suppress_reset__', resetTimer);
+
+    ctx.updateConfigFingerprint();
+    log.info({ model: msg.model }, 'Image generation model updated');
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err }, `Failed to set image gen model: ${message}`);
+  }
+}
+
 export function handleAddTrustRule(
   msg: AddTrustRule,
   _socket: net.Socket,
@@ -207,13 +238,15 @@ export function handleSchedulesList(socket: net.Socket, ctx: HandlerContext): vo
       id: j.id,
       name: j.name,
       enabled: j.enabled,
+      syntax: j.syntax,
+      expression: j.expression,
       cronExpression: j.cronExpression,
       timezone: j.timezone,
       message: j.message,
       nextRunAt: j.nextRunAt,
       lastRunAt: j.lastRunAt,
       lastStatus: j.lastStatus,
-      description: describeCronExpression(j.cronExpression),
+      description: j.syntax === 'cron' ? describeCronExpression(j.cronExpression) : j.expression,
     })),
   });
 }
@@ -425,6 +458,140 @@ export function handleVercelApiConfig(
   }
 }
 
+export function handleTwitterIntegrationConfig(
+  msg: TwitterIntegrationConfigRequest,
+  socket: net.Socket,
+  ctx: HandlerContext,
+): void {
+  try {
+    if (msg.action === 'get') {
+      const raw = loadRawConfig();
+      const mode = (raw.twitterIntegrationMode as 'local_byo' | 'managed' | undefined) ?? 'local_byo';
+      const localClientConfigured = !!getSecureKey('credential:integration:twitter:oauth_client_id');
+      const connected = !!getSecureKey('credential:integration:twitter:access_token');
+      const meta = getCredentialMetadata('integration:twitter', 'access_token');
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: true,
+        mode,
+        managedAvailable: false,
+        localClientConfigured,
+        connected,
+        accountInfo: meta?.accountInfo ?? undefined,
+      });
+    } else if (msg.action === 'set_mode') {
+      const raw = loadRawConfig();
+      raw.twitterIntegrationMode = msg.mode ?? 'local_byo';
+      saveRawConfig(raw);
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: true,
+        mode: msg.mode ?? 'local_byo',
+        managedAvailable: false,
+        localClientConfigured: !!getSecureKey('credential:integration:twitter:oauth_client_id'),
+        connected: !!getSecureKey('credential:integration:twitter:access_token'),
+      });
+    } else if (msg.action === 'set_local_client') {
+      if (!msg.clientId) {
+        ctx.send(socket, {
+          type: 'twitter_integration_config_response',
+          success: false,
+          managedAvailable: false,
+          localClientConfigured: false,
+          connected: false,
+          error: 'clientId is required for set_local_client action',
+        });
+        return;
+      }
+      const storedId = setSecureKey('credential:integration:twitter:oauth_client_id', msg.clientId);
+      if (!storedId) {
+        ctx.send(socket, {
+          type: 'twitter_integration_config_response',
+          success: false,
+          managedAvailable: false,
+          localClientConfigured: false,
+          connected: false,
+          error: 'Failed to store client ID in secure storage',
+        });
+        return;
+      }
+      if (msg.clientSecret) {
+        const storedSecret = setSecureKey('credential:integration:twitter:oauth_client_secret', msg.clientSecret);
+        if (!storedSecret) {
+          // Roll back the already-persisted client ID to avoid inconsistent OAuth state
+          deleteSecureKey('credential:integration:twitter:oauth_client_id');
+          ctx.send(socket, {
+            type: 'twitter_integration_config_response',
+            success: false,
+            managedAvailable: false,
+            localClientConfigured: false,
+            connected: false,
+            error: 'Failed to store client secret in secure storage',
+          });
+          return;
+        }
+      } else {
+        // Clear any stale secret when updating client without a secret (e.g. switching to PKCE)
+        deleteSecureKey('credential:integration:twitter:oauth_client_secret');
+      }
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: true,
+        managedAvailable: false,
+        localClientConfigured: true,
+        connected: !!getSecureKey('credential:integration:twitter:access_token'),
+      });
+    } else if (msg.action === 'clear_local_client') {
+      // If connected, disconnect first
+      if (getSecureKey('credential:integration:twitter:access_token')) {
+        deleteSecureKey('credential:integration:twitter:access_token');
+        deleteSecureKey('credential:integration:twitter:refresh_token');
+        deleteCredentialMetadata('integration:twitter', 'access_token');
+      }
+      deleteSecureKey('credential:integration:twitter:oauth_client_id');
+      deleteSecureKey('credential:integration:twitter:oauth_client_secret');
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: true,
+        managedAvailable: false,
+        localClientConfigured: false,
+        connected: false,
+      });
+    } else if (msg.action === 'disconnect') {
+      deleteSecureKey('credential:integration:twitter:access_token');
+      deleteSecureKey('credential:integration:twitter:refresh_token');
+      deleteCredentialMetadata('integration:twitter', 'access_token');
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: true,
+        managedAvailable: false,
+        localClientConfigured: !!getSecureKey('credential:integration:twitter:oauth_client_id'),
+        connected: false,
+      });
+    } else {
+      ctx.send(socket, {
+        type: 'twitter_integration_config_response',
+        success: false,
+        managedAvailable: false,
+        localClientConfigured: false,
+        connected: false,
+        error: `Unknown action: ${String((msg as unknown as Record<string, unknown>).action)}`,
+      });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err }, 'Failed to handle Twitter integration config');
+    ctx.send(socket, {
+      type: 'twitter_integration_config_response',
+      success: false,
+      managedAvailable: false,
+      localClientConfigured: false,
+      connected: false,
+      error: message,
+    });
+  }
+}
+
 export function handleEnvVarsRequest(socket: net.Socket, ctx: HandlerContext): void {
   const vars: Record<string, string> = {};
   for (const [key, value] of Object.entries(process.env)) {
@@ -432,3 +599,24 @@ export function handleEnvVarsRequest(socket: net.Socket, ctx: HandlerContext): v
   }
   ctx.send(socket, { type: 'env_vars_response', vars });
 }
+
+export const configHandlers = defineHandlers({
+  model_get: (_msg, socket, ctx) => handleModelGet(socket, ctx),
+  model_set: handleModelSet,
+  image_gen_model_set: handleImageGenModelSet,
+  add_trust_rule: handleAddTrustRule,
+  trust_rules_list: (_msg, socket, ctx) => handleTrustRulesList(socket, ctx),
+  remove_trust_rule: handleRemoveTrustRule,
+  update_trust_rule: handleUpdateTrustRule,
+  accept_starter_bundle: (_msg, socket, ctx) => handleAcceptStarterBundle(socket, ctx),
+  schedules_list: (_msg, socket, ctx) => handleSchedulesList(socket, ctx),
+  schedule_toggle: handleScheduleToggle,
+  schedule_remove: handleScheduleRemove,
+  reminders_list: (_msg, socket, ctx) => handleRemindersList(socket, ctx),
+  reminder_cancel: handleReminderCancel,
+  share_to_slack: handleShareToSlack,
+  slack_webhook_config: handleSlackWebhookConfig,
+  vercel_api_config: handleVercelApiConfig,
+  twitter_integration_config: handleTwitterIntegrationConfig,
+  env_vars_request: (_msg, socket, ctx) => handleEnvVarsRequest(socket, ctx),
+});

package/src/daemon/handlers/diagnostics.ts

@@ -9,7 +9,7 @@ import archiver from 'archiver';
 import { getDb } from '../../memory/db.js';
 import { messages, toolInvocations, llmUsageEvents, llmRequestLogs } from '../../memory/schema.js';
 import type { DiagnosticsExportRequest } from '../ipc-protocol.js';
-import { log, type HandlerContext } from './shared.js';
+import { log, defineHandlers, type HandlerContext } from './shared.js';
 
 const MAX_CONTENT_LENGTH = 500;
 
@@ -332,3 +332,7 @@ export async function handleDiagnosticsExport(
     });
   }
 }
+
+export const diagnosticsHandlers = defineHandlers({
+  diagnostics_export_request: handleDiagnosticsExport,
+});

package/src/daemon/handlers/documents.ts

@@ -1,42 +1,28 @@
+import { defineHandlers } from './shared.js';
 import type { HandlerContext } from './shared.js';
 import type { DocumentSaveRequest, DocumentLoadRequest, DocumentListRequest } from '../ipc-protocol.js';
 import type * as net from 'node:net';
 import type { Database } from 'bun:sqlite';
 import { getDb } from '../../memory/db.js';
+import { getLogger } from '../../util/logger.js';
 
-import { writeFileSync } from 'node:fs';
+const log = getLogger('documents');
 
 export function handleDocumentSave(msg: DocumentSaveRequest, socket: net.Socket, ctx: HandlerContext): void {
-  const logMsg = `[${new Date().toISOString()}] handleDocumentSave called: ${JSON.stringify({
+  log.info({
     surfaceId: msg.surfaceId,
     conversationId: msg.conversationId,
     title: msg.title,
     contentLength: msg.content.length,
     wordCount: msg.wordCount,
-  })}\n`;
+  }, 'Received save request');
 
   try {
-    writeFileSync('/tmp/document-save-debug.log', logMsg, { flag: 'a' });
-  } catch {
-    // Ignore logging errors
-  }
-
-  console.log('💾 [handleDocumentSave] Received save request:', {
-    surfaceId: msg.surfaceId,
-    conversationId: msg.conversationId,
-    title: msg.title,
-    contentLength: msg.content.length,
-    wordCount: msg.wordCount,
-  });
-
-  try {
-    writeFileSync('/tmp/document-save-debug.log', `[${new Date().toISOString()}] Getting db...\n`, { flag: 'a' });
     const db = getDb();
     // Get the raw SQLite client from Drizzle
     const sqlite = (db as unknown as { $client: Database }).$client;
     const now = Date.now();
 
-    writeFileSync('/tmp/document-save-debug.log', `[${new Date().toISOString()}] Running sqlite.run()...\n`, { flag: 'a' });
     // Upsert document (insert or update if exists)
     sqlite.run(
       `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at)
@@ -49,18 +35,15 @@ export function handleDocumentSave(msg: DocumentSaveRequest, socket: net.Socket,
       [msg.surfaceId, msg.conversationId, msg.title, msg.content, msg.wordCount, now, now]
     );
 
-    writeFileSync('/tmp/document-save-debug.log', `[${new Date().toISOString()}] db.run() completed, sending response...\n`, { flag: 'a' });
     ctx.send(socket, {
       type: 'document_save_response',
       surfaceId: msg.surfaceId,
       success: true,
     });
 
-    writeFileSync('/tmp/document-save-debug.log', `[${new Date().toISOString()}] Response sent successfully\n`, { flag: 'a' });
-
-    console.log(`[documents] Saved document: ${msg.surfaceId} - "${msg.title}"`);
+    log.info({ surfaceId: msg.surfaceId, title: msg.title }, 'Saved document');
   } catch (error) {
-    console.error('[documents] Save error:', error);
+    log.error({ err: error, surfaceId: msg.surfaceId }, 'Save error');
     ctx.send(socket, {
       type: 'document_save_response',
       surfaceId: msg.surfaceId,
@@ -101,7 +84,7 @@ export function handleDocumentLoad(msg: DocumentLoadRequest, socket: net.Socket,
         updatedAt: result.updated_at,
         success: true,
       });
-      console.log(`[documents] Loaded document: ${msg.surfaceId}`);
+      log.info({ surfaceId: msg.surfaceId }, 'Loaded document');
     } else {
       ctx.send(socket, {
         type: 'document_load_response',
@@ -115,10 +98,10 @@ export function handleDocumentLoad(msg: DocumentLoadRequest, socket: net.Socket,
         success: false,
         error: 'Document not found',
       });
-      console.log(`[documents] Document not found: ${msg.surfaceId}`);
+      log.info({ surfaceId: msg.surfaceId }, 'Document not found');
     }
   } catch (error) {
-    console.error('[documents] Load error:', error);
+    log.error({ err: error, surfaceId: msg.surfaceId }, 'Load error');
     ctx.send(socket, {
       type: 'document_load_response',
       surfaceId: msg.surfaceId,
@@ -173,12 +156,18 @@ export function handleDocumentList(msg: DocumentListRequest, socket: net.Socket,
       })),
     });
 
-    console.log(`[documents] Listed ${results.length} documents`);
+    log.info({ count: results.length }, 'Listed documents');
   } catch (error) {
-    console.error('[documents] List error:', error);
+    log.error({ err: error }, 'List error');
     ctx.send(socket, {
       type: 'document_list_response',
       documents: [],
     });
   }
 }
+
+export const documentHandlers = defineHandlers({
+  document_save: handleDocumentSave,
+  document_load: handleDocumentLoad,
+  document_list: handleDocumentList,
+});

package/src/daemon/handlers/home-base.ts

@@ -7,7 +7,7 @@ import {
 } from '../../home-base/prebuilt/seed.js';
 import { getHomeBaseAppLink } from '../../home-base/app-link-store.js';
 import { getApp } from '../../memory/app-store.js';
-import { log, type HandlerContext } from './shared.js';
+import { log, defineHandlers, type HandlerContext } from './shared.js';
 
 export function handleHomeBaseGet(
   msg: HomeBaseGetRequest,
@@ -71,3 +71,7 @@ export function handleHomeBaseGet(
     ctx.send(socket, { type: 'error', message: `Failed to resolve home base metadata: ${message}` });
   }
 }
+
+export const homeBaseHandlers = defineHandlers({
+  home_base_get: handleHomeBaseGet,
+});