clawmini 0.0.8 → 0.0.9

package/src/cli/supervisor.ts

@@ -0,0 +1,277 @@
+import type { ChildProcess } from 'node:child_process';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+
+import { getSocketPath } from '../shared/workspace.js';
+
+export type ServiceName = 'daemon' | 'web' | 'adapter-discord' | 'adapter-google-chat';
+
+export const DISPLAY_NAMES: Record<ServiceName, string> = {
+  daemon: 'daemon',
+  web: 'web',
+  'adapter-discord': 'discord',
+  'adapter-google-chat': 'google-chat',
+};
+
+// Adapters and the web UI are mostly stateless — give them a tight window.
+// The daemon runs `down` hooks (e.g. sandbox/container teardown) that can
+// legitimately take tens of seconds, so it needs much longer to drain.
+const ADAPTER_TERMINATE_TIMEOUT_MS = 10_000;
+const DAEMON_TERMINATE_TIMEOUT_MS = 60_000;
+
+interface ResolvedCommand {
+  command: string;
+  args: string[];
+}
+
+export function resolveServiceCommand(service: ServiceName): ResolvedCommand {
+  const cliPath = fileURLToPath(import.meta.url);
+  switch (service) {
+    case 'daemon':
+      return {
+        command: process.execPath,
+        args: [new URL('../daemon/index.mjs', import.meta.url).pathname],
+      };
+    case 'web':
+      return { command: process.execPath, args: [cliPath, 'web'] };
+    case 'adapter-discord':
+      return {
+        command: process.execPath,
+        args: [new URL('../adapter-discord/index.mjs', import.meta.url).pathname],
+      };
+    case 'adapter-google-chat':
+      return {
+        command: process.execPath,
+        args: [new URL('../adapter-google-chat/index.mjs', import.meta.url).pathname],
+      };
+  }
+}
+
+export class Supervisor {
+  private children = new Map<ServiceName, ChildProcess>();
+  private logFds = new Map<ServiceName, number>();
+  private shuttingDown = false;
+  private restarting = new Set<ServiceName>();
+  // Services that have ever been started in this supervisor's lifetime. Used
+  // by restartAll() to know what to bring back after a stopAllChildren().
+  // We don't remove entries when a service stops — a crash-and-restart of an
+  // adapter shouldn't drop it from the "originally enabled" set.
+  private enabledServices = new Set<ServiceName>();
+  private readonly logDir: string;
+
+  constructor(logDir: string) {
+    this.logDir = logDir;
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  async startService(service: ServiceName): Promise<void> {
+    this.enabledServices.add(service);
+    const { command, args } = resolveServiceCommand(service);
+    const logPath = path.join(this.logDir, `${service}.log`);
+    const logFd = fs.openSync(logPath, 'a');
+    this.logFds.set(service, logFd);
+
+    fs.writeSync(
+      logFd,
+      `\n--- clawmini serve: ${service} starting at ${new Date().toISOString()} ---\n`
+    );
+
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+      cwd: process.cwd(),
+    });
+
+    this.children.set(service, child);
+    this.attachPipe(service, child.stdout!, logFd, 'stdout');
+    this.attachPipe(service, child.stderr!, logFd, 'stderr');
+
+    child.on('exit', (code, signal) => {
+      const msg = `exited code=${code} signal=${signal}`;
+      process.stderr.write(`[${DISPLAY_NAMES[service]}] ${msg}\n`);
+      try {
+        fs.writeSync(logFd, `--- ${msg} at ${new Date().toISOString()} ---\n`);
+        fs.closeSync(logFd);
+      } catch {
+        // best-effort
+      }
+      this.logFds.delete(service);
+      this.children.delete(service);
+
+      if (service === 'daemon' && !this.shuttingDown && !this.restarting.has('daemon')) {
+        process.stderr.write('[supervisor] daemon exited unexpectedly — shutting down\n');
+        void this.shutdown(1);
+      }
+    });
+  }
+
+  private attachPipe(
+    service: ServiceName,
+    stream: NodeJS.ReadableStream,
+    logFd: number,
+    kind: 'stdout' | 'stderr'
+  ): void {
+    const prefix = `[${DISPLAY_NAMES[service]}] `;
+    const target = kind === 'stderr' ? process.stderr : process.stdout;
+    const rl = readline.createInterface({ input: stream });
+    rl.on('line', (line) => {
+      try {
+        fs.writeSync(logFd, line + '\n');
+      } catch {
+        // best-effort: logs on disk are not critical
+      }
+      target.write(prefix + line + '\n');
+    });
+  }
+
+  async waitForDaemonSocket(timeoutMs = 10_000): Promise<void> {
+    const socketPath = getSocketPath();
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      if (fs.existsSync(socketPath)) return;
+      if (!this.children.has('daemon')) {
+        throw new Error('Daemon exited before socket became available.');
+      }
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    throw new Error(`Daemon did not start within ${timeoutMs}ms`);
+  }
+
+  async shutdown(exitCode = 0): Promise<void> {
+    if (this.shuttingDown) return;
+    this.shuttingDown = true;
+    process.stderr.write('\n[supervisor] shutting down...\n');
+
+    await this.stopAllChildren();
+
+    process.exit(exitCode);
+  }
+
+  /**
+   * Stop all children and close log fds without exiting the process. Used by
+   * `/upgrade`, which needs to tear down everything, run an install, then
+   * launch a fresh supervisor.
+   */
+  async stopAllChildren(): Promise<void> {
+    // Phase 1: stop adapters and the web UI in parallel. They depend on the
+    // daemon, so taking them down first lets the daemon's `down` hooks run
+    // without interference from disconnect noise.
+    const adapterStops: Promise<void>[] = [];
+    for (const [name, child] of this.children) {
+      if (name === 'daemon') continue;
+      adapterStops.push(Supervisor.terminateChild(name, child, ADAPTER_TERMINATE_TIMEOUT_MS));
+    }
+    await Promise.allSettled(adapterStops);
+
+    // Phase 2: stop the daemon with a generous timeout so its `down` hooks
+    // (sandbox/container teardown) can complete.
+    const daemonChild = this.children.get('daemon');
+    if (daemonChild) {
+      await Supervisor.terminateChild('daemon', daemonChild, DAEMON_TERMINATE_TIMEOUT_MS);
+    }
+
+    for (const fd of this.logFds.values()) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+        // best-effort
+      }
+    }
+    this.logFds.clear();
+  }
+
+  /**
+   * Bounce every service that has ever been started under this supervisor.
+   * Daemon goes down with the adapters, then comes back first so the
+   * adapters can re-establish their tRPC subscriptions to the new daemon.
+   *
+   * This is what `/restart` and the `/upgrade` failure recovery paths call:
+   * just bouncing the daemon would leave adapter-discord (and any other
+   * adapter) holding a dead subscription, so outbound messages would never
+   * reach the chat. The user-visible symptom was "I send /restart and then
+   * the daemon's reply never shows up in Discord."
+   */
+  async restartAll(): Promise<void> {
+    if (this.shuttingDown) return;
+    // Suppress the daemon's unexpected-exit guard while we tear it down.
+    this.restarting.add('daemon');
+    try {
+      await this.stopAllChildren();
+      // Wait for the exit handlers to drain bookkeeping.
+      await new Promise((r) => setImmediate(r));
+
+      if (this.enabledServices.has('daemon')) {
+        await this.startService('daemon');
+        await this.waitForDaemonSocket();
+      }
+      for (const name of this.enabledServices) {
+        if (name === 'daemon') continue;
+        await this.startService(name);
+      }
+    } finally {
+      this.restarting.delete('daemon');
+    }
+  }
+
+  /**
+   * Stop and re-spawn a single service. The exit handler is suppressed so a
+   * restarted daemon doesn't trigger a full shutdown.
+   */
+  async restartService(service: ServiceName): Promise<void> {
+    if (this.shuttingDown) return;
+    this.restarting.add(service);
+    try {
+      const child = this.children.get(service);
+      if (child) {
+        const timeoutMs =
+          service === 'daemon' ? DAEMON_TERMINATE_TIMEOUT_MS : ADAPTER_TERMINATE_TIMEOUT_MS;
+        await Supervisor.terminateChild(service, child, timeoutMs);
+      }
+      // Wait until the exit handler has cleared bookkeeping. The handler runs
+      // synchronously on the same tick as `exit`, so a microtask hop is enough.
+      await new Promise((r) => setImmediate(r));
+      await this.startService(service);
+      if (service === 'daemon') {
+        await this.waitForDaemonSocket();
+      }
+    } finally {
+      this.restarting.delete(service);
+    }
+  }
+
+  private static terminateChild(
+    name: ServiceName,
+    child: ChildProcess,
+    timeoutMs: number
+  ): Promise<void> {
+    return new Promise((resolve) => {
+      if (child.exitCode !== null || child.signalCode !== null) {
+        resolve();
+        return;
+      }
+      const timer = setTimeout(() => {
+        process.stderr.write(
+          `[supervisor] ${name} did not exit in ${Math.round(timeoutMs / 1000)}s, sending SIGKILL\n`
+        );
+        try {
+          child.kill('SIGKILL');
+        } catch {
+          // ignore
+        }
+      }, timeoutMs);
+      child.once('exit', () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      try {
+        child.kill('SIGTERM');
+      } catch {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+  }
+}

package/src/daemon/agent/agent-context.ts

@@ -1,8 +1,9 @@
 import { type FallbackSchema } from '../../shared/config.js';
 import {
   getActiveEnvironmentInfo,
-  getEnvironmentPath,
+  getEnvironmentSearchDirs,
   readEnvironment,
+  substituteLayeredEnvDir,
 } from '../../shared/workspace.js';
 import { z } from 'zod';
 
@@ -10,19 +11,21 @@ export type Fallback = z.infer<typeof FallbackSchema>;
 
 function formatEnvironmentPrefix(
   prefix: string,
-  replacements: { targetPath: string; executionCwd: string; envDir: string; envArgs: string }
+  searchDirs: string[],
+  replacements: { targetPath: string; executionCwd: string; envArgs: string }
 ): string {
+  let out = substituteLayeredEnvDir(prefix, searchDirs);
   const map: Record<string, string> = {
     '{WORKSPACE_DIR}': replacements.targetPath,
     '{AGENT_DIR}': replacements.executionCwd,
-    '{ENV_DIR}': replacements.envDir,
     '{HOME_DIR}': process.env.HOME || '',
     '{ENV_ARGS}': replacements.envArgs,
   };
-  return prefix.replace(
-    /{(WORKSPACE_DIR|AGENT_DIR|ENV_DIR|HOME_DIR|ENV_ARGS)}/g,
+  out = out.replace(
+    /{(WORKSPACE_DIR|AGENT_DIR|HOME_DIR|ENV_ARGS)}/g,
     (match) => map[match] || match
   );
+  return out;
 }
 
 export async function sandboxExecutionContext(
@@ -38,6 +41,7 @@ export async function sandboxExecutionContext(
 
   const activeEnvName = activeEnvInfo.name;
   const activeEnv = await readEnvironment(activeEnvName, cwd);
+  const searchDirs = await getEnvironmentSearchDirs(activeEnvName, cwd);
 
   if (activeEnv?.env) {
     for (const [key, value] of Object.entries(activeEnv.env)) {
@@ -47,10 +51,7 @@ export async function sandboxExecutionContext(
       } else {
         let interpolatedValue = String(value);
         interpolatedValue = interpolatedValue.replace(/\{PATH\}/g, process.env.PATH || '');
-        interpolatedValue = interpolatedValue.replace(
-          /\{ENV_DIR\}/g,
-          getEnvironmentPath(activeEnvName, cwd)
-        );
+        interpolatedValue = substituteLayeredEnvDir(interpolatedValue, searchDirs);
         interpolatedValue = interpolatedValue.replace(
           /\{WORKSPACE_DIR\}/g,
           activeEnvInfo.targetPath
@@ -71,10 +72,9 @@ export async function sandboxExecutionContext(
       })
       .join(' ');
 
-    const prefixReplaced = formatEnvironmentPrefix(activeEnv.prefix, {
+    const prefixReplaced = formatEnvironmentPrefix(activeEnv.prefix, searchDirs, {
       targetPath: activeEnvInfo.targetPath,
       executionCwd: executionCwd,
-      envDir: getEnvironmentPath(activeEnvName, cwd),
       envArgs,
     });
 

package/src/daemon/agent/agent-session.ts

@@ -23,6 +23,7 @@ export class AgentSession {
   public readonly sessionId: string;
   public readonly chatId: string;
   public readonly subagentId: string | undefined;
+  public readonly turnId: string | undefined;
   public readonly settings: Agent;
   public readonly workspaceRoot: string;
   public readonly globalSettings: Settings | undefined;
@@ -33,6 +34,7 @@ export class AgentSession {
     sessionId: string;
     chatId: string;
     subagentId?: string;
+    turnId?: string;
     settings: Agent;
     workspaceRoot: string;
     globalSettings: Settings | undefined;
@@ -42,11 +44,13 @@ export class AgentSession {
     this.sessionId = config.sessionId;
     this.chatId = config.chatId;
     this.subagentId = config.subagentId;
+    this.turnId = config.turnId;
     this.settings = config.settings;
     this.workspaceRoot = config.workspaceRoot;
     this.globalSettings = config.globalSettings;
 
-    this.logger = config.logger ?? createChatLogger(this.chatId, this.subagentId);
+    this.logger =
+      config.logger ?? createChatLogger(this.chatId, this.subagentId, this.sessionId, this.turnId);
   }
 
   async buildExecutionContext(
@@ -110,6 +114,7 @@ export class AgentSession {
         agentId: this.agentId,
         sessionId: this.sessionId,
         ...(this.subagentId ? { subagentId: this.subagentId } : {}),
+        ...(this.turnId ? { turnId: this.turnId } : {}),
         timestamp: Date.now(),
       });
 
@@ -215,6 +220,7 @@ export async function createAgentSession(options: {
   agentId: string;
   sessionId: string;
   subagentId?: string;
+  turnId?: string;
   cwd: string;
   settings?: Settings | undefined;
   logger?: Logger;
@@ -229,6 +235,7 @@ export async function createAgentSession(options: {
     sessionId: options.sessionId,
     chatId: options.chatId,
     ...(options.subagentId ? { subagentId: options.subagentId } : {}),
+    ...(options.turnId ? { turnId: options.turnId } : {}),
     settings: mergedAgent,
     workspaceRoot,
     globalSettings: settings,

package/src/daemon/agent/chat-logger.test.ts

@@ -38,11 +38,52 @@ describe('ChatLogger', () => {
       );
     });
 
+    it('should inject sessionId into outgoing messages', async () => {
+      const logger = createChatLogger('chat-1', undefined, 'session-42');
+      await logger.logUserMessage('hello session');
+      await logger.logAgentReply({ content: 'reply' });
+      await logger.logCommandResult({
+        messageId: 'm',
+        content: '',
+        command: 'echo',
+        cwd: '/tmp',
+        result: { stdout: '', stderr: '', exitCode: 0 },
+      });
+      await logger.logToolMessage({
+        content: 'c',
+        messageId: 'm',
+        name: 't',
+        payload: {},
+      });
+      await logger.logSystemMessage({ content: 's', event: 'cron' });
+
+      const calls = vi.mocked(daemonChats.appendMessage).mock.calls;
+      expect(calls).toHaveLength(5);
+      for (const [, msg] of calls) {
+        expect(msg).toEqual(expect.objectContaining({ sessionId: 'session-42' }));
+        expect(msg).not.toHaveProperty('subagentId');
+      }
+    });
+
     it('should filter incoming logs for the subagent', async () => {
       const mockMessages: ChatMessage[] = [
-        { id: '1', role: 'user', content: 'root msg', timestamp: '1' },
-        { id: '2', role: 'user', content: 'sub msg', timestamp: '2', subagentId: 'sub-1' },
-        { id: '3', role: 'user', content: 'other sub', timestamp: '3', subagentId: 'sub-2' },
+        { id: '1', role: 'user', content: 'root msg', timestamp: '1', sessionId: undefined },
+        {
+          id: '2',
+          role: 'user',
+          content: 'sub msg',
+          timestamp: '2',
+          subagentId: 'sub-1',
+          sessionId: undefined,
+        },
+        {
+          id: '3',
+          role: 'user',
+          content: 'other sub',
+          timestamp: '3',
+          subagentId: 'sub-2',
+          sessionId: undefined,
+        },
       ];
       vi.mocked(daemonChats.getMessages).mockResolvedValue(mockMessages);
 
@@ -56,10 +97,31 @@ describe('ChatLogger', () => {
 
     it('should limit messages after filtering', async () => {
       const mockMessages: ChatMessage[] = [
-        { id: '1', role: 'user', content: 'root msg', timestamp: '1' },
-        { id: '2', role: 'user', content: 'sub msg 1', timestamp: '2', subagentId: 'sub-1' },
-        { id: '3', role: 'user', content: 'other sub', timestamp: '3', subagentId: 'sub-2' },
-        { id: '4', role: 'user', content: 'sub msg 2', timestamp: '4', subagentId: 'sub-1' },
+        { id: '1', role: 'user', content: 'root msg', timestamp: '1', sessionId: undefined },
+        {
+          id: '2',
+          role: 'user',
+          content: 'sub msg 1',
+          timestamp: '2',
+          subagentId: 'sub-1',
+          sessionId: undefined,
+        },
+        {
+          id: '3',
+          role: 'user',
+          content: 'other sub',
+          timestamp: '3',
+          subagentId: 'sub-2',
+          sessionId: undefined,
+        },
+        {
+          id: '4',
+          role: 'user',
+          content: 'sub msg 2',
+          timestamp: '4',
+          subagentId: 'sub-1',
+          sessionId: undefined,
+        },
       ];
       vi.mocked(daemonChats.getMessages).mockResolvedValue(mockMessages);
 
@@ -72,8 +134,15 @@ describe('ChatLogger', () => {
 
     it('should not return subagent messages if no subagentId', async () => {
       const mockMessages: ChatMessage[] = [
-        { id: '1', role: 'user', content: 'root msg', timestamp: '1' },
-        { id: '2', role: 'user', content: 'sub msg 1', timestamp: '2', subagentId: 'sub-1' },
+        { id: '1', role: 'user', content: 'root msg', timestamp: '1', sessionId: undefined },
+        {
+          id: '2',
+          role: 'user',
+          content: 'sub msg 1',
+          timestamp: '2',
+          subagentId: 'sub-1',
+          sessionId: undefined,
+        },
       ];
       vi.mocked(daemonChats.getMessages).mockResolvedValue(mockMessages);
 

package/src/daemon/agent/chat-logger.ts

@@ -13,11 +13,18 @@ import {
 } from '../chats.js';
 import type { Logger } from './types.js';
 
-export function createChatLogger(chatId: string, subagentId?: string): Logger {
+export function createChatLogger(
+  chatId: string,
+  subagentId?: string,
+  sessionId?: string,
+  turnId?: string
+): Logger {
   async function append<T extends ChatMessage>(msg: T): Promise<T> {
-    const finalMsg = subagentId ? { ...msg, subagentId } : msg;
+    let finalMsg: T = msg;
+    if (subagentId) finalMsg = { ...finalMsg, subagentId };
+    if (turnId) finalMsg = { ...finalMsg, turnId };
     await appendMessage(chatId, finalMsg);
-    return finalMsg as T;
+    return finalMsg;
   }
 
   return {
@@ -45,6 +52,7 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         role: 'user',
         content: msg,
         timestamp: new Date().toISOString(),
+        sessionId,
       } satisfies UserMessage),
 
     logCommandResult: async ({ messageId, content, command, cwd, result }) =>
@@ -53,6 +61,7 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         role: 'command',
         content,
         timestamp: new Date().toISOString(),
+        sessionId,
 
         messageId,
 
@@ -61,7 +70,7 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         stdout: result.stdout,
         stderr: result.stderr,
         exitCode: result.exitCode,
-      }),
+      } satisfies CommandLogMessage),
 
     logSystemEvent: async ({ content }) =>
       append({
@@ -69,6 +78,7 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         role: 'command',
         content,
         timestamp: new Date().toISOString(),
+        sessionId,
 
         messageId: crypto.randomUUID(),
 
@@ -85,6 +95,7 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         role: 'system',
         content,
         timestamp: new Date().toISOString(),
+        sessionId,
 
         messageId,
         event: 'router',
@@ -97,6 +108,7 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         role: 'command',
         content,
         timestamp: new Date().toISOString(),
+        sessionId,
 
         messageId,
 
@@ -108,13 +120,14 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         exitCode: 0,
       } satisfies CommandLogMessage),
 
-    logSystemMessage: async ({ content, event, messageId, displayRole }) => {
+    logSystemMessage: async ({ content, event, messageId, displayRole, jobId }) => {
       const msg: SystemMessage = {
         id: crypto.randomUUID(),
         role: 'system',
         content,
         event,
         timestamp: new Date().toISOString(),
+        sessionId,
       };
       if (messageId !== undefined) {
         msg.messageId = messageId;
@@ -122,6 +135,9 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
       if (displayRole !== undefined) {
         msg.displayRole = displayRole;
       }
+      if (jobId !== undefined) {
+        msg.jobId = jobId;
+      }
       return append<SystemMessage>(msg);
     },
 
@@ -133,6 +149,7 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         subagentId: targetSubagentId,
         status,
         timestamp: new Date().toISOString(),
+        sessionId,
       };
       return append<SubagentStatusMessage>(msg);
     },
@@ -143,6 +160,7 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         role: 'agent',
         content,
         timestamp: new Date().toISOString(),
+        sessionId,
       };
       if (files !== undefined) {
         msg.files = files;
@@ -159,6 +177,7 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         name,
         payload,
         timestamp: new Date().toISOString(),
+        sessionId,
       };
       return append<ToolMessage>(msg);
     },
@@ -181,6 +200,7 @@ export function createChatLogger(chatId: string, subagentId?: string): Logger {
         args,
         status,
         timestamp: new Date().toISOString(),
+        sessionId,
       };
       return append<PolicyRequestMessage>(msg);
     },