clawmini 0.0.3 → 0.0.5

package/src/daemon/policy-request-service.ts

@@ -20,7 +20,9 @@ export class PolicyRequestService {
     args: string[],
     fileMappings: Record<string, string>,
     chatId: string,
-    agentId: string
+    agentId: string,
+    skipSave: boolean = false,
+    subagentId?: string
   ): Promise<PolicyRequest> {
     const allRequests = await this.store.list();
     const pendingCount = allRequests.filter((r) => r.state === 'Pending').length;
@@ -45,13 +47,16 @@ export class PolicyRequestService {
       commandName,
       args,
       fileMappings: snapshotMappings,
-      state: 'Pending',
+      state: skipSave ? 'Approved' : 'Pending',
       createdAt: Date.now(),
       chatId,
       agentId,
+      ...(subagentId ? { subagentId } : {}),
     };
 
-    await this.store.save(request);
+    if (!skipSave) {
+      await this.store.save(request);
+    }
 
     return request;
   }

package/src/daemon/policy-utils.ts

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { pathIsInsideDir } from '../shared/utils/fs.js';
-import type { PolicyRequest } from '../shared/policies.js';
+import type { PolicyRequest, PolicyDefinition } from '../shared/policies.js';
 
 export const MAX_SNAPSHOT_SIZE = 5 * 1024 * 1024;
 
@@ -127,6 +127,24 @@ export function executeSafe(
   });
 }
 
+export async function executeRequest(
+  request: PolicyRequest,
+  policy: PolicyDefinition,
+  cwd?: string
+): Promise<{ stdout: string; stderr: string; exitCode: number; commandStr: string }> {
+  const fullArgs = [...(policy.args || []), ...request.args];
+  const interpolatedArgs = interpolateArgs(fullArgs, request.fileMappings);
+
+  const { stdout, stderr, exitCode } = await executeSafe(
+    policy.command,
+    interpolatedArgs,
+    cwd ? { cwd } : undefined
+  );
+
+  const commandStr = `${policy.command} ${interpolatedArgs.join(' ')}`;
+  return { stdout, stderr, exitCode, commandStr };
+}
+
 export async function generateRequestPreview(request: PolicyRequest): Promise<string> {
   let previewContent = `Sandbox Policy Request: ${request.commandName}\n`;
   previewContent += `ID: ${request.id}\n`;

package/src/daemon/queue.ts

@@ -85,6 +85,22 @@ export class Queue<TPayload = string> {
 
     return extracted;
   }
+
+  interrupt(predicate?: (payload: TPayload) => boolean): TPayload[] {
+    const payloads: TPayload[] = [];
+
+    const currentMatches =
+      !predicate || (this.currentPayload !== undefined && predicate(this.currentPayload));
+    if (currentMatches && this.currentPayload !== undefined) {
+      payloads.push(this.currentPayload);
+    }
+
+    this.abortCurrent(predicate);
+
+    payloads.push(...this.extractPending(predicate));
+
+    return payloads;
+  }
 }
 
 export interface MessageQueuePayload {

package/src/daemon/request-store.test.ts

@@ -6,6 +6,10 @@ import path from 'path';
 import * as workspace from '../shared/workspace.js';
 
 vi.mock('../shared/workspace.js', () => ({
+  resolveAgentWorkDir: vi
+    .fn()
+    .mockImplementation((id, dir, root) => (dir ? `${root}/${dir}` : `${root}/${id}`)),
+
   getClawminiDir: vi.fn(),
 }));
 

package/src/daemon/routers/session-timeout.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createSessionTimeoutRouter } from './session-timeout.js';
+import type { RouterState } from './types.js';
+
+// Mock crypto.randomUUID to return a predictable value
+vi.mock('node:crypto', () => ({
+  randomUUID: () => 'mock-uuid',
+}));
+
+describe('sessionTimeoutRouter', () => {
+  it('refreshes the timeout job with default settings', () => {
+    const router = createSessionTimeoutRouter();
+    const initialState: RouterState = {
+      messageId: 'msg-1',
+      message: 'Hello!',
+      chatId: 'chat-1',
+      sessionId: 'session-123',
+    };
+
+    const nextState = router(initialState);
+
+    expect(nextState.nextSessionId).toBeUndefined(); // Should not modify current session
+    expect(nextState.jobs?.remove).toContain('__session_timeout__session-123');
+    expect(nextState.jobs?.add).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: '__session_timeout__session-123',
+          schedule: { at: '60m' },
+          message:
+            'This chat session has ended. Save any important details from it to your memory. When finished, reply with NO_REPLY_NECESSARY.',
+          reply: '[@clawmini/session-timeout] Starting a fresh session...',
+          nextSessionId: 'mock-uuid',
+          session: { type: 'existing', id: 'session-123' },
+          jobs: {
+            remove: ['__session_timeout__session-123'],
+          },
+        }),
+      ])
+    );
+  });
+
+  it('works correctly when sessionId is undefined', () => {
+    const router = createSessionTimeoutRouter();
+    const initialState: RouterState = {
+      messageId: 'msg-1',
+      message: 'Hello!',
+      chatId: 'chat-1',
+    };
+
+    const nextState = router(initialState);
+    const generatedSessionId = nextState.sessionId;
+
+    expect(generatedSessionId).toBeDefined();
+    expect(nextState.jobs?.remove).toContain(`__session_timeout__${generatedSessionId}`);
+    expect(nextState.jobs?.add).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: `__session_timeout__${generatedSessionId}`,
+          schedule: { at: '60m' },
+          message:
+            'This chat session has ended. Save any important details from it to your memory. When finished, reply with NO_REPLY_NECESSARY.',
+          reply: '[@clawmini/session-timeout] Starting a fresh session...',
+          nextSessionId: expect.any(String),
+          session: { type: 'existing', id: generatedSessionId },
+          env: { __SESSION_TIMEOUT__: 'true' },
+          jobs: {
+            remove: [`__session_timeout__${generatedSessionId}`],
+          },
+        }),
+      ])
+    );
+  });
+
+  it('respects custom timeout and prompt configuration', () => {
+    const router = createSessionTimeoutRouter({
+      timeout: '30m',
+      prompt: 'Custom prompt',
+    });
+    const initialState: RouterState = {
+      messageId: 'msg-2',
+      message: 'Hello again!',
+      chatId: 'chat-1',
+      sessionId: 'session-abc',
+    };
+
+    const nextState = router(initialState);
+
+    expect(nextState.jobs?.remove).toContain('__session_timeout__session-abc');
+    expect(nextState.jobs?.add).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: '__session_timeout__session-abc',
+          schedule: { at: '30m' },
+          message: 'Custom prompt',
+          reply: '[@clawmini/session-timeout] Starting a fresh session...',
+          nextSessionId: 'mock-uuid',
+          session: { type: 'existing', id: 'session-abc' },
+          env: { __SESSION_TIMEOUT__: 'true' },
+          jobs: {
+            remove: ['__session_timeout__session-abc'],
+          },
+        }),
+      ])
+    );
+  });
+
+  it('bypasses timeout job creation if currently executing a timeout', () => {
+    const router = createSessionTimeoutRouter();
+    const initialState: RouterState = {
+      messageId: 'msg-3',
+      message: 'Timeout prompt',
+      chatId: 'chat-1',
+      sessionId: 'session-xyz',
+      env: { __SESSION_TIMEOUT__: 'true' },
+      jobs: { remove: ['__session_timeout__session-xyz'] },
+    };
+
+    const nextState = router(initialState);
+
+    expect(nextState).toBe(initialState); // Returns exactly the same state without modifications
+  });
+});

package/src/daemon/routers/session-timeout.ts

@@ -0,0 +1,71 @@
+import type { RouterState } from './types.js';
+import { randomUUID } from 'node:crypto';
+
+export interface SessionTimeoutConfig {
+  timeout?: string;
+  prompt?: string;
+}
+
+/**
+ * Router that automatically starts a new session after a period of inactivity.
+ *
+ * To register this router, add it to your `~/.gemini/settings.json`:
+ * ```json
+ * {
+ *   "routers": [
+ *     {
+ *       "use": "session-timeout",
+ *       "with": {
+ *         "timeout": "60m",
+ *         "prompt": "This chat session has ended. Save any important details from it to your memory. When finished, reply with NO_REPLY_NECESSARY."
+ *       }
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+export function createSessionTimeoutRouter(config: SessionTimeoutConfig = {}) {
+  const timeStr = config.timeout ?? '60m';
+  const prompt =
+    config.prompt ??
+    'This chat session has ended. Save any important details from it to your memory. When finished, reply with NO_REPLY_NECESSARY.';
+
+  return function (state: RouterState): RouterState {
+    if (state.env?.__SESSION_TIMEOUT__ === 'true') {
+      return state;
+    }
+
+    const sessionId = state.sessionId || crypto.randomUUID();
+    const jobId = `__session_timeout__${sessionId}`;
+
+    const jobs = {
+      ...state.jobs,
+      remove: [...(state.jobs?.remove || []), jobId, '__session_timeout__'],
+    };
+
+    return {
+      ...state,
+      sessionId,
+      jobs: {
+        ...jobs,
+        add: [
+          ...(jobs.add || []),
+          // Add a job after the timeout that will send the prompt, reply to the user,
+          // start a fresh session, and delete the job
+          {
+            id: jobId,
+            schedule: { at: timeStr },
+            message: prompt,
+            reply: '[@clawmini/session-timeout] Starting a fresh session...',
+            nextSessionId: randomUUID(),
+            session: { type: 'existing', id: sessionId },
+            env: { __SESSION_TIMEOUT__: 'true' },
+            jobs: {
+              remove: [jobId],
+            },
+          },
+        ],
+      },
+    };
+  };
+}

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

@@ -3,10 +3,12 @@ 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();
+    const id = crypto.randomUUID();
     return {
       ...state,
       message: newMessage,
-      sessionId: crypto.randomUUID(),
+      sessionId: id,
+      nextSessionId: id,
       reply: '[@clawmini/slash-new] Starting a new session...',
     };
   }

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

@@ -3,7 +3,7 @@ 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 { executeRequest } from '../policy-utils.js';
 import { appendMessage } from '../chats.js';
 import type { PolicyRequest } from '../../shared/policies.js';
 
@@ -40,11 +40,11 @@ describe('slashPolicies', () => {
         },
       },
     });
-    vi.mocked(interpolateArgs).mockReturnValue(['hello', 'world']);
-    vi.mocked(executeSafe).mockResolvedValue({
+    vi.mocked(executeRequest).mockResolvedValue({
       stdout: 'hello world',
       stderr: '',
       exitCode: 0,
+      commandStr: 'echo hello world',
     });
   });
 
@@ -97,16 +97,19 @@ describe('slashPolicies', () => {
     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(mockStore.save).toHaveBeenCalledWith({
+      ...pendingReq,
+      state: 'Approved',
+      executionResult: { stdout: 'hello world', stderr: '', exitCode: 0 },
+    });
+    expect(executeRequest).toHaveBeenCalledWith(pendingReq, expect.any(Object), undefined);
     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,
+        role: 'system',
+        event: 'policy_approved',
+        displayRole: 'user',
+        content: expect.stringContaining('Request req-1 approved.'),
       })
     );
     expect(result.action).toBeUndefined();
@@ -139,13 +142,23 @@ describe('slashPolicies', () => {
       state: 'Rejected',
       rejectionReason: 'Not allowed',
     });
+    expect(appendMessage).toHaveBeenCalledTimes(2);
+    expect(appendMessage).toHaveBeenCalledWith(
+      'chat-1',
+      expect.objectContaining({
+        role: 'system',
+        event: 'policy_rejected',
+        displayRole: 'user',
+        content: 'Request req-1 rejected. Reason: Not allowed',
+      })
+    );
     expect(appendMessage).toHaveBeenCalledWith(
       'chat-1',
       expect.objectContaining({
-        role: 'log',
+        role: 'system',
+        event: 'policy_rejected',
+        displayRole: 'agent',
         content: 'Request req-1 rejected. Reason: Not allowed',
-        command: 'policy-request-reject req-1',
-        exitCode: 1,
       })
     );
     expect(result.action).toBeUndefined();

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

@@ -2,9 +2,9 @@ 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 { executeRequest } from '../policy-utils.js';
 import { appendMessage } from '../chats.js';
-import type { CommandLogMessage } from '../../shared/chats.js';
+import type { SystemMessage } from '../../shared/chats.js';
 
 async function loadAndValidateRequest(id: string, state: RouterState) {
   const store = new RequestStore(getWorkspaceRoot());
@@ -54,37 +54,32 @@ export async function slashPolicies(state: RouterState): Promise<RouterState> {
     }
 
     req.state = 'Approved';
-    await store.save(req);
 
-    const fullArgs = [...(policy.args || []), ...req.args];
-    const interpolatedArgs = interpolateArgs(fullArgs, req.fileMappings);
+    const { stdout, stderr, exitCode } = await executeRequest(req, policy, getWorkspaceRoot());
 
-    const { stdout, stderr, exitCode } = await executeSafe(policy.command, interpolatedArgs, {
-      cwd: getWorkspaceRoot(),
-    });
+    req.executionResult = { stdout, stderr, exitCode };
+    await store.save(req);
 
-    const commandStr = `${policy.command} ${interpolatedArgs.join(' ')}`;
-    const logMsg: CommandLogMessage = {
+    const agentMessage = `Request ${id} approved.\n\n${wrapInHtml('stdout', stdout)}\n\n${wrapInHtml('stderr', stderr)}\n\nExit Code: ${exitCode}`;
+
+    const logMsg: SystemMessage = {
       id: randomUUID(),
       messageId: state.messageId,
-      role: 'log',
-      source: 'router',
-      content: `Request ${id} approved and executed.`,
-      stderr,
-      stdout,
+      role: 'system',
+      event: 'policy_approved',
+      displayRole: 'user',
+      content: agentMessage,
       timestamp: new Date().toISOString(),
-      command: commandStr,
-      cwd: getWorkspaceRoot(),
-      exitCode,
+      ...(req.subagentId ? { subagentId: req.subagentId } : {}),
     };
 
     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}`,
+      ...(req.subagentId ? { subagentId: req.subagentId } : {}),
     };
   }
 
@@ -101,23 +96,38 @@ export async function slashPolicies(state: RouterState): Promise<RouterState> {
     req.rejectionReason = reason;
     await store.save(req);
 
-    const logMsg: CommandLogMessage = {
+    const agentMessage = `Request ${id} rejected. Reason: ${reason}`;
+
+    const logMsg: SystemMessage = {
       id: randomUUID(),
       messageId: state.messageId,
-      role: 'log',
-      source: 'router',
-      content: `Request ${id} rejected. Reason: ${reason}`,
-      stderr: '',
+      role: 'system',
+      event: 'policy_rejected',
+      displayRole: 'user',
+      content: agentMessage,
       timestamp: new Date().toISOString(),
-      command: `policy-request-reject ${id}`,
-      cwd: getWorkspaceRoot(),
-      exitCode: 1,
+      ...(req.subagentId ? { subagentId: req.subagentId } : {}),
+    };
+
+    const userNotificationMsg: SystemMessage = {
+      id: randomUUID(),
+      messageId: state.messageId,
+      role: 'system',
+      event: 'policy_rejected',
+      displayRole: 'agent',
+      content: agentMessage,
+      timestamp: new Date().toISOString(),
+      ...(req.subagentId ? { subagentId: req.subagentId } : {}),
     };
 
     await appendMessage(state.chatId, logMsg);
+    await appendMessage(state.chatId, userNotificationMsg);
 
-    const agentMessage = `Request ${id} rejected. Reason: ${reason}`;
-    return { ...state, message: agentMessage };
+    return {
+      ...state,
+      message: agentMessage,
+      ...(req.subagentId ? { subagentId: req.subagentId } : {}),
+    };
   }
 
   return state;

package/src/daemon/routers/types.ts

@@ -1,10 +1,18 @@
+import type { CronJob } from '../../shared/config.js';
+
 export interface RouterState {
   messageId: string;
   message: string;
   chatId: string;
   agentId?: string;
+  subagentId?: string;
   sessionId?: string;
+  nextSessionId?: string;
   env?: Record<string, string>;
   reply?: string;
   action?: 'stop' | 'interrupt' | 'continue';
+  jobs?: {
+    add?: CronJob[];
+    remove?: string[];
+  };
 }

package/src/daemon/routers.ts

@@ -5,18 +5,78 @@ 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';
+import { createSessionTimeoutRouter } from './routers/session-timeout.js';
+import type { RouterConfig } from '../shared/config.js';
+
+export const GLOBAL_ROUTERS: RouterConfig[] = ['@clawmini/session-timeout'];
+
+export const USER_ROUTERS: RouterConfig[] = [
+  '@clawmini/slash-new',
+  '@clawmini/slash-command',
+  '@clawmini/slash-stop',
+  '@clawmini/slash-interrupt',
+  '@clawmini/slash-policies',
+];
+
+export function resolveRouters(
+  userRouters: RouterConfig[],
+  isUserMessage: boolean
+): RouterConfig[] {
+  const resolvedGlobals: RouterConfig[] = [];
+  const resolvedUsers: RouterConfig[] = [];
+
+  const userConfigMap = new Map<string, unknown>();
+  for (const r of userRouters) {
+    const name = typeof r === 'string' ? r : r.use;
+    const config = typeof r === 'string' ? {} : r.with || {};
+
+    if (name.startsWith('@clawmini/')) {
+      userConfigMap.set(name, config);
+    } else {
+      resolvedUsers.push(r);
+    }
+  }
+
+  for (const globalRouter of GLOBAL_ROUTERS) {
+    const name = typeof globalRouter === 'string' ? globalRouter : globalRouter.use;
+    const baseConfig = typeof globalRouter === 'string' ? {} : globalRouter.with || {};
+    const userConfig = userConfigMap.get(name) || {};
+    const mergedConfig = { ...baseConfig, ...userConfig };
+
+    resolvedGlobals.push({ use: name, with: mergedConfig });
+  }
+
+  const defaultUserRouters: RouterConfig[] = [];
+  for (const defaultUserRouter of USER_ROUTERS) {
+    const name = typeof defaultUserRouter === 'string' ? defaultUserRouter : defaultUserRouter.use;
+    const baseConfig = typeof defaultUserRouter === 'string' ? {} : defaultUserRouter.with || {};
+    const userConfig = userConfigMap.get(name) || {};
+    const mergedConfig = { ...baseConfig, ...userConfig };
+
+    defaultUserRouters.push({ use: name, with: mergedConfig });
+  }
+
+  if (isUserMessage) {
+    return [...resolvedGlobals, ...defaultUserRouters, ...resolvedUsers];
+  } else {
+    return resolvedGlobals;
+  }
+}
 
 export async function executeRouterPipeline(
   initialState: RouterState,
-  routers: string[]
+  routers: RouterConfig[]
 ): Promise<RouterState> {
   let state = { ...initialState };
 
-  for (const router of routers) {
+  for (const routerDef of routers) {
     if (state.action === 'stop') {
       break;
     }
 
+    const router = typeof routerDef === 'string' ? routerDef : routerDef.use;
+    const config = typeof routerDef === 'string' ? {} : routerDef.with || {};
+
     if (router === '@clawmini/slash-new') {
       state = slashNew(state);
     } else if (router === '@clawmini/slash-command') {
@@ -27,6 +87,8 @@ export async function executeRouterPipeline(
       state = slashInterrupt(state);
     } else if (router === '@clawmini/slash-policies') {
       state = await slashPolicies(state);
+    } else if (router === '@clawmini/session-timeout') {
+      state = createSessionTimeoutRouter(config)(state);
     } else {
       // Execute as custom shell command
       try {

package/src/daemon/utils/spawn.ts

@@ -1,16 +1,14 @@
 import { spawn } from 'node:child_process';
-import type { RunCommandFn } from '../message.js';
+import type { RunCommandFn } from '../agent/types.js';
 
-export const runCommand: RunCommandFn &
-  ((
-    args: Parameters<RunCommandFn>[0] & { logToTerminal?: boolean }
-  ) => ReturnType<RunCommandFn>) = async ({
+const LOG_TO_TERMINAL = true;
+
+export const runCommand: 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 });
@@ -31,7 +29,7 @@ export const runCommand: RunCommandFn &
     if (p.stdout) {
       p.stdout.on('data', (data) => {
         stdout += data.toString();
-        if (logToTerminal && !stdin) {
+        if (LOG_TO_TERMINAL && !stdin) {
           process.stdout.write(data);
         }
       });
@@ -40,7 +38,7 @@ export const runCommand: RunCommandFn &
     if (p.stderr) {
       p.stderr.on('data', (data) => {
         stderr += data.toString();
-        if (logToTerminal && !stdin) {
+        if (LOG_TO_TERMINAL && !stdin) {
           process.stderr.write(data);
         }
       });