clawmini 0.0.1

package/src/daemon/routers.ts

@@ -0,0 +1,115 @@
+import { spawn } from 'node:child_process';
+import type { RouterState } from './routers/types.js';
+import { slashNew } from './routers/slash-new.js';
+import { slashCommand } from './routers/slash-command.js';
+import { slashStop } from './routers/slash-stop.js';
+import { slashInterrupt } from './routers/slash-interrupt.js';
+import { slashPolicies } from './routers/slash-policies.js';
+
+export async function executeRouterPipeline(
+  initialState: RouterState,
+  routers: string[]
+): Promise<RouterState> {
+  let state = { ...initialState };
+
+  for (const router of routers) {
+    if (state.action === 'stop') {
+      break;
+    }
+
+    if (router === '@clawmini/slash-new') {
+      state = slashNew(state);
+    } else if (router === '@clawmini/slash-command') {
+      state = await slashCommand(state);
+    } else if (router === '@clawmini/slash-stop') {
+      state = slashStop(state);
+    } else if (router === '@clawmini/slash-interrupt') {
+      state = slashInterrupt(state);
+    } else if (router === '@clawmini/slash-policies') {
+      state = await slashPolicies(state);
+    } else {
+      // Execute as custom shell command
+      try {
+        state = await executeCustomRouter(router, state);
+      } catch (err) {
+        // Silent failure handling: log but do not halt
+        console.error(`Router error [${router}]:`, err);
+      }
+    }
+  }
+
+  return state;
+}
+
+async function executeCustomRouter(command: string, state: RouterState): Promise<RouterState> {
+  return new Promise((resolve, reject) => {
+    // We run the command via shell
+    const child = spawn(command, { shell: true });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    // timeout fallback to avoid hanging indefinitely
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error('Router execution timed out'));
+    }, 10000);
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        return reject(new Error(`Process exited with code ${code}. Stderr: ${stderr}`));
+      }
+
+      try {
+        const result = JSON.parse(stdout);
+        const newState = { ...state };
+
+        if (typeof result.message === 'string') newState.message = result.message;
+        if (typeof result.agent === 'string') newState.agentId = result.agent;
+        if (typeof result.session === 'string') newState.sessionId = result.session;
+        if (typeof result.env === 'object' && result.env !== null) {
+          newState.env = { ...newState.env, ...result.env };
+        }
+        if (typeof result.reply === 'string') newState.reply = result.reply;
+        if (typeof result.action === 'string') newState.action = result.action;
+
+        resolve(newState);
+      } catch (err) {
+        reject(new Error(`Failed to parse router output: ${err}. Stdout: ${stdout}`));
+      }
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+
+    // Write state to stdin
+    const inputState = {
+      message: state.message,
+      chatId: state.chatId,
+      agentId: state.agentId,
+      sessionId: state.sessionId,
+      env: state.env,
+      action: state.action,
+    };
+
+    if (child.stdin) {
+      child.stdin.on('error', (err) => {
+        if ((err as NodeJS.ErrnoException).code !== 'EPIPE') {
+          console.error('stdin error:', err);
+        }
+      });
+      child.stdin.write(JSON.stringify(inputState));
+      child.stdin.end();
+    }
+  });
+}

package/src/daemon/utils/spawn.ts

@@ -0,0 +1,61 @@
+import { spawn } from 'node:child_process';
+import type { RunCommandFn } from '../message.js';
+
+export const runCommand: RunCommandFn &
+  ((
+    args: Parameters<RunCommandFn>[0] & { logToTerminal?: boolean }
+  ) => ReturnType<RunCommandFn>) = async ({
+  command,
+  cwd,
+  env,
+  stdin,
+  signal,
+  logToTerminal,
+}: Parameters<RunCommandFn>[0] & { logToTerminal?: boolean }) => {
+  return new Promise<{ stdout: string; stderr: string; exitCode: number }>((resolve, reject) => {
+    const p = spawn(command, { shell: true, cwd, env, signal });
+
+    if (stdin && p.stdin) {
+      p.stdin.on('error', (err) => {
+        if ((err as NodeJS.ErrnoException).code !== 'EPIPE') {
+          console.error('stdin error:', err);
+        }
+      });
+      p.stdin.write(stdin);
+      p.stdin.end();
+    }
+
+    let stdout = '';
+    let stderr = '';
+
+    if (p.stdout) {
+      p.stdout.on('data', (data) => {
+        stdout += data.toString();
+        if (logToTerminal && !stdin) {
+          process.stdout.write(data);
+        }
+      });
+    }
+
+    if (p.stderr) {
+      p.stderr.on('data', (data) => {
+        stderr += data.toString();
+        if (logToTerminal && !stdin) {
+          process.stderr.write(data);
+        }
+      });
+    }
+
+    p.on('close', (code) => {
+      resolve({ stdout, stderr, exitCode: code ?? 1 });
+    });
+
+    p.on('error', (err) => {
+      if (err.name === 'AbortError') {
+        reject(err);
+        return;
+      }
+      resolve({ stdout: '', stderr: err.toString(), exitCode: 1 });
+    });
+  });
+};

package/src/shared/agent-utils.ts

@@ -0,0 +1,30 @@
+import { type Agent } from './config.js';
+import {
+  writeAgentSettings,
+  applyTemplateToAgent,
+  readChatSettings,
+  writeChatSettings,
+} from './workspace.js';
+import { createChat, listChats } from './chats.js';
+
+export async function createAgentWithChat(
+  agentId: string,
+  agentData: Agent,
+  template?: string,
+  startDir = process.cwd()
+): Promise<void> {
+  await writeAgentSettings(agentId, agentData, startDir);
+
+  if (template) {
+    await applyTemplateToAgent(agentId, template, agentData, startDir);
+  }
+
+  const existingChats = await listChats(startDir);
+  if (existingChats.includes(agentId)) {
+    console.warn(`Warning: Chat ${agentId} already exists.`);
+  } else {
+    await createChat(agentId, startDir);
+    const currentSettings = (await readChatSettings(agentId, startDir)) || {};
+    await writeChatSettings(agentId, { ...currentSettings, defaultAgent: agentId }, startDir);
+  }
+}

package/src/shared/chats.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import {
+  createChat,
+  listChats,
+  deleteChat,
+  appendMessage,
+  getMessages,
+  getDefaultChatId,
+  setDefaultChatId,
+  type UserMessage,
+  type CommandLogMessage,
+} from './chats.js';
+
+const TEST_DIR = path.join(process.cwd(), '.clawmini_test_chats');
+
+describe('chats utilities', () => {
+  beforeEach(async () => {
+    if (existsSync(TEST_DIR)) {
+      await fs.rm(TEST_DIR, { recursive: true, force: true });
+    }
+    await fs.mkdir(path.join(TEST_DIR, '.clawmini'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    if (existsSync(TEST_DIR)) {
+      await fs.rm(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  it('should create and list chats', async () => {
+    await createChat('chat1', TEST_DIR);
+    await createChat('chat2', TEST_DIR);
+
+    const chats = await listChats(TEST_DIR);
+    expect(chats).toContain('chat1');
+    expect(chats).toContain('chat2');
+    expect(chats.length).toBe(2);
+  });
+
+  it('should delete a chat', async () => {
+    await createChat('chat1', TEST_DIR);
+    let chats = await listChats(TEST_DIR);
+    expect(chats).toContain('chat1');
+
+    await deleteChat('chat1', TEST_DIR);
+    chats = await listChats(TEST_DIR);
+    expect(chats).not.toContain('chat1');
+  });
+
+  it('should append and get messages in JSONL format', async () => {
+    await createChat('chat1', TEST_DIR);
+
+    const msg1: UserMessage = {
+      id: 'msg-1',
+      role: 'user',
+      content: 'Hello',
+      timestamp: new Date().toISOString(),
+    };
+
+    const msg2: CommandLogMessage = {
+      id: 'log-1',
+      messageId: 'msg-1',
+      role: 'log',
+      content: 'output',
+      stderr: '',
+      timestamp: new Date().toISOString(),
+      command: 'echo output',
+      cwd: '/tmp',
+      exitCode: 0,
+    };
+
+    const msg3: CommandLogMessage = {
+      id: 'log-2',
+      messageId: 'msg-1',
+      role: 'log',
+      source: 'router',
+      content: 'router modified message',
+      stderr: '',
+      timestamp: new Date().toISOString(),
+      command: 'router',
+      cwd: '/tmp',
+      exitCode: 0,
+    };
+
+    await appendMessage('chat1', msg1, TEST_DIR);
+    await appendMessage('chat1', msg2, TEST_DIR);
+    await appendMessage('chat1', msg3, TEST_DIR);
+
+    const messages = await getMessages('chat1', undefined, TEST_DIR);
+    expect(messages.length).toBe(3);
+    expect(messages[0]).toEqual(msg1);
+    expect(messages[1]).toEqual(msg2);
+    expect(messages[2]).toEqual(msg3);
+
+    // Test limit
+    const limited = await getMessages('chat1', 1, TEST_DIR);
+    expect(limited.length).toBe(1);
+    expect(limited[0]).toEqual(msg3);
+  });
+
+  it('should manage default chat id in settings.json', async () => {
+    let defaultId = await getDefaultChatId(TEST_DIR);
+    expect(defaultId).toBe('default'); // fallback
+
+    await setDefaultChatId('my-chat', TEST_DIR);
+    defaultId = await getDefaultChatId(TEST_DIR);
+    expect(defaultId).toBe('my-chat');
+  });
+});

package/src/shared/chats.ts

@@ -0,0 +1,164 @@
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { getClawminiDir, getSettingsPath } from './workspace.js';
+import { pathIsInsideDir } from './utils/fs.js';
+
+export const DEFAULT_CHAT_ID = 'default';
+
+export interface UserMessage {
+  id: string;
+  role: 'user';
+  content: string;
+  timestamp: string;
+}
+
+export interface CommandLogMessage {
+  id: string;
+  messageId: string;
+  role: 'log';
+  source?: 'router';
+  content: string;
+  stderr: string;
+  timestamp: string;
+  command: string;
+  cwd: string;
+  exitCode: number;
+  stdout?: string;
+  files?: string[];
+  level?: 'default' | 'debug' | 'verbose';
+}
+
+export type ChatMessage = UserMessage | CommandLogMessage;
+
+export async function getChatsDir(startDir = process.cwd()): Promise<string> {
+  const dir = path.join(getClawminiDir(startDir), 'chats');
+  if (!existsSync(dir)) {
+    await fs.mkdir(dir, { recursive: true });
+  }
+  return dir;
+}
+
+export function isValidChatId(chatId: string): boolean {
+  if (!chatId || chatId.length === 0) return false;
+  return /^[a-zA-Z0-9_-]+$/.test(chatId);
+}
+
+function assertValidChatId(id: string): void {
+  if (!isValidChatId(id)) {
+    throw new Error(`Invalid chat ID: ${id}`);
+  }
+}
+
+export async function createChat(id: string, startDir = process.cwd()): Promise<void> {
+  assertValidChatId(id);
+  const chatsDir = await getChatsDir(startDir);
+  const chatDir = path.join(chatsDir, id);
+  if (!existsSync(chatDir)) {
+    await fs.mkdir(chatDir, { recursive: true });
+  }
+  const chatFile = path.join(chatDir, 'chat.jsonl');
+  if (!existsSync(chatFile)) {
+    await fs.writeFile(chatFile, '');
+  }
+}
+
+export async function listChats(startDir = process.cwd()): Promise<string[]> {
+  const chatsDir = await getChatsDir(startDir);
+  try {
+    const entries = await fs.readdir(chatsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+export async function deleteChat(id: string, startDir = process.cwd()): Promise<void> {
+  assertValidChatId(id);
+  const chatsDir = await getChatsDir(startDir);
+  const chatDir = path.join(chatsDir, id);
+
+  if (!pathIsInsideDir(chatDir, chatsDir)) {
+    throw new Error(`Security Error: Cannot delete chat directory outside of ${chatsDir}`);
+  }
+
+  if (existsSync(chatDir)) {
+    await fs.rm(chatDir, { recursive: true, force: true });
+  }
+}
+
+export async function appendMessage(
+  id: string,
+  message: ChatMessage,
+  startDir = process.cwd()
+): Promise<void> {
+  assertValidChatId(id);
+  const chatsDir = await getChatsDir(startDir);
+  const chatDir = path.join(chatsDir, id);
+  if (!existsSync(chatDir)) {
+    await createChat(id, startDir);
+  }
+  const chatFile = path.join(chatDir, 'chat.jsonl');
+  await fs.appendFile(chatFile, JSON.stringify(message) + '\n');
+}
+
+export async function getMessages(
+  id: string,
+  limit?: number,
+  startDir = process.cwd()
+): Promise<ChatMessage[]> {
+  assertValidChatId(id);
+  const chatsDir = await getChatsDir(startDir);
+  const chatFile = path.join(chatsDir, id, 'chat.jsonl');
+  if (!existsSync(chatFile)) {
+    throw new Error(`Chat directory or file for '${id}' not found.`);
+  }
+  const content = await fs.readFile(chatFile, 'utf8');
+  const lines = content.split('\n').filter((line) => line.trim() !== '');
+  const messages = lines.map((line) => JSON.parse(line) as ChatMessage);
+
+  if (limit !== undefined && limit > 0) {
+    return messages.slice(-limit);
+  }
+  return messages;
+}
+
+export async function getDefaultChatId(startDir = process.cwd()): Promise<string> {
+  const settingsPath = getSettingsPath(startDir);
+  if (!existsSync(settingsPath)) return DEFAULT_CHAT_ID;
+
+  try {
+    const content = await fs.readFile(settingsPath, 'utf8');
+    const settings = JSON.parse(content);
+    return settings.chats?.defaultId || DEFAULT_CHAT_ID;
+  } catch {
+    return DEFAULT_CHAT_ID;
+  }
+}
+
+export async function setDefaultChatId(id: string, startDir = process.cwd()): Promise<void> {
+  assertValidChatId(id);
+  const settingsPath = getSettingsPath(startDir);
+  let settings: { chats?: { defaultId?: string; [key: string]: unknown }; [key: string]: unknown } =
+    {};
+  if (existsSync(settingsPath)) {
+    try {
+      const content = await fs.readFile(settingsPath, 'utf8');
+      settings = JSON.parse(content);
+    } catch {
+      // Ignore invalid JSON
+    }
+  }
+
+  if (!settings.chats) {
+    settings.chats = {};
+  }
+  settings.chats.defaultId = id;
+
+  const clawminiDir = getClawminiDir(startDir);
+  if (!existsSync(clawminiDir)) {
+    await fs.mkdir(clawminiDir, { recursive: true });
+  }
+
+  await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+}

package/src/shared/config.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'vitest';
+import { SettingsSchema, AgentSchema } from './config.js';
+
+describe('SettingsSchema', () => {
+  it('should parse empty settings', () => {
+    const result = SettingsSchema.safeParse({});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.api).toBeUndefined();
+    }
+  });
+
+  it('should parse api: false', () => {
+    const result = SettingsSchema.safeParse({ api: false });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.api).toBe(false);
+    }
+  });
+
+  it('should parse api: true', () => {
+    const result = SettingsSchema.safeParse({ api: true });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.api).toBe(true);
+    }
+  });
+
+  it('should parse api: { host: string, port: number }', () => {
+    const result = SettingsSchema.safeParse({ api: { host: '127.0.0.1', port: 3000 } });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.api).toEqual({ host: '127.0.0.1', port: 3000 });
+    }
+  });
+
+  it('should fail if api has wrong type', () => {
+    const result = SettingsSchema.safeParse({ api: 'yes' });
+    expect(result.success).toBe(false);
+  });
+
+  it('should parse api object missing port', () => {
+    const result = SettingsSchema.safeParse({ api: { host: '127.0.0.1' } });
+    expect(result.success).toBe(true);
+  });
+
+  it('should parse api object missing host', () => {
+    const result = SettingsSchema.safeParse({ api: { port: 3000 } });
+    expect(result.success).toBe(true);
+  });
+
+  it('should parse api object with proxy_host', () => {
+    const result = SettingsSchema.safeParse({ api: { proxy_host: 'http://my-proxy' } });
+    expect(result.success).toBe(true);
+  });
+
+  it('should parse files property with default', () => {
+    const result = SettingsSchema.safeParse({});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.files).toBe('./attachments');
+    }
+  });
+
+  it('should parse custom files property', () => {
+    const result = SettingsSchema.safeParse({ files: './my-files' });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.files).toBe('./my-files');
+    }
+  });
+});
+
+describe('AgentSchema', () => {
+  it('should parse files property with default', () => {
+    const result = AgentSchema.safeParse({});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.files).toBe('./attachments');
+    }
+  });
+
+  it('should parse custom files property', () => {
+    const result = AgentSchema.safeParse({ files: './my-files' });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.files).toBe('./my-files');
+    }
+  });
+});

package/src/shared/config.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+
+export const FallbackSchema = z.looseObject({
+  commands: z
+    .looseObject({
+      new: z.string().optional(),
+      append: z.string().optional(),
+      getSessionId: z.string().optional(),
+      getMessageContent: z.string().optional(),
+    })
+    .optional(),
+  env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+  retries: z.number().int().min(0).default(1),
+  delayMs: z.number().int().min(0).default(1000),
+});
+
+export const AgentSchema = z.looseObject({
+  commands: z
+    .looseObject({
+      new: z.string().optional(),
+      append: z.string().optional(),
+      getSessionId: z.string().optional(),
+      getMessageContent: z.string().optional(),
+    })
+    .optional(),
+  env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+  directory: z.string().optional(),
+  fallbacks: z.array(FallbackSchema).optional(),
+  files: z.string().default('./attachments').optional(),
+});
+
+export type Agent = z.infer<typeof AgentSchema>;
+
+export const CronJobSchema = z.looseObject({
+  id: z.string().min(1),
+  createdAt: z.string().optional(),
+  message: z.string().default(''),
+  reply: z.string().optional(),
+  agentId: z.string().optional(),
+  env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+  session: z.looseObject({ type: z.string() }).optional(),
+  schedule: z.union([
+    z.looseObject({ cron: z.string() }),
+    z.looseObject({ every: z.string() }),
+    z.looseObject({ at: z.string() }),
+  ]),
+});
+
+export type CronJob = z.infer<typeof CronJobSchema>;
+
+export const ChatSettingsSchema = z.looseObject({
+  defaultAgent: z.string().optional(),
+  sessions: z.record(z.string(), z.string()).optional(),
+  routers: z.array(z.string()).optional(),
+  jobs: z.array(CronJobSchema).optional(),
+});
+
+export type ChatSettings = z.infer<typeof ChatSettingsSchema>;
+
+export const AgentSessionSettingsSchema = z.looseObject({
+  env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+});
+
+export type AgentSessionSettings = z.infer<typeof AgentSessionSettingsSchema>;
+
+export const EnvironmentSchema = z.looseObject({
+  init: z.string().optional(),
+  up: z.string().optional(),
+  down: z.string().optional(),
+  prefix: z.string().optional(),
+  envFormat: z.string().optional(),
+  exportLiteTo: z.string().optional(),
+  env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+});
+
+export type Environment = z.infer<typeof EnvironmentSchema>;
+
+export const SettingsSchema = z.looseObject({
+  chats: z
+    .looseObject({
+      defaultId: z.string().optional(),
+    })
+    .optional(),
+  defaultAgent: AgentSchema.optional(),
+  environments: z.record(z.string(), z.string()).optional(),
+  routers: z.array(z.string()).optional(),
+  files: z.string().default('./attachments').optional(),
+  api: z
+    .union([
+      z.boolean(),
+      z.looseObject({
+        host: z.string().optional(),
+        port: z.number().optional(),
+        proxy_host: z.string().optional(),
+      }),
+    ])
+    .optional(),
+});
+
+export type Settings = z.infer<typeof SettingsSchema>;