clawmini 0.0.3 → 0.0.5

package/src/shared/agent-utils.ts

@@ -4,6 +4,7 @@ import {
   applyTemplateToAgent,
   readChatSettings,
   writeChatSettings,
+  copyAgentSkills,
 } from './workspace.js';
 import { createChat, listChats } from './chats.js';
 
@@ -19,6 +20,15 @@ export async function createAgentWithChat(
     await applyTemplateToAgent(agentId, template, agentData, startDir);
   }
 
+  try {
+    await copyAgentSkills(agentId, startDir);
+    console.log(`Copied skills to agent ${agentId}.`);
+  } catch (err) {
+    console.warn(
+      `Warning: Failed to copy skills to agent ${agentId}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+
   const existingChats = await listChats(startDir);
   if (existingChats.includes(agentId)) {
     console.warn(`Warning: Chat ${agentId} already exists.`);

package/src/shared/chats.test.ts

@@ -63,9 +63,10 @@ describe('chats utilities', () => {
     const msg2: CommandLogMessage = {
       id: 'log-1',
       messageId: 'msg-1',
-      role: 'log',
+      role: 'command',
       content: 'output',
       stderr: '',
+      stdout: '',
       timestamp: new Date().toISOString(),
       command: 'echo output',
       cwd: '/tmp',
@@ -75,10 +76,10 @@ describe('chats utilities', () => {
     const msg3: CommandLogMessage = {
       id: 'log-2',
       messageId: 'msg-1',
-      role: 'log',
-      source: 'router',
+      role: 'command',
       content: 'router modified message',
       stderr: '',
+      stdout: '',
       timestamp: new Date().toISOString(),
       command: 'router',
       cwd: '/tmp',
@@ -99,6 +100,16 @@ describe('chats utilities', () => {
     const limited = await getMessages('chat1', 1, TEST_DIR);
     expect(limited.length).toBe(1);
     expect(limited[0]).toEqual(msg3);
+
+    // Test predicate filtering combined with limit
+    const msgSub = { ...msg2, id: 'sub-1', subagentId: 'sub-123' };
+    await appendMessage('chat1', msgSub as CommandLogMessage, TEST_DIR);
+
+    // Total is now 4 messages (3 normal, 1 subagent)
+    const withPredicate = await getMessages('chat1', 2, TEST_DIR, (m) => !m.subagentId);
+    expect(withPredicate.length).toBe(2);
+    expect(withPredicate[0]).toEqual(msg2);
+    expect(withPredicate[1]).toEqual(msg3);
   });
 
   it('should manage default chat id in settings.json', async () => {
@@ -109,4 +120,135 @@ describe('chats utilities', () => {
     defaultId = await getDefaultChatId(TEST_DIR);
     expect(defaultId).toBe('my-chat');
   });
+
+  it('should support message pagination with before cursor and limits', async () => {
+    await createChat('chat1', TEST_DIR);
+
+    const msgs: UserMessage[] = Array.from({ length: 5 }, (_, i) => ({
+      id: `msg-${i + 1}`,
+      role: 'user',
+      content: `Message ${i + 1}`,
+      timestamp: new Date().toISOString(),
+    }));
+
+    for (const msg of msgs) {
+      await appendMessage('chat1', msg, TEST_DIR);
+    }
+
+    // Default limit should be 100, which returns all 5
+    const all = await getMessages('chat1', undefined, TEST_DIR);
+    expect(all.length).toBe(5);
+
+    // Limit to 2 should return the last 2
+    const lastTwo = await getMessages('chat1', 2, TEST_DIR);
+    expect(lastTwo.length).toBe(2);
+    expect(lastTwo[0]?.id).toBe('msg-4');
+    expect(lastTwo[1]?.id).toBe('msg-5');
+
+    // Before cursor with limit
+    const beforeCursor = await getMessages('chat1', 2, TEST_DIR, undefined, 'msg-4');
+    expect(beforeCursor.length).toBe(2);
+    expect(beforeCursor[0]?.id).toBe('msg-2');
+    expect(beforeCursor[1]?.id).toBe('msg-3');
+
+    // Before cursor reaching the start
+    const beforeCursorStart = await getMessages('chat1', 2, TEST_DIR, undefined, 'msg-2');
+    expect(beforeCursorStart.length).toBe(1);
+    expect(beforeCursorStart[0]?.id).toBe('msg-1');
+
+    // Before cursor that doesn't exist returns empty
+    const beforeCursorUnknown = await getMessages('chat1', 2, TEST_DIR, undefined, 'msg-unknown');
+    expect(beforeCursorUnknown.length).toBe(0);
+
+    // Limit 0 or negative should read all (Wait, limit 0 reads all?)
+    // Our implementation sets default to 100 if undefined. If 0 is explicitly passed, it hits `limit <= 0` and reads all.
+    const readAll = await getMessages('chat1', 0, TEST_DIR);
+    expect(readAll.length).toBe(5);
+
+    // Before cursor with limit <= 0
+    const readAllBefore = await getMessages('chat1', 0, TEST_DIR, undefined, 'msg-4');
+    expect(readAllBefore.length).toBe(3);
+    expect(readAllBefore[0]?.id).toBe('msg-1');
+  });
+
+  it('should parse legacy log messages gracefully', async () => {
+    await createChat('chat1', TEST_DIR);
+
+    // Old plain log missing messageId
+    const oldPlainLog = {
+      id: 'log-1',
+      role: 'log',
+      content: 'legacy content',
+      timestamp: new Date().toISOString(),
+    };
+
+    // Old command log with legacy properties
+    const oldCommandLog = {
+      id: 'log-2',
+      role: 'log',
+      messageId: 'msg-1',
+      content: 'output',
+      command: 'echo output',
+      timestamp: new Date().toISOString(),
+    };
+
+    // New generic log message without legacy properties
+    const newLogMsg = {
+      id: 'log-3',
+      role: 'log',
+      messageId: 'msg-1',
+      content: 'new log',
+      timestamp: new Date().toISOString(),
+      type: 'tool',
+    };
+
+    const chatFile = path.join(TEST_DIR, '.clawmini', 'chats', 'chat1', 'chat.jsonl');
+    await fs.appendFile(chatFile, JSON.stringify(oldPlainLog) + '\n');
+    await fs.appendFile(chatFile, JSON.stringify(oldCommandLog) + '\n');
+    await fs.appendFile(chatFile, JSON.stringify(newLogMsg) + '\n');
+
+    const messages = await getMessages('chat1', undefined, TEST_DIR);
+    expect(messages.length).toBe(3);
+
+    // Should map to legacy_log
+    expect(messages[0]?.role).toBe('legacy_log');
+    expect(messages[1]?.role).toBe('legacy_log');
+    expect(messages[2]?.role).toBe('legacy_log');
+  });
+
+  it('should skip corrupted JSON lines gracefully', async () => {
+    await createChat('chat1', TEST_DIR);
+
+    const validMsg1 = {
+      id: 'msg-1',
+      role: 'user',
+      content: 'Hello',
+      timestamp: new Date().toISOString(),
+    };
+
+    const validMsg2 = {
+      id: 'msg-2',
+      role: 'agent',
+      content: 'Hi',
+      timestamp: new Date().toISOString(),
+    };
+
+    const chatFile = path.join(TEST_DIR, '.clawmini', 'chats', 'chat1', 'chat.jsonl');
+    await fs.appendFile(chatFile, JSON.stringify(validMsg1) + '\n');
+    await fs.appendFile(chatFile, '{ "id": "corrupted", "role": "user" \n'); // Invalid JSON
+    await fs.appendFile(chatFile, JSON.stringify(validMsg2) + '\n');
+    await fs.appendFile(chatFile, 'This is completely not JSON\n'); // Invalid JSON
+
+    // Test getMessages with limit > 0
+    const limitedMessages = await getMessages('chat1', 10, TEST_DIR);
+    expect(limitedMessages.length).toBe(2);
+    expect(limitedMessages[0]?.id).toBe('msg-1');
+    expect(limitedMessages[1]?.id).toBe('msg-2');
+
+    // Test getMessages with limit <= 0 (read all)
+    const allMessages = await getMessages('chat1', 0, TEST_DIR);
+    expect(allMessages.length).toBe(2);
+    expect(allMessages[0]?.id).toBe('msg-1');
+    expect(allMessages[1]?.id).toBe('msg-2');
+  });
 });

package/src/shared/chats.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import fs from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
@@ -6,30 +7,93 @@ import { pathIsInsideDir } from './utils/fs.js';
 
 export const DEFAULT_CHAT_ID = 'default';
 
-export interface UserMessage {
+export interface BaseMessage {
   id: string;
-  role: 'user';
+  role: string;
+  displayRole?: 'user' | 'agent';
   content: string;
   timestamp: string;
+  subagentId?: string;
 }
 
-export interface CommandLogMessage {
-  id: string;
-  messageId: string;
+export interface UserMessage extends BaseMessage {
+  role: 'user';
+  agentContent?: string;
+  files?: string[];
+}
+
+export interface AgentReplyMessage extends BaseMessage {
+  role: 'agent';
+  files?: string[];
+}
+
+export interface LogMessage extends BaseMessage {
   role: 'log';
-  source?: 'router';
-  content: string;
-  stderr: string;
-  timestamp: string;
+  messageId: string;
+  type?: 'tool' | 'unknown';
+}
+
+export interface CommandLogMessage extends BaseMessage {
+  role: 'command';
+  messageId: string;
   command: string;
   cwd: string;
+  stdout: string;
+  stderr: string;
   exitCode: number;
-  stdout?: string;
+  retryAttemptIndex?: number;
+}
+
+export interface SystemMessage extends BaseMessage {
+  role: 'system';
+  event: 'cron' | 'policy_approved' | 'policy_rejected' | 'subagent_update' | 'router' | 'other';
+  messageId?: string;
+}
+
+export interface ToolMessage extends BaseMessage {
+  role: 'tool';
+  messageId: string;
+  name: string;
+  payload: unknown;
+}
+
+export interface PolicyRequestMessage extends BaseMessage {
+  role: 'policy';
+  messageId: string;
+  requestId: string;
+  commandName: string;
+  args: string[];
+  status: 'pending' | 'approved' | 'rejected';
+}
+
+export interface SubagentStatusMessage extends BaseMessage {
+  role: 'subagent_status';
+  subagentId: string;
+  status: 'completed' | 'failed';
+}
+
+export interface LegacyLogMessage extends BaseMessage {
+  role: 'legacy_log';
+  messageId?: string;
+  source?: string;
   files?: string[];
   level?: 'default' | 'debug' | 'verbose';
+  command?: string;
+  cwd?: string;
+  stdout?: string;
+  stderr?: string;
+  exitCode?: number;
 }
 
-export type ChatMessage = UserMessage | CommandLogMessage;
+export type ChatMessage =
+  | UserMessage
+  | AgentReplyMessage
+  | CommandLogMessage
+  | SystemMessage
+  | ToolMessage
+  | PolicyRequestMessage
+  | SubagentStatusMessage
+  | LegacyLogMessage;
 
 export async function getChatsDir(startDir = process.cwd()): Promise<string> {
   const dir = path.join(getClawminiDir(startDir), 'chats');
@@ -102,10 +166,71 @@ export async function appendMessage(
   await fs.appendFile(chatFile, JSON.stringify(message) + '\n');
 }
 
+async function* readLinesBackwards(filePath: string): AsyncGenerator<string, void, unknown> {
+  const fd = await fs.open(filePath, 'r');
+  try {
+    const stats = await fd.stat();
+    if (stats.size === 0) return;
+
+    const chunkSize = 64 * 1024;
+    let position = stats.size;
+    const buffer = Buffer.alloc(chunkSize);
+    let leftoverBuffer = Buffer.alloc(0);
+
+    while (position > 0) {
+      const readSize = Math.min(chunkSize, position);
+      position -= readSize;
+
+      const { bytesRead } = await fd.read(buffer, 0, readSize, position);
+
+      const currentChunk = buffer.subarray(0, bytesRead);
+      let combinedBuffer = Buffer.concat([currentChunk, leftoverBuffer]);
+
+      let lastNewlineIdx = combinedBuffer.lastIndexOf(0x0a);
+
+      while (lastNewlineIdx !== -1) {
+        const lineBuffer = combinedBuffer.subarray(lastNewlineIdx + 1);
+        const line = lineBuffer.toString('utf8').trim();
+
+        if (line) {
+          yield line;
+        }
+
+        combinedBuffer = combinedBuffer.subarray(0, lastNewlineIdx);
+        lastNewlineIdx = combinedBuffer.lastIndexOf(0x0a);
+      }
+      leftoverBuffer = combinedBuffer;
+    }
+
+    if (leftoverBuffer.length > 0) {
+      const line = leftoverBuffer.toString('utf8').trim();
+      if (line) {
+        yield line;
+      }
+    }
+  } finally {
+    await fd.close();
+  }
+}
+
+export function parseChatMessage(line: string): ChatMessage | null {
+  try {
+    const msg = JSON.parse(line);
+    if (msg && msg.role === 'log') {
+      msg.role = 'legacy_log';
+    }
+    return msg as ChatMessage;
+  } catch {
+    return null;
+  }
+}
+
 export async function getMessages(
   id: string,
   limit?: number,
-  startDir = process.cwd()
+  startDir = process.cwd(),
+  predicate?: (msg: ChatMessage) => boolean,
+  before?: string
 ): Promise<ChatMessage[]> {
   assertValidChatId(id);
   const chatsDir = await getChatsDir(startDir);
@@ -113,14 +238,61 @@ export async function getMessages(
   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);
+  limit = limit ?? 100;
+
+  if (limit <= 0) {
+    const content = await fs.readFile(chatFile, 'utf8');
+    const lines = content.split('\n').filter((line) => line.trim() !== '');
+
+    let messages = lines
+      .map((line) => parseChatMessage(line))
+      .filter((msg): msg is ChatMessage => msg !== null);
+
+    if (before) {
+      const beforeIndex = messages.findIndex((m) => m.id === before);
+      if (beforeIndex !== -1) {
+        messages = messages.slice(0, beforeIndex);
+      } else {
+        messages = [];
+      }
+    }
+
+    if (predicate) {
+      messages = messages.filter(predicate);
+    }
+
+    return messages;
+  }
+
+  // We have a limit > 0, read backwards to avoid parsing the whole file
+  const messages: ChatMessage[] = [];
+  let skipping = before !== undefined;
+
+  for await (const line of readLinesBackwards(chatFile)) {
+    try {
+      const msg = parseChatMessage(line);
+      if (!msg) continue;
+
+      if (skipping) {
+        if (msg.id === before) {
+          skipping = false;
+        }
+        continue;
+      }
+
+      if (!predicate || predicate(msg)) {
+        messages.push(msg);
+        if (messages.length >= limit) {
+          break;
+        }
+      }
+    } catch {
+      // Ignore invalid JSON lines
+    }
   }
-  return messages;
+
+  return messages.reverse();
 }
 
 export async function getDefaultChatId(startDir = process.cwd()): Promise<string> {
@@ -162,3 +334,28 @@ export async function setDefaultChatId(id: string, startDir = process.cwd()): Pr
 
   await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
+
+export async function findLastMessage(
+  id: string,
+  predicate: (msg: ChatMessage) => boolean,
+  startDir = process.cwd()
+): Promise<ChatMessage | null> {
+  assertValidChatId(id);
+  const chatsDir = await getChatsDir(startDir);
+  const chatFile = path.join(chatsDir, id, 'chat.jsonl');
+  if (!existsSync(chatFile)) {
+    return null;
+  }
+
+  for await (const line of readLinesBackwards(chatFile)) {
+    try {
+      const msg = parseChatMessage(line);
+      if (!msg) continue;
+      if (predicate(msg)) return msg;
+    } catch {
+      // Ignore invalid JSON lines
+    }
+  }
+
+  return null;
+}

package/src/shared/config.ts

@@ -23,36 +23,88 @@ export const AgentSchema = z.looseObject({
       getMessageContent: z.string().optional(),
     })
     .optional(),
+  apiTokenEnvVar: z.string().optional(),
+  apiUrlEnvVar: z.string().optional(),
   env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+  subagentEnv: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
   directory: z.string().optional(),
+  skillsDir: 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(),
+export type CronJob = {
+  id: string;
+  createdAt?: string;
+  message: string;
+  reply?: string;
+  agentId?: string;
+  env?: Record<string, string | boolean>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  session?: { type: string; [key: string]: any };
+  schedule: { cron: string } | { every: string } | { at: string };
+  nextSessionId?: string;
+  action?: 'stop' | 'interrupt' | 'continue';
+  jobs?: {
+    add?: CronJob[];
+    remove?: string[];
+  };
+};
+
+export const CronJobSchema = z.lazy(() =>
+  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() }),
+    ]),
+    nextSessionId: z.string().optional(),
+    action: z.enum(['stop', 'interrupt', 'continue']).optional(),
+    jobs: z
+      .looseObject({
+        add: z.array(z.lazy(() => CronJobSchema)).optional(),
+        remove: z.array(z.string()).optional(),
+      })
+      .optional(),
+  })
+) as z.ZodType<CronJob>;
+
+export const RouterConfigSchema = z.union([
+  z.string(),
+  z.looseObject({
+    use: z.string(),
+    with: z.record(z.string(), z.any()).optional(),
+  }),
+]);
+
+export type RouterConfig = z.infer<typeof RouterConfigSchema>;
+
+export const SubagentTrackerSchema = z.looseObject({
+  id: z.string(),
   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() }),
-  ]),
+  sessionId: z.string().optional(),
+  createdAt: z.string(),
+  status: z.enum(['active', 'completed', 'failed']),
+  parentId: z.string().optional(),
 });
 
-export type CronJob = z.infer<typeof CronJobSchema>;
+export type SubagentTracker = z.infer<typeof SubagentTrackerSchema>;
 
 export const ChatSettingsSchema = z.looseObject({
   defaultAgent: z.string().optional(),
   sessions: z.record(z.string(), z.string()).optional(),
-  routers: z.array(z.string()).optional(),
+  routers: z.array(RouterConfigSchema).optional(),
   jobs: z.array(CronJobSchema).optional(),
+  subagents: z.record(z.string(), SubagentTrackerSchema).optional(),
 });
 
 export type ChatSettings = z.infer<typeof ChatSettingsSchema>;
@@ -83,7 +135,7 @@ export const SettingsSchema = z.looseObject({
     .optional(),
   defaultAgent: AgentSchema.optional(),
   environments: z.record(z.string(), z.string()).optional(),
-  routers: z.array(z.string()).optional(),
+  routers: z.array(RouterConfigSchema).optional(),
   files: z.string().default('./attachments').optional(),
   api: z
     .union([

package/src/shared/lite.ts

@@ -4,31 +4,35 @@ import { fileURLToPath } from 'node:url';
 import { readSettings, readEnvironment, getWorkspaceRoot } from './workspace.js';
 import type { Environment } from './config.js';
 
-export async function getLiteScriptContent(): Promise<string> {
-  let liteScriptContent: string;
-  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export async function resolveCompiledScript(scriptName: string, metaUrl: string): Promise<string> {
+  const __dirname = path.dirname(fileURLToPath(metaUrl));
+  const filename = scriptName.endsWith('.mjs') ? scriptName : `${scriptName}.mjs`;
 
-  let liteScriptPath = path.resolve(__dirname, 'cli/lite.mjs'); // if bundled in a shared chunk at dist/
+  const searchPaths = [
+    path.resolve(__dirname, `cli/${filename}`), // If bundled in a shared chunk at dist/
+    path.resolve(__dirname, filename), // If bundled in dist/cli or dist/daemon and lite is next to it
+    path.resolve(__dirname, `../cli/${filename}`), // If bundled in dist/daemon, it might be in ../cli/
+    path.resolve(__dirname, `../../dist/cli/${filename}`), // Fallback for development/testing when running from src/shared
+    path.resolve(__dirname, `../${filename}`), // Used from src/cli/commands (1 level deep) -> dist/cli
+    path.resolve(__dirname, `../../${filename}`), // Used from src/cli/commands -> dist/cli (2 levels deep)
+  ];
 
-  try {
-    await fs.access(liteScriptPath);
-  } catch {
+  for (const scriptPath of searchPaths) {
     try {
-      // If bundled in dist/cli or dist/daemon and lite is next to it
-      liteScriptPath = path.resolve(__dirname, 'lite.mjs');
-      await fs.access(liteScriptPath);
+      await fs.access(scriptPath);
+      return scriptPath;
     } catch {
-      try {
-        // If bundled in dist/daemon, it might be in ../cli/lite.mjs
-        liteScriptPath = path.resolve(__dirname, '../cli/lite.mjs');
-        await fs.access(liteScriptPath);
-      } catch {
-        // Fallback for development/testing when running from src/shared
-        liteScriptPath = path.resolve(__dirname, '../../dist/cli/lite.mjs');
-      }
+      // Continue searching
     }
   }
 
+  throw new Error(`Could not find compiled script: ${filename}`);
+}
+
+export async function getLiteScriptContent(): Promise<string> {
+  let liteScriptContent: string;
+  const liteScriptPath = await resolveCompiledScript('lite', import.meta.url);
+
   liteScriptContent = await fs.readFile(liteScriptPath, 'utf8');
 
   // Ensure it has the hashbang (if tsdown stripped it or if missing)

package/src/shared/policies.ts

@@ -3,6 +3,7 @@ export interface PolicyDefinition {
   command: string;
   args?: string[];
   allowHelp?: boolean;
+  autoApprove?: boolean;
 }
 
 export interface PolicyConfig {
@@ -21,4 +22,10 @@ export interface PolicyRequest {
   rejectionReason?: string;
   chatId: string;
   agentId: string;
+  subagentId?: string;
+  executionResult?: {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+  };
 }