@tryfridayai/cli 0.2.0

package/src/commands/install.js

@@ -0,0 +1,152 @@
+/**
+ * friday install <plugin> — Install a plugin with guided credential setup
+ *
+ * Reads the plugin manifest from the catalog, prompts for required
+ * credentials, stores them, and registers the plugin as installed.
+ */
+
+import readline from 'readline';
+import { createRequire } from 'module';
+import path from 'path';
+
+const require = createRequire(import.meta.url);
+let runtimeDir;
+try {
+  const runtimePkg = require.resolve('friday-runtime/package.json');
+  runtimeDir = path.dirname(runtimePkg);
+} catch {
+  runtimeDir = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..', '..', 'runtime');
+}
+
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+
+function ask(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+
+function maskValue(value) {
+  if (!value || value.length < 8) return '****';
+  return value.slice(0, 4) + '...' + value.slice(-4);
+}
+
+export default async function install(args) {
+  const pluginId = args._[1]; // friday install <plugin>
+
+  // Lazy-import the PluginManager from the runtime package
+  const { PluginManager } = await import(path.join(runtimeDir, 'src', 'plugins', 'PluginManager.js'));
+  const pm = new PluginManager();
+
+  // No plugin specified — show available plugins
+  if (!pluginId) {
+    console.log('');
+    console.log(`  ${BOLD}Usage:${RESET} friday install <plugin>`);
+    console.log('');
+    console.log(`  ${BOLD}Available plugins:${RESET}`);
+    console.log('');
+    const available = pm.listAvailable();
+    const categories = {};
+    for (const p of available) {
+      if (!categories[p.category]) categories[p.category] = [];
+      categories[p.category].push(p);
+    }
+    for (const [category, plugins] of Object.entries(categories)) {
+      console.log(`  ${DIM}${category}${RESET}`);
+      for (const p of plugins) {
+        const status = p.installed ? `${GREEN}installed${RESET}` : '';
+        console.log(`    ${BOLD}${p.id}${RESET}  ${p.description}  ${status}`);
+      }
+      console.log('');
+    }
+    console.log(`  Example: ${DIM}friday install github${RESET}`);
+    console.log('');
+    return;
+  }
+
+  // Check if plugin exists in catalog
+  const manifest = pm.getPluginManifest(pluginId);
+  if (!manifest) {
+    console.log('');
+    console.log(`  ${RED}Unknown plugin: ${pluginId}${RESET}`);
+    console.log(`  Run ${DIM}friday install${RESET} to see available plugins.`);
+    console.log('');
+    return;
+  }
+
+  // Check if already installed
+  if (pm.isInstalled(pluginId)) {
+    console.log('');
+    console.log(`  ${manifest.name} is already installed.`);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const reinstall = await ask(rl, `  Reinstall and update credentials? (y/N): `);
+    if (reinstall.toLowerCase() !== 'y') {
+      rl.close();
+      return;
+    }
+    rl.close();
+  }
+
+  const fields = pm.getCredentialFields(pluginId);
+
+  console.log('');
+  console.log(`  ${BOLD}Installing ${manifest.name}${RESET}`);
+  console.log(`  ${DIM}${manifest.description}${RESET}`);
+  console.log('');
+
+  // If no credentials needed (e.g. Vercel with remote-oauth)
+  if (fields.length === 0) {
+    if (manifest.setup?.note) {
+      console.log(`  ${DIM}${manifest.setup.note}${RESET}`);
+      console.log('');
+    }
+    pm.install(pluginId, {});
+    console.log(`  ${GREEN}${manifest.name} installed.${RESET}`);
+    console.log('');
+    return;
+  }
+
+  // Prompt for credentials
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const credentials = {};
+
+  if (manifest.setup?.note) {
+    console.log(`  ${DIM}${manifest.setup.note}${RESET}`);
+    console.log('');
+  }
+
+  for (const field of fields) {
+    if (field.instructions) {
+      console.log(`  ${DIM}${field.instructions}${RESET}`);
+    }
+
+    const requiredTag = field.required ? '' : ` ${DIM}(optional)${RESET}`;
+    const prompt = `  ${field.label}${requiredTag}: `;
+    const value = await ask(rl, prompt);
+
+    if (value) {
+      credentials[field.key] = value;
+      if (field.type === 'secret') {
+        // Clear the line and reprint masked
+        process.stdout.write(`\x1b[1A\x1b[2K`);
+        console.log(`  ${field.label}${requiredTag}: ${DIM}${maskValue(value)}${RESET}`);
+      }
+    } else if (field.required) {
+      console.log(`  ${YELLOW}Skipped (required). Plugin may not work without this.${RESET}`);
+    }
+    console.log('');
+  }
+
+  rl.close();
+
+  // Install
+  pm.install(pluginId, credentials);
+  console.log(`  ${GREEN}${manifest.name} installed.${RESET}`);
+  console.log(`  The agent can now use ${manifest.name} tools.`);
+  console.log('');
+}

package/src/commands/plugins.js

@@ -0,0 +1,65 @@
+/**
+ * friday plugins — List installed and available plugins
+ */
+
+import { createRequire } from 'module';
+import path from 'path';
+
+const require = createRequire(import.meta.url);
+let runtimeDir;
+try {
+  const runtimePkg = require.resolve('friday-runtime/package.json');
+  runtimeDir = path.dirname(runtimePkg);
+} catch {
+  runtimeDir = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..', '..', 'runtime');
+}
+
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const GREEN = '\x1b[32m';
+
+export default async function plugins(args) {
+  const { PluginManager } = await import(path.join(runtimeDir, 'src', 'plugins', 'PluginManager.js'));
+  const pm = new PluginManager();
+
+  const installed = pm.listInstalled();
+  const available = pm.listAvailable();
+
+  console.log('');
+
+  // Show installed plugins
+  if (installed.length > 0) {
+    console.log(`  ${BOLD}Installed:${RESET}`);
+    console.log('');
+    for (const p of installed) {
+      console.log(`    ${GREEN}${p.id}${RESET}  ${p.description}`);
+    }
+    console.log('');
+  } else {
+    console.log(`  ${DIM}No plugins installed yet.${RESET}`);
+    console.log('');
+  }
+
+  // Show available (not installed) plugins
+  const notInstalled = available.filter(p => !p.installed);
+  if (notInstalled.length > 0) {
+    console.log(`  ${BOLD}Available:${RESET}`);
+    console.log('');
+    const categories = {};
+    for (const p of notInstalled) {
+      if (!categories[p.category]) categories[p.category] = [];
+      categories[p.category].push(p);
+    }
+    for (const [category, plugins] of Object.entries(categories)) {
+      console.log(`  ${DIM}${category}${RESET}`);
+      for (const p of plugins) {
+        console.log(`    ${BOLD}${p.id}${RESET}  ${p.description}`);
+      }
+      console.log('');
+    }
+  }
+
+  console.log(`  Install with: ${DIM}friday install <plugin>${RESET}`);
+  console.log('');
+}

package/src/commands/schedule.js

@@ -0,0 +1,278 @@
+/**
+ * friday schedule — Manage scheduled agents
+ *
+ * Commands:
+ *   friday schedule              List all scheduled agents
+ *   friday schedule create       Create a new scheduled agent
+ *   friday schedule delete <id>  Delete a scheduled agent
+ */
+
+import readline from 'readline';
+import { createRequire } from 'module';
+import path from 'path';
+
+const require = createRequire(import.meta.url);
+let runtimeDir;
+try {
+  const runtimePkg = require.resolve('friday-runtime/package.json');
+  runtimeDir = path.dirname(runtimePkg);
+} catch {
+  runtimeDir = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..', '..', 'runtime');
+}
+
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+
+function ask(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+
+/**
+ * Parse natural language schedule into cron expression.
+ */
+function parseSchedule(input) {
+  const lower = input.toLowerCase().trim();
+
+  // "every X hours"
+  const hoursMatch = lower.match(/every\s+(\d+)\s+hours?/);
+  if (hoursMatch) {
+    const hours = parseInt(hoursMatch[1]);
+    return { cron: `0 */${hours} * * *`, humanReadable: `Every ${hours} hours` };
+  }
+
+  // "every X minutes"
+  const minutesMatch = lower.match(/every\s+(\d+)\s+minutes?/);
+  if (minutesMatch) {
+    const mins = parseInt(minutesMatch[1]);
+    return { cron: `*/${mins} * * * *`, humanReadable: `Every ${mins} minutes` };
+  }
+
+  // "every day at Xam/pm" or "daily at X"
+  const dailyMatch = lower.match(/(?:every\s+day|daily)\s+at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
+  if (dailyMatch) {
+    let hour = parseInt(dailyMatch[1]);
+    const minute = parseInt(dailyMatch[2] || '0');
+    const ampm = dailyMatch[3];
+    if (ampm === 'pm' && hour < 12) hour += 12;
+    if (ampm === 'am' && hour === 12) hour = 0;
+    const timeStr = `${hour}:${minute.toString().padStart(2, '0')}`;
+    return { cron: `${minute} ${hour} * * *`, humanReadable: `Every day at ${timeStr}` };
+  }
+
+  // "every morning" (9am)
+  if (lower.includes('every morning')) {
+    return { cron: '0 9 * * *', humanReadable: 'Every morning at 9:00' };
+  }
+
+  // "every evening" (6pm)
+  if (lower.includes('every evening')) {
+    return { cron: '0 18 * * *', humanReadable: 'Every evening at 18:00' };
+  }
+
+  // "every hour"
+  if (lower === 'every hour' || lower === 'hourly') {
+    return { cron: '0 * * * *', humanReadable: 'Every hour' };
+  }
+
+  // Day-of-week patterns: "every monday at 9am"
+  const dayMatch = lower.match(/every\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)\s+at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
+  if (dayMatch) {
+    const days = { sunday: 0, monday: 1, tuesday: 2, wednesday: 3, thursday: 4, friday: 5, saturday: 6 };
+    const day = days[dayMatch[1].toLowerCase()];
+    let hour = parseInt(dayMatch[2]);
+    const minute = parseInt(dayMatch[3] || '0');
+    const ampm = dayMatch[4];
+    if (ampm === 'pm' && hour < 12) hour += 12;
+    if (ampm === 'am' && hour === 12) hour = 0;
+    return {
+      cron: `${minute} ${hour} * * ${day}`,
+      humanReadable: `Every ${dayMatch[1]} at ${hour}:${minute.toString().padStart(2, '0')}`,
+    };
+  }
+
+  // "weekdays at Xam"
+  const weekdayMatch = lower.match(/weekdays?\s+at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
+  if (weekdayMatch) {
+    let hour = parseInt(weekdayMatch[1]);
+    const minute = parseInt(weekdayMatch[2] || '0');
+    const ampm = weekdayMatch[3];
+    if (ampm === 'pm' && hour < 12) hour += 12;
+    if (ampm === 'am' && hour === 12) hour = 0;
+    return {
+      cron: `${minute} ${hour} * * 1-5`,
+      humanReadable: `Weekdays at ${hour}:${minute.toString().padStart(2, '0')}`,
+    };
+  }
+
+  // Raw cron expression (5 fields)
+  if (/^[\d*/,-]+\s+[\d*/,-]+\s+[\d*/,-]+\s+[\d*/,-]+\s+[\d*/,-]+$/.test(lower)) {
+    return { cron: lower, humanReadable: lower };
+  }
+
+  return null;
+}
+
+export default async function schedule(args) {
+  const subcommand = args._[1]; // friday schedule <subcommand>
+
+  const ScheduledAgentStore = (await import(path.join(runtimeDir, 'src', 'scheduled-agents', 'ScheduledAgentStore.js'))).default;
+  const store = new ScheduledAgentStore();
+
+  // ── List ────────────────────────────────────────────────────────────
+  if (!subcommand || subcommand === 'list') {
+    const agents = await store.listAgents('default');
+
+    console.log('');
+    if (agents.length === 0) {
+      console.log(`  ${DIM}No scheduled agents.${RESET}`);
+      console.log(`  Create one with: ${DIM}friday schedule create${RESET}`);
+    } else {
+      console.log(`  ${BOLD}Scheduled agents:${RESET}`);
+      console.log('');
+      for (const agent of agents) {
+        const status = agent.status === 'active' ? `${GREEN}active${RESET}` : `${DIM}${agent.status}${RESET}`;
+        const schedule = agent.schedule?.humanReadable || agent.schedule?.cron || 'unknown';
+        const nextRun = agent.nextRunAt ? new Date(agent.nextRunAt).toLocaleString() : 'unknown';
+        console.log(`  ${BOLD}${agent.name}${RESET}  ${DIM}(${agent.id})${RESET}`);
+        console.log(`    ${schedule}  ·  ${status}  ·  Next: ${nextRun}`);
+        if (agent.description) {
+          console.log(`    ${DIM}${agent.description}${RESET}`);
+        }
+        console.log('');
+      }
+    }
+    console.log('');
+    return;
+  }
+
+  // ── Create ──────────────────────────────────────────────────────────
+  if (subcommand === 'create') {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    console.log('');
+    console.log(`  ${BOLD}Create a scheduled agent${RESET}`);
+    console.log(`  ${DIM}Describe what you want in natural language.${RESET}`);
+    console.log(`  ${DIM}Examples:${RESET}`);
+    console.log(`    ${DIM}"check my emails every morning at 9am"${RESET}`);
+    console.log(`    ${DIM}"research AI news every day at 8am using firecrawl"${RESET}`);
+    console.log(`    ${DIM}"run tests every 3 hours"${RESET}`);
+    console.log('');
+
+    const description = await ask(rl, '  > ');
+    if (!description) {
+      console.log(`  ${RED}Description is required.${RESET}`);
+      rl.close();
+      return;
+    }
+
+    // Parse schedule from the description
+    let parsed = parseSchedule(description);
+
+    // If no schedule detected, ask for it separately
+    if (!parsed) {
+      console.log(`  ${DIM}Couldn't detect a schedule. When should this run?${RESET}`);
+      console.log(`  ${DIM}Examples: "every morning at 9am", "every 3 hours", "weekdays at 8am"${RESET}`);
+      const scheduleInput = await ask(rl, '  Schedule: ');
+      parsed = parseSchedule(scheduleInput);
+      if (!parsed) {
+        console.log(`  ${RED}Could not parse schedule: "${scheduleInput}"${RESET}`);
+        rl.close();
+        return;
+      }
+    }
+
+    // Extract a name from the description (first few meaningful words)
+    const nameFromDesc = description
+      .replace(/every\s+(day|morning|evening|hour|monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b.*$/i, '')
+      .replace(/\b(at\s+\d{1,2}(:\d{2})?\s*(am|pm)?)\b/gi, '')
+      .replace(/\b(daily|hourly|weekdays?)\b/gi, '')
+      .replace(/\bevery\s+\d+\s+(minutes?|hours?)\b/gi, '')
+      .replace(/\busing\s+\w+\b/gi, '')
+      .trim();
+    const name = nameFromDesc.length > 3
+      ? nameFromDesc.charAt(0).toUpperCase() + nameFromDesc.slice(1)
+      : description.slice(0, 50);
+
+    // Extract plugin names if mentioned (e.g., "using firecrawl")
+    const pluginMatch = description.match(/\busing\s+([\w,\s]+?)(?:\s+(?:every|daily|hourly|at)\b|$)/i);
+    const plugins = pluginMatch
+      ? pluginMatch[1].split(/[,\s]+/).map(p => p.trim()).filter(Boolean)
+      : [];
+
+    console.log('');
+    console.log(`  ${DIM}Name: ${name}${RESET}`);
+    console.log(`  ${DIM}Schedule: ${parsed.humanReadable} (${parsed.cron})${RESET}`);
+    console.log(`  ${DIM}Task: ${description}${RESET}`);
+    if (plugins.length > 0) {
+      console.log(`  ${DIM}Plugins: ${plugins.join(', ')}${RESET}`);
+    }
+    console.log('');
+
+    const confirm = await ask(rl, `  Create this agent? (Y/n): `);
+    rl.close();
+
+    if (confirm.toLowerCase() === 'n') {
+      console.log(`  ${DIM}Cancelled.${RESET}`);
+      return;
+    }
+
+    try {
+      const agent = await store.createAgent('default', {
+        name,
+        description: description.slice(0, 100),
+        instructions: description,
+        schedule: {
+          cron: parsed.cron,
+          timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+          humanReadable: parsed.humanReadable,
+        },
+        mcpServers: plugins.length > 0 ? plugins : ['terminal'],
+        permissions: { preAuthorized: true, tools: [] },
+      });
+
+      console.log('');
+      console.log(`  ${GREEN}Agent created: ${agent.name}${RESET} ${DIM}(${agent.id})${RESET}`);
+      console.log(`  ${parsed.humanReadable}`);
+      console.log(`  ${DIM}Will take effect next time Friday starts.${RESET}`);
+      console.log('');
+    } catch (error) {
+      console.log(`  ${RED}Failed to create agent: ${error.message}${RESET}`);
+    }
+    return;
+  }
+
+  // ── Delete ──────────────────────────────────────────────────────────
+  if (subcommand === 'delete') {
+    const agentId = args._[2];
+    if (!agentId) {
+      console.log(`  ${BOLD}Usage:${RESET} friday schedule delete <agent-id>`);
+      return;
+    }
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const confirm = await ask(rl, `  Delete agent ${agentId}? (y/N): `);
+    rl.close();
+
+    if (confirm.toLowerCase() !== 'y') {
+      console.log(`  ${DIM}Cancelled.${RESET}`);
+      return;
+    }
+
+    try {
+      await store.deleteAgent('default', agentId);
+      console.log(`  ${GREEN}Agent deleted.${RESET}`);
+    } catch (error) {
+      console.log(`  ${RED}Failed: ${error.message}${RESET}`);
+    }
+    return;
+  }
+
+  console.log(`  ${RED}Unknown subcommand: ${subcommand}${RESET}`);
+  console.log(`  Usage: friday schedule [list|create|delete]`);
+}

package/src/commands/serve.js

@@ -0,0 +1,206 @@
+/**
+ * friday serve — Start the HTTP/WebSocket server
+ *
+ * Exposes the agent runtime over WebSocket (for real-time streaming)
+ * and HTTP REST (for agent/skill management). Clients connect via
+ * ws://host:port/ws for conversations.
+ */
+
+import http from 'http';
+import { WebSocketServer } from 'ws';
+import { AgentRuntime, loadBackendConfig, agentManager, skillManager } from 'friday-runtime';
+
+// --- HTTP helpers ---
+
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', (chunk) => (body += chunk));
+    req.on('end', () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+function sendJson(res, statusCode, data) {
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type',
+  });
+  res.end(JSON.stringify(data));
+}
+
+function parseUrl(url) {
+  const [pathname, queryString] = url.split('?');
+  const query = {};
+  if (queryString) {
+    queryString.split('&').forEach((pair) => {
+      const [key, value] = pair.split('=');
+      query[decodeURIComponent(key)] = decodeURIComponent(value || '');
+    });
+  }
+  return { pathname, query };
+}
+
+// --- Server ---
+
+export default async function serve(args) {
+  const port = Number(args.port || process.env.PORT || 8787);
+
+  if (args.help) {
+    console.log(`
+friday serve — Start HTTP/WebSocket server
+
+Options:
+  --port <port>        Port to listen on (default: 8787)
+  --workspace <path>   Working directory for agent (default: ~/FridayWorkspace)
+`);
+    process.exit(0);
+  }
+
+  if (args.workspace) {
+    process.env.FRIDAY_WORKSPACE = args.workspace;
+  }
+
+  const config = await loadBackendConfig();
+
+  const httpServer = http.createServer(async (req, res) => {
+    const { pathname, query } = parseUrl(req.url);
+    const method = req.method;
+
+    if (method === 'OPTIONS') {
+      res.writeHead(204, {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+      });
+      res.end();
+      return;
+    }
+
+    try {
+      // Health check
+      if (pathname === '/health') {
+        sendJson(res, 200, { ok: true, workspace: config.workspacePath });
+        return;
+      }
+
+      // --- Agent endpoints ---
+
+      if (pathname === '/api/agents' && method === 'GET') {
+        const userId = query.userId || 'default';
+        const agents = await agentManager.getUserAgents(userId);
+        sendJson(res, 200, { agents });
+        return;
+      }
+
+      const agentMatch = pathname.match(/^\/api\/agents\/([^/]+)$/);
+      if (agentMatch && method === 'GET') {
+        const userId = query.userId || 'default';
+        try {
+          const agent = await agentManager.loadUserAgentConfig(userId, agentMatch[1]);
+          sendJson(res, 200, { agent });
+        } catch (error) {
+          sendJson(res, 404, { error: error.message });
+        }
+        return;
+      }
+
+      if (pathname === '/api/agents/custom' && method === 'POST') {
+        const body = await parseBody(req);
+        const { userId = 'default', agentData } = body;
+        const newAgent = await agentManager.createUserAgent(userId, agentData);
+        sendJson(res, 201, { success: true, agent: newAgent });
+        return;
+      }
+
+      // --- Skill endpoints ---
+
+      if (pathname === '/api/skills' && method === 'GET') {
+        const userId = query.userId || 'default';
+        const skills = await skillManager.getUserAvailableSkills(userId);
+        sendJson(res, 200, skills);
+        return;
+      }
+
+      if (pathname === '/api/skills/search' && method === 'GET') {
+        const userId = query.userId || 'default';
+        const results = await skillManager.searchSkills(userId, query.q || '');
+        sendJson(res, 200, { results });
+        return;
+      }
+
+      sendJson(res, 404, { error: 'Not found' });
+    } catch (error) {
+      console.error('[HTTP] Error:', error);
+      sendJson(res, 500, { error: error.message });
+    }
+  });
+
+  // --- WebSocket ---
+
+  const wss = new WebSocketServer({ server: httpServer, path: '/ws' });
+
+  wss.on('connection', (socket) => {
+    const runtime = new AgentRuntime({
+      workspacePath: config.workspacePath,
+      rules: config.rules,
+      mcpServers: config.mcpServers,
+      sessionsPath: config.sessionsPath,
+    });
+
+    const send = (payload) => {
+      try {
+        socket.send(JSON.stringify(payload));
+      } catch (error) {
+        console.error('[WS] Failed to send:', error.message);
+      }
+    };
+
+    runtime.on('message', send);
+    send({ type: 'ready' });
+
+    socket.on('message', async (raw) => {
+      try {
+        const data = JSON.parse(raw.toString());
+        switch (data.type) {
+          case 'query':
+            await runtime.handleQuery(data.message, data.session_id || null, data.metadata || {});
+            break;
+          case 'new_session':
+            runtime.currentSessionId = null;
+            runtime.resetSessionState();
+            runtime.emitMessage({ type: 'info', message: 'Started new conversation' });
+            break;
+          case 'permission_response':
+            runtime.handlePermissionResponse(data);
+            break;
+          case 'rule_action':
+            await runtime.handleRuleActionMessage(data);
+            break;
+          default:
+            runtime.emitMessage({ type: 'error', message: `Unknown message type: ${data.type}` });
+        }
+      } catch (error) {
+        send({ type: 'error', message: error.message || 'Invalid payload' });
+      }
+    });
+
+    socket.on('close', () => {
+      runtime.removeAllListeners('message');
+    });
+  });
+
+  httpServer.listen(port, () => {
+    console.log(`Friday server listening on http://localhost:${port}`);
+    console.log(`WebSocket: ws://localhost:${port}/ws`);
+    console.log(`Workspace: ${config.workspacePath}`);
+  });
+}