clawmini 0.0.3 → 0.0.5

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

@@ -0,0 +1,153 @@
+import { emitTyping } from '../events.js';
+import type { ExecutionResponse, Message, RunCommandFn } from './types.js';
+import { type Fallback } from './agent-context.js';
+import { extractMessageContent, extractSessionId } from './agent-extractors.js';
+import type { AgentSession } from './agent-session.js';
+import { isNewSession } from './utils.js';
+
+export function calculateDelay(
+  attempt: number,
+  baseDelayMs: number,
+  isFallback: boolean = false
+): number {
+  const effectiveAttempt = isFallback ? attempt + 1 : attempt;
+  if (effectiveAttempt <= 0) return 0;
+  const delay = baseDelayMs * Math.pow(2, effectiveAttempt - 1);
+  return Math.min(delay, 15000);
+}
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export class AgentRunner {
+  constructor(
+    private readonly session: AgentSession,
+    private readonly runCommand: RunCommandFn
+  ) {}
+
+  private async withTypingIndicator<T>(fn: () => Promise<T>): Promise<T> {
+    const interval = setInterval(() => emitTyping(this.session.chatId), 5000);
+    try {
+      return await fn();
+    } finally {
+      clearInterval(interval);
+    }
+  }
+
+  private *getExecutionAttempts() {
+    const fallbacks = this.session.settings.fallbacks || [];
+    const executionConfigs = [
+      { fallback: undefined, retries: 0, delayMs: 1000 },
+      ...fallbacks.map((f) => ({ fallback: f, retries: f.retries, delayMs: f.delayMs })),
+    ];
+
+    for (let configIdx = 0; configIdx < executionConfigs.length; configIdx++) {
+      const config = executionConfigs[configIdx]!;
+      const isFallbackConfig = configIdx > 0;
+
+      for (let attempt = 0; attempt <= config.retries; attempt++) {
+        yield {
+          fallback: config.fallback,
+          delay: calculateDelay(attempt, config.delayMs, isFallbackConfig),
+        };
+      }
+    }
+  }
+
+  private async executeSingleAttempt(
+    message: Message,
+    fallback?: Fallback | undefined,
+    signal?: AbortSignal | undefined
+  ): Promise<{ success: boolean; response?: ExecutionResponse }> {
+    const context = await this.session.buildExecutionContext(
+      message.content,
+      message.env,
+      fallback
+    );
+
+    if (!context) return { success: false };
+
+    const mainResult = await this.withTypingIndicator(() =>
+      this.runCommand({
+        command: context.command,
+        cwd: this.session.workDirectory,
+        env: context.env,
+        signal,
+      })
+    );
+
+    let success = mainResult.exitCode === 0;
+    let finalContent = mainResult.stdout.trim();
+    const additonalErrors = [];
+
+    if (success && context.currentAgent.commands?.getMessageContent) {
+      const extraction = await extractMessageContent(
+        context,
+        mainResult,
+        this.runCommand,
+        this.session.workDirectory,
+        signal
+      );
+      if (extraction.error) additonalErrors.push(extraction.error);
+      if (extraction.result !== undefined) finalContent = extraction.result.trim();
+      if (!finalContent) success = false;
+    }
+
+    let extractedSessionId: string | undefined;
+
+    if (success && isNewSession(message.env) && context.currentAgent.commands?.getSessionId) {
+      const extraction = await extractSessionId(
+        context,
+        mainResult,
+        this.runCommand,
+        this.session.workDirectory,
+        signal
+      );
+      if (extraction.error) additonalErrors.push(extraction.error);
+      if (extraction.result) {
+        extractedSessionId = extraction.result;
+      }
+    }
+
+    return {
+      success,
+      response: {
+        messageId: message.id,
+        content: finalContent,
+        command: context.command,
+        cwd: this.session.workDirectory,
+        extractedSessionId,
+        result: {
+          ...mainResult,
+          stderr: [mainResult.stderr, ...additonalErrors].join('\n\n'),
+        },
+      },
+    };
+  }
+
+  async executeWithFallbacks(
+    message: Message,
+    signal?: AbortSignal | undefined
+  ): Promise<ExecutionResponse | undefined> {
+    let lastResponse: ExecutionResponse | undefined;
+
+    for (const attempt of this.getExecutionAttempts()) {
+      if (attempt.delay > 0) {
+        await this.session.logger.logCommandRetry({
+          messageId: message.id,
+          content: `Error running agent, retrying in ${Math.round(attempt.delay / 1000)} seconds...`,
+          cwd: this.session.workDirectory,
+        });
+        await sleep(attempt.delay);
+      }
+
+      const attemptResult = await this.executeSingleAttempt(message, attempt.fallback, signal);
+
+      lastResponse = attemptResult.response || lastResponse;
+      if (attemptResult.success) {
+        return lastResponse;
+      }
+    }
+
+    return lastResponse;
+  }
+}

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

@@ -0,0 +1,261 @@
+import type { Agent, Settings } from '../../shared/config.js';
+import { AgentRunner } from './agent-runner.js';
+import type { Logger, Message } from './types.js';
+import { runCommand } from '../utils/spawn.js';
+import {
+  getAgent,
+  getWorkspaceRoot,
+  readAgentSessionSettings,
+  writeAgentSessionSettings,
+  readSettings,
+  resolveAgentWorkDir,
+} from '../../shared/workspace.js';
+import { formatPendingMessages, isNewSession } from './utils.js';
+import { createChatLogger } from './chat-logger.js';
+import { sandboxExecutionContext, type Fallback } from './agent-context.js';
+import { applyEnvOverrides, getActiveEnvKeys } from '../../shared/utils/env.js';
+import { getApiContext, generateToken } from '../auth.js';
+import { taskScheduler } from './task-scheduler.js';
+import { randomUUID } from 'node:crypto';
+
+export class AgentSession {
+  public readonly agentId: string;
+  public readonly sessionId: string;
+  public readonly chatId: string;
+  public readonly subagentId: string | undefined;
+  public readonly settings: Agent;
+  public readonly workspaceRoot: string;
+  public readonly globalSettings: Settings | undefined;
+  public readonly logger: Logger;
+
+  constructor(config: {
+    agentId: string;
+    sessionId: string;
+    chatId: string;
+    subagentId?: string;
+    settings: Agent;
+    workspaceRoot: string;
+    globalSettings: Settings | undefined;
+    logger?: Logger;
+  }) {
+    this.agentId = config.agentId;
+    this.sessionId = config.sessionId;
+    this.chatId = config.chatId;
+    this.subagentId = config.subagentId;
+    this.settings = config.settings;
+    this.workspaceRoot = config.workspaceRoot;
+    this.globalSettings = config.globalSettings;
+
+    this.logger = config.logger ?? createChatLogger(this.chatId, this.subagentId);
+  }
+
+  async buildExecutionContext(
+    messageContent: string,
+    routerEnv: Record<string, string>,
+    fallback?: Fallback
+  ): Promise<{ command: string; env: Record<string, string>; currentAgent: Agent } | null> {
+    const currentAgent: Agent = {
+      ...this.settings,
+      commands: {
+        ...this.settings.commands,
+        ...(fallback?.commands || {}),
+      },
+      env: {
+        ...this.settings.env,
+        ...(this.subagentId && this.settings.subagentEnv ? this.settings.subagentEnv : {}),
+        ...(fallback?.env || {}),
+      },
+    };
+
+    let initialCommand = currentAgent.commands?.new ?? '';
+    const env = {
+      ...process.env,
+      CLAW_CLI_MESSAGE: messageContent,
+    } as Record<string, string>;
+
+    applyEnvOverrides(env, currentAgent.env);
+
+    if (!isNewSession(routerEnv) && currentAgent.commands?.append) {
+      initialCommand = currentAgent.commands.append;
+    }
+
+    if (!initialCommand) {
+      return null;
+    }
+
+    const agentSpecificEnvKeys = getActiveEnvKeys(currentAgent.env);
+    agentSpecificEnvKeys.add('CLAW_CLI_MESSAGE');
+
+    Object.assign(env, routerEnv);
+    Object.keys(routerEnv).forEach((k) => agentSpecificEnvKeys.add(k));
+
+    const apiCtx = getApiContext(this.globalSettings);
+    if (apiCtx) {
+      const proxyUrl = apiCtx.proxy_host
+        ? `${apiCtx.proxy_host}:${apiCtx.port}`
+        : `http://${apiCtx.host}:${apiCtx.port}`;
+
+      if (currentAgent.apiUrlEnvVar) {
+        env[currentAgent.apiUrlEnvVar] = proxyUrl;
+        agentSpecificEnvKeys.add(currentAgent.apiUrlEnvVar);
+        env['CLAW_LITE_URL_VAR'] = currentAgent.apiUrlEnvVar;
+        agentSpecificEnvKeys.add('CLAW_LITE_URL_VAR');
+      } else {
+        env['CLAW_API_URL'] = proxyUrl;
+        agentSpecificEnvKeys.add('CLAW_API_URL');
+      }
+
+      const token = generateToken({
+        chatId: this.chatId,
+        agentId: this.agentId,
+        sessionId: this.sessionId,
+        ...(this.subagentId ? { subagentId: this.subagentId } : {}),
+        timestamp: Date.now(),
+      });
+
+      if (currentAgent.apiTokenEnvVar) {
+        env[currentAgent.apiTokenEnvVar] = token;
+        agentSpecificEnvKeys.add(currentAgent.apiTokenEnvVar);
+        env['CLAW_LITE_API_VAR'] = currentAgent.apiTokenEnvVar;
+        agentSpecificEnvKeys.add('CLAW_LITE_API_VAR');
+      } else {
+        env['CLAW_API_TOKEN'] = token;
+        agentSpecificEnvKeys.add('CLAW_API_TOKEN');
+      }
+    }
+
+    let command = initialCommand;
+    command = await sandboxExecutionContext(
+      command,
+      env,
+      agentSpecificEnvKeys,
+      this.workDirectory,
+      this.workspaceRoot
+    );
+
+    return { command, env, currentAgent };
+  }
+
+  createRunner(): AgentRunner {
+    return new AgentRunner(this, runCommand);
+  }
+
+  get workDirectory(): string {
+    return resolveAgentWorkDir(this.agentId, this.settings.directory, this.workspaceRoot);
+  }
+
+  stop() {
+    taskScheduler.abortTasks(this.sessionId);
+  }
+
+  interrupt(message: Message): Message {
+    const payloads = taskScheduler.interruptTasks(this.sessionId);
+
+    if (payloads.length > 0) {
+      // TODO: Figure out how to handle merging payloads when they have different env settings or other config.
+      // Currently, we only preserve the text content and drop any specific configuration attached to individual messages.
+      const pendingText = formatPendingMessages(payloads);
+      return {
+        ...message,
+        content: `${pendingText}\n\n<message>\n${message.content}\n</message>`.trim(),
+      };
+    }
+    return message;
+  }
+
+  async handleMessage(message: Message): Promise<void> {
+    if (!message.content.trim()) {
+      return;
+    }
+
+    await taskScheduler.schedule({
+      id: `task-${this.agentId}-${randomUUID()}`,
+      rootChatId: this.chatId,
+      dirPath: this.workDirectory,
+      sessionId: this.sessionId,
+      text: message.content,
+      execute: async (signal) => {
+        // Refresh sessionSettings immediately before execution
+        const sessionSettings = await readAgentSessionSettings(
+          this.agentId,
+          this.sessionId,
+          this.workspaceRoot
+        );
+        // TODO: create a copy of the message first
+        applyEnvOverrides(message.env, sessionSettings?.env);
+
+        const runner = this.createRunner();
+        const result = await runner.executeWithFallbacks(message, signal);
+        if (!result) {
+          // TODO: throw an error? Log an error?
+          return;
+        }
+
+        if (result.extractedSessionId) {
+          await writeAgentSessionSettings(
+            this.agentId,
+            this.sessionId,
+            { env: { SESSION_ID: result.extractedSessionId } },
+            this.workspaceRoot
+          );
+        }
+
+        await this.logger.logCommandResult(result);
+
+        if (!result.content.includes('NO_REPLY_NECESSARY')) {
+          await this.logger.logAgentReply({ content: result.content });
+        }
+      },
+    });
+  }
+}
+
+export async function createAgentSession(options: {
+  chatId: string;
+  agentId: string;
+  sessionId: string;
+  subagentId?: string;
+  cwd: string;
+  settings?: Settings | undefined;
+  logger?: Logger;
+}) {
+  // TODO: make it so that readSettings returns Settings|undefined
+  const settings = options.settings ?? (await readSettings(options.cwd)) ?? undefined;
+  const mergedAgent = await resolveMergedAgent(options.agentId, settings, options.cwd);
+  const workspaceRoot = getWorkspaceRoot(options.cwd);
+
+  return new AgentSession({
+    agentId: options.agentId,
+    sessionId: options.sessionId,
+    chatId: options.chatId,
+    ...(options.subagentId ? { subagentId: options.subagentId } : {}),
+    settings: mergedAgent,
+    workspaceRoot,
+    globalSettings: settings,
+    ...(options.logger ? { logger: options.logger } : {}),
+  });
+}
+
+async function resolveMergedAgent(
+  agentId: string,
+  settings: Settings | undefined,
+  cwd: string
+): Promise<Agent> {
+  let mergedAgent: Agent = settings?.defaultAgent || {};
+  if (agentId !== 'default') {
+    try {
+      const customAgent = await getAgent(agentId, cwd);
+      if (customAgent) {
+        mergedAgent = {
+          ...mergedAgent,
+          ...customAgent,
+          commands: { ...mergedAgent.commands, ...customAgent.commands },
+          env: { ...mergedAgent.env, ...customAgent.env },
+        };
+      }
+    } catch {
+      // Fall back to default if agent not found
+    }
+  }
+  return mergedAgent;
+}

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

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createChatLogger } from './chat-logger.js';
+import * as daemonChats from '../chats.js';
+import { type ChatMessage } from '../chats.js';
+
+vi.mock('../chats.js', async () => {
+  const actual = await vi.importActual('../chats.js');
+  return {
+    ...actual,
+    appendMessage: vi.fn(),
+    getMessages: vi.fn(),
+  };
+});
+
+describe('ChatLogger', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('createChatLogger', () => {
+    it('should create a standard logger without subagentId', async () => {
+      const logger = createChatLogger('chat-1');
+      await logger.logUserMessage('hello');
+
+      expect(daemonChats.appendMessage).toHaveBeenCalledWith(
+        'chat-1',
+        expect.objectContaining({ role: 'user', content: 'hello' })
+      );
+    });
+
+    it('should inject subagentId into outgoing messages', async () => {
+      const logger = createChatLogger('chat-1', 'sub-1');
+      await logger.logUserMessage('hello subagent');
+
+      expect(daemonChats.appendMessage).toHaveBeenCalledWith(
+        'chat-1',
+        expect.objectContaining({ role: 'user', content: 'hello subagent', subagentId: 'sub-1' })
+      );
+    });
+
+    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' },
+      ];
+      vi.mocked(daemonChats.getMessages).mockResolvedValue(mockMessages);
+
+      const logger = createChatLogger('chat-1', 'sub-1');
+      const filtered = await logger.getMessages();
+
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0]!.id).toBe('2');
+      expect(daemonChats.getMessages).toHaveBeenCalledWith('chat-1');
+    });
+
+    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' },
+      ];
+      vi.mocked(daemonChats.getMessages).mockResolvedValue(mockMessages);
+
+      const logger = createChatLogger('chat-1', 'sub-1');
+      const filtered = await logger.getMessages(1);
+
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0]!.id).toBe('4');
+    });
+
+    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' },
+      ];
+      vi.mocked(daemonChats.getMessages).mockResolvedValue(mockMessages);
+
+      const logger = createChatLogger('chat-1');
+      const filtered = await logger.getMessages();
+
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0]!.id).toBe('1');
+    });
+
+    it('should log system message correctly', async () => {
+      const logger = createChatLogger('chat-1');
+      await logger.logSystemMessage({ content: 'test', event: 'cron', messageId: 'msg-1' });
+
+      expect(daemonChats.appendMessage).toHaveBeenCalledWith(
+        'chat-1',
+        expect.objectContaining({
+          role: 'system',
+          content: 'test',
+          event: 'cron',
+          messageId: 'msg-1',
+        })
+      );
+    });
+
+    it('should log agent reply correctly', async () => {
+      const logger = createChatLogger('chat-1');
+      await logger.logAgentReply({ content: 'reply', files: ['test.txt'] });
+
+      expect(daemonChats.appendMessage).toHaveBeenCalledWith(
+        'chat-1',
+        expect.objectContaining({ role: 'agent', content: 'reply', files: ['test.txt'] })
+      );
+    });
+
+    it('should log tool message correctly', async () => {
+      const logger = createChatLogger('chat-1');
+      await logger.logToolMessage({
+        content: 'tool content',
+        messageId: 'msg-1',
+        name: 'myTool',
+        payload: { a: 1 },
+      });
+
+      expect(daemonChats.appendMessage).toHaveBeenCalledWith(
+        'chat-1',
+        expect.objectContaining({
+          role: 'tool',
+          content: 'tool content',
+          messageId: 'msg-1',
+          name: 'myTool',
+          payload: { a: 1 },
+        })
+      );
+    });
+
+    it('should log policy request correctly', async () => {
+      const logger = createChatLogger('chat-1');
+      await logger.logPolicyRequestMessage({
+        content: 'please allow',
+        messageId: 'msg-1',
+        requestId: 'req-1',
+        commandName: 'ls',
+        args: ['-la'],
+        status: 'pending',
+      });
+
+      expect(daemonChats.appendMessage).toHaveBeenCalledWith(
+        'chat-1',
+        expect.objectContaining({
+          role: 'policy',
+          content: 'please allow',
+          messageId: 'msg-1',
+          requestId: 'req-1',
+          commandName: 'ls',
+          args: ['-la'],
+          status: 'pending',
+        })
+      );
+    });
+  });
+});