clawmini 0.0.1

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

@@ -0,0 +1,87 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { RequestStore } from './request-store.js';
+import { PolicyRequestService } from './policy-request-service.js';
+
+describe('PolicyRequestService', () => {
+  let tmpDir: string;
+  let agentDir: string;
+  let snapshotDir: string;
+  let store: RequestStore;
+  let service: PolicyRequestService;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'policy-request-service-test-'));
+    agentDir = path.join(tmpDir, 'agent');
+    snapshotDir = path.join(tmpDir, 'snapshots');
+
+    await fs.mkdir(agentDir, { recursive: true });
+
+    store = new RequestStore(tmpDir);
+    service = new PolicyRequestService(store, agentDir, snapshotDir, 2);
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should create a request, snapshotting files and storing it', async () => {
+    const testFile = path.join(agentDir, 'test.txt');
+    await fs.writeFile(testFile, 'hello world');
+
+    const request = await service.createRequest(
+      'testCmd',
+      ['--file', '{{myFile}}'],
+      {
+        myFile: 'test.txt',
+      },
+      'chat-123',
+      'agent-abc'
+    );
+
+    expect(request.id).toBeDefined();
+    expect(request.commandName).toBe('testCmd');
+    expect(request.state).toBe('Pending');
+    expect(Object.keys(request.fileMappings)).toHaveLength(1);
+
+    const snapshotPath = request.fileMappings['myFile'];
+    expect(snapshotPath).toBeDefined();
+    expect(snapshotPath!.startsWith(snapshotDir)).toBe(true);
+
+    const snapshotContent = await fs.readFile(snapshotPath!, 'utf8');
+    expect(snapshotContent).toBe('hello world');
+
+    const storedRequests = await store.list();
+    expect(storedRequests).toHaveLength(1);
+    expect(storedRequests[0]?.id).toBe(request.id);
+  });
+
+  it('should reject when pending limit is reached', async () => {
+    await service.createRequest('cmd1', [], {}, 'chat-1', 'agent-1');
+    await service.createRequest('cmd2', [], {}, 'chat-2', 'agent-2');
+
+    await expect(service.createRequest('cmd3', [], {}, 'chat-3', 'agent-3')).rejects.toThrow(
+      'Maximum number of pending requests (2) reached.'
+    );
+  });
+
+  it('should correctly interpolate arguments', async () => {
+    const testFile = path.join(agentDir, 'test.txt');
+    await fs.writeFile(testFile, 'hello world');
+
+    const request = await service.createRequest(
+      'testCmd',
+      ['--input', '{{inputFile}}'],
+      {
+        inputFile: 'test.txt',
+      },
+      'chat-4',
+      'agent-4'
+    );
+
+    const interpolatedArgs = service.getInterpolatedArgs(request);
+    expect(interpolatedArgs).toEqual(['--input', request.fileMappings['inputFile']]);
+  });
+});

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

@@ -0,0 +1,62 @@
+import { RequestStore, generateRandomAlphaNumericString } from './request-store.js';
+import { createSnapshot, interpolateArgs } from './policy-utils.js';
+import type { PolicyRequest } from '../shared/policies.js';
+
+export class PolicyRequestService {
+  private store: RequestStore;
+  private maxPending: number;
+  private agentDir: string;
+  private snapshotDir: string;
+
+  constructor(store: RequestStore, agentDir: string, snapshotDir: string, maxPending = 100) {
+    this.store = store;
+    this.agentDir = agentDir;
+    this.snapshotDir = snapshotDir;
+    this.maxPending = maxPending;
+  }
+
+  async createRequest(
+    commandName: string,
+    args: string[],
+    fileMappings: Record<string, string>,
+    chatId: string,
+    agentId: string
+  ): Promise<PolicyRequest> {
+    const allRequests = await this.store.list();
+    const pendingCount = allRequests.filter((r) => r.state === 'Pending').length;
+
+    if (pendingCount >= this.maxPending) {
+      throw new Error(`Maximum number of pending requests (${this.maxPending}) reached.`);
+    }
+
+    const snapshotMappings: Record<string, string> = {};
+
+    for (const [key, requestedPath] of Object.entries(fileMappings)) {
+      snapshotMappings[key] = await createSnapshot(requestedPath, this.agentDir, this.snapshotDir);
+    }
+
+    let id = '';
+    do {
+      id = generateRandomAlphaNumericString(3);
+    } while (allRequests.some((r) => r.id === id));
+
+    const request: PolicyRequest = {
+      id,
+      commandName,
+      args,
+      fileMappings: snapshotMappings,
+      state: 'Pending',
+      createdAt: Date.now(),
+      chatId,
+      agentId,
+    };
+
+    await this.store.save(request);
+
+    return request;
+  }
+
+  getInterpolatedArgs(request: PolicyRequest): string[] {
+    return interpolateArgs(request.args, request.fileMappings);
+  }
+}

package/src/daemon/policy-utils.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { createSnapshot, interpolateArgs, executeSafe, MAX_SNAPSHOT_SIZE } from './policy-utils.js';
+
+describe('policy-utils', () => {
+  let tempDir: string;
+  let agentDir: string;
+  let snapshotDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'clawmini-test-policies-'));
+    agentDir = path.join(tempDir, 'agent');
+    snapshotDir = path.join(tempDir, 'snapshots');
+    await fs.mkdir(agentDir, { recursive: true });
+    await fs.mkdir(snapshotDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('createSnapshot', () => {
+    it('creates a snapshot for a valid file in the agent directory', async () => {
+      const testFile = path.join(agentDir, 'test.txt');
+      await fs.writeFile(testFile, 'hello world');
+
+      const snapshotPath = await createSnapshot('test.txt', agentDir, snapshotDir);
+
+      expect(snapshotPath).toMatch(/test_[a-f0-9]{16}\.txt$/);
+      expect(snapshotPath.startsWith(snapshotDir)).toBe(true);
+
+      const content = await fs.readFile(snapshotPath, 'utf8');
+      expect(content).toBe('hello world');
+    });
+
+    it('rejects path traversal attempts', async () => {
+      const outsideFile = path.join(tempDir, 'outside.txt');
+      await fs.writeFile(outsideFile, 'secret');
+
+      await expect(createSnapshot('../outside.txt', agentDir, snapshotDir)).rejects.toThrow(
+        /Security Error: Path resolves outside/
+      );
+    });
+
+    it('rejects symlinks completely', async () => {
+      const targetFile = path.join(agentDir, 'target.txt');
+      await fs.writeFile(targetFile, 'target content');
+
+      const symlinkPath = path.join(agentDir, 'link.txt');
+      await fs.symlink(targetFile, symlinkPath);
+
+      await expect(createSnapshot('link.txt', agentDir, snapshotDir)).rejects.toThrow(
+        /Security Error: Symlinks are not allowed/
+      );
+    });
+
+    it('rejects files over MAX_SNAPSHOT_SIZE', async () => {
+      const largeFile = path.join(agentDir, 'large.txt');
+      const fd = await fs.open(largeFile, 'w');
+      await fd.truncate(MAX_SNAPSHOT_SIZE + 100);
+      await fd.close();
+
+      await expect(createSnapshot('large.txt', agentDir, snapshotDir)).rejects.toThrow(
+        /exceeds maximum snapshot size of 5MB/
+      );
+    });
+
+    it('rejects non-files (directories)', async () => {
+      const dirPath = path.join(agentDir, 'subdir');
+      await fs.mkdir(dirPath);
+
+      await expect(createSnapshot('subdir', agentDir, snapshotDir)).rejects.toThrow(
+        /Requested path is not a file/
+      );
+    });
+  });
+
+  describe('interpolateArgs', () => {
+    it('replaces variables with snapshot paths', () => {
+      const args = ['--to', 'admin@example.com', '--body', '{{body_txt}}'];
+      const mappings = {
+        body_txt: '/tmp/snapshots/test_123.txt',
+      };
+
+      const result = interpolateArgs(args, mappings);
+      expect(result).toEqual([
+        '--to',
+        'admin@example.com',
+        '--body',
+        '/tmp/snapshots/test_123.txt',
+      ]);
+    });
+
+    it('replaces multiple occurrences in a single arg', () => {
+      const args = ['--config', 'file1={{f1}},file2={{f2}}'];
+      const mappings = {
+        f1: '/tmp/f1.txt',
+        f2: '/tmp/f2.txt',
+      };
+
+      const result = interpolateArgs(args, mappings);
+      expect(result).toEqual(['--config', 'file1=/tmp/f1.txt,file2=/tmp/f2.txt']);
+    });
+
+    it('leaves unmatched variables alone', () => {
+      const args = ['--arg', '{{unknown}}'];
+      const mappings = {};
+      const result = interpolateArgs(args, mappings);
+      expect(result).toEqual(['--arg', '{{unknown}}']);
+    });
+  });
+
+  describe('executeSafe', () => {
+    it('executes a command and returns output', async () => {
+      const result = await executeSafe('echo', ['hello', 'world']);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.trim()).toBe('hello world');
+      expect(result.stderr).toBe('');
+    });
+
+    it('handles command failures gracefully', async () => {
+      // Execute ls on a non-existent file
+      const result = await executeSafe('ls', ['/does/not/exist/12345']);
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toMatch(/No such file or directory/);
+    });
+
+    it('does not execute shell operators (injection prevention)', async () => {
+      // If shell was true, `echo hello && echo injected` would run two commands.
+      // Since shell is false, it treats `&&` and `echo injected` as arguments to echo.
+      const result = await executeSafe('echo', ['hello', '&&', 'echo', 'injected']);
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout.trim()).toBe('hello && echo injected');
+    });
+  });
+});

package/src/daemon/policy-utils.ts

@@ -0,0 +1,152 @@
+import fs from 'node:fs/promises';
+import { constants } from 'node:fs';
+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';
+
+export const MAX_SNAPSHOT_SIZE = 5 * 1024 * 1024;
+
+export async function createSnapshot(
+  requestedPath: string,
+  agentDir: string,
+  snapshotDir: string
+): Promise<string> {
+  let realAgentDir: string;
+  try {
+    realAgentDir = await fs.realpath(agentDir);
+  } catch (err) {
+    throw new Error(`Agent directory not found or cannot be resolved: ${agentDir}`, { cause: err });
+  }
+
+  const resolvedRequestedPath = path.resolve(realAgentDir, requestedPath);
+
+  // Verify it is inside the allowed agent directory
+  if (!pathIsInsideDir(resolvedRequestedPath, realAgentDir, { allowSameDir: true })) {
+    throw new Error(
+      `Security Error: Path resolves outside the allowed agent directory: ${resolvedRequestedPath}`
+    );
+  }
+
+  // Lstat prevents TOCTOU attacks by not following symlinks
+  let stat;
+  try {
+    stat = await fs.lstat(resolvedRequestedPath);
+  } catch (err) {
+    throw new Error(`File not found or cannot be accessed: ${requestedPath}`, { cause: err });
+  }
+
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Security Error: Symlinks are not allowed: ${requestedPath}`);
+  }
+
+  if (!stat.isFile()) {
+    throw new Error(`Requested path is not a file: ${requestedPath}`);
+  }
+  if (stat.size > MAX_SNAPSHOT_SIZE) {
+    throw new Error(`File exceeds maximum snapshot size of 5MB: ${requestedPath}`);
+  }
+
+  // Generate unique filename for the snapshot
+  const ext = path.extname(resolvedRequestedPath);
+  const base = path.basename(resolvedRequestedPath, ext);
+
+  await fs.mkdir(snapshotDir, { recursive: true });
+
+  let snapshotPath: string;
+  while (true) {
+    const uniqueId = randomBytes(8).toString('hex');
+    const snapshotFileName = `${base}_${uniqueId}${ext}`;
+    snapshotPath = path.join(snapshotDir, snapshotFileName);
+
+    try {
+      await fs.copyFile(resolvedRequestedPath, snapshotPath, constants.COPYFILE_EXCL);
+      break;
+    } catch (err: unknown) {
+      if (
+        err instanceof Error &&
+        'code' in err &&
+        (err as Error & { code?: string }).code === 'EEXIST'
+      ) {
+        continue;
+      }
+      throw err;
+    }
+  }
+
+  return snapshotPath;
+}
+
+export function interpolateArgs(args: string[], snapshots: Record<string, string>): string[] {
+  return args.map((arg) => {
+    let interpolated = arg;
+    for (const [key, snapshotPath] of Object.entries(snapshots)) {
+      const variable = `{{${key}}}`;
+      interpolated = interpolated.replaceAll(variable, snapshotPath);
+    }
+    return interpolated;
+  });
+}
+
+export function executeSafe(
+  command: string,
+  args: string[],
+  options?: { cwd?: string; env?: NodeJS.ProcessEnv }
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  return new Promise((resolve) => {
+    // Safe execution: shell is strictly false to prevent command injection
+    const p = spawn(command, args, {
+      shell: false,
+      cwd: options?.cwd,
+      env: options?.env,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    if (p.stdout) {
+      p.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+    }
+
+    if (p.stderr) {
+      p.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+    }
+
+    p.on('close', (code) => {
+      resolve({ stdout, stderr, exitCode: code ?? 1 });
+    });
+
+    p.on('error', (err) => {
+      resolve({ stdout: '', stderr: err.toString(), exitCode: 1 });
+    });
+  });
+}
+
+export async function generateRequestPreview(request: PolicyRequest): Promise<string> {
+  let previewContent = `Sandbox Policy Request: ${request.commandName}\n`;
+  previewContent += `ID: ${request.id}\n`;
+  if (request.args.length > 0) {
+    previewContent += `Args: ${request.args.join(' ')}\n`;
+  }
+
+  for (const [name, snapPath] of Object.entries(request.fileMappings)) {
+    previewContent += `File [${name}]:\n`;
+    try {
+      let content = await fs.readFile(snapPath, 'utf8');
+      if (content.length > 500) {
+        content = content.substring(0, 500) + '\n... (truncated)\n';
+      }
+      previewContent += content;
+    } catch (e: unknown) {
+      previewContent += `<Error reading file: ${(e as Error).message}>\n`;
+    }
+  }
+
+  previewContent += `\nUse /approve ${request.id} or /reject ${request.id} [reason]`;
+  return previewContent;
+}

package/src/daemon/queue.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Queue } from './queue.js';
+
+describe('Queue', () => {
+  it('should process tasks in order', async () => {
+    const queue = new Queue();
+    const order: number[] = [];
+
+    const task1 = queue.enqueue(async () => {
+      await new Promise((r) => setTimeout(r, 10));
+      order.push(1);
+    });
+
+    const task2 = queue.enqueue(async () => {
+      order.push(2);
+    });
+
+    await Promise.all([task1, task2]);
+    expect(order).toEqual([1, 2]);
+  });
+
+  it('should support aborting the current task', async () => {
+    const queue = new Queue();
+    let aborted = false;
+
+    const task1 = queue.enqueue(async (signal: AbortSignal) => {
+      return new Promise<void>((resolve, reject) => {
+        const onAbort = () => {
+          aborted = true;
+          reject(signal.reason);
+        };
+        signal.addEventListener('abort', onAbort);
+      });
+    });
+
+    // Let the task start
+    await new Promise((r) => setTimeout(r, 0));
+    queue.abortCurrent();
+
+    await expect(task1).rejects.toThrow('Task aborted');
+    expect(aborted).toBe(true);
+  });
+
+  it('should clear pending tasks', async () => {
+    const queue = new Queue();
+    const mockTask1 = vi.fn().mockImplementation(async () => {
+      await new Promise((r) => setTimeout(r, 10));
+    });
+    const mockTask2 = vi.fn().mockResolvedValue(undefined);
+
+    const task1 = queue.enqueue(mockTask1);
+    const task2 = queue.enqueue(mockTask2);
+    task2.catch(() => {});
+
+    queue.clear();
+
+    await task1; // task1 is already running, should complete
+    await expect(task2).rejects.toThrow('Task cleared');
+
+    expect(mockTask1).toHaveBeenCalled();
+    expect(mockTask2).not.toHaveBeenCalled();
+  });
+
+  it('should extract pending tasks', async () => {
+    const queue = new Queue();
+    const mockTask1 = vi.fn().mockImplementation(async () => {
+      await new Promise((r) => setTimeout(r, 10));
+    });
+    const mockTask2 = vi.fn().mockResolvedValue(undefined);
+    const mockTask3 = vi.fn().mockResolvedValue(undefined);
+
+    const task1 = queue.enqueue(mockTask1, 'payload1');
+    const task2 = queue.enqueue(mockTask2, 'payload2');
+    const task3 = queue.enqueue(mockTask3); // no payload
+    task2.catch(() => {});
+    task3.catch(() => {});
+
+    const pendingPayloads = queue.extractPending();
+
+    await task1; // task1 is running
+    await expect(task2).rejects.toThrow('Task extracted for batching');
+    await expect(task3).rejects.toThrow('Task extracted for batching');
+
+    expect(pendingPayloads).toEqual(['payload2']);
+    expect(mockTask1).toHaveBeenCalled();
+    expect(mockTask2).not.toHaveBeenCalled();
+    expect(mockTask3).not.toHaveBeenCalled();
+  });
+});

package/src/daemon/queue.ts

@@ -0,0 +1,87 @@
+export type Task<T = void> = (signal: AbortSignal) => Promise<T>;
+
+interface QueueEntry<TPayload = string> {
+  task: Task;
+  payload?: TPayload | undefined;
+  resolve: (value: void | PromiseLike<void>) => void;
+  reject: (reason?: unknown) => void;
+}
+
+export class Queue<TPayload = string> {
+  private pending: QueueEntry<TPayload>[] = [];
+  private isRunning = false;
+  private currentController: AbortController | null = null;
+  private currentPayload?: TPayload | undefined;
+
+  enqueue(task: Task, payload?: TPayload): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.pending.push({ task, payload, resolve, reject });
+      // We don't await processNext because we want enqueue to return the task's promise
+      // and let processNext run in the background.
+      this.processNext().catch(() => {});
+    });
+  }
+
+  private async processNext() {
+    if (this.isRunning || this.pending.length === 0) return;
+
+    this.isRunning = true;
+    const entry = this.pending.shift()!;
+    this.currentController = new AbortController();
+    this.currentPayload = entry.payload;
+
+    try {
+      await entry.task(this.currentController.signal);
+      entry.resolve();
+    } catch (error) {
+      entry.reject(error);
+    } finally {
+      this.isRunning = false;
+      this.currentController = null;
+      this.currentPayload = undefined;
+      // Continue processing the next item
+      this.processNext().catch(() => {});
+    }
+  }
+
+  abortCurrent(): void {
+    if (this.currentController) {
+      const error = new Error('Task aborted');
+      error.name = 'AbortError';
+      this.currentController.abort(error);
+    }
+  }
+
+  getCurrentPayload(): TPayload | undefined {
+    return this.currentPayload;
+  }
+
+  clear(reason: string = 'Task cleared'): void {
+    const tasksToClear = [...this.pending];
+    this.pending = [];
+    for (const { reject } of tasksToClear) {
+      const error = new Error(reason);
+      error.name = 'AbortError';
+      reject(error);
+    }
+  }
+
+  extractPending(): TPayload[] {
+    const extracted = this.pending
+      .map((p) => p.payload)
+      .filter((p): p is TPayload => p !== undefined);
+
+    this.clear('Task extracted for batching');
+
+    return extracted;
+  }
+}
+
+const directoryQueues = new Map<string, Queue>();
+
+export function getQueue(dir: string): Queue {
+  if (!directoryQueues.has(dir)) {
+    directoryQueues.set(dir, new Queue());
+  }
+  return directoryQueues.get(dir)!;
+}