clawmini 0.0.1

package/src/cli/commands/web-api/utils.ts

@@ -0,0 +1,27 @@
+import http from 'node:http';
+import { type ZodType } from 'zod';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function parseJsonBody<T = any>(
+  req: http.IncomingMessage,
+  schema?: ZodType<T>
+): Promise<T> {
+  if (req.headers['content-type'] !== 'application/json') {
+    throw new Error('Invalid Content-Type');
+  }
+  let bodyStr = '';
+  for await (const chunk of req) {
+    bodyStr += chunk;
+  }
+  const rawBody = JSON.parse(bodyStr);
+  if (schema) {
+    return schema.parse(rawBody);
+  }
+  return rawBody as T;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function sendJsonResponse(res: http.ServerResponse, statusCode: number, data: any) {
+  res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(data));
+}

package/src/cli/commands/web.ts

@@ -0,0 +1,105 @@
+import { Command } from 'commander';
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { pathIsInsideDir } from '../../shared/utils/fs.js';
+import { sendJsonResponse } from './web-api/utils.js';
+import { handleApiAgents } from './web-api/agents.js';
+import { handleApiChats } from './web-api/chats.js';
+
+const mimeTypes: Record<string, string> = {
+  '.html': 'text/html',
+  '.js': 'text/javascript',
+  '.mjs': 'text/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+};
+
+export const webCmd = new Command('web')
+  .description('Start the local clawmini web interface')
+  .option('-p, --port <number>', 'Port to bind the server to', '8080')
+  .option('-H, --host <string>', 'Host to bind the server to', '127.0.0.1')
+  .action((options) => {
+    const port = parseInt(options.port, 10);
+    if (isNaN(port)) {
+      console.error('Invalid port number.');
+      process.exit(1);
+    }
+
+    // When bundled into dist/cli/index.mjs, import.meta.url resolves to that file.
+    // So __dirname will be dist/cli, and webDir will be dist/web.
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const webDir = path.resolve(__dirname, '../web');
+
+    const server = http.createServer(async (req, res) => {
+      try {
+        const urlPath = req.url === '/' ? '/index.html' : req.url?.split('?')[0] || '/';
+
+        // API Routes
+        if (urlPath.startsWith('/api/')) {
+          res.setHeader('Content-Type', 'application/json');
+          res.setHeader('Access-Control-Allow-Origin', '*');
+          res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+          res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+          if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+          }
+
+          if (urlPath.startsWith('/api/agents') && (await handleApiAgents(req, res, urlPath)))
+            return;
+          if (urlPath.startsWith('/api/chats') && (await handleApiChats(req, res, urlPath))) return;
+
+          sendJsonResponse(res, 404, { error: 'Not Found' });
+          return;
+        }
+
+        // Static Files
+        let filePath = path.join(webDir, urlPath);
+
+        // Prevent directory traversal
+        if (!pathIsInsideDir(filePath, webDir)) {
+          res.writeHead(403);
+          res.end('Forbidden');
+          return;
+        }
+
+        if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+          // SPA fallback to index.html
+          filePath = path.join(webDir, 'index.html');
+          if (!fs.existsSync(filePath)) {
+            res.writeHead(404);
+            res.end('Not Found');
+            return;
+          }
+        }
+
+        const extname = path.extname(filePath).toLowerCase();
+        const contentType = mimeTypes[extname] || 'application/octet-stream';
+
+        res.writeHead(200, { 'Content-Type': contentType });
+        const readStream = fs.createReadStream(filePath);
+        readStream.pipe(res);
+      } catch (err) {
+        console.error('Error serving request:', err);
+        res.writeHead(500);
+        res.end('Internal Server Error');
+      }
+    });
+
+    server.listen(port, options.host, () => {
+      console.log(`Clawmini web interface running at http://${options.host}:${port}/`);
+    });
+  });

package/src/cli/e2e/adapter-discord.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import path from 'node:path';
+import { createE2EContext } from './utils.js';
+import { getTRPCClient } from '../../adapter-discord/client.js';
+
+const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-discord');
+describe('Discord Adapter Client E2E', () => {
+  beforeAll(async () => {
+    await setupE2E();
+    await runCli(['init']);
+    await runCli(['up']);
+  }, 30000);
+
+  afterAll(async () => {
+    await runCli(['down']);
+    await teardownE2E();
+  }, 30000);
+
+  it('should successfully connect to the daemon and subscribe to messages', async () => {
+    const socketPath = path.join(e2eDir, '.clawmini', 'server.sock');
+    const trpc = getTRPCClient({ socketPath });
+
+    const pingResult = await trpc.ping.query();
+    expect(pingResult).toEqual({ status: 'ok' });
+
+    await runCli(['chats', 'add', 'discord-chat']);
+
+    let subscription: { unsubscribe: () => void } | undefined;
+    const messages: Record<string, unknown>[] = [];
+
+    await new Promise<void>((resolve, reject) => {
+      subscription = trpc.waitForMessages.subscribe(
+        { chatId: 'discord-chat' },
+        {
+          onData: (data) => {
+            messages.push(...(data as Record<string, unknown>[]));
+            if (messages.some((m) => m.content === 'hello from adapter e2e test')) {
+              resolve();
+            }
+          },
+          onError: (err) => {
+            reject(err);
+          },
+        }
+      );
+
+      // Wait a brief moment to ensure subscription is established before sending a message
+      setTimeout(async () => {
+        try {
+          await runCli([
+            'messages',
+            'send',
+            'hello from adapter e2e test',
+            '--chat',
+            'discord-chat',
+            '--no-wait',
+          ]);
+        } catch (e) {
+          reject(e);
+        }
+      }, 500);
+
+      // Safety timeout
+      setTimeout(() => reject(new Error('Timeout waiting for message')), 5000);
+    });
+
+    if (subscription) {
+      subscription.unsubscribe();
+    }
+
+    expect(messages.length).toBeGreaterThan(0);
+    const found = messages.find((m) => m.content === 'hello from adapter e2e test');
+    expect(found).toBeDefined();
+    expect(found!.role).toBe('user');
+  });
+});

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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,43 @@
+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);
+  });
+});

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

@@ -0,0 +1,132 @@
+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: * * * * *)');
+  });
+
+  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");
+  });
+});