clawmini 0.0.1

package/src/daemon/routers/slash-command.ts

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { RouterState } from './types.js';
+import { getClawminiDir } from '../../shared/workspace.js';
+import { pathIsInsideDir } from '../../shared/utils/fs.js';
+
+export async function slashCommand(state: RouterState): Promise<RouterState> {
+  const commandsDir = path.resolve(getClawminiDir(), 'commands');
+  let currentMessage = state.message;
+
+  // Regex to match slash commands (e.g., /foo or /foo:bar) that appear as whole words.
+  // We use lookbehind and lookahead to ensure it's bounded by whitespace or string start/end.
+  const commandRegex = /(?<=^|\s)\/([a-zA-Z0-9_\-:.]+)(?=\s|$)/g;
+  const matches = [...currentMessage.matchAll(commandRegex)];
+
+  if (matches.length === 0) {
+    return state;
+  }
+
+  for (const match of matches) {
+    const fullMatch = match[0];
+    const commandName = match[1];
+    if (!commandName) continue;
+
+    const targetPathMd = path.resolve(commandsDir, `${commandName}.md`);
+    const targetPathTxt = path.resolve(commandsDir, `${commandName}.txt`);
+
+    // Strict path traversal protection
+    const baseTargetPath = path.resolve(commandsDir, commandName);
+    if (!pathIsInsideDir(baseTargetPath, commandsDir)) {
+      continue;
+    }
+
+    let content: string;
+
+    try {
+      content = await fs.readFile(targetPathMd, 'utf8');
+    } catch {
+      try {
+        content = await fs.readFile(targetPathTxt, 'utf8');
+      } catch {
+        // If file doesn't exist or can't be read, leave it as is.
+        continue;
+      }
+    }
+
+    // Replace the command with the content. We only replace the exact occurrence.
+    // Since replace replaces the first occurrence, and we are iterating over all matches,
+    // it should replace them sequentially. If there are multiple identical commands,
+    // it's fine, each will be replaced in turn.
+    currentMessage = currentMessage.replace(fullMatch, content.trim());
+  }
+
+  return {
+    ...state,
+    message: currentMessage,
+  };
+}

package/src/daemon/routers/slash-interrupt.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { slashInterrupt } from './slash-interrupt.js';
+import type { RouterState } from './types.js';
+
+describe('slashInterrupt', () => {
+  it('should not modify state if message does not start with /interrupt', () => {
+    const state: RouterState = { message: 'hello world', messageId: 'mock-msg-id', chatId: '123' };
+    const newState = slashInterrupt(state);
+    expect(newState).toEqual(state);
+  });
+
+  it('should set action to interrupt and reply if message is /interrupt', () => {
+    const state: RouterState = { message: '/interrupt', messageId: 'mock-msg-id', chatId: '123' };
+    const newState = slashInterrupt(state);
+    expect(newState.action).toBe('interrupt');
+    expect(newState.reply).toBe('Interrupting current task...');
+    expect(newState.message).toBe('');
+  });
+
+  it('should preserve remainder of message', () => {
+    const state: RouterState = {
+      message: '/interrupt extra text',
+      messageId: 'mock-msg-id',
+      chatId: '123',
+    };
+    const newState = slashInterrupt(state);
+    expect(newState.action).toBe('interrupt');
+    expect(newState.message).toBe('extra text');
+  });
+});

package/src/daemon/routers/slash-interrupt.ts

@@ -0,0 +1,7 @@
+import { createSlashActionRouter } from './utils.js';
+
+export const slashInterrupt = createSlashActionRouter(
+  'interrupt',
+  'interrupt',
+  'Interrupting current task...'
+);

package/src/daemon/routers/slash-new.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi } from 'vitest';
+import { slashNew } from './slash-new.js';
+
+vi.stubGlobal('crypto', { randomUUID: () => 'mock-uuid-1234' });
+
+describe('slashNew router', () => {
+  it('should remove /new from the beginning and set a new sessionId', () => {
+    const initialState = {
+      message: '/new hello world',
+      messageId: 'mock-msg-id',
+      chatId: 'test-chat',
+      sessionId: 'old-session',
+    };
+
+    const newState = slashNew(initialState);
+    expect(newState.message).toBe('hello world');
+    expect(newState.sessionId).toBe('mock-uuid-1234');
+    expect(newState.chatId).toBe('test-chat');
+  });
+
+  it('should handle /new by itself', () => {
+    const initialState = {
+      message: '/new',
+      messageId: 'mock-msg-id',
+      chatId: 'test-chat',
+      sessionId: 'old-session',
+    };
+
+    const newState = slashNew(initialState);
+    expect(newState.message).toBe('');
+    expect(newState.sessionId).toBe('mock-uuid-1234');
+  });
+
+  it('should do nothing if /new is not at the start', () => {
+    const initialState = {
+      message: 'hello /new world',
+      messageId: 'mock-msg-id',
+      chatId: 'test-chat',
+      sessionId: 'old-session',
+    };
+
+    const newState = slashNew(initialState);
+    expect(newState.message).toBe('hello /new world');
+    expect(newState.sessionId).toBe('old-session');
+  });
+
+  it('should do nothing if the message just starts with /newly', () => {
+    const initialState = {
+      message: '/newly minted',
+      messageId: 'mock-msg-id',
+      chatId: 'test-chat',
+      sessionId: 'old-session',
+    };
+
+    const newState = slashNew(initialState);
+    expect(newState.message).toBe('/newly minted');
+    expect(newState.sessionId).toBe('old-session');
+  });
+});

package/src/daemon/routers/slash-new.ts

@@ -0,0 +1,14 @@
+import type { RouterState } from './types.js';
+
+export function slashNew(state: RouterState): RouterState {
+  if (/^\/new(\s|$)/.test(state.message)) {
+    const newMessage = state.message.replace(/^\/new(\s+|$)/, '').trim();
+    return {
+      ...state,
+      message: newMessage,
+      sessionId: crypto.randomUUID(),
+      reply: '[@clawmini/slash-new] Starting a new session...',
+    };
+  }
+  return state;
+}

package/src/daemon/routers/slash-policies.test.ts

@@ -0,0 +1,167 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { slashPolicies } from './slash-policies.js';
+import { RequestStore } from '../request-store.js';
+import { readPolicies } from '../../shared/workspace.js';
+import { executeSafe, interpolateArgs } from '../policy-utils.js';
+import { appendMessage } from '../chats.js';
+import type { PolicyRequest } from '../../shared/policies.js';
+
+vi.mock('../request-store.js');
+vi.mock('../../shared/workspace.js');
+vi.mock('../policy-utils.js');
+vi.mock('../chats.js');
+vi.mock('node:crypto', () => ({
+  randomUUID: vi.fn(() => 'mock-uuid'),
+}));
+
+describe('slashPolicies', () => {
+  let mockStore: any;
+
+  beforeEach(() => {
+    mockStore = {
+      list: vi.fn(),
+      load: vi.fn(),
+      save: vi.fn(),
+    };
+    vi.mocked(RequestStore).mockImplementation(function (this: any) {
+      this.list = mockStore.list;
+      this.load = mockStore.load;
+      this.save = mockStore.save;
+      return this;
+    } as any);
+
+    vi.mocked(appendMessage).mockResolvedValue(undefined);
+    vi.mocked(readPolicies).mockResolvedValue({
+      policies: {
+        'test-cmd': {
+          command: 'echo',
+          args: ['hello'],
+        },
+      },
+    });
+    vi.mocked(interpolateArgs).mockReturnValue(['hello', 'world']);
+    vi.mocked(executeSafe).mockResolvedValue({
+      stdout: 'hello world',
+      stderr: '',
+      exitCode: 0,
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should ignore non-matching messages', async () => {
+    const state = { message: 'hello world', messageId: 'mock-msg-id', chatId: 'chat-1' };
+    const result = await slashPolicies(state);
+    expect(result).toEqual(state);
+  });
+
+  it('should list pending requests on /pending', async () => {
+    const pendingReq: PolicyRequest = {
+      id: 'req-1',
+      commandName: 'test-cmd',
+      args: ['world'],
+      fileMappings: {},
+      state: 'Pending',
+      createdAt: Date.now(),
+      chatId: 'chat-1',
+      agentId: 'agent-1',
+    };
+    const approvedReq: PolicyRequest = { ...pendingReq, id: 'req-2', state: 'Approved' };
+    mockStore.list.mockResolvedValue([pendingReq, approvedReq]);
+
+    const state = { message: '/pending', messageId: 'mock-msg-id', chatId: 'chat-1' };
+    const result = await slashPolicies(state);
+
+    expect(result.action).toBe('stop');
+    expect(result.reply).toContain('Pending Requests (1):');
+    expect(result.reply).toContain('- ID: req-1 | Command: test-cmd world');
+    expect(result.reply).not.toContain('req-2');
+  });
+
+  it('should approve a pending request on /approve, execute it, and inject feedback', async () => {
+    const pendingReq: PolicyRequest = {
+      id: 'req-1',
+      commandName: 'test-cmd',
+      args: ['world'],
+      fileMappings: {},
+      state: 'Pending',
+      createdAt: Date.now(),
+      chatId: 'chat-1',
+      agentId: 'agent-1',
+    };
+    mockStore.load.mockResolvedValue(pendingReq);
+
+    const state = { message: '/approve req-1', messageId: 'mock-msg-id', chatId: 'chat-1' };
+    const result = await slashPolicies(state);
+
+    expect(mockStore.save).toHaveBeenCalledWith({ ...pendingReq, state: 'Approved' });
+    expect(executeSafe).toHaveBeenCalledWith('echo', ['hello', 'world'], expect.any(Object));
+    expect(appendMessage).toHaveBeenCalledWith(
+      'chat-1',
+      expect.objectContaining({
+        role: 'log',
+        content: 'Request req-1 approved and executed.',
+        command: 'echo hello world',
+        stdout: 'hello world',
+        exitCode: 0,
+      })
+    );
+    expect(result.action).toBeUndefined();
+    expect(result.message).toContain('Request req-1 approved.');
+    expect(result.message).toContain('<stdout>\nhello world\n</stdout>');
+  });
+
+  it('should reject a pending request on /reject with reason and inject feedback', async () => {
+    const pendingReq: PolicyRequest = {
+      id: 'req-1',
+      commandName: 'test-cmd',
+      args: [],
+      fileMappings: {},
+      state: 'Pending',
+      createdAt: Date.now(),
+      chatId: 'chat-1',
+      agentId: 'agent-1',
+    };
+    mockStore.load.mockResolvedValue(pendingReq);
+
+    const state = {
+      message: '/reject req-1 Not allowed',
+      messageId: 'mock-msg-id',
+      chatId: 'chat-1',
+    };
+    const result = await slashPolicies(state);
+
+    expect(mockStore.save).toHaveBeenCalledWith({
+      ...pendingReq,
+      state: 'Rejected',
+      rejectionReason: 'Not allowed',
+    });
+    expect(appendMessage).toHaveBeenCalledWith(
+      'chat-1',
+      expect.objectContaining({
+        role: 'log',
+        content: 'Request req-1 rejected. Reason: Not allowed',
+        command: 'policy-request-reject req-1',
+        exitCode: 1,
+      })
+    );
+    expect(result.action).toBeUndefined();
+    expect(result.message).toBe('Request req-1 rejected. Reason: Not allowed');
+  });
+
+  it('should not act if request is not found', async () => {
+    mockStore.load.mockResolvedValue(null);
+
+    const state = { message: '/approve req-1', messageId: 'mock-msg-id', chatId: 'chat-1' };
+    const result = await slashPolicies(state);
+
+    expect(mockStore.save).not.toHaveBeenCalled();
+    expect(appendMessage).not.toHaveBeenCalled();
+    expect(result.action).toBeUndefined();
+    expect(result.message).toBe('');
+    expect(result.reply).toBe('Request not found: req-1');
+  });
+});

package/src/daemon/routers/slash-policies.ts

@@ -0,0 +1,131 @@
+import { randomUUID } from 'node:crypto';
+import type { RouterState } from './types.js';
+import { RequestStore } from '../request-store.js';
+import { readPolicies, getWorkspaceRoot } from '../../shared/workspace.js';
+import { executeSafe, interpolateArgs } from '../policy-utils.js';
+import { appendMessage } from '../chats.js';
+import type { CommandLogMessage } from '../../shared/chats.js';
+
+async function loadAndValidateRequest(id: string, state: RouterState) {
+  const store = new RequestStore(getWorkspaceRoot());
+  const req = await store.load(id);
+  if (!req) return { error: { ...state, message: '', reply: `Request not found: ${id}` } };
+  if (req.chatId && req.chatId !== state.chatId)
+    return {
+      error: { ...state, message: '', reply: `Request belongs to a different chat: ${req.chatId}` },
+    };
+  if (req.state !== 'Pending')
+    return { error: { ...state, message: '', reply: `Request is not pending: ${id}` } };
+  return { req, store };
+}
+
+export async function slashPolicies(state: RouterState): Promise<RouterState> {
+  const message = state.message.trim();
+
+  if (message === '/pending') {
+    const store = new RequestStore(getWorkspaceRoot());
+    const requests = await store.list();
+    const pending = requests.filter((r) => r.state === 'Pending');
+
+    let reply = `Pending Requests (${pending.length}):\n`;
+    for (const req of pending) {
+      reply += `- ID: ${req.id} | Command: ${req.commandName} ${req.args.join(' ')}\n`;
+    }
+
+    return {
+      ...state,
+      reply,
+      action: 'stop',
+    };
+  }
+
+  const approveMatch = message.match(/^\/approve\s+([^\s]+)/);
+  if (approveMatch) {
+    const id = approveMatch[1];
+    if (!id) return state;
+    const { req, store, error } = await loadAndValidateRequest(id, state);
+    if (error) return error;
+    if (!req || !store) return state; // Should not happen if error is undefined
+
+    const config = await readPolicies();
+    const policy = config?.policies?.[req.commandName];
+    if (!policy) {
+      return { ...state, message: '', reply: `Policy not found: ${req.commandName}` };
+    }
+
+    req.state = 'Approved';
+    await store.save(req);
+
+    const fullArgs = [...(policy.args || []), ...req.args];
+    const interpolatedArgs = interpolateArgs(fullArgs, req.fileMappings);
+
+    const { stdout, stderr, exitCode } = await executeSafe(policy.command, interpolatedArgs, {
+      cwd: getWorkspaceRoot(),
+    });
+
+    const commandStr = `${policy.command} ${interpolatedArgs.join(' ')}`;
+    const logMsg: CommandLogMessage = {
+      id: randomUUID(),
+      messageId: state.messageId,
+      role: 'log',
+      source: 'router',
+      content: `Request ${id} approved and executed.`,
+      stderr,
+      stdout,
+      timestamp: new Date().toISOString(),
+      command: commandStr,
+      cwd: getWorkspaceRoot(),
+      exitCode,
+    };
+
+    await appendMessage(state.chatId, logMsg);
+
+    const agentMessage = `Request ${id} approved.\n\n${wrapInHtml('stdout', stdout)}\n\n${wrapInHtml('stderr', stderr)}\n\nExit Code: ${exitCode}`;
+    return {
+      ...state,
+      message: agentMessage,
+      reply: `Approved request, running ${req.commandName}`,
+    };
+  }
+
+  const rejectMatch = message.match(/^\/reject\s+([^\s]+)(?:\s+(.*))?/);
+  if (rejectMatch) {
+    const id = rejectMatch[1];
+    if (!id) return state;
+    const reason = rejectMatch[2] || 'No reason provided';
+    const { req, store, error } = await loadAndValidateRequest(id, state);
+    if (error) return error;
+    if (!req || !store) return state; // Should not happen if error is undefined
+
+    req.state = 'Rejected';
+    req.rejectionReason = reason;
+    await store.save(req);
+
+    const logMsg: CommandLogMessage = {
+      id: randomUUID(),
+      messageId: state.messageId,
+      role: 'log',
+      source: 'router',
+      content: `Request ${id} rejected. Reason: ${reason}`,
+      stderr: '',
+      timestamp: new Date().toISOString(),
+      command: `policy-request-reject ${id}`,
+      cwd: getWorkspaceRoot(),
+      exitCode: 1,
+    };
+
+    await appendMessage(state.chatId, logMsg);
+
+    const agentMessage = `Request ${id} rejected. Reason: ${reason}`;
+    return { ...state, message: agentMessage };
+  }
+
+  return state;
+}
+
+function wrapInHtml(tag: string, text: string): string {
+  if (text.trim().length === 0) {
+    return `<${tag}></${tag}>`;
+  }
+  return `<${tag}>\n${text.trim()}\n</${tag}>`;
+}

package/src/daemon/routers/slash-stop.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { slashStop } from './slash-stop.js';
+import type { RouterState } from './types.js';
+
+describe('slashStop', () => {
+  it('should not modify state if message does not start with /stop', () => {
+    const state: RouterState = { message: 'hello world', messageId: 'mock-msg-id', chatId: '123' };
+    const newState = slashStop(state);
+    expect(newState).toEqual(state);
+  });
+
+  it('should set action to stop and reply if message is /stop', () => {
+    const state: RouterState = { message: '/stop', messageId: 'mock-msg-id', chatId: '123' };
+    const newState = slashStop(state);
+    expect(newState.action).toBe('stop');
+    expect(newState.reply).toBe('Stopping current task...');
+    expect(newState.message).toBe('');
+  });
+
+  it('should preserve remainder of message', () => {
+    const state: RouterState = {
+      message: '/stop extra text',
+      messageId: 'mock-msg-id',
+      chatId: '123',
+    };
+    const newState = slashStop(state);
+    expect(newState.action).toBe('stop');
+    expect(newState.message).toBe('extra text');
+  });
+});

package/src/daemon/routers/slash-stop.ts

@@ -0,0 +1,3 @@
+import { createSlashActionRouter } from './utils.js';
+
+export const slashStop = createSlashActionRouter('stop', 'stop', 'Stopping current task...');

package/src/daemon/routers/types.ts

@@ -0,0 +1,10 @@
+export interface RouterState {
+  messageId: string;
+  message: string;
+  chatId: string;
+  agentId?: string;
+  sessionId?: string;
+  env?: Record<string, string>;
+  reply?: string;
+  action?: 'stop' | 'interrupt' | 'continue';
+}

package/src/daemon/routers/utils.ts

@@ -0,0 +1,22 @@
+import type { RouterState } from './types.js';
+
+export function createSlashActionRouter(
+  command: string,
+  action: NonNullable<RouterState['action']>,
+  replyMessage: string
+) {
+  return function (state: RouterState): RouterState {
+    const regex = new RegExp(`^\\/${command}(\\s|$)`);
+    if (regex.test(state.message)) {
+      const replaceRegex = new RegExp(`^\\/${command}(\\s+|$)`);
+      const newMessage = state.message.replace(replaceRegex, '').trim();
+      return {
+        ...state,
+        message: newMessage,
+        action,
+        reply: replyMessage,
+      };
+    }
+    return state;
+  };
+}

package/src/daemon/routers.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { executeRouterPipeline } from './routers.js';
+import type { RouterState } from './routers/types.js';
+
+vi.mock('./routers/slash-new.js', () => ({
+  slashNew: vi.fn((state: RouterState) => ({ ...state, message: 'slash-new-called' })),
+}));
+
+vi.mock('./routers/slash-command.js', () => ({
+  slashCommand: vi.fn(async (state: RouterState) => ({
+    ...state,
+    message: 'slash-command-called',
+  })),
+}));
+
+vi.mock('./routers/slash-stop.js', () => ({
+  slashStop: vi.fn((state: RouterState) => ({ ...state, action: 'stop' })),
+}));
+
+vi.mock('./routers/slash-interrupt.js', () => ({
+  slashInterrupt: vi.fn((state: RouterState) => ({ ...state, action: 'interrupt' })),
+}));
+
+vi.mock('./routers/slash-policies.js', () => ({
+  slashPolicies: vi.fn(async (state: RouterState) => state),
+}));
+
+describe('Router Pipeline Execution', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should pass state unchanged when no routers are provided', async () => {
+    const initialState: RouterState = {
+      message: 'hello',
+      messageId: 'mock-msg-id',
+      chatId: 'chat-1',
+    };
+    const finalState = await executeRouterPipeline(initialState, []);
+    expect(finalState).toEqual(initialState);
+  });
+
+  it('should call built-in @clawmini/slash-new router', async () => {
+    const initialState: RouterState = {
+      message: 'hello',
+      messageId: 'mock-msg-id',
+      chatId: 'chat-1',
+    };
+    const finalState = await executeRouterPipeline(initialState, ['@clawmini/slash-new']);
+    expect(finalState.message).toBe('slash-new-called');
+    expect(finalState.chatId).toBe('chat-1');
+  });
+
+  it('should call built-in @clawmini/slash-command router', async () => {
+    const initialState: RouterState = {
+      message: 'hello',
+      messageId: 'mock-msg-id',
+      chatId: 'chat-1',
+    };
+    const finalState = await executeRouterPipeline(initialState, ['@clawmini/slash-command']);
+    expect(finalState.message).toBe('slash-command-called');
+  });
+
+  it('should call built-in @clawmini/slash-stop router', async () => {
+    const initialState: RouterState = {
+      message: 'hello',
+      messageId: 'mock-msg-id',
+      chatId: 'chat-1',
+    };
+    const finalState = await executeRouterPipeline(initialState, ['@clawmini/slash-stop']);
+    expect(finalState.action).toBe('stop');
+  });
+
+  it('should call built-in @clawmini/slash-interrupt router', async () => {
+    const initialState: RouterState = {
+      message: 'hello',
+      messageId: 'mock-msg-id',
+      chatId: 'chat-1',
+    };
+    const finalState = await executeRouterPipeline(initialState, ['@clawmini/slash-interrupt']);
+    expect(finalState.action).toBe('interrupt');
+  });
+
+  it('should execute custom shell command router and merge state correctly', async () => {
+    const initialState: RouterState = {
+      message: 'hello',
+      messageId: 'mock-msg-id',
+      chatId: 'chat-1',
+      env: { FOO: 'bar' },
+    };
+
+    // Command that parses stdin and outputs a modified JSON object
+    const command = `node -e "
+      let input = ''; 
+      process.stdin.on('data', d => input += d); 
+      process.stdin.on('end', () => { 
+        const data = JSON.parse(input); 
+        console.log(JSON.stringify({ 
+          message: data.message + ' world', 
+          agent: 'new-agent', 
+          session: 'new-session', 
+          env: { BAZ: 'qux' }, 
+          reply: 'Custom router reply' 
+        })); 
+      }); 
+    "`;
+
+    const finalState = await executeRouterPipeline(initialState, [command]);
+
+    expect(finalState.message).toBe('hello world');
+    expect(finalState.agentId).toBe('new-agent');
+    expect(finalState.sessionId).toBe('new-session');
+    expect(finalState.env).toEqual({ FOO: 'bar', BAZ: 'qux' });
+    expect(finalState.reply).toBe('Custom router reply');
+    expect(finalState.chatId).toBe('chat-1'); // Unchanged
+  });
+
+  it('should handle silent failure of custom shell command router', async () => {
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const initialState: RouterState = {
+      message: 'hello',
+      messageId: 'mock-msg-id',
+      chatId: 'chat-1',
+    };
+
+    // Command that intentionally fails with a non-zero exit code
+    const command = `node -e "process.exit(1);"`;
+
+    const finalState = await executeRouterPipeline(initialState, [command]);
+
+    // State should remain unchanged
+    expect(finalState).toEqual(initialState);
+
+    // The error should have been logged
+    expect(consoleErrorSpy).toHaveBeenCalled();
+  });
+});