@newsails/veil-cli 1.0.1

package/core/router.js

@@ -0,0 +1,386 @@
+'use strict';
+
+const { runLoop } = require('./loop');
+const { loadAgent, getEffectiveModeConfig } = require('./agent');
+const { assembleSystemPrompt } = require('./prompt');
+const { loadBuiltinTools } = require('./registry');
+const { loadSettings, getModelConfig } = require('../utils/settings');
+const db = require('../infrastructure/database');
+const { notifyTaskSubscribers } = require('./queue');
+const cancelRegistry = require('./cancel');
+const eventBus = require('./events');
+const path = require('path');
+
+// Load built-in tools once at startup
+const TOOLS_DIR = path.join(__dirname, '..', 'tools');
+let _toolsLoaded = false;
+
+function ensureToolsLoaded() {
+  if (_toolsLoaded) return;
+  loadBuiltinTools(TOOLS_DIR);
+  _toolsLoaded = true;
+}
+
+/**
+ * Run a chat-mode interaction.
+ *
+ * @param {{ agentName: string, message: string, sessionId?: string, cwd: string, settings: Object, onStreamChunk?: (text: string) => void }} opts
+ * @returns {Promise<{ sessionId: string, content: string, tokenUsage: Object }>}
+ */
+async function runChat({ agentName, message, sessionId, cwd, settings, onStreamChunk, onInferenceToolStart, onEvent, onSessionStart }) {
+  ensureToolsLoaded();
+
+  const agent = loadAgent({ cwd, name: agentName });
+  const modeConfig = getEffectiveModeConfig(agent, 'chat', settings);
+
+  // Get or create session
+  let sid = sessionId;
+  let messages = [];
+  let thinking = agent.thinking || null;
+
+  if (sid) {
+    const session = db.getSession(sid);
+    if (!session) throw Object.assign(new Error(`Session not found: ${sid}`), { code: 'SESSION_NOT_FOUND' });
+    if (session.status === 'closed') throw Object.assign(new Error(`Session is closed: ${sid}`), { code: 'SESSION_CLOSED' });
+    // Session-level thinking overrides agent default
+    if (session.model_thinking) {
+      try { thinking = JSON.parse(session.model_thinking); } catch { /* keep agent default */ }
+    }
+    // Load existing messages
+    const dbMessages = db.getMessages(sid);
+    messages = dbMessages.map(m => {
+      const msg = { role: m.role, content: m.content };
+      if (m.tool_calls) msg.tool_calls = m.tool_calls;
+      if (m.tool_call_id) msg.tool_call_id = m.tool_call_id;
+      return msg;
+    });
+  } else {
+    const modelConfig = getModelConfig(settings, 'main');
+    sid = db.createSession({
+      agentName,
+      mode: 'chat',
+      instanceFolder: cwd,
+      model: agent.model || modelConfig.model,
+      modelThinking: thinking,
+    });
+    if (onSessionStart) onSessionStart(sid);
+    eventBus.emit('event', { type: 'session.created', sessionId: sid, agentName, event: { mode: 'chat', timestamp: Date.now() } });
+
+    // Build system prompt and add as first message
+    const systemPrompt = assembleSystemPrompt({ agent, mode: 'chat', sessionId: sid, cwd, settings });
+    messages.push({ role: 'system', content: systemPrompt });
+    db.addMessage({ sessionId: sid, role: 'system', content: systemPrompt });
+  }
+
+  // Add user message
+  messages.push({ role: 'user', content: message });
+  db.addMessage({ sessionId: sid, role: 'user', content: message });
+  eventBus.emit('event', { type: 'chat.user_message', sessionId: sid, agentName, event: { content: message, timestamp: Date.now() } });
+
+  // Run loop
+  const runStartTime = Date.now();
+  let responseContent = null;
+  let tokenUsage = { input: 0, output: 0, cache: 0, cost: 0 };
+  let responseModel = null;
+  let totalIterations = 0;
+  const toolCallLog = [];
+
+  // When no SSE callbacks are provided (HTTP JSON, agent_message, agent_spawn, etc.),
+  // emit inference.tool events to the bus so WS clients see them.
+  const effectiveOnInferenceToolStart = onInferenceToolStart || ((toolName) => {
+    eventBus.emit('event', { type: 'chat.inference_tool', sessionId: sid, agentName, event: { name: toolName, timestamp: Date.now() } });
+  });
+
+  for await (const event of runLoop({ agent, messages, settings, mode: 'chat', sessionId: sid, cwd, modeConfig, thinking, onStreamChunk, onInferenceToolStart: effectiveOnInferenceToolStart })) {
+    if (onEvent) onEvent(event);
+    // When no SSE onEvent is provided, emit message events directly to the bus
+    // so WS clients see assistant content and tool results regardless of trigger path.
+    else if (event.type === 'message') {
+      eventBus.emit('event', { type: 'chat.message', sessionId: sid, agentName, event: { ...event.message, finishReason: event.finishReason, iteration: event.iteration, tokenUsage: event.tokenUsage, timestamp: Date.now() } });
+    }
+    if (event.type === 'chat.response') {
+      responseContent = event.content;
+      tokenUsage = { input: event.totalTokens.input, output: event.totalTokens.output, cache: event.totalTokens.cache, cost: event.totalTokens.cost };
+      responseModel = event.model;
+      totalIterations = event.iteration;
+    }
+    if (event.type === 'tool.end') {
+      toolCallLog.push({ name: event.toolName, durationMs: event.durationMs, success: event.success });
+    }
+  }
+
+  eventBus.emit('event', { type: 'chat.response', sessionId: sid, agentName, event: { content: responseContent ? responseContent.slice(0, 500) : null, toolCount: toolCallLog.length, timestamp: Date.now() } });
+
+  const session = db.getSession(sid);
+  return { sessionId: sid, content: responseContent, tokenUsage, toolCalls: toolCallLog, agentName, model: responseModel, iterations: totalIterations, durationMs: Date.now() - runStartTime, session };
+}
+
+/**
+ * Run a task. Either creates a new session or resumes an existing task.
+ *
+ * @param {{ taskId: string, cwd: string, settings?: Object }} opts
+ * @returns {Promise<{ taskId: string, status: string, output: string|null }>}
+ */
+async function runTask({ taskId, cwd, settings: overrideSettings }) {
+  ensureToolsLoaded();
+
+  const task = db.getTask(taskId);
+  if (!task) throw new Error(`Task not found: ${taskId}`);
+
+  const taskSettings = overrideSettings || loadSettings({ cwd });
+  const agent = loadAgent({ cwd, name: task.agent_name });
+  const modeConfig = getEffectiveModeConfig(agent, 'task', taskSettings);
+
+  const taskInput = typeof task.input === 'string' ? task.input : JSON.stringify(task.input);
+  const modelConfig = getModelConfig(taskSettings, 'main');
+
+  let sessionId;
+  let messages;
+
+  // Check if task has an existing session to continue from
+  if (task.session_id) {
+    sessionId = task.session_id;
+    // Load existing messages from the session
+    const dbMessages = db.getMessages(sessionId);
+    messages = dbMessages.map(m => {
+      const msg = { role: m.role, content: m.content };
+      if (m.tool_calls) msg.tool_calls = m.tool_calls;
+      if (m.tool_call_id) msg.tool_call_id = m.tool_call_id;
+      return msg;
+    });
+    // Add the new task input as a user message
+    messages.push({ role: 'user', content: taskInput });
+    db.addMessage({ sessionId, role: 'user', content: taskInput });
+  } else {
+    // Create new session for this task
+    sessionId = db.createSession({
+      agentName: task.agent_name,
+      mode: 'task',
+      instanceFolder: cwd,
+      model: agent.model || modelConfig.model,
+    });
+
+    const systemPrompt = assembleSystemPrompt({
+      agent,
+      mode: 'task',
+      sessionId,
+      taskId,
+      cwd,
+      settings: taskSettings,
+      taskBrief: taskInput,
+    });
+
+    messages = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: taskInput },
+    ];
+
+    db.addMessage({ sessionId, role: 'system', content: systemPrompt });
+    db.addMessage({ sessionId, role: 'user', content: taskInput });
+  }
+
+  db.updateTask(taskId, { sessionId, status: 'processing', startedAt: new Date().toISOString() });
+  db.addTaskEvent({ taskId, type: 'status.change', data: { from: 'pending', to: 'processing' } });
+  eventBus.emit('event', { type: 'task.status', taskId, agentName: task.agent_name, event: { status: 'processing', sessionId, timestamp: Date.now() } });
+
+  // Register cancellation signal
+  const cancelSignal = cancelRegistry.register(taskId);
+
+  try {
+    for await (const event of runLoop({ agent, messages, settings: taskSettings, mode: 'task', taskId, sessionId, cwd, modeConfig, cancelSignal })) {
+      // Events emitted — task status/output updated inside loop
+    }
+  } finally {
+    cancelRegistry.cleanup(taskId);
+  }
+
+  // Notify task subscribers on completion
+  const finalTask = db.getTask(taskId);
+  if (finalTask.status === 'finished' || finalTask.status === 'failed' || finalTask.status === 'canceled') {
+    notifyTaskSubscribers({ taskId, task: finalTask });
+  }
+
+  return { taskId, sessionId, status: finalTask.status, output: finalTask.output };
+}
+
+/**
+ * Resume a waiting task after /tasks/:id/respond is called.
+ * Loads existing session and continues the loop.
+ *
+ * @param {{ taskId: string, cwd: string, settings?: Object }} opts
+ * @returns {Promise<{ taskId: string, status: string, output: string|null }>}
+ */
+async function resumeTask({ taskId, cwd, settings: overrideSettings }) {
+  ensureToolsLoaded();
+
+  const task = db.getTask(taskId);
+  if (!task) throw new Error(`Task not found: ${taskId}`);
+  if (!task.session_id) throw new Error(`Task ${taskId} has no session to resume`);
+
+  const taskSettings = overrideSettings || loadSettings({ cwd });
+  const agent = loadAgent({ cwd, name: task.agent_name });
+  const modeConfig = getEffectiveModeConfig(agent, 'task', taskSettings);
+
+  const sessionId = task.session_id;
+
+  // Load existing messages from the session
+  const dbMessages = db.getMessages(sessionId);
+  const messages = dbMessages.map(m => {
+    const msg = { role: m.role, content: m.content };
+    if (m.tool_calls) msg.tool_calls = m.tool_calls;
+    if (m.tool_call_id) msg.tool_call_id = m.tool_call_id;
+    return msg;
+  });
+
+  db.updateTask(taskId, { status: 'processing' });
+  db.addTaskEvent({ taskId, type: 'status.change', data: { from: 'waiting', to: 'processing', reason: 'resumed' } });
+  eventBus.emit('event', { type: 'task.status', taskId, agentName: task.agent_name, event: { status: 'processing', reason: 'resumed', timestamp: Date.now() } });
+
+  // Register cancellation signal
+  const cancelSignal = cancelRegistry.register(taskId);
+
+  try {
+    for await (const event of runLoop({ agent, messages, settings: taskSettings, mode: 'task', taskId, sessionId, cwd, modeConfig, cancelSignal })) {
+      // Events emitted — task status/output updated inside loop
+    }
+  } finally {
+    cancelRegistry.cleanup(taskId);
+  }
+
+  // Notify task subscribers on completion
+  const finalTask = db.getTask(taskId);
+  if (finalTask.status === 'finished' || finalTask.status === 'failed' || finalTask.status === 'canceled') {
+    notifyTaskSubscribers({ taskId, task: finalTask });
+  }
+
+  return { taskId, status: finalTask.status, output: finalTask.output };
+}
+
+/**
+ * Run a subagent (spawned by agent_spawn). Uses modes.subagent config.
+ *
+ * @param {{ taskId: string, cwd: string, settings?: Object }} opts
+ * @returns {Promise<{ taskId: string, status: string, output: string|null }>}
+ */
+async function runSubagent({ taskId, cwd, settings: overrideSettings }) {
+  ensureToolsLoaded();
+
+  const task = db.getTask(taskId);
+  if (!task) throw new Error(`Task not found: ${taskId}`);
+
+  const taskSettings = overrideSettings || loadSettings({ cwd });
+  const agent = loadAgent({ cwd, name: task.agent_name });
+  const modeConfig = getEffectiveModeConfig(agent, 'subagent', taskSettings);
+
+  // Create session for this subagent run
+  const modelConfig = getModelConfig(taskSettings, 'main');
+  const sessionId = db.createSession({
+    agentName: task.agent_name,
+    mode: 'subagent',
+    instanceFolder: cwd,
+    model: agent.model || modelConfig.model,
+  });
+
+  db.updateTask(taskId, { sessionId, status: 'processing', startedAt: new Date().toISOString() });
+  db.addTaskEvent({ taskId, type: 'status.change', data: { from: 'pending', to: 'processing' } });
+  eventBus.emit('event', { type: 'task.status', taskId, agentName: task.agent_name, event: { status: 'processing', sessionId, timestamp: Date.now() } });
+
+  // Register cancellation signal
+  const cancelSignal = cancelRegistry.register(taskId);
+
+  const taskInput = typeof task.input === 'string' ? task.input : JSON.stringify(task.input);
+
+  const systemPrompt = assembleSystemPrompt({
+    agent,
+    mode: 'subagent',
+    sessionId,
+    taskId,
+    cwd,
+    settings: taskSettings,
+    taskBrief: taskInput,
+  });
+
+  const messages = [
+    { role: 'system', content: systemPrompt },
+    { role: 'user', content: taskInput },
+  ];
+
+  db.addMessage({ sessionId, role: 'system', content: systemPrompt });
+  db.addMessage({ sessionId, role: 'user', content: taskInput });
+
+  try {
+    for await (const event of runLoop({ agent, messages, settings: taskSettings, mode: 'subagent', taskId, sessionId, cwd, modeConfig, cancelSignal })) {
+      // Events emitted — task status/output updated inside loop
+    }
+  } finally {
+    cancelRegistry.cleanup(taskId);
+  }
+
+  // Notify task subscribers on completion
+  const finalTask = db.getTask(taskId);
+  if (finalTask.status === 'finished' || finalTask.status === 'failed' || finalTask.status === 'canceled') {
+    notifyTaskSubscribers({ taskId, task: finalTask });
+  }
+
+  return { taskId, status: finalTask.status, output: finalTask.output };
+}
+
+/**
+ * Run a single daemon tick.
+ *
+ * @param {{ agentName: string, cwd: string, settings: Object }} opts
+ * @returns {Promise<{ status: string, content: string|null }>}
+ */
+async function runDaemonTick({ agentName, cwd, settings }) {
+  ensureToolsLoaded();
+
+  const agent = loadAgent({ cwd, name: agentName });
+  const modeConfig = getEffectiveModeConfig(agent, 'daemon', settings);
+
+  const modelConfig = getModelConfig(settings, 'main');
+  const sessionId = db.createSession({
+    agentName,
+    mode: 'daemon',
+    instanceFolder: cwd,
+    model: agent.model || modelConfig.model,
+  });
+
+  const systemPrompt = assembleSystemPrompt({ agent, mode: 'daemon', sessionId, cwd, settings });
+
+  // Read heartbeat file if exists
+  const { getHeartbeatsDir } = require('../utils/paths');
+  const fs = require('fs');
+  const path = require('path');
+  const heartbeatPath = (agent.modes?.daemon?.heartbeatFile)
+    ? path.resolve(cwd, agent.modes.daemon.heartbeatFile)
+    : path.join(getHeartbeatsDir(cwd), `${agentName}.md`);
+
+  let daemonInstruction = `You are running a scheduled daemon tick. Check your heartbeat file and perform your scheduled duties.`;
+  if (fs.existsSync(heartbeatPath)) {
+    daemonInstruction = fs.readFileSync(heartbeatPath, 'utf8');
+  }
+
+  const messages = [
+    { role: 'system', content: systemPrompt },
+    { role: 'user', content: daemonInstruction },
+  ];
+
+  eventBus.emit('event', { type: 'daemon.tick', agentName, event: { status: 'running', sessionId, timestamp: Date.now() } });
+
+  let result = null;
+  try {
+    for await (const event of runLoop({ agent, messages, settings, mode: 'daemon', sessionId, cwd, modeConfig })) {
+      if (event.type === 'daemon.tick.complete') result = event.content;
+    }
+    eventBus.emit('event', { type: 'daemon.tick', agentName, event: { status: 'done', sessionId, timestamp: Date.now() } });
+  } catch (err) {
+    eventBus.emit('event', { type: 'daemon.tick', agentName, event: { status: 'error', error: err.message, sessionId, timestamp: Date.now() } });
+    throw err;
+  } finally {
+    db.closeSession(sessionId);
+  }
+
+  return { status: 'done', content: result };
+}
+
+module.exports = { runChat, runTask, resumeTask, runSubagent, runDaemonTick };

package/core/running-sessions.js

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * In-memory set of session IDs that currently have an active runLoop running.
+ * Used by agent_message / agent_send to decide whether to queue-inject or
+ * trigger a new turn directly.
+ *
+ * Populated / cleared inside core/loop.js runLoop() via try/finally.
+ * Process-local only — does not survive restarts (that is intentional:
+ * after a restart no loop is running, so the set is correctly empty).
+ */
+const running = new Set();
+
+module.exports = {
+  add:    (sessionId) => running.add(sessionId),
+  delete: (sessionId) => running.delete(sessionId),
+  has:    (sessionId) => running.has(sessionId),
+};

package/docs/api/01-system.md

@@ -0,0 +1,84 @@
+# System Endpoints
+
+---
+
+## GET /health
+
+Lightweight liveness check. Returns immediately, no DB access.
+
+**Response**
+```json
+{
+  "status": "ok",
+  "version": "0.1.0",
+  "uptime": 142
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `status` | string | Always `"ok"` |
+| `version` | string | VeilCLI version |
+| `uptime` | integer | Seconds since server start |
+
+**Example**
+```bash
+curl http://localhost:5050/health
+```
+
+---
+
+## GET /status
+
+Full server status snapshot including agent, session, task, and daemon counts.
+
+**Response**
+```json
+{
+  "status": "ok",
+  "version": "0.1.0",
+  "uptime": 261,
+  "cwd": "/home/user/my-workspace",
+  "agents": 3,
+  "activeSessions": 2,
+  "pendingTasks": 1,
+  "processingTasks": 0,
+  "daemons": 1
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `cwd` | string | Workspace directory the server was started in |
+| `agents` | integer | Number of agents found in `.veil/agents/` |
+| `activeSessions` | integer | Open chat/task sessions |
+| `pendingTasks` | integer | Tasks queued but not yet started |
+| `processingTasks` | integer | Tasks currently running |
+| `daemons` | integer | Daemon agents currently scheduled |
+
+**Example**
+```bash
+curl http://localhost:5050/status
+```
+
+---
+
+## POST /shutdown
+
+Triggers a graceful shutdown of the server. The server closes active connections, stops all daemon schedulers, closes the SQLite database, and removes its PID file before exiting.
+
+**Request body** — none
+
+**Response**
+```json
+{
+  "status": "shutting_down"
+}
+```
+
+The process exits approximately 500ms after responding.
+
+**Example**
+```bash
+curl -X POST http://localhost:5050/shutdown
+```