clawmini 0.0.1

package/src/cli/commands/init.ts

@@ -0,0 +1,79 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import { isValidAgentId, enableEnvironment } from '../../shared/workspace.js';
+import { setDefaultChatId } from '../../shared/chats.js';
+import { type Agent } from '../../shared/config.js';
+import { createAgentWithChat } from '../../shared/agent-utils.js';
+import { handleError } from '../utils.js';
+
+export const initCmd = new Command('init')
+  .description('Initialize a new .clawmini settings folder')
+  .option('--agent <name>', 'Initialize with a specific agent')
+  .option('--agent-template <name>', 'Template to use for the agent')
+  .option('--environment <name>', 'Enable a specific environment')
+  .action(async (options: { agent?: string; agentTemplate?: string; environment?: string }) => {
+    if (options.agentTemplate && !options.agent) {
+      handleError('initialize', new Error('--agent-template cannot be used without --agent'));
+    }
+
+    if (options.agent && !isValidAgentId(options.agent)) {
+      handleError('initialize', new Error(`Invalid agent ID: ${options.agent}`));
+    }
+
+    const cwd = process.cwd();
+    const dirPath = path.join(cwd, '.clawmini');
+    const settingsPath = path.join(dirPath, 'settings.json');
+
+    if (fs.existsSync(settingsPath)) {
+      console.log('.clawmini already initialized');
+      return;
+    }
+
+    const defaultSettings = {
+      defaultAgent: {
+        commands: {
+          new: 'echo $CLAW_CLI_MESSAGE',
+        },
+        env: {},
+      },
+      routers: [
+        '@clawmini/slash-new',
+        '@clawmini/slash-stop',
+        '@clawmini/slash-interrupt',
+        '@clawmini/slash-policies',
+        '@clawmini/slash-command',
+      ],
+      api: true,
+    };
+
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+
+    fs.writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2));
+    console.log('Initialized .clawmini/settings.json');
+
+    if (options.agent) {
+      try {
+        const agentId = options.agent;
+        const agentData: Agent = {};
+        await createAgentWithChat(agentId, agentData, options.agentTemplate);
+
+        console.log(`Agent ${agentId} created successfully.`);
+
+        await setDefaultChatId(agentId);
+        console.log(`Default chat set to ${agentId}.`);
+      } catch (err) {
+        handleError('create agent', err);
+      }
+    }
+
+    if (options.environment) {
+      try {
+        await enableEnvironment(options.environment);
+      } catch (err) {
+        handleError('enable environment', err);
+      }
+    }
+  });

package/src/cli/commands/jobs.ts

@@ -0,0 +1,141 @@
+import { Command } from 'commander';
+import { getDaemonClient } from '../client.js';
+import type { CronJob } from '../../shared/config.js';
+
+export const jobsCmd = new Command('jobs').description('Manage background jobs');
+
+function parseKeyValueArray(arr: string[] | undefined): Record<string, string> | undefined {
+  if (!arr || arr.length === 0) return undefined;
+  const result: Record<string, string> = {};
+  for (const item of arr) {
+    const [key, ...rest] = item.split('=');
+    if (key && rest.length >= 0) {
+      result[key] = rest.join('=');
+    }
+  }
+  return result;
+}
+
+function handleError(action: string, err: unknown): never {
+  console.error(`Failed to ${action}:`, err instanceof Error ? err.message : String(err));
+  process.exit(1);
+}
+
+jobsCmd
+  .command('list')
+  .description('Display existing jobs')
+  .option('-c, --chat <id>', 'Specific chat to list jobs from')
+  .option('--json', 'Output full JSON for each job')
+  .action(async (options) => {
+    try {
+      const trpc = await getDaemonClient();
+      let jobs = await trpc.listCronJobs.query({ chatId: options.chat });
+
+      jobs = jobs.sort((a, b) => {
+        const timeA = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+        const timeB = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+        return timeA - timeB;
+      });
+
+      if (options.json) {
+        console.log(JSON.stringify(jobs, null, 2));
+        return;
+      }
+
+      if (jobs.length === 0) {
+        console.log('No jobs found.');
+        return;
+      }
+      for (const job of jobs) {
+        let schedule = '';
+        if ('cron' in job.schedule) schedule = `cron: ${job.schedule.cron}`;
+        else if ('every' in job.schedule) schedule = `every: ${job.schedule.every}`;
+        else if ('at' in job.schedule) schedule = `at: ${job.schedule.at}`;
+
+        console.log(`- ${job.id} (${schedule})`);
+      }
+    } catch (err) {
+      handleError('list jobs', err);
+    }
+  });
+
+jobsCmd
+  .command('add <name>')
+  .description('Create a new job')
+  .option('-m, --message <text>', 'The message to send', '')
+  .option('-r, --reply <text>', 'An immediate reply to append')
+  .option(
+    '--at <time-or-interval>',
+    'Execute once at this UTC time or after an interval (e.g., 2m, 4h)'
+  )
+  .option('--every <duration>', 'Execute repeatedly at this interval (e.g., 20m, 4h)')
+  .option('--cron <expression>', 'Execute according to the crontab expression')
+  .option('-a, --agent <agentid>', 'Agent to use')
+  .option(
+    '-e, --env <env...>',
+    'Environment variables in KEY=VALUE format (can be specified multiple times)'
+  )
+  .option('-s, --session <type>', 'Session type (e.g. new)')
+  .option('-c, --chat <chatid>', 'Specify the chat')
+  .action(async (name, options) => {
+    try {
+      const schedules = [options.at, options.every, options.cron].filter(Boolean);
+      if (schedules.length > 1) {
+        throw new Error(
+          'More than one schedule flag was set. Please use only one of --at, --every, or --cron.'
+        );
+      }
+      if (schedules.length === 0) {
+        throw new Error('A schedule must be specified (--at, --every, or --cron).');
+      }
+
+      let schedule: CronJob['schedule'];
+      if (options.at) schedule = { at: options.at };
+      else if (options.every) schedule = { every: options.every };
+      else schedule = { cron: options.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;
+
+      const env = parseKeyValueArray(options.env);
+      if (env) job.env = env;
+
+      if (options.session) {
+        if (options.session !== 'new') {
+          throw new Error('Only the "new" session type is supported.');
+        }
+        job.session = { type: options.session };
+      }
+
+      const trpc = await getDaemonClient();
+      await trpc.addCronJob.mutate({ chatId: options.chat, job });
+      console.log(`Job '${name}' created successfully.`);
+    } catch (err) {
+      handleError('create job', err);
+    }
+  });
+
+jobsCmd
+  .command('delete <name>')
+  .description('Remove a job')
+  .option('-c, --chat <chatid>', 'Specify the chat')
+  .action(async (name, options) => {
+    try {
+      const trpc = await getDaemonClient();
+      const result = await trpc.deleteCronJob.mutate({ chatId: options.chat, id: name });
+      if (result.deleted) {
+        console.log(`Job '${name}' deleted successfully.`);
+      } else {
+        console.log(`Job '${name}' not found.`);
+      }
+    } catch (err) {
+      handleError('delete job', err);
+    }
+  });

package/src/cli/commands/messages.ts

@@ -0,0 +1,103 @@
+import { Command } from 'commander';
+import { getDaemonClient } from '../client.js';
+import { getMessages, getDefaultChatId } from '../../shared/chats.js';
+import { getAgent, isValidAgentId, getClawminiDir } from '../../shared/workspace.js';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+
+export const messagesCmd = new Command('messages').description('Manage messages');
+
+messagesCmd
+  .command('send <message>')
+  .description('Send a new message')
+  .option('-c, --chat <id>', 'Specific chat to send the message to')
+  .option('-s, --session <id>', 'Specific session to send the message to')
+  .option('-a, --agent <name>', 'Specific agent to use for this message')
+  .option('--no-wait', 'Return immediately after the server queues the message')
+  .option('-f, --file <path>', 'File to attach', (val, prev: string[]) => prev.concat([val]), [])
+  .action(async (message, options) => {
+    try {
+      if (options.agent) {
+        if (!isValidAgentId(options.agent)) {
+          console.error(`Error: Invalid agent ID '${options.agent}'.`);
+          process.exit(1);
+        }
+
+        if (options.agent !== 'default') {
+          const agent = await getAgent(options.agent);
+          if (!agent) {
+            console.error(`Error: Agent '${options.agent}' not found.`);
+            process.exit(1);
+          }
+        }
+      }
+
+      let finalFiles: string[] | undefined = undefined;
+      if (options.file && options.file.length > 0) {
+        finalFiles = [];
+        const tmpDir = path.join(getClawminiDir(process.cwd()), 'tmp');
+        await fs.mkdir(tmpDir, { recursive: true });
+        for (const f of options.file) {
+          const dest = path.join(
+            tmpDir,
+            `cli-${Date.now()}-${Math.random().toString(36).substring(2, 7)}-${path.basename(f)}`
+          );
+          await fs.copyFile(path.resolve(process.cwd(), f), dest);
+          finalFiles.push(dest);
+        }
+      }
+
+      const trpc = await getDaemonClient();
+      await trpc.sendMessage.mutate({
+        type: 'send-message',
+        client: 'cli',
+        data: {
+          message,
+          chatId: options.chat,
+          sessionId: options.session,
+          agentId: options.agent,
+          noWait: !options.wait,
+          files: finalFiles,
+        },
+      });
+      console.log('Message sent successfully.');
+    } catch (err) {
+      console.error('Failed to send message:', err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+
+messagesCmd
+  .command('tail')
+  .description('View message history')
+  .option('-n, --lines <number>', 'Number of messages to show', parseInt)
+  .option('--json', 'Output raw JSONL format')
+  .option('-c, --chat <id>', 'Specific chat to view')
+  .action(async (options) => {
+    try {
+      const chatId = options.chat ?? (await getDefaultChatId());
+      const messages = await getMessages(chatId, options.lines);
+
+      if (options.json) {
+        messages.forEach((msg) => console.log(JSON.stringify(msg)));
+      } else {
+        messages.forEach((msg) => {
+          if (msg.role === 'user') {
+            console.log(`[USER] ${msg.content}`);
+          } else if (msg.role === 'log') {
+            if (msg.content) {
+              console.log(`[LOG] ${msg.content.trim()}`);
+            } else if (msg.stderr) {
+              console.error(`[STDERR] ${msg.stderr.trim()}`);
+            }
+          }
+        });
+      }
+    } catch (err) {
+      console.error(
+        'Failed to retrieve messages:',
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(1);
+    }
+  });

package/src/cli/commands/up.ts

@@ -0,0 +1,26 @@
+import { Command } from 'commander';
+import { getDaemonClient } from '../client.js';
+import { getSocketPath } from '../../shared/workspace.js';
+import fs from 'node:fs';
+
+export const upCmd = new Command('up')
+  .description('Start the local clawmini daemon server')
+  .action(async () => {
+    try {
+      const socketPath = getSocketPath();
+      const wasRunning = fs.existsSync(socketPath);
+
+      const client = await getDaemonClient({ autoStart: true });
+      // Perform a ping to ensure the server is responding
+      await client.ping.query();
+
+      if (wasRunning) {
+        console.log('Daemon is already running.');
+      } else {
+        console.log('Successfully started clawmini daemon.');
+      }
+    } catch (err: unknown) {
+      console.error('Failed to start daemon:', err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });

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

@@ -0,0 +1,138 @@
+import http from 'node:http';
+import { z } from 'zod';
+import {
+  listAgents,
+  getAgent,
+  writeAgentSettings,
+  deleteAgent,
+  isValidAgentId,
+} from '../../../shared/workspace.js';
+import { parseJsonBody, sendJsonResponse } from './utils.js';
+
+export async function handleApiAgents(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  urlPath: string
+) {
+  if (req.method === 'GET' && urlPath === '/api/agents') {
+    const agentIds = await listAgents();
+    const agents = [];
+    for (const id of agentIds) {
+      try {
+        const agent = await getAgent(id);
+        if (agent) {
+          agents.push({ id, ...agent });
+        }
+      } catch (err: unknown) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        console.error(`Failed to load agent ${id}: ${errorMessage}`);
+        agents.push({ id, error: errorMessage });
+      }
+    }
+    sendJsonResponse(res, 200, agents);
+    return true;
+  }
+
+  if (req.method === 'POST' && urlPath === '/api/agents') {
+    try {
+      const schema = z.object({
+        id: z.string().refine(isValidAgentId, { message: 'Invalid agent ID' }),
+        directory: z.string().optional(),
+        env: z.record(z.string(), z.string()).optional(),
+        commands: z.record(z.string(), z.string()).optional(),
+      });
+
+      const body = await parseJsonBody(req, schema);
+
+      const existing = await getAgent(body.id);
+      if (existing) {
+        sendJsonResponse(res, 409, { error: 'Agent already exists' });
+        return true;
+      }
+
+      const newAgent = {
+        directory: body.directory,
+        env: body.env || {},
+        commands: body.commands || {},
+      };
+
+      try {
+        await writeAgentSettings(body.id, newAgent);
+      } catch (err) {
+        sendJsonResponse(res, 400, {
+          error: err instanceof Error ? err.message : 'Invalid agent directory',
+        });
+        return true;
+      }
+
+      sendJsonResponse(res, 201, { id: body.id, ...newAgent });
+    } catch {
+      sendJsonResponse(res, 500, { error: 'Failed to create agent' });
+    }
+    return true;
+  }
+
+  const agentMatch = urlPath.match(/^\/api\/agents\/([^/]+)$/);
+  if (agentMatch && agentMatch[1]) {
+    const agentId = agentMatch[1];
+
+    if (!isValidAgentId(agentId)) {
+      sendJsonResponse(res, 400, { error: 'Invalid agent ID' });
+      return true;
+    }
+
+    if (req.method === 'GET') {
+      try {
+        const agent = await getAgent(agentId);
+        if (!agent) {
+          sendJsonResponse(res, 404, { error: 'Agent not found' });
+          return true;
+        }
+        sendJsonResponse(res, 200, { id: agentId, ...agent });
+      } catch (err: unknown) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        sendJsonResponse(res, 500, { error: errorMessage });
+      }
+      return true;
+    }
+
+    if (req.method === 'PUT' || req.method === 'POST') {
+      try {
+        const schema = z.object({
+          directory: z.string().optional(),
+          env: z.record(z.string(), z.string()).optional(),
+          commands: z.record(z.string(), z.string()).optional(),
+        });
+
+        const body = await parseJsonBody(req, schema);
+
+        const agent = (await getAgent(agentId)) || {};
+        if (body.directory !== undefined) agent.directory = body.directory;
+        if (body.env !== undefined) agent.env = body.env;
+        if (body.commands !== undefined) agent.commands = body.commands;
+
+        try {
+          await writeAgentSettings(agentId, agent);
+        } catch (err) {
+          sendJsonResponse(res, 400, {
+            error: err instanceof Error ? err.message : 'Invalid agent directory',
+          });
+          return true;
+        }
+
+        sendJsonResponse(res, 200, { id: agentId, ...agent });
+      } catch {
+        sendJsonResponse(res, 500, { error: 'Failed to update agent' });
+      }
+      return true;
+    }
+
+    if (req.method === 'DELETE') {
+      await deleteAgent(agentId);
+      sendJsonResponse(res, 200, { success: true });
+      return true;
+    }
+  }
+
+  return false;
+}

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

@@ -0,0 +1,213 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import {
+  listChats,
+  getMessages,
+  getChatsDir,
+  createChat,
+  isValidChatId,
+} from '../../../shared/chats.js';
+import { writeChatSettings } from '../../../shared/workspace.js';
+import { getDaemonClient } from '../../client.js';
+import { parseJsonBody, sendJsonResponse } from './utils.js';
+
+export async function handleApiChats(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  urlPath: string
+) {
+  if (req.method === 'GET' && urlPath === '/api/chats') {
+    const chats = await listChats();
+    sendJsonResponse(res, 200, chats);
+    return true;
+  }
+
+  if (req.method === 'POST' && urlPath === '/api/chats') {
+    try {
+      const schema = z.object({
+        id: z.string().refine(isValidChatId, {
+          message: 'Invalid chat ID. Must be alphanumeric with dashes or underscores.',
+        }),
+        agent: z.string().optional(),
+      });
+
+      const body = await parseJsonBody(req, schema);
+
+      await createChat(body.id);
+      if (body.agent) {
+        await writeChatSettings(body.id, { defaultAgent: body.agent });
+      }
+      sendJsonResponse(res, 201, { id: body.id, agent: body.agent });
+    } catch {
+      sendJsonResponse(res, 500, { error: 'Failed to create chat' });
+    }
+    return true;
+  }
+
+  const chatMatch = urlPath.match(/^\/api\/chats\/([^/]+)$/);
+  if (req.method === 'GET' && chatMatch && chatMatch[1]) {
+    const chatId = chatMatch[1];
+    try {
+      const url = new URL(req.url || '', `http://${req.headers.host}`);
+      const since = url.searchParams.get('since');
+
+      let messages = await getMessages(chatId);
+
+      if (since) {
+        const sinceIndex = messages.findIndex((m) => m.id === since);
+        if (sinceIndex !== -1) {
+          messages = messages.slice(sinceIndex + 1);
+        }
+      }
+
+      sendJsonResponse(res, 200, messages);
+    } catch {
+      sendJsonResponse(res, 404, { error: 'Chat not found' });
+    }
+    return true;
+  }
+
+  const streamMatch = urlPath.match(/^\/api\/chats\/([^/]+)\/stream$/);
+  if (req.method === 'GET' && streamMatch && streamMatch[1]) {
+    const chatId = streamMatch[1];
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.flushHeaders();
+
+    const chatsDir = await getChatsDir();
+    const chatFile = path.join(chatsDir, chatId, 'chat.jsonl');
+
+    if (!fs.existsSync(chatFile)) {
+      await createChat(chatId);
+    }
+
+    let currentSize = fs.statSync(chatFile).size;
+
+    const watcher = fs.watch(chatFile, (eventType) => {
+      if (eventType === 'change') {
+        try {
+          const stat = fs.statSync(chatFile);
+          if (stat.size > currentSize) {
+            const stream = fs.createReadStream(chatFile, {
+              start: currentSize,
+              end: stat.size - 1,
+            });
+            currentSize = stat.size;
+
+            let buffer = '';
+            stream.on('data', (chunk) => {
+              buffer += chunk.toString();
+              const parts = buffer.split('\n');
+              buffer = parts.pop() || '';
+              for (const line of parts) {
+                if (line.trim()) {
+                  res.write(`data: ${line}\n\n`);
+                }
+              }
+            });
+            stream.on('end', () => {
+              if (buffer.trim()) {
+                res.write(`data: ${buffer}\n\n`);
+              }
+            });
+          }
+        } catch {
+          // File might be temporarily inaccessible
+        }
+      }
+    });
+
+    req.on('close', () => {
+      watcher.close();
+    });
+
+    // Send an initial ping to establish connection
+    res.write(': connected\n\n');
+    return true;
+  }
+
+  const messageMatch = urlPath.match(/^\/api\/chats\/([^/]+)\/messages$/);
+  if (req.method === 'POST' && messageMatch && messageMatch[1]) {
+    const chatId = messageMatch[1];
+
+    const schema = z.object({
+      message: z.string().min(1, 'Missing or invalid "message" field'),
+    });
+
+    let body;
+    try {
+      body = await parseJsonBody(req, schema);
+    } catch (err) {
+      sendJsonResponse(res, 400, {
+        error: err instanceof Error ? err.message : 'Invalid request',
+      });
+      return true;
+    }
+
+    try {
+      const client = await getDaemonClient();
+      await client.sendMessage.mutate({
+        type: 'send-message',
+        client: 'cli',
+        data: {
+          message: body.message,
+          chatId,
+          noWait: true,
+        },
+      });
+      sendJsonResponse(res, 200, { success: true });
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+      sendJsonResponse(res, 500, { error: errorMessage || 'Internal Server Error' });
+    }
+    return true;
+  }
+
+  const cronMatch = urlPath.match(/^\/api\/chats\/([^/]+)\/cron(?:\/([^/]+))?$/);
+  if (cronMatch && cronMatch[1]) {
+    const chatId = cronMatch[1];
+    const jobId = cronMatch[2]; // undefined if not present
+
+    if (req.method === 'GET') {
+      try {
+        const client = await getDaemonClient();
+        const jobs = await client.listCronJobs.query({ chatId });
+        sendJsonResponse(res, 200, jobs);
+      } catch {
+        sendJsonResponse(res, 500, { error: 'Failed to list cron jobs' });
+      }
+      return true;
+    }
+
+    if (req.method === 'POST') {
+      try {
+        const client = await getDaemonClient();
+        const body = await parseJsonBody(req);
+        await client.addCronJob.mutate({ chatId, job: body });
+        sendJsonResponse(res, 201, { success: true });
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+        sendJsonResponse(res, 500, { error: errorMessage || 'Failed to add cron job' });
+      }
+      return true;
+    }
+
+    if (req.method === 'DELETE' && jobId) {
+      try {
+        const client = await getDaemonClient();
+        await client.deleteCronJob.mutate({ chatId, id: jobId });
+        sendJsonResponse(res, 200, { success: true });
+      } catch {
+        sendJsonResponse(res, 500, { error: 'Failed to delete cron job' });
+      }
+      return true;
+    }
+  }
+
+  return false;
+}