clawmini 0.0.1

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

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs';
+import fsPromises from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { createE2EContext } from './utils.js';
+
+const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-tmp-requests');
+
+describe('E2E Requests Tests (Lite)', () => {
+  let litePath = '';
+  let envUrl = '';
+  let envToken = '';
+
+  beforeAll(async () => {
+    await setupE2E();
+    await runCli(['init']);
+
+    // Setup policies.json
+    const policiesPath = path.join(e2eDir, '.clawmini', 'policies.json');
+    await fsPromises.writeFile(
+      policiesPath,
+      JSON.stringify({
+        policies: {
+          'test-cmd': {
+            description: 'A test policy',
+            command: 'echo',
+            args: ['hello'],
+            allowHelp: true,
+          },
+          'no-help-cmd': {
+            description: 'A no help policy',
+            command: 'echo',
+            args: ['nohelp'],
+          },
+        },
+      })
+    );
+
+    // Setup daemon with API enabled
+    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: 3008 },
+      })
+    );
+    await runCli(['up']);
+
+    // Export lite script
+    litePath = path.resolve(e2eDir, 'clawmini-lite.js');
+    await runCli(['export-lite', '--out', litePath]);
+
+    // Setup env-dumper agent
+    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, 3000));
+
+    const envTxtPath = path.resolve(envDumperAgentDir, 'env.txt');
+    if (!fs.existsSync(envTxtPath)) {
+      throw new Error('env.txt not generated by agent');
+    }
+    const envContent = fs.readFileSync(envTxtPath, 'utf8');
+    const urlMatch = envContent.match(/CLAW_API_URL=(.+)/);
+    const tokenMatch = envContent.match(/CLAW_API_TOKEN=(.+)/);
+
+    if (!urlMatch || !tokenMatch) {
+      throw new Error('Could not find API credentials');
+    }
+
+    envUrl = urlMatch[1]!.trim();
+    envToken = tokenMatch[1]!.trim();
+  }, 30000);
+
+  afterAll(teardownE2E, 30000);
+
+  function runLite(
+    args: string[]
+  ): Promise<{ stdout: string; stderr: string; code: number | null }> {
+    return new Promise((resolve) => {
+      const p = spawn('node', [litePath, ...args], {
+        env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
+        cwd: e2eDir,
+      });
+      let stdout = '';
+      let stderr = '';
+      p.stdout.on('data', (d) => (stdout += d.toString()));
+      p.stderr.on('data', (d) => (stderr += d.toString()));
+      p.on('close', (code) => resolve({ stdout, stderr, code }));
+    });
+  }
+
+  it('should list policies', async () => {
+    const { stdout, code } = await runLite(['requests', 'list']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('Available Policies:');
+    expect(stdout).toContain('- test-cmd');
+    expect(stdout).toContain('Description: A test policy');
+  });
+
+  it('should run --help on underlying command', async () => {
+    const { stdout, code } = await runLite(['request', 'test-cmd', '--help']);
+    expect(code).toBe(0);
+    expect(stdout).toBeTruthy();
+  });
+
+  it('should block --help if allowHelp is not true', async () => {
+    const { stderr, code } = await runLite(['request', 'no-help-cmd', '--help']);
+    expect(code).toBe(1);
+    expect(stderr).toContain('This command does not support --help');
+  });
+
+  it('should create a request and return an ID', async () => {
+    const dummyFilePath = path.join(e2eDir, 'lite-env-dumper', 'dummy.txt');
+    await fsPromises.writeFile(dummyFilePath, 'dummy content');
+
+    const { stdout, stderr, code } = await runLite([
+      'request',
+      'test-cmd',
+      '--file',
+      `target=${dummyFilePath}`,
+      '--',
+      'extra1',
+      'extra2',
+    ]);
+
+    expect(stderr).toBe('');
+    expect(code).toBe(0);
+    expect(stdout).toContain('Request created successfully.');
+    expect(stdout).toContain('Request ID:');
+
+    // Verify the request was saved
+    const requestsDir = path.join(e2eDir, '.clawmini', 'tmp', 'requests');
+    const files = await fsPromises.readdir(requestsDir);
+    const jsonFiles = files.filter((f) => f.endsWith('.json'));
+    expect(jsonFiles.length).toBe(1);
+
+    const reqData = await fsPromises.readFile(path.join(requestsDir, jsonFiles[0]!), 'utf8');
+    const req = JSON.parse(reqData);
+
+    expect(req.commandName).toBe('test-cmd');
+    expect(req.args).toEqual(['extra1', 'extra2']);
+    expect(req.fileMappings).toHaveProperty('target');
+
+    // Check snapshot exists
+    const snapshotPath = req.fileMappings.target;
+    const snapshotContent = await fsPromises.readFile(snapshotPath, 'utf8');
+    expect(snapshotContent).toBe('dummy content');
+  });
+});

package/src/cli/e2e/utils.ts

@@ -0,0 +1,66 @@
+import { spawn, execSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+
+export function createE2EContext(dirName: string) {
+  const binPath = path.resolve(__dirname, '../../../dist/cli/index.mjs');
+  const e2eDir = path.resolve(__dirname, `../../../${dirName}`);
+
+  function runCli(
+    args: string[]
+  ): Promise<{ stdout: string; stderr: string; code: number | null }> {
+    const isInit = args[0] === 'init';
+    return new Promise((resolve) => {
+      const child = spawn('node', [binPath, ...args], {
+        cwd: e2eDir,
+        env: { ...process.env },
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        if (isInit && code === 0) {
+          // Update settings to set API port to 0, assigning a random available port
+          const settingsPath = path.resolve(e2eDir, '.clawmini/settings.json');
+          if (fs.existsSync(settingsPath)) {
+            try {
+              const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+              settings.api = { port: 0 }; // Use random available port to avoid EADDRINUSE during parallel e2e tests
+              fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+            } catch {
+              // ignore
+            }
+          }
+        }
+        resolve({ stdout, stderr, code });
+      });
+    });
+  }
+
+  async function setupE2E() {
+    if (fs.existsSync(e2eDir)) {
+      fs.rmSync(e2eDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(e2eDir, { recursive: true });
+    execSync('git init', { cwd: e2eDir, stdio: 'ignore' });
+  }
+
+  async function teardownE2E() {
+    await runCli(['down']);
+
+    if (fs.existsSync(e2eDir)) {
+      fs.rmSync(e2eDir, { recursive: true, force: true });
+    }
+  }
+
+  return { runCli, e2eDir, binPath, setupE2E, teardownE2E };
+}

package/src/cli/index.test.ts

@@ -0,0 +1,7 @@
+import { describe, it, expect } from 'vitest';
+
+describe('CLI placeholder tests', () => {
+  it('should be true', () => {
+    expect(true).toBe(true);
+  });
+});

package/src/cli/index.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initCmd } from './commands/init.js';
+import { messagesCmd } from './commands/messages.js';
+import { chatsCmd } from './commands/chats.js';
+import { agentsCmd } from './commands/agents.js';
+import { downCmd } from './commands/down.js';
+import { upCmd } from './commands/up.js';
+import { webCmd } from './commands/web.js';
+import { jobsCmd } from './commands/jobs.js';
+import { exportLiteCmd } from './commands/export-lite.js';
+import { environmentsCmd } from './commands/environments.js';
+
+const program = new Command();
+
+program.name('clawmini').description('Clawmini CLI').version('0.0.1');
+
+program.addCommand(initCmd);
+program.addCommand(messagesCmd);
+program.addCommand(chatsCmd);
+program.addCommand(agentsCmd);
+program.addCommand(environmentsCmd);
+program.addCommand(downCmd);
+program.addCommand(upCmd);
+program.addCommand(webCmd);
+program.addCommand(jobsCmd);
+program.addCommand(exportLiteCmd);
+
+program.parse();

package/src/cli/lite.ts

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { createTRPCClient, httpLink } from '@trpc/client';
+import type { AppRouter } from '../daemon/router.js';
+import type { CronJob } from '../shared/config.js';
+
+/**
+ * clawmini-lite - A standalone client
+ */
+const API_URL = process.env.CLAW_API_URL;
+const API_TOKEN = process.env.CLAW_API_TOKEN;
+
+function getClient() {
+  return createTRPCClient<AppRouter>({
+    links: [
+      httpLink({
+        url: API_URL as string,
+        headers() {
+          return {
+            Authorization: `Bearer ${API_TOKEN}`,
+            'Content-Type': 'application/json',
+          };
+        },
+      }),
+    ],
+  });
+}
+
+const program = new Command();
+
+program
+  .name('clawmini-lite')
+  .description('A standalone client for clawmini')
+  .hook('preAction', () => {
+    if (!API_URL || !API_TOKEN) {
+      console.error('CLAW_API_URL and CLAW_API_TOKEN must be set in the environment.');
+      process.exit(1);
+    }
+  });
+
+program
+  .command('log [message]')
+  .description('Log a message')
+  .option(
+    '-f, --file <path>',
+    'File path(s) to attach (can specify multiple)',
+    (val: string, prev: string[]) => prev.concat([val]),
+    []
+  )
+  .action(async (message, options) => {
+    try {
+      const files = options.file.length > 0 ? options.file : undefined;
+      const payload: { message?: string; files?: string[] } = {};
+      if (message !== undefined) payload.message = message;
+      if (files !== undefined) payload.files = files;
+
+      const client = getClient();
+      await client.logMessage.mutate(payload);
+      console.log('Log message appended.');
+    } catch (err) {
+      console.error('Error:', err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+
+const jobs = program.command('jobs').description('Manage cron jobs');
+
+jobs
+  .command('list')
+  .description('List cron jobs')
+  .action(async () => {
+    try {
+      const client = getClient();
+      const jobsList = await client.listCronJobs.query({});
+      console.log(JSON.stringify(jobsList, null, 2));
+    } catch (err) {
+      console.error('Error:', err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+
+jobs
+  .command('add <name>')
+  .description('Add a cron job')
+  .option('--at <time>', 'Schedule at specific time')
+  .option('--every <interval>', 'Schedule at interval')
+  .option('--cron <cron>', 'Schedule via cron expression')
+  .option('-m, --message <msg>', 'Message to send')
+  .option('-r, --reply <reply>', 'Reply text')
+  .option('-a, --agent <agentId>', 'Agent ID')
+  .option('-s, --session <type>', 'Session type (must be "new")')
+  .option(
+    '-e, --env <env>',
+    'Environment variables in key=value format',
+    (val: string, prev: string[]) => prev.concat([val]),
+    []
+  )
+  .option('-c, --chat <chatId>', 'Chat ID')
+  .action(async (name, options) => {
+    try {
+      let schedule;
+      if (options.at) schedule = { at: options.at };
+      else if (options.every) schedule = { every: options.every };
+      else if (options.cron) schedule = { cron: options.cron };
+      else throw new Error('A schedule must be specified (--at, --every, or --cron).');
+
+      const job: CronJob = {
+        id: name,
+        createdAt: new Date().toISOString(),
+        message: options.message || '',
+        schedule,
+      };
+
+      if (options.reply) job.reply = options.reply;
+      if (options.agent) job.agentId = options.agent;
+      if (options.session) {
+        if (options.session !== 'new') throw new Error('Only "new" session type is supported.');
+        job.session = { type: 'new' };
+      }
+
+      if (options.env && options.env.length > 0) {
+        const jobEnv: Record<string, string> = {};
+        for (const e of options.env) {
+          const [k, ...v] = e.split('=');
+          if (k) jobEnv[k] = v.join('=');
+        }
+        job.env = jobEnv;
+      }
+
+      const client = getClient();
+      await client.addCronJob.mutate({ chatId: options.chat, job });
+      console.log(`Job '${name}' created successfully.`);
+    } catch (err) {
+      console.error('Error:', err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+
+jobs
+  .command('delete <name>')
+  .description('Delete a cron job')
+  .option('-c, --chat <chatId>', 'Chat ID')
+  .action(async (name, options) => {
+    try {
+      const client = getClient();
+      const result = await client.deleteCronJob.mutate({ chatId: options.chat, id: name });
+      if (result && result.deleted) {
+        console.log(`Job '${name}' deleted successfully.`);
+      } else {
+        console.log(`Job '${name}' not found.`);
+      }
+    } catch (err) {
+      console.error('Error:', err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+
+const requests = program.command('requests').description('Manage sandbox policy requests');
+
+requests
+  .command('list')
+  .description('List available policies')
+  .action(async () => {
+    try {
+      const client = getClient();
+      const config = await client.listPolicies.query();
+
+      if (!config || !config.policies || Object.keys(config.policies).length === 0) {
+        console.log('No policies configured.');
+        return;
+      }
+
+      console.log('Available Policies:\n');
+      for (const [name, policy] of Object.entries(config.policies)) {
+        console.log(`- ${name}`);
+        if (policy.description) {
+          console.log(`  Description: ${policy.description}`);
+        }
+      }
+    } catch (err) {
+      console.error('Error:', err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('request <cmd>')
+  .description('Submit a sandbox policy request')
+  .option('--help', 'Execute the underlying command with --help and print the output')
+  .option('-f, --file <mappings...>', 'File mappings in the format name=path')
+  .allowUnknownOption()
+  .allowExcessArguments(true)
+  .helpOption('-h, --cli-help', 'display CLI help for command')
+  .action(async (cmdName, options, command) => {
+    try {
+      const client = getClient();
+      const config = await client.listPolicies.query();
+      const policy = config?.policies?.[cmdName];
+
+      if (!policy) {
+        throw new Error(`Policy not found: ${cmdName}`);
+      }
+
+      if (options.help) {
+        // Execute underlying command with --help via the daemon
+        const helpOutput = await client.executePolicyHelp.query({ commandName: cmdName });
+        if (helpOutput.stdout) {
+          process.stdout.write(helpOutput.stdout);
+        }
+        if (helpOutput.stderr) {
+          process.stderr.write(helpOutput.stderr);
+        }
+        process.exit(helpOutput.exitCode);
+      }
+
+      const dashDashIndex = process.argv.indexOf('--');
+      const opaqueArgs =
+        dashDashIndex !== -1 ? process.argv.slice(dashDashIndex + 1) : command.args.slice(1);
+
+      const fileMappings: Record<string, string> = {};
+      if (options.file) {
+        for (const mapping of options.file) {
+          const [name, ...pathParts] = mapping.split('=');
+          const pathStr = pathParts.join('=');
+          if (!name || !pathStr) {
+            throw new Error(`Invalid file mapping: ${mapping}. Expected format name=path`);
+          }
+          fileMappings[name] = pathStr;
+        }
+      }
+
+      const request = await client.createPolicyRequest.mutate({
+        commandName: cmdName,
+        args: opaqueArgs,
+        fileMappings,
+      });
+
+      console.log(`Request created successfully.`);
+      console.log(`Request ID: ${request.id}`);
+    } catch (err) {
+      console.error('Error:', err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/src/cli/utils.ts

@@ -0,0 +1,4 @@
+export function handleError(action: string, err: unknown): never {
+  console.error(`Failed to ${action}:`, err instanceof Error ? err.message : String(err));
+  process.exit(1);
+}

package/src/daemon/auth.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { generateToken, validateToken, type TokenPayload } from './auth.js';
+
+describe('Auth token generation and validation', () => {
+  it('should generate a valid token and validate it successfully', () => {
+    const payload: TokenPayload = {
+      chatId: 'chat-123',
+      agentId: 'agent-456',
+      sessionId: 'session-789',
+      timestamp: Date.now(),
+    };
+
+    const token = generateToken(payload);
+    expect(typeof token).toBe('string');
+    expect(token).toContain('.');
+
+    const validated = validateToken(token);
+    expect(validated).not.toBeNull();
+    expect(validated?.chatId).toBe(payload.chatId);
+    expect(validated?.agentId).toBe(payload.agentId);
+    expect(validated?.sessionId).toBe(payload.sessionId);
+    expect(validated?.timestamp).toBe(payload.timestamp);
+  });
+
+  it('should return null for invalid tokens', () => {
+    expect(validateToken('invalid-token')).toBeNull();
+    expect(validateToken('part1.part2')).toBeNull();
+    expect(validateToken('')).toBeNull();
+  });
+
+  it('should return null if token signature is modified', () => {
+    const payload: TokenPayload = {
+      chatId: 'chat-123',
+      agentId: 'agent-456',
+      sessionId: 'session-789',
+      timestamp: Date.now(),
+    };
+
+    const token = generateToken(payload);
+    const parts = token.split('.');
+    if (!parts[1]) throw new Error('Invalid token');
+
+    // Modify the signature slightly
+    const modifiedSignature =
+      parts[1].substring(0, parts[1].length - 1) + (parts[1].endsWith('a') ? 'b' : 'a');
+    const tamperedToken = `${parts[0]}.${modifiedSignature}`;
+
+    expect(validateToken(tamperedToken)).toBeNull();
+  });
+});

package/src/daemon/auth.ts

@@ -0,0 +1,69 @@
+import crypto from 'node:crypto';
+import type { Settings } from '../shared/config.js';
+
+// In-memory secret generated on daemon startup.
+// Valid tokens will only last for the lifetime of the daemon process.
+const DAEMON_SECRET = crypto.randomBytes(32);
+
+export interface TokenPayload {
+  chatId: string;
+  agentId: string;
+  sessionId: string;
+  timestamp: number;
+}
+
+export function generateToken(payload: TokenPayload): string {
+  const payloadStr = Buffer.from(JSON.stringify(payload)).toString('base64');
+  const hmac = crypto.createHmac('sha256', DAEMON_SECRET).update(payloadStr).digest('hex');
+  return `${payloadStr}.${hmac}`;
+}
+
+export function validateToken(token: string): TokenPayload | null {
+  try {
+    const parts = token.split('.');
+    if (parts.length !== 2) return null;
+
+    const [payloadStr, signature] = parts;
+    if (!payloadStr || !signature) return null;
+
+    const expectedHmac = crypto
+      .createHmac('sha256', DAEMON_SECRET)
+      .update(payloadStr)
+      .digest('hex');
+
+    const signatureBuffer = Buffer.from(signature, 'hex');
+    const expectedHmacBuffer = Buffer.from(expectedHmac, 'hex');
+
+    if (
+      signatureBuffer.length !== expectedHmacBuffer.length ||
+      !crypto.timingSafeEqual(signatureBuffer, expectedHmacBuffer)
+    ) {
+      return null;
+    }
+
+    const payloadJson = Buffer.from(payloadStr, 'base64').toString('utf8');
+    return JSON.parse(payloadJson) as TokenPayload;
+  } catch {
+    return null;
+  }
+}
+
+export function getApiContext(settings?: Settings) {
+  if (settings?.api === undefined) return null;
+  let isApiEnabled = false;
+  let apiHost = '127.0.0.1';
+  let apiPort = 3000;
+  let proxyHost: string | undefined = undefined;
+
+  if (typeof settings.api === 'boolean') {
+    isApiEnabled = settings.api;
+  } else if (typeof settings.api === 'object') {
+    isApiEnabled = true;
+    apiHost = settings.api.host ?? '127.0.0.1';
+    apiPort = settings.api.port ?? 3000;
+    proxyHost = settings.api.proxy_host;
+  }
+
+  if (!isApiEnabled) return null;
+  return { host: apiHost, port: apiPort, proxy_host: proxyHost };
+}

package/src/daemon/chats.ts

@@ -0,0 +1,26 @@
+import * as shared from '../shared/chats.js';
+import { emitMessageAppended } from './events.js';
+
+export async function appendMessage(
+  id: string,
+  message: shared.ChatMessage,
+  startDir = process.cwd()
+): Promise<void> {
+  await shared.appendMessage(id, message, startDir);
+  emitMessageAppended(id, message);
+}
+
+export {
+  type ChatMessage,
+  type UserMessage,
+  type CommandLogMessage,
+  getChatsDir,
+  isValidChatId,
+  createChat,
+  listChats,
+  deleteChat,
+  getMessages,
+  getDefaultChatId,
+  setDefaultChatId,
+  DEFAULT_CHAT_ID,
+} from '../shared/chats.js';