clawmini 0.0.8 → 0.0.9

package/e2e/agents/custom-api-env.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  commandWith,
+  agentReplyWith,
+} from '../_helpers/test-environment.js';
+
+describe('E2E Agent Custom API Env Var Names', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-custom-api-env');
+    await env.setup();
+    await env.setupSubagentEnv();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('injects custom-named URL/token envs and lite consumes them via pointer vars', async () => {
+    await env.runCli(['agents', 'add', 'custom-env-dumper']);
+    const agentDir = path.resolve(env.e2eDir, 'custom-env-dumper');
+    fs.mkdirSync(agentDir, { recursive: true });
+
+    env.writeAgentSettings('custom-env-dumper', {
+      apiTokenEnvVar: 'MY_CUSTOM_TOKEN',
+      apiUrlEnvVar: 'MY_CUSTOM_URL',
+      commands: { new: 'env' },
+    });
+
+    await env.addChat('custom-env-chat', 'custom-env-dumper');
+    chat = await env.connect('custom-env-chat');
+
+    await env.sendMessage('dump', { chat: 'custom-env-chat', agent: 'custom-env-dumper' });
+
+    const log = await chat.waitForMessage(commandWith('MY_CUSTOM_URL='));
+
+    expect(log.stdout).toContain('CLAW_LITE_API_VAR=MY_CUSTOM_TOKEN');
+    expect(log.stdout).toContain('CLAW_LITE_URL_VAR=MY_CUSTOM_URL');
+    expect(log.stdout).toMatch(/^MY_CUSTOM_URL=http:\/\/127\.0\.0\.1:\d+$/m);
+    expect(log.stdout).toMatch(/^MY_CUSTOM_TOKEN=.+$/m);
+    // The default-named vars should NOT be present when custom names are set.
+    expect(log.stdout).not.toMatch(/^CLAW_API_URL=/m);
+    expect(log.stdout).not.toMatch(/^CLAW_API_TOKEN=/m);
+
+    const urlMatch = log.stdout.match(/^MY_CUSTOM_URL=(.+)$/m);
+    const tokenMatch = log.stdout.match(/^MY_CUSTOM_TOKEN=(.+)$/m);
+    const customUrl = urlMatch![1]!.trim();
+    const customToken = tokenMatch![1]!.trim();
+
+    // Spawn lite directly (TestEnvironment.runLite forces CLAW_API_URL/TOKEN, which
+    // wouldn't exercise the dynamic-name path).
+    const litePath = path.resolve(env.e2eDir, 'clawmini-lite.js');
+    const reply = await new Promise<{ stdout: string; code: number | null }>((resolve) => {
+      const p = spawn('node', [litePath, 'reply', 'hello from custom env'], {
+        env: {
+          ...process.env,
+          MY_CUSTOM_URL: customUrl,
+          MY_CUSTOM_TOKEN: customToken,
+          CLAW_LITE_URL_VAR: 'MY_CUSTOM_URL',
+          CLAW_LITE_API_VAR: 'MY_CUSTOM_TOKEN',
+        },
+        cwd: agentDir,
+      });
+      let stdout = '';
+      p.stdout.on('data', (d) => (stdout += d.toString()));
+      p.stderr.on('data', (d) => (stdout += d.toString()));
+      p.on('close', (code) => resolve({ stdout, code }));
+    });
+    expect(reply.stdout).toContain('Reply message appended');
+
+    const replyMsg = await chat.waitForMessage(agentReplyWith('hello from custom env'));
+    expect(replyMsg).toBeTruthy();
+  }, 20000);
+});

package/e2e/agents/export-lite-func.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  type ToolMessage,
+  agentReplyWith,
+} from '../_helpers/test-environment.js';
+
+// Covers lite-only commands that aren't reachable via the main CLI: reply,
+// reply --file, tool, and fetch-pending. Lite's jobs CRUD is covered by
+// e2e/jobs/agent-jobs.test.ts and e2e/jobs/cron.test.ts.
+//
+// Every `it` here shares `__creds__` — the chat TestEnvironment.runLite uses
+// when resolving its API token. A token is scoped to a single chatId, so all
+// lite mutations in this file target `__creds__`.
+
+describe('E2E Export Lite Chat/Tool Commands', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-exp-lite');
+    await env.setup();
+    await env.setupSubagentEnv();
+    // Warm up credentials (creates `__creds__` chat + sends one debug echo).
+    await env.getAgentCredentials();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('reply appends an agent reply to the chat', async () => {
+    chat = await env.connect('__creds__');
+    const { stdout, code } = await env.runLite(['reply', 'hello reply']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('Reply message appended');
+
+    const msg = await chat.waitForMessage(agentReplyWith('hello reply'));
+    expect(msg).toBeTruthy();
+  }, 15000);
+
+  it('reply --file records the attachment path relative to the workspace', async () => {
+    chat = await env.connect('__creds__');
+    const agentDir = path.resolve(env.e2eDir, 'debug-agent');
+    fs.mkdirSync(agentDir, { recursive: true });
+    fs.writeFileSync(path.join(agentDir, 'attach.txt'), 'attached');
+
+    const { stdout, code } = await env.runLite(
+      ['reply', 'hello with file', '--file', 'attach.txt'],
+      { cwd: agentDir }
+    );
+    expect(code).toBe(0);
+    expect(stdout).toContain('Reply message appended');
+
+    const msg = await chat.waitForMessage(agentReplyWith('hello with file'));
+    expect(msg.files).toEqual(['debug-agent/attach.txt']);
+  }, 15000);
+
+  it('tool appends a tool message preserving the JSON payload', async () => {
+    chat = await env.connect('__creds__');
+    const { stdout, code } = await env.runLite([
+      'tool',
+      'mytool',
+      JSON.stringify({ key: 'value' }),
+    ]);
+    expect(code).toBe(0);
+    expect(stdout).toContain('Tool message appended');
+
+    const msg = await chat.waitForMessage(
+      (m): m is ToolMessage => m.role === 'tool' && m.name === 'mytool'
+    );
+    expect(msg.payload).toEqual({ key: 'value' });
+  }, 15000);
+
+  it('fetch-pending returns queued messages while the agent is busy', async () => {
+    chat = await env.connect('__creds__');
+    // Swap debug-agent's commands to something slow so the first send blocks
+    // the task queue and the second send stays pending until fetch-pending.
+    // Both `new` and `append` must be overridden — getAgentCredentials has
+    // already captured a SESSION_ID, so subsequent sends use `append`.
+    env.updateAgentSettings('debug-agent', {
+      commands: { new: 'sleep 5', append: 'sleep 5' },
+    });
+
+    await env.sendMessage('block queue', {
+      chat: '__creds__',
+      agent: 'debug-agent',
+      noWait: true,
+    });
+    await env.sendMessage('my pending message', {
+      chat: '__creds__',
+      agent: 'debug-agent',
+      noWait: true,
+    });
+
+    const { stdout, code } = await env.runLite(['fetch-pending']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('<message>');
+    expect(stdout).toContain('my pending message');
+    expect(stdout).toContain('</message>');
+  }, 20000);
+});

package/e2e/agents/fallbacks.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  commandMatching,
+  agentReply,
+} from '../_helpers/test-environment.js';
+
+describe('E2E Fallbacks Tests', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-fallbacks');
+    await env.setup();
+    await env.init();
+    await env.up();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('should fallback when base agent fails with exit code', async () => {
+    env.setDefaultAgent({
+      commands: {
+        new: 'if [ "$SUCCESS" = "true" ]; then echo "Succeeded"; else echo "Failed" >&2; exit 1; fi',
+      },
+      fallbacks: [{ env: { SUCCESS: 'true' }, retries: 0, delayMs: 100 }],
+    });
+
+    await env.addChat('fb-chat-1');
+    chat = await env.connect('fb-chat-1');
+    await env.sendMessage('test-1', { chat: 'fb-chat-1' });
+
+    const success = await chat.waitForMessage(
+      commandMatching((m) => m.stdout.trim() === 'Succeeded' && m.exitCode === 0)
+    );
+    expect(success).toBeTruthy();
+    expect(
+      chat.messageBuffer.some((m) => m.role === 'command' && m.content.includes('retrying'))
+    ).toBe(true);
+  });
+
+  it('should fallback when base agent returns empty content', async () => {
+    env.setDefaultAgent({
+      commands: {
+        new: 'echo "Base output"',
+        getMessageContent: 'echo ""',
+      },
+      fallbacks: [
+        {
+          commands: { getMessageContent: 'echo "Fallback success"' },
+          retries: 0,
+          delayMs: 100,
+        },
+      ],
+    });
+
+    await env.addChat('fb-chat-2');
+    chat = await env.connect('fb-chat-2');
+    await env.sendMessage('test-2', { chat: 'fb-chat-2' });
+
+    const reply = await chat.waitForMessage(agentReply());
+    expect(reply.content.trim()).toBe('Fallback success');
+  });
+
+  it('should support multiple retries with exponential backoff logs', async () => {
+    const attemptFile = path.resolve(env.e2eDir, 'attempts.txt');
+    fs.writeFileSync(attemptFile, '0');
+
+    env.setDefaultAgent({
+      commands: {
+        new: `
+          attempts=$(cat ${attemptFile})
+          attempts=$((attempts + 1))
+          echo $attempts > ${attemptFile}
+          if [ $attempts -lt 3 ]; then
+            exit 1
+          else
+            echo "Third time is a charm"
+          fi
+        `,
+      },
+      fallbacks: [{ retries: 2, delayMs: 100 }],
+    });
+
+    await env.addChat('fb-chat-3');
+    chat = await env.connect('fb-chat-3');
+    await env.sendMessage('test-3', { chat: 'fb-chat-3' });
+
+    const success = await chat.waitForMessage(
+      commandMatching((m) => m.stdout.trim() === 'Third time is a charm')
+    );
+    expect(success).toBeTruthy();
+    expect(
+      chat.messageBuffer.filter((m) => m.role === 'command' && m.content.includes('retrying'))
+        .length
+    ).toBeGreaterThanOrEqual(1);
+  }, 10000);
+
+  it('should report final failure when all fallbacks are exhausted', async () => {
+    env.setDefaultAgent({
+      commands: { new: 'exit 1' },
+      fallbacks: [
+        {
+          commands: { new: 'echo "Fallback 1 fail" && exit 1' },
+          retries: 0,
+          delayMs: 100,
+        },
+      ],
+    });
+
+    await env.addChat('fb-chat-4');
+    chat = await env.connect('fb-chat-4');
+    await env.sendMessage('test-4', { chat: 'fb-chat-4' });
+
+    const failure = await chat.waitForMessage(
+      commandMatching((m) => m.stdout.trim() === 'Fallback 1 fail' && m.exitCode === 1)
+    );
+    expect(failure).toBeTruthy();
+  });
+});

package/e2e/agents/interrupt.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { TestEnvironment, type ChatSubscription, commandMatching } from '../_helpers/test-environment.js';
+
+describe('E2E Agent Interrupt + Pending Message Merge', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-agent-interrupt');
+    await env.setup();
+    await env.init();
+    await env.up();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('aborts the active task and prepends pending payloads to the new message', async () => {
+    await env.runCli(['agents', 'add', 'interrupt-agent']);
+    env.writeAgentSettings('interrupt-agent', {
+      // Echo the message we were invoked with so the final merged content lands
+      // in the command log's stdout, then sleep long enough that the first
+      // run is still active when /interrupt arrives.
+      commands: { new: 'echo "RAN: $CLAW_CLI_MESSAGE" && sleep 2' },
+    });
+
+    await env.addChat('interrupt-chat', 'interrupt-agent');
+    chat = await env.connect('interrupt-chat');
+
+    // first: becomes the active task
+    await env.sendMessage('first', { chat: 'interrupt-chat', noWait: true });
+    // Give the scheduler a moment to dispatch it into runCommand.
+    await new Promise((r) => setTimeout(r, 300));
+
+    // second: queues behind first
+    await env.sendMessage('second', { chat: 'interrupt-chat', noWait: true });
+    // third: /interrupt aborts first, extracts second's payload, and prepends both
+    // as <message>...</message> blocks to "third".
+    await env.sendMessage('/interrupt third', { chat: 'interrupt-chat', noWait: true });
+
+    const mergedLog = await chat.waitForMessage(
+      commandMatching((m) => m.stdout.includes('RAN:') && m.stdout.includes('third')),
+      20000
+    );
+
+    expect(mergedLog.stdout).toContain('<message>\nfirst\n</message>');
+    expect(mergedLog.stdout).toContain('<message>\nsecond\n</message>');
+    expect(mergedLog.stdout).toContain('<message>\nthird\n</message>');
+  }, 30000);
+});

package/e2e/agents/no-reply-necessary.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  commandWith,
+  agentReply,
+} from '../_helpers/test-environment.js';
+
+describe('E2E NO_REPLY_NECESSARY short-circuit', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-no-reply');
+    await env.setup();
+    await env.init();
+    await env.up();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('skips the agent reply when NO_REPLY_NECESSARY appears anywhere in the output', async () => {
+    await env.runCli(['agents', 'add', 'no-reply-agent']);
+    // Emit the sentinel mid-string to prove the match is a substring, not
+    // an exact token equality.
+    env.writeAgentSettings('no-reply-agent', {
+      commands: { new: 'echo "prefix NO_REPLY_NECESSARY suffix"' },
+    });
+
+    await env.addChat('no-reply-chat', 'no-reply-agent');
+    chat = await env.connect('no-reply-chat');
+
+    await env.sendMessage('ping', { chat: 'no-reply-chat', agent: 'no-reply-agent' });
+
+    // The command log is always written; only the agent reply should be suppressed.
+    await chat.waitForMessage(commandWith('NO_REPLY_NECESSARY'));
+    // Give the logger a beat in case an agent reply is (incorrectly) pending.
+    await new Promise((r) => setTimeout(r, 300));
+    expect(chat.messageBuffer.some((m) => m.role === 'agent')).toBe(false);
+  }, 15000);
+
+  it('logs the agent reply when the sentinel is absent', async () => {
+    await env.runCli(['agents', 'add', 'reply-agent']);
+    env.writeAgentSettings('reply-agent', {
+      commands: { new: 'echo "normal reply"' },
+    });
+
+    await env.addChat('reply-chat', 'reply-agent');
+    chat = await env.connect('reply-chat');
+
+    await env.sendMessage('ping', { chat: 'reply-chat', agent: 'reply-agent' });
+
+    const reply = await chat.waitForMessage(agentReply());
+    expect(reply.content.trim()).toBe('normal reply');
+  }, 15000);
+});

package/e2e/agents/session-timeout-subagents.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { TestEnvironment, type ChatSubscription, commandWith } from '../_helpers/test-environment.js';
+
+describe('Session Timeout Subagents E2E', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-timeout-subagents');
+    await env.setup();
+    await env.setupSubagentEnv();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('should not schedule a session timeout when a subagent sends a message', async () => {
+    await env.addChat('chat-timeout');
+    chat = await env.connect('chat-timeout');
+
+    // First, send a normal message so we have a timeout job started from the user.
+    await env.sendMessage('hello', { chat: 'chat-timeout', agent: 'debug-agent' });
+    await chat.waitForMessage(commandWith('[DEBUG] hello'));
+
+    // Now let the subagent spawn a message
+    await env.sendMessage(
+      'clawmini-lite.js subagents spawn --async "echo subagent-hello"',
+      { chat: 'chat-timeout', agent: 'debug-agent' }
+    );
+    const subLog = await chat.waitForMessage(commandWith('[DEBUG] echo subagent-hello:'));
+    expect(subLog).toBeTruthy();
+
+    // Check jobs list to verify no duplicate timeout was scheduled for the subagent interaction
+    const jobsList = (env.getChatSettings('chat-timeout').jobs || []) as Record<string, unknown>[];
+    const timeoutJobs = jobsList.filter(
+      (j: Record<string, unknown>) =>
+        typeof j.id === 'string' && j.id.startsWith('__session_timeout__')
+    );
+
+    // It should just be the 1 job scheduled from the first message/second message
+    expect(timeoutJobs.length).toBe(1);
+    expect(timeoutJobs[0]!.subagentId).toBeUndefined();
+    expect(timeoutJobs[0]!).toMatchInlineSnapshot(
+      {
+        id: expect.stringMatching(/^__session_timeout__/),
+        nextSessionId: expect.any(String),
+        session: { id: expect.any(String) },
+        jobs: { remove: [expect.stringMatching(/^__session_timeout__/)] },
+        schedule: { at: expect.any(String) },
+      },
+      `
+      {
+        "env": {
+          "__SESSION_TIMEOUT__": "true",
+        },
+        "id": StringMatching /\\^__session_timeout__/,
+        "jobs": {
+          "remove": [
+            StringMatching /\\^__session_timeout__/,
+          ],
+        },
+        "message": "This chat session has ended. Save any important details from it to your memory. When finished, reply with NO_REPLY_NECESSARY.",
+        "nextSessionId": Any<String>,
+        "reply": "[@clawmini/session-timeout] Starting a fresh session...",
+        "schedule": {
+          "at": Any<String>,
+        },
+        "session": {
+          "id": Any<String>,
+          "type": "existing",
+        },
+      }
+    `
+    );
+  }, 15000);
+});