clawmini 0.0.1 → 0.0.3

package/docs/guides/sandbox_policies.md

@@ -1,10 +1,10 @@
-# Sandbox Policies Guide
+# Configuring Permission Requests
 
 The Sandbox Policies feature provides a secure framework for AI agents operating within restricted sandbox environments to request and execute sensitive or network-dependent operations. Using a formal "request-and-approve" workflow, users retain full control via their chat interface while agents gain the ability to perform complex, privileged tasks like sending emails or promoting files to external systems.
 
 ## Registering a Policy
 
-Policies are configured centrally in a JSON file located at `.clawmini/policies.json`. This configuration maps an easy-to-use policy command name to the actual script or binary you want to run when the request is approved. 
+Policies are configured centrally in a JSON file located at `.clawmini/policies.json`. This configuration maps an easy-to-use policy command name to the actual script or binary you want to run when the request is approved.
 
 The framework treats the command execution as a "dumb pipe". It executes the specified script using a secure execution wrapper (bypassing the shell to prevent injection attacks) and interpolates safe, verified file paths.
 
@@ -33,15 +33,18 @@ Agents running within their environment can interact with the Policies feature u
 
 1. **Discovery:**
    Agents can view available policies and their descriptions:
+
    ```bash
    clawmini-lite requests list
    ```
 
 2. **Help Documentation:**
    If a policy is configured with `"allowHelp": true`, agents can query it for help. This securely passes the `--help` flag to the underlying wrapper command and returns the output to the agent:
+
    ```bash
    clawmini-lite request send-email --help
    ```
+
    If `"allowHelp"` is missing or set to `false`, the agent will receive an error stating that `--help` is not supported.
 
 3. **Submitting a Request:**
@@ -58,19 +61,23 @@ When an agent creates a request, the daemon intercepts it and sends a preview me
 You can then review and interact with the pending request using the following slash commands in your chat:
 
 - **List Pending Requests:**
+
   ```text
   /pending
   ```
-  *Lists all active pending requests that need review.*
+
+  _Lists all active pending requests that need review._
 
 - **Approve a Request:**
+
   ```text
   /approve <request_id>
   ```
-  *Approves the request. The configured script executes securely, and the STDOUT/STDERR results are automatically sent back to the agent in the chat.*
+
+  _Approves the request. The configured script executes securely, and the STDOUT/STDERR results are automatically sent back to the agent in the chat._
 
 - **Reject a Request:**
   ```text
   /reject <request_id> [reason]
   ```
-  *Rejects the request. You can provide an optional natural language reason (e.g., `/reject 123 Tone needs to be more formal`) to help the agent correct its output and try again.*
+  _Rejects the request. You can provide an optional natural language reason (e.g., `/reject 123 Tone needs to be more formal`) to help the agent correct its output and try again._

package/eslint.config.js

@@ -34,6 +34,17 @@ export default defineConfig([
     rules: {
       '@typescript-eslint/no-explicit-any': 'warn',
       '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'ImportExpression',
+          message: 'Dynamic imports are not allowed. Please use top-level imports.',
+        },
+        {
+          selector: 'TSImportType',
+          message: 'Inline type imports are not allowed. Please use top-level imports.',
+        },
+      ],
       'max-lines': ['error', { max: 300, skipBlankLines: true, skipComments: true }],
     },
   },
@@ -41,6 +52,7 @@ export default defineConfig([
     files: ['**/*.test.ts', '**/*.spec.ts'],
     rules: {
       'max-lines': 'off',
+      'no-restricted-syntax': 'off',
     },
   },
   eslintConfigPrettier,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmini",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "workspaces": [
     "web"
@@ -24,7 +24,8 @@
     "format": "prettier --write \"src/**/*.ts\" \"web/src/**/*.ts\"",
     "check": "tsc --noEmit && npm run check -w web",
     "test": "vitest run && npm run test -w web",
-    "build:web": "npm run build -w web"
+    "build:web": "npm run build -w web",
+    "validate": "npm run format:check && npm run lint && npm run check && npm run test"
   },
   "dependencies": {
     "@trpc/client": "^11.12.0",

package/src/adapter-discord/client.ts

@@ -1,5 +1,5 @@
 import { createTRPCClient, httpLink, splitLink, httpSubscriptionLink } from '@trpc/client';
-import type { AppRouter } from '../daemon/router.js';
+import type { UserRouter as AppRouter } from '../daemon/api/index.js';
 import { getSocketPath } from '../shared/workspace.js';
 import { createUnixSocketFetch } from '../shared/fetch.js';
 import { createUnixSocketEventSource } from '../shared/event-source.js';

package/src/adapter-discord/index.ts

@@ -4,6 +4,7 @@ import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
 import { readDiscordConfig, isAuthorized, initDiscordConfig } from './config.js';
 import { getTRPCClient } from './client.js';
 import { startDaemonToDiscordForwarder } from './forwarder.js';
+import { getClawminiDir } from '../shared/workspace.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
@@ -62,7 +63,6 @@ export async function main() {
 
     const downloadedFiles: string[] = [];
     if (message.attachments.size > 0) {
-      const { getClawminiDir } = await import('../shared/workspace.js');
       const tmpDir = path.join(getClawminiDir(process.cwd()), 'tmp', 'discord');
       await fs.mkdir(tmpDir, { recursive: true });
       const maxSizeMB = config.maxAttachmentSizeMB ?? 25;
@@ -141,7 +141,24 @@ export async function main() {
   }
 }
 
-main().catch((error) => {
-  console.error('Unhandled error in Discord Adapter:', error);
-  process.exit(1);
-});
+import { fileURLToPath } from 'node:url';
+
+const isMainModule = (() => {
+  try {
+    if (typeof process === 'undefined' || !process.argv || process.argv.length < 2) return false;
+    const argv1 = process.argv[1];
+    if (!argv1) return false;
+    const p1 = path.resolve(argv1);
+    const p2 = path.resolve(fileURLToPath(import.meta.url));
+    return p1 === p2;
+  } catch {
+    return false;
+  }
+})();
+
+if (isMainModule) {
+  main().catch((error) => {
+    console.error('Unhandled error in Discord Adapter:', error);
+    process.exit(1);
+  });
+}

package/src/cli/client.ts

@@ -1,5 +1,5 @@
 import { createTRPCClient, httpLink } from '@trpc/client';
-import type { AppRouter } from '../daemon/router.js';
+import type { UserRouter as AppRouter } from '../daemon/api/index.js';
 import { getSocketPath, getClawminiDir } from '../shared/workspace.js';
 import { createUnixSocketFetch } from '../shared/fetch.js';
 import { spawn } from 'node:child_process';
@@ -27,8 +27,13 @@ export async function getDaemonClient(options: { autoStart?: boolean } = {}) {
     });
     child.unref();
 
-    // Wait a moment for the daemon to start and create the socket
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    // Wait up to 5 seconds for the daemon to start and create the socket
+    for (let i = 0; i < 50; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      if (fs.existsSync(socketPath)) {
+        break;
+      }
+    }
 
     if (!fs.existsSync(socketPath)) {
       throw new Error('Failed to start daemon.');

package/src/cli/e2e/adapter-discord.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import path from 'node:path';
 import { createE2EContext } from './utils.js';
 import { getTRPCClient } from '../../adapter-discord/client.js';
+import { getSocketPath } from '../../shared/workspace.js';
 
 const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-discord');
 describe('Discord Adapter Client E2E', () => {
@@ -17,7 +17,7 @@ describe('Discord Adapter Client E2E', () => {
   }, 30000);
 
   it('should successfully connect to the daemon and subscribe to messages', async () => {
-    const socketPath = path.join(e2eDir, '.clawmini', 'server.sock');
+    const socketPath = getSocketPath(e2eDir);
     const trpc = getTRPCClient({ socketPath });
 
     const pingResult = await trpc.ping.query();

package/src/cli/e2e/daemon.test.ts

@@ -3,6 +3,7 @@ import { spawn } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import type { ChatMessage } from '../../shared/chats.js';
+import { getSocketPath } from '../../shared/workspace.js';
 import { createE2EContext } from './utils.js';
 
 const { runCli, e2eDir, binPath, setupE2E, teardownE2E } = createE2EContext('e2e-tmp-daemon');
@@ -31,7 +32,7 @@ describe('E2E Daemon and Web Tests', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 500));
 
-    const socketPath = path.resolve(e2eDir, '.clawmini/daemon.sock');
+    const socketPath = getSocketPath(e2eDir);
     expect(fs.existsSync(socketPath)).toBe(false);
 
     const { stdout: stdoutAgain, code: codeAgain } = await runCli(['down']);

package/src/cli/e2e/export-lite-func.test.ts

@@ -105,18 +105,7 @@ describe('E2E Export Lite Functionality Tests', () => {
     // 2. Test jobs add
     const addProcess = spawn(
       'node',
-      [
-        litePath,
-        'jobs',
-        'add',
-        'lite-job',
-        '--cron',
-        '* * * * *',
-        '--message',
-        'lite message',
-        '--chat',
-        'lite-chat',
-      ],
+      [litePath, 'jobs', 'add', 'lite-job', '--cron', '* * * * *', '--message', 'lite message'],
       {
         env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
       }
@@ -139,7 +128,7 @@ describe('E2E Export Lite Functionality Tests', () => {
     expect(listStdout).toContain('* * * * *');
 
     // 4. Test jobs delete
-    const delProcess = spawn('node', [litePath, 'jobs', 'delete', 'lite-job', '-c', 'lite-chat'], {
+    const delProcess = spawn('node', [litePath, 'jobs', 'delete', 'lite-job'], {
       env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
     });
     let delStdout = '';
@@ -148,6 +137,45 @@ describe('E2E Export Lite Functionality Tests', () => {
     await new Promise((resolve) => delProcess.on('close', resolve));
     expect(delStdout).toContain("Job 'lite-job' deleted successfully.");
 
+    // 5. Test fetch-pending
+    const sleeperAgentDir = path.resolve(e2eDir, 'sleeper');
+    fs.mkdirSync(sleeperAgentDir, { recursive: true });
+    await runCli(['agents', 'add', 'sleeper', '--dir', 'sleeper']);
+    const sleeperSettings = path.resolve(e2eDir, '.clawmini/agents/sleeper/settings.json');
+    fs.mkdirSync(path.dirname(sleeperSettings), { recursive: true });
+    const sleepCommand =
+      process.platform === 'win32' ? 'node -e "setTimeout(() => {}, 5000)"' : 'sleep 5';
+    fs.writeFileSync(sleeperSettings, JSON.stringify({ commands: { new: sleepCommand } }));
+
+    await runCli(['chats', 'add', 'sleep-chat']);
+    // Start the sleeper agent to block the queue
+    await runCli([
+      'messages',
+      'send',
+      'block queue',
+      '--chat',
+      'sleep-chat',
+      '--agent',
+      'sleeper',
+      '--no-wait',
+    ]);
+
+    // Send a pending message that will be queued
+    await runCli(['messages', 'send', 'my pending message', '--chat', 'sleep-chat', '--no-wait']);
+
+    // Fetch the pending message
+    const fetchProcess = spawn('node', [litePath, 'fetch-pending'], {
+      env: { ...process.env, CLAW_API_URL: envUrl, CLAW_API_TOKEN: envToken },
+    });
+    let fetchStdout = '';
+    fetchProcess.stdout.on('data', (d) => (fetchStdout += d.toString()));
+    fetchProcess.stderr.on('data', (d) => (fetchStdout += d.toString()));
+    await new Promise((resolve) => fetchProcess.on('close', resolve));
+
+    expect(fetchStdout).toContain('<message>');
+    expect(fetchStdout).toContain('my pending message');
+    expect(fetchStdout).toContain('</message>');
+
     await runCli(['down']);
     fs.writeFileSync(settingsPath, originalSettings);
     await runCli(['up']);

package/src/cli/e2e/fallbacks.test.ts

@@ -40,6 +40,7 @@ describe('E2E Fallbacks Tests', () => {
     const lines = chatLog
       .trim()
       .split('\n')
+      .filter((l) => l.trim().length > 0)
       .map((l) => JSON.parse(l));
 
     // Lines: USER, LOG (retry-delay), LOG (success)
@@ -80,6 +81,7 @@ describe('E2E Fallbacks Tests', () => {
     const lines = chatLog
       .trim()
       .split('\n')
+      .filter((l) => l.trim().length > 0)
       .map((l) => JSON.parse(l));
 
     const lastLog = lines[lines.length - 1];
@@ -125,6 +127,7 @@ describe('E2E Fallbacks Tests', () => {
     const lines = chatLog
       .trim()
       .split('\n')
+      .filter((l) => l.trim().length > 0)
       .map((l) => JSON.parse(l));
 
     expect(
@@ -160,6 +163,7 @@ describe('E2E Fallbacks Tests', () => {
     const lines = chatLog
       .trim()
       .split('\n')
+      .filter((l) => l.trim().length > 0)
       .map((l) => JSON.parse(l));
 
     const lastLog = lines[lines.length - 1];

package/src/cli/lite.ts

@@ -2,7 +2,7 @@
 
 import { Command } from 'commander';
 import { createTRPCClient, httpLink } from '@trpc/client';
-import type { AppRouter } from '../daemon/router.js';
+import type { AgentRouter as AppRouter } from '../daemon/api/index.js';
 import type { CronJob } from '../shared/config.js';
 
 /**
@@ -64,6 +64,25 @@ program
     }
   });
 
+program
+  .command('fetch-pending')
+  .description('Fetch pending messages and output them as formatted strings')
+  .action(async () => {
+    try {
+      const client = getClient();
+      const result = await client.fetchPendingMessages.mutate();
+      if (result && result.messages) {
+        process.stdout.write(result.messages);
+        if (!result.messages.endsWith('\n')) {
+          process.stdout.write('\n');
+        }
+      }
+    } catch (err) {
+      console.error('Error:', err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+
 const jobs = program.command('jobs').description('Manage cron jobs');
 
 jobs
@@ -72,7 +91,7 @@ jobs
   .action(async () => {
     try {
       const client = getClient();
-      const jobsList = await client.listCronJobs.query({});
+      const jobsList = await client.listCronJobs.query();
       console.log(JSON.stringify(jobsList, null, 2));
     } catch (err) {
       console.error('Error:', err instanceof Error ? err.message : err);
@@ -129,7 +148,7 @@ jobs
       }
 
       const client = getClient();
-      await client.addCronJob.mutate({ chatId: options.chat, job });
+      await client.addCronJob.mutate({ job });
       console.log(`Job '${name}' created successfully.`);
     } catch (err) {
       console.error('Error:', err instanceof Error ? err.message : err);
@@ -140,11 +159,10 @@ jobs
 jobs
   .command('delete <name>')
   .description('Delete a cron job')
-  .option('-c, --chat <chatId>', 'Chat ID')
-  .action(async (name, options) => {
+  .action(async (name) => {
     try {
       const client = getClient();
-      const result = await client.deleteCronJob.mutate({ chatId: options.chat, id: name });
+      const result = await client.deleteCronJob.mutate({ id: name });
       if (result && result.deleted) {
         console.log(`Job '${name}' deleted successfully.`);
       } else {

package/src/daemon/api/agent-router.ts

@@ -0,0 +1,191 @@
+import { z } from 'zod';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { TRPCError } from '@trpc/server';
+import { appendMessage, type CommandLogMessage } from '../chats.js';
+import { executeSafe, generateRequestPreview } from '../policy-utils.js';
+import { getWorkspaceRoot, readPolicies, getClawminiDir } from '../../shared/workspace.js';
+import { PolicyRequestService } from '../policy-request-service.js';
+import { RequestStore } from '../request-store.js';
+import { CronJobSchema } from '../../shared/config.js';
+import { apiProcedure, router } from './trpc.js';
+import { getMessageQueue } from '../queue.js';
+import { formatPendingMessages } from '../message.js';
+import {
+  resolveAgentDir,
+  validateLogFile,
+  listCronJobsShared,
+  addCronJobShared,
+  deleteCronJobShared,
+} from './router-utils.js';
+
+export const logMessage = apiProcedure
+  .input(
+    z.object({
+      message: z.string().optional(),
+      files: z.array(z.string()).optional(),
+    })
+  )
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+    const timestamp = new Date().toISOString();
+    const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
+
+    const filePaths: string[] = [];
+    if (input.files && input.files.length > 0) {
+      const workspaceRoot = getWorkspaceRoot(process.cwd());
+      const agentDir = await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot);
+
+      for (const file of input.files) {
+        const validPath = await validateLogFile(file, agentDir, workspaceRoot);
+        filePaths.push(validPath);
+      }
+    }
+
+    const filesArgStr = filePaths.map((p) => ` --file ${p}`).join('');
+    const messageStr = input.message || '';
+    const logMsg: CommandLogMessage = {
+      id,
+      messageId: id,
+      role: 'log',
+      source: 'router',
+      content: messageStr,
+      stderr: '',
+      timestamp,
+      command: `clawmini-lite log${filesArgStr}`,
+      cwd: process.cwd(),
+      exitCode: 0,
+      ...(filePaths.length > 0 ? { files: filePaths } : {}),
+    };
+
+    await appendMessage(chatId, logMsg);
+    return { success: true };
+  });
+
+export const agentListCronJobs = apiProcedure.query(async ({ ctx }) => {
+  if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+  const chatId = ctx.tokenPayload.chatId;
+  return listCronJobsShared(chatId);
+});
+
+export const agentAddCronJob = apiProcedure
+  .input(z.object({ job: CronJobSchema }))
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+    const job = { ...input.job, agentId: ctx.tokenPayload.agentId };
+    return addCronJobShared(chatId, job);
+  });
+
+export const agentDeleteCronJob = apiProcedure
+  .input(z.object({ id: z.string() }))
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const chatId = ctx.tokenPayload.chatId;
+    return deleteCronJobShared(chatId, input.id);
+  });
+
+export const listPolicies = apiProcedure.query(async () => {
+  return await readPolicies();
+});
+
+export const executePolicyHelp = apiProcedure
+  .input(z.object({ commandName: z.string() }))
+  .query(async ({ input }) => {
+    const config = await readPolicies();
+    const policy = config?.policies?.[input.commandName];
+
+    if (!policy) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: `Policy not found: ${input.commandName}`,
+      });
+    }
+
+    if (!policy.allowHelp) {
+      return { stdout: '', stderr: 'This command does not support --help\n', exitCode: 1 };
+    }
+
+    const fullArgs = [...(policy.args || []), '--help'];
+    const { stdout, stderr, exitCode } = await executeSafe(policy.command, fullArgs, {
+      cwd: getWorkspaceRoot(),
+    });
+
+    return { stdout, stderr, exitCode };
+  });
+
+export const createPolicyRequest = apiProcedure
+  .input(
+    z.object({
+      commandName: z.string(),
+      args: z.array(z.string()),
+      fileMappings: z.record(z.string(), z.string()),
+    })
+  )
+  .mutation(async ({ input, ctx }) => {
+    if (!ctx.tokenPayload) throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Missing token' });
+    const workspaceRoot = getWorkspaceRoot(process.cwd());
+    const snapshotDir = path.join(getClawminiDir(process.cwd()), 'tmp', 'snapshots');
+    const store = new RequestStore(process.cwd());
+    const agentDir = await resolveAgentDir(ctx.tokenPayload?.agentId, workspaceRoot);
+    const service = new PolicyRequestService(store, agentDir, snapshotDir);
+
+    const chatId = ctx.tokenPayload.chatId;
+    const agentId = ctx.tokenPayload.agentId;
+
+    const request = await service.createRequest(
+      input.commandName,
+      input.args,
+      input.fileMappings,
+      chatId,
+      agentId
+    );
+
+    const previewContent = await generateRequestPreview(request);
+
+    const logMsg = {
+      id: randomUUID(),
+      // TODO: we should store the message ID in the CLAW_API_TOKEN, and extract it here
+      messageId: randomUUID(),
+      role: 'log' as const,
+      source: 'router' as const,
+      content: previewContent,
+      stderr: '',
+      timestamp: new Date().toISOString(),
+      command: 'policy-request',
+      cwd: process.cwd(),
+      exitCode: 0,
+    };
+
+    await appendMessage(chatId, logMsg);
+    return request;
+  });
+
+import { ping } from './user-router.js';
+
+export const fetchPendingMessages = apiProcedure.mutation(async ({ ctx }) => {
+  const cwd = process.cwd();
+  const queue = getMessageQueue(cwd);
+  const targetSessionId = ctx.tokenPayload?.sessionId || 'default';
+
+  const extracted = queue.extractPending((p) => p.sessionId === targetSessionId);
+  if (extracted.length === 0) {
+    return { messages: '' };
+  }
+  return { messages: formatPendingMessages(extracted.map((p) => p.text)) };
+});
+
+export const agentRouter = router({
+  logMessage,
+  listCronJobs: agentListCronJobs,
+  addCronJob: agentAddCronJob,
+  deleteCronJob: agentDeleteCronJob,
+  listPolicies,
+  executePolicyHelp,
+  createPolicyRequest,
+  fetchPendingMessages,
+  ping,
+});
+
+export type AgentRouter = typeof agentRouter;