clawmini 0.0.7 → 0.0.9

package/src/cli/e2e/agents.test.ts

@@ -1,140 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import path from 'node:path';
-import fs from 'node:fs';
-import { createE2EContext } from './utils.js';
-
-const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-tmp-agents');
-
-describe('E2E Agents Tests', () => {
-  beforeAll(async () => {
-    await setupE2E();
-    await runCli(['init']);
-  }, 30000);
-
-  afterAll(teardownE2E, 30000);
-
-  it('should create, list, update and delete agents', async () => {
-    const { stdout: stdoutAdd, code: codeAdd } = await runCli([
-      'agents',
-      'add',
-      'test-agent',
-      '--directory',
-      './test-agent-dir',
-      '--env',
-      'FOO=BAR',
-      '--env',
-      'BAZ=QUX',
-    ]);
-    expect(codeAdd).toBe(0);
-    expect(stdoutAdd).toContain('Agent test-agent created successfully.');
-
-    const chatSettingsPath = path.resolve(e2eDir, '.clawmini/chats/test-agent/settings.json');
-    expect(fs.existsSync(chatSettingsPath)).toBe(true);
-    const chatData = JSON.parse(fs.readFileSync(chatSettingsPath, 'utf8'));
-    expect(chatData.defaultAgent).toBe('test-agent');
-
-    const agentSettingsPath = path.resolve(e2eDir, '.clawmini/agents/test-agent/settings.json');
-    expect(fs.existsSync(agentSettingsPath)).toBe(true);
-    const agentData = JSON.parse(fs.readFileSync(agentSettingsPath, 'utf8'));
-    expect(agentData.directory).toBe('./test-agent-dir');
-    expect(agentData.env?.FOO).toBe('BAR');
-    expect(agentData.env?.BAZ).toBe('QUX');
-
-    const { stdout: stdoutList1 } = await runCli(['agents', 'list']);
-    expect(stdoutList1).toContain('- test-agent');
-
-    const { stdout: stdoutUpdate, code: codeUpdate } = await runCli([
-      'agents',
-      'update',
-      'test-agent',
-      '--directory',
-      './new-dir',
-      '--env',
-      'FOO=NEW_BAR',
-    ]);
-    expect(codeUpdate).toBe(0);
-    expect(stdoutUpdate).toContain('Agent test-agent updated successfully.');
-
-    const updatedAgentData = JSON.parse(fs.readFileSync(agentSettingsPath, 'utf8'));
-    expect(updatedAgentData.directory).toBe('./new-dir');
-    expect(updatedAgentData.env?.FOO).toBe('NEW_BAR');
-    expect(updatedAgentData.env?.BAZ).toBe('QUX');
-
-    const { stdout: stdoutDelete, code: codeDelete } = await runCli([
-      'agents',
-      'delete',
-      'test-agent',
-    ]);
-    expect(codeDelete).toBe(0);
-    expect(stdoutDelete).toContain('Agent test-agent deleted successfully.');
-    expect(fs.existsSync(agentSettingsPath)).toBe(false);
-  });
-
-  it('should output a warning if chat already exists when adding an agent', async () => {
-    // First, manually create a chat directory
-    const chatDir = path.resolve(e2eDir, '.clawmini/chats/existing-chat');
-    fs.mkdirSync(chatDir, { recursive: true });
-
-    const { stdout, stderr, code } = await runCli(['agents', 'add', 'existing-chat']);
-
-    expect(code).toBe(0);
-    expect(stderr).toContain('Warning: Chat existing-chat already exists.');
-    expect(stdout).toContain('Agent existing-chat created successfully.');
-  });
-
-  it('should create an agent using a template and merge settings correctly', async () => {
-    // Create a local template
-    const templateDir = path.resolve(e2eDir, '.clawmini/templates/test-template');
-    fs.mkdirSync(templateDir, { recursive: true });
-
-    // Create some template files
-    fs.writeFileSync(path.join(templateDir, 'hello.txt'), 'Hello Template!');
-
-    // Create a settings.json that should be merged/overridden
-    const templateSettings = {
-      directory: './should-be-ignored',
-      env: {
-        TEMPLATE_VAR: 'template_value',
-        FOO: 'WILL_BE_OVERRIDDEN',
-      },
-    };
-    fs.writeFileSync(path.join(templateDir, 'settings.json'), JSON.stringify(templateSettings));
-
-    const { stdout, stderr, code } = await runCli([
-      'agents',
-      'add',
-      'test-template-agent',
-      '--template',
-      'test-template',
-      '--directory',
-      './custom-agent-dir',
-      '--env',
-      'FOO=BAR',
-    ]);
-
-    expect(code).toBe(0);
-    expect(stderr).toContain("Warning: Ignoring 'directory' field from template settings.json");
-    expect(stdout).toContain('Agent test-template-agent created successfully.');
-    const agentSettingsPath = path.resolve(
-      e2eDir,
-      '.clawmini/agents/test-template-agent/settings.json'
-    );
-    expect(fs.existsSync(agentSettingsPath)).toBe(true);
-
-    const agentData = JSON.parse(fs.readFileSync(agentSettingsPath, 'utf8'));
-
-    // Verify directory override
-    expect(agentData.directory).toBe('./custom-agent-dir');
-
-    // Verify env merge
-    expect(agentData.env?.TEMPLATE_VAR).toBe('template_value');
-    expect(agentData.env?.FOO).toBe('BAR');
-
-    // Verify template files were copied
-    const customDir = path.resolve(e2eDir, 'custom-agent-dir');
-    expect(fs.existsSync(path.join(customDir, 'hello.txt'))).toBe(true);
-
-    // Verify settings.json was deleted from the agent working dir
-    expect(fs.existsSync(path.join(customDir, 'settings.json'))).toBe(false);
-  });
-});

package/src/cli/e2e/basic.test.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import path from 'node:path';
-import fs from 'node:fs';
-import { createE2EContext } from './utils.js';
-
-const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-tmp-basic');
-
-describe('E2E Basic Tests', () => {
-  beforeAll(setupE2E, 30000);
-  afterAll(teardownE2E, 30000);
-
-  it('should run init and initialize settings', async () => {
-    const { stdout, code } = await runCli(['init']);
-
-    expect(code).toBe(0);
-    expect(stdout).toContain('Initialized .clawmini/settings.json');
-
-    const clawminiDir = path.resolve(e2eDir, '.clawmini');
-    expect(fs.existsSync(path.join(clawminiDir, 'settings.json'))).toBe(true);
-  });
-
-  it('should create, list, set-default and delete chats', async () => {
-    const { stdout: stdoutAdd, code: codeAdd } = await runCli(['chats', 'add', 'test-chat']);
-    expect(codeAdd).toBe(0);
-    expect(stdoutAdd).toContain('Chat test-chat created successfully.');
-
-    const chatsDir = path.resolve(e2eDir, '.clawmini/chats');
-    expect(fs.existsSync(path.join(chatsDir, 'test-chat', 'chat.jsonl'))).toBe(true);
-
-    const { stdout: stdoutList1 } = await runCli(['chats', 'list']);
-    expect(stdoutList1).toContain('- test-chat');
-
-    const { stdout: stdoutSetDefault } = await runCli(['chats', 'set-default', 'test-chat']);
-    expect(stdoutSetDefault).toContain('Default chat set to test-chat.');
-
-    const { stdout: stdoutList2 } = await runCli(['chats', 'list']);
-    expect(stdoutList2).toContain('- test-chat *');
-
-    const { stdout: stdoutDelete } = await runCli(['chats', 'delete', 'test-chat']);
-    expect(stdoutDelete).toContain('Chat test-chat deleted successfully.');
-    expect(fs.existsSync(path.join(chatsDir, 'test-chat'))).toBe(false);
-  }, 15000);
-});

package/src/cli/e2e/cron.test.ts

@@ -1,132 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { createE2EContext } from './utils.js';
-
-const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-tmp-cron');
-
-describe('E2E Cron Tests', () => {
-  beforeAll(async () => {
-    await setupE2E();
-    await runCli(['init']);
-  }, 30000);
-
-  afterAll(async () => {
-    await teardownE2E();
-  }, 30000);
-
-  it('should add, list, and delete jobs', async () => {
-    // 1. Add a job
-    const { stdout: stdoutAdd, code: codeAdd } = await runCli([
-      'jobs',
-      'add',
-      'test-job-1',
-      '--message',
-      'hello world',
-      '--every',
-      '10m',
-      '--agent',
-      'my-agent',
-      '--env',
-      'FOO=BAR',
-      '--session',
-      'new',
-    ]);
-    expect(codeAdd).toBe(0);
-    expect(stdoutAdd).toContain("Job 'test-job-1' created successfully.");
-
-    // 2. List jobs
-    const { stdout: stdoutList1, code: codeList1 } = await runCli(['jobs', 'list']);
-    expect(codeList1).toBe(0);
-    expect(stdoutList1).toContain('- test-job-1 (every: 10m)');
-
-    // 3. Add a second job using cron expression
-    const { stdout: stdoutAdd2, code: codeAdd2 } = await runCli([
-      'jobs',
-      'add',
-      'test-job-2',
-      '--cron',
-      '* * * * *',
-    ]);
-    expect(codeAdd2).toBe(0);
-    expect(stdoutAdd2).toContain("Job 'test-job-2' created successfully.");
-
-    const { stdout: stdoutList2 } = await runCli(['jobs', 'list']);
-    expect(stdoutList2).toContain('- test-job-1 (every: 10m)');
-    expect(stdoutList2).toContain('- test-job-2 (cron: * * * * *)');
-
-    // 4. Delete the first job
-    const { stdout: stdoutDelete, code: codeDelete } = await runCli([
-      'jobs',
-      'delete',
-      'test-job-1',
-    ]);
-    expect(codeDelete).toBe(0);
-    expect(stdoutDelete).toContain("Job 'test-job-1' deleted successfully.");
-
-    const { stdout: stdoutList3 } = await runCli(['jobs', 'list']);
-    expect(stdoutList3).not.toContain('test-job-1');
-    expect(stdoutList3).toContain('- test-job-2 (cron: * * * * *)');
-  }, 15000);
-
-  it('should execute a job and inherit chat default agent and session', async () => {
-    // 1. Create a specific agent for this chat
-    await runCli(['agents', 'add', 'cron-exec-agent']);
-    const fs = await import('node:fs');
-    const path = await import('node:path');
-    const agentPath = path.resolve(e2eDir, '.clawmini/agents/cron-exec-agent/settings.json');
-    const agentData = JSON.parse(fs.readFileSync(agentPath, 'utf8'));
-    agentData.commands = { new: 'echo "executed with $SESSION_ID and msg: $CLAW_CLI_MESSAGE"' };
-    fs.writeFileSync(agentPath, JSON.stringify(agentData));
-
-    // 2. Setup the chat with this agent and get a session ID
-    await runCli(['chats', 'add', 'cron-chat']);
-    const { code: codeSetup, stderr: stderrSetup } = await runCli([
-      'messages',
-      'send',
-      'setup session',
-      '-c',
-      'cron-chat',
-      '-a',
-      'cron-exec-agent',
-    ]);
-    if (codeSetup !== 0) console.error(stderrSetup);
-    expect(codeSetup).toBe(0);
-
-    // 3. Schedule a job for 2 seconds in the future
-    const futureTime = new Date(Date.now() + 2000).toISOString();
-    const { stdout: stdoutAdd, code: codeAdd } = await runCli([
-      'jobs',
-      'add',
-      'test-exec-job',
-      '-c',
-      'cron-chat',
-      '--at',
-      futureTime,
-      '--message',
-      'hello from future',
-    ]);
-    expect(codeAdd).toBe(0);
-    expect(stdoutAdd).toContain("Job 'test-exec-job' created successfully.");
-
-    // 4. Wait for job to execute (approx 3 seconds)
-    await new Promise((resolve) => setTimeout(resolve, 3000));
-
-    // 5. Check if the message was sent and properly inherited the agent and session
-
-    // Fallback if e2e test uses a different dir, get it from the e2eDir context
-    // Actually createE2EContext returns e2eDir, but it's not exported from the setup block directly if not destructured.
-    // wait, I can just use `runCli(['messages', 'tail', '-c', 'cron-chat', '--json'])`
-    const { stdout: stdoutHistory } = await runCli(['messages', 'tail', '-c', 'cron-chat']);
-
-    // It should have executed the cron job
-    expect(stdoutHistory).toContain('hello from future');
-    // It should have used cron-exec-agent, not default
-    expect(stdoutHistory).toContain('msg: hello from future');
-    // Session ID should not be empty or undefined, it should have been set by the previous message
-  }, 10000);
-
-  it('should reject jobs with invalid --at date format', async () => {
-    const { stderr, code } = await runCli(['jobs', 'add', 'invalid-job', '--at', 'invalid-date']);
-    expect(code).not.toBe(0);
-    expect(stderr).toContain("Invalid date format for 'at' schedule: invalid-date");
-  });
-});

package/src/cli/e2e/export-lite-func.test.ts

@@ -1,206 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-import { createE2EContext } from './utils.js';
-
-const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-exp-lite');
-
-describe('E2E Export Lite Functionality Tests', () => {
-  beforeAll(async () => {
-    await setupE2E();
-    await runCli(['init']);
-  }, 30000);
-
-  afterAll(teardownE2E, 30000);
-
-  it('should run exported clawmini-lite script and verify its functionality', async () => {
-    await runCli(['down']);
-    const settingsPath = path.resolve(e2eDir, '.clawmini/settings.json');
-    let originalSettings = '{}';
-    if (fs.existsSync(settingsPath)) {
-      originalSettings = fs.readFileSync(settingsPath, 'utf8');
-    }
-    fs.writeFileSync(
-      settingsPath,
-      JSON.stringify({
-        ...JSON.parse(originalSettings),
-        api: { host: '127.0.0.1', port: 3007 },
-      })
-    );
-    await runCli(['up']);
-
-    // Export lite script
-    const litePath = path.resolve(e2eDir, 'clawmini-lite.js');
-    await runCli(['export-lite', '--out', litePath]);
-    expect(fs.existsSync(litePath)).toBe(true);
-
-    const envDumperAgentDir = path.resolve(e2eDir, 'lite-env-dumper');
-    fs.mkdirSync(envDumperAgentDir, { recursive: true });
-    await runCli(['agents', 'add', 'lite-env-dumper', '--dir', 'lite-env-dumper']);
-
-    const dumperSettings = path.resolve(e2eDir, '.clawmini/agents/lite-env-dumper/settings.json');
-    fs.mkdirSync(path.dirname(dumperSettings), { recursive: true });
-
-    const dumperScript = process.platform === 'win32' ? 'set > env.txt' : 'env > env.txt';
-    fs.writeFileSync(dumperSettings, JSON.stringify({ commands: { new: dumperScript } }));
-
-    await runCli(['chats', 'add', 'lite-chat']);
-    await runCli(['messages', 'send', 'dump', '--chat', 'lite-chat', '--agent', 'lite-env-dumper']);
-
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-
-    const envTxtPath = path.resolve(envDumperAgentDir, 'env.txt');
-    expect(fs.existsSync(envTxtPath)).toBe(true);
-    const envContent = fs.readFileSync(envTxtPath, 'utf8');
-
-    const urlMatch = envContent.match(/CLAW_API_URL=(.+)/);
-    const tokenMatch = envContent.match(/CLAW_API_TOKEN=(.+)/);
-
-    expect(urlMatch).toBeTruthy();
-    expect(tokenMatch).toBeTruthy();
-
-    if (!urlMatch || !tokenMatch) {
-      throw new Error('Could not find API credentials');
-    }
-
-    const envUrl = urlMatch[1]!.trim();
-    const envToken = tokenMatch[1]!.trim();
-    const chatLogPath = path.resolve(e2eDir, '.clawmini/chats/lite-chat/chat.jsonl');
-
-    // 1. Test reply with file
-    const replyFileProcess = spawn(
-      'node',
-      [litePath, 'reply', 'hello with file', '--file', 'env.txt'],
-      {
-        env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
-        cwd: envDumperAgentDir,
-      }
-    );
-
-    let replyFileStdout = '';
-    replyFileProcess.stdout.on('data', (d) => (replyFileStdout += d.toString()));
-    replyFileProcess.stderr.on('data', (d) => (replyFileStdout += d.toString()));
-    await new Promise((resolve) => replyFileProcess.on('close', resolve));
-    expect(replyFileStdout).toContain('Reply message appended');
-
-    const chatLogContentUpdated = fs.readFileSync(chatLogPath, 'utf8');
-    expect(chatLogContentUpdated).toContain('hello with file');
-    expect(chatLogContentUpdated).toContain('"files":["lite-env-dumper/env.txt"]');
-
-    // 1.6 Test reply
-    const replyProcess = spawn('node', [litePath, 'reply', 'hello reply'], {
-      env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
-    });
-    let replyStdout = '';
-    replyProcess.stdout.on('data', (d) => (replyStdout += d.toString()));
-    replyProcess.stderr.on('data', (d) => (replyStdout += d.toString()));
-    await new Promise((resolve) => replyProcess.on('close', resolve));
-    expect(replyStdout).toContain('Reply message appended');
-
-    const chatLogContentReply = fs.readFileSync(chatLogPath, 'utf8');
-    expect(chatLogContentReply).toContain('hello reply');
-    expect(chatLogContentReply).toContain('"role":"agent"');
-
-    // 1.7 Test tool
-    const toolProcess = spawn(
-      'node',
-      [litePath, 'tool', 'mytool', JSON.stringify({ key: 'value' })],
-      {
-        env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
-      }
-    );
-    let toolStdout = '';
-    toolProcess.stdout.on('data', (d) => (toolStdout += d.toString()));
-    toolProcess.stderr.on('data', (d) => (toolStdout += d.toString()));
-    await new Promise((resolve) => toolProcess.on('close', resolve));
-    expect(toolStdout).toContain('Tool message appended');
-
-    const chatLogContentTool = fs.readFileSync(chatLogPath, 'utf8');
-    expect(chatLogContentTool).toContain('"name":"mytool"');
-    expect(chatLogContentTool).toContain('"role":"tool"');
-    expect(chatLogContentTool).toContain('"payload":{"key":"value"}');
-
-    // 2. Test jobs add
-    const addProcess = spawn(
-      'node',
-      [litePath, 'jobs', 'add', 'lite-job', '--cron', '* * * * *', '--message', 'lite message'],
-      {
-        env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
-      }
-    );
-    let addStdout = '';
-    addProcess.stdout.on('data', (d) => (addStdout += d.toString()));
-    addProcess.stderr.on('data', (d) => (addStdout += d.toString()));
-    await new Promise((resolve) => addProcess.on('close', resolve));
-    expect(addStdout).toContain("Job 'lite-job' created successfully.");
-
-    // 3. Test jobs list
-    const listProcess = spawn('node', [litePath, 'jobs', 'list'], {
-      env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
-    });
-    let listStdout = '';
-    listProcess.stdout.on('data', (d) => (listStdout += d.toString()));
-    listProcess.stderr.on('data', (d) => (listStdout += d.toString()));
-    await new Promise((resolve) => listProcess.on('close', resolve));
-    expect(listStdout).toContain('lite-job');
-    expect(listStdout).toContain('* * * * *');
-
-    // 4. Test jobs delete
-    const delProcess = spawn('node', [litePath, 'jobs', 'delete', 'lite-job'], {
-      env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
-    });
-    let delStdout = '';
-    delProcess.stdout.on('data', (d) => (delStdout += d.toString()));
-    delProcess.stderr.on('data', (d) => (delStdout += d.toString()));
-    await new Promise((resolve) => delProcess.on('close', resolve));
-    expect(delStdout).toContain("Job 'lite-job' deleted successfully.");
-
-    // 5. Test fetch-pending
-    const sleepCommand =
-      process.platform === 'win32' ? 'node -e "setTimeout(() => {}, 5000)"' : 'sleep 5';
-    fs.writeFileSync(dumperSettings, JSON.stringify({ commands: { new: sleepCommand } }));
-
-    await runCli(['chats', 'add', 'sleep-chat']);
-    // Start the agent to block the queue
-    await runCli([
-      'messages',
-      'send',
-      'block queue',
-      '--chat',
-      'sleep-chat',
-      '--agent',
-      'lite-env-dumper',
-      '--no-wait',
-    ]);
-
-    // Send a pending message that will be queued
-    await runCli([
-      'messages',
-      'send',
-      'my pending message',
-      '--chat',
-      'sleep-chat',
-      '--agent',
-      'lite-env-dumper',
-      '--no-wait',
-    ]);
-
-    // Fetch the pending message
-    const fetchProcess = spawn('node', [litePath, 'fetch-pending'], {
-      env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
-    });
-    let fetchStdout = '';
-    fetchProcess.stdout.on('data', (d) => (fetchStdout += d.toString()));
-    fetchProcess.stderr.on('data', (d) => (fetchStdout += d.toString()));
-    await new Promise((resolve) => fetchProcess.on('close', resolve));
-
-    expect(fetchStdout).toContain('<message>');
-    expect(fetchStdout).toContain('my pending message');
-    expect(fetchStdout).toContain('</message>');
-
-    await runCli(['down']);
-    fs.writeFileSync(settingsPath, originalSettings);
-    await runCli(['up']);
-  }, 30000);
-});