@openparachute/agent 0.1.2 → 0.2.2

package/src/modules/scheduling/db.test.ts

@@ -1,282 +0,0 @@
-/**
- * Tests for the scheduling module's task DB helpers — focused on the
- * series_id invariant that lets cancel/pause/resume/update reach the live
- * next occurrence of a recurring task, even after the row the agent
- * remembers has completed and been replaced by a follow-up.
- */
-import fs from 'fs';
-import path from 'path';
-import { describe, it, expect, afterEach } from 'vitest';
-
-import { ensureSchema, openInboundDb } from '../../db/session-db.js';
-import {
-  insertTask,
-  insertRecurrence,
-  cancelTask,
-  pauseTask,
-  resumeTask,
-  updateTask,
-  getCompletedRecurring,
-  type RecurringMessage,
-} from './db.js';
-
-const TEST_DIR = '/tmp/paraclaw-scheduling-db-test';
-const DB_PATH = path.join(TEST_DIR, 'inbound.db');
-
-function freshDb() {
-  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-  fs.mkdirSync(TEST_DIR, { recursive: true });
-  ensureSchema(DB_PATH, 'inbound');
-  return openInboundDb(DB_PATH);
-}
-
-function insertBasicTask(db: ReturnType<typeof openInboundDb>, id: string, recurrence: string | null) {
-  insertTask(db, {
-    id,
-    processAfter: new Date().toISOString(),
-    recurrence,
-    platformId: null,
-    channelType: null,
-    threadId: null,
-    content: JSON.stringify({ prompt: 'noop' }),
-  });
-}
-
-afterEach(() => {
-  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-});
-
-describe('insertTask', () => {
-  it('stamps series_id = id on insert', () => {
-    const db = freshDb();
-    insertBasicTask(db, 'task-1', null);
-    const row = db.prepare('SELECT series_id FROM messages_in WHERE id = ?').get('task-1') as { series_id: string };
-    expect(row.series_id).toBe('task-1');
-    db.close();
-  });
-});
-
-describe('cancelTask / pauseTask / resumeTask series matching', () => {
-  // Simulates the recurrence chain that used to survive cancellation:
-  // the original task completes → handleRecurrence spawns a follow-up
-  // row → agent calls cancel_task(originalId) → historically only hit
-  // the completed row, leaving the live one running.
-  function seedRecurringChain(db: ReturnType<typeof openInboundDb>) {
-    insertBasicTask(db, 'task-orig', '0 9 * * *');
-    // Mark the original as completed (as syncProcessingAcks would do).
-    db.prepare("UPDATE messages_in SET status = 'completed' WHERE id = 'task-orig'").run();
-
-    const msg: RecurringMessage = {
-      id: 'task-orig',
-      kind: 'task',
-      content: JSON.stringify({ prompt: 'noop' }),
-      recurrence: '0 9 * * *',
-      process_after: null,
-      platform_id: null,
-      channel_type: null,
-      thread_id: null,
-      series_id: 'task-orig',
-    };
-    insertRecurrence(db, msg, 'task-next', new Date(Date.now() + 86400000).toISOString());
-  }
-
-  it('cancel by original id reaches the live follow-up via series_id', () => {
-    const db = freshDb();
-    seedRecurringChain(db);
-
-    cancelTask(db, 'task-orig');
-
-    const live = db.prepare("SELECT id, status, recurrence FROM messages_in WHERE status = 'pending'").all();
-    expect(live).toHaveLength(0);
-
-    const followUp = db.prepare("SELECT status, recurrence FROM messages_in WHERE id = 'task-next'").get() as {
-      status: string;
-      recurrence: string | null;
-    };
-    expect(followUp.status).toBe('completed');
-    // Recurrence cleared so the sweep doesn't spawn another clone.
-    expect(followUp.recurrence).toBeNull();
-    db.close();
-  });
-
-  it('cancelled task is not picked up by getCompletedRecurring', () => {
-    const db = freshDb();
-    insertBasicTask(db, 'task-1', '0 9 * * *');
-    cancelTask(db, 'task-1');
-
-    const recurring = getCompletedRecurring(db);
-    expect(recurring).toHaveLength(0);
-    db.close();
-  });
-
-  it('pause by original id pauses the live follow-up', () => {
-    const db = freshDb();
-    seedRecurringChain(db);
-
-    pauseTask(db, 'task-orig');
-
-    const followUp = db.prepare("SELECT status FROM messages_in WHERE id = 'task-next'").get() as { status: string };
-    expect(followUp.status).toBe('paused');
-    db.close();
-  });
-
-  it('resume by original id resumes the live follow-up', () => {
-    const db = freshDb();
-    seedRecurringChain(db);
-
-    db.prepare("UPDATE messages_in SET status = 'paused' WHERE id = 'task-next'").run();
-    resumeTask(db, 'task-orig');
-
-    const followUp = db.prepare("SELECT status FROM messages_in WHERE id = 'task-next'").get() as { status: string };
-    expect(followUp.status).toBe('pending');
-    db.close();
-  });
-});
-
-describe('updateTask', () => {
-  it('merges supplied fields into content JSON without clobbering others', () => {
-    const db = freshDb();
-    insertTask(db, {
-      id: 'task-1',
-      processAfter: new Date().toISOString(),
-      recurrence: null,
-      platformId: null,
-      channelType: null,
-      threadId: null,
-      content: JSON.stringify({ prompt: 'old', script: 'echo old', extra: 'keep me' }),
-    });
-
-    const touched = updateTask(db, 'task-1', { prompt: 'new' });
-    expect(touched).toBe(1);
-
-    const row = db.prepare('SELECT content FROM messages_in WHERE id = ?').get('task-1') as { content: string };
-    const parsed = JSON.parse(row.content);
-    expect(parsed.prompt).toBe('new');
-    expect(parsed.script).toBe('echo old');
-    expect(parsed.extra).toBe('keep me');
-  });
-
-  it('updates recurrence and process_after when supplied', () => {
-    const db = freshDb();
-    insertTask(db, {
-      id: 'task-1',
-      processAfter: '2026-01-01T00:00:00Z',
-      recurrence: '0 9 * * *',
-      platformId: null,
-      channelType: null,
-      threadId: null,
-      content: JSON.stringify({ prompt: 'p' }),
-    });
-
-    updateTask(db, 'task-1', { recurrence: '0 18 * * *', processAfter: '2026-02-01T00:00:00Z' });
-
-    const row = db.prepare('SELECT recurrence, process_after FROM messages_in WHERE id = ?').get('task-1') as {
-      recurrence: string;
-      process_after: string;
-    };
-    expect(row.recurrence).toBe('0 18 * * *');
-    expect(row.process_after).toBe('2026-02-01T00:00:00Z');
-  });
-
-  it('clears recurrence when null is passed', () => {
-    const db = freshDb();
-    insertTask(db, {
-      id: 'task-1',
-      processAfter: '2026-01-01T00:00:00Z',
-      recurrence: '0 9 * * *',
-      platformId: null,
-      channelType: null,
-      threadId: null,
-      content: JSON.stringify({ prompt: 'p' }),
-    });
-
-    updateTask(db, 'task-1', { recurrence: null });
-
-    const row = db.prepare('SELECT recurrence FROM messages_in WHERE id = ?').get('task-1') as {
-      recurrence: string | null;
-    };
-    expect(row.recurrence).toBeNull();
-  });
-
-  it('reaches the live follow-up via series_id when called with the original id', () => {
-    const db = freshDb();
-    insertTask(db, {
-      id: 'task-orig',
-      processAfter: new Date().toISOString(),
-      recurrence: '0 9 * * *',
-      platformId: null,
-      channelType: null,
-      threadId: null,
-      content: JSON.stringify({ prompt: 'old' }),
-    });
-    db.prepare("UPDATE messages_in SET status = 'completed' WHERE id = 'task-orig'").run();
-
-    const msg: RecurringMessage = {
-      id: 'task-orig',
-      kind: 'task',
-      content: JSON.stringify({ prompt: 'old' }),
-      recurrence: '0 9 * * *',
-      process_after: null,
-      platform_id: null,
-      channel_type: null,
-      thread_id: null,
-      series_id: 'task-orig',
-    };
-    insertRecurrence(db, msg, 'task-next', new Date(Date.now() + 86400000).toISOString());
-
-    const touched = updateTask(db, 'task-orig', { prompt: 'new' });
-    // Only the live follow-up should be touched — completed rows are excluded.
-    expect(touched).toBe(1);
-
-    const live = db.prepare("SELECT content FROM messages_in WHERE id = 'task-next'").get() as { content: string };
-    expect(JSON.parse(live.content).prompt).toBe('new');
-
-    // Original (completed) row left alone.
-    const orig = db.prepare("SELECT content FROM messages_in WHERE id = 'task-orig'").get() as { content: string };
-    expect(JSON.parse(orig.content).prompt).toBe('old');
-  });
-
-  it('returns 0 when no live task matches', () => {
-    const db = freshDb();
-    insertTask(db, {
-      id: 'task-1',
-      processAfter: new Date().toISOString(),
-      recurrence: null,
-      platformId: null,
-      channelType: null,
-      threadId: null,
-      content: JSON.stringify({ prompt: 'p' }),
-    });
-    db.prepare("UPDATE messages_in SET status = 'completed' WHERE id = 'task-1'").run();
-
-    const touched = updateTask(db, 'task-1', { prompt: 'new' });
-    expect(touched).toBe(0);
-  });
-});
-
-describe('insertRecurrence', () => {
-  it('copies series_id forward', () => {
-    const db = freshDb();
-    insertBasicTask(db, 'task-orig', '0 9 * * *');
-    db.prepare("UPDATE messages_in SET status = 'completed' WHERE id = 'task-orig'").run();
-
-    const msg: RecurringMessage = {
-      id: 'task-orig',
-      kind: 'task',
-      content: '{}',
-      recurrence: '0 9 * * *',
-      process_after: null,
-      platform_id: null,
-      channel_type: null,
-      thread_id: null,
-      series_id: 'task-orig',
-    };
-    insertRecurrence(db, msg, 'task-next', new Date().toISOString());
-
-    const row = db.prepare('SELECT series_id FROM messages_in WHERE id = ?').get('task-next') as {
-      series_id: string;
-    };
-    expect(row.series_id).toBe('task-orig');
-    db.close();
-  });
-});

package/src/modules/scheduling/db.ts

@@ -1,148 +0,0 @@
-/**
- * Task DB helpers used by the scheduling module.
- *
- * Tasks are `messages_in` rows with `kind='task'`. This module doesn't own
- * its own table — it piggybacks on the core schema. That's why there's no
- * `module-scheduling-*.ts` migration file.
- *
- * cancel/pause/resume match any live row in the series, not just the exact id.
- * Recurring tasks get a new row per occurrence (see handleRecurrence), all
- * sharing series_id. Matching by id alone would only hit the completed row
- * the agent remembers, missing the live next occurrence.
- */
-import type { Database } from '../../db/connection.js';
-
-import { nextEvenSeq } from '../../db/session-db.js';
-
-export function insertTask(
-  db: Database,
-  task: {
-    id: string;
-    processAfter: string;
-    recurrence: string | null;
-    platformId: string | null;
-    channelType: string | null;
-    threadId: string | null;
-    content: string;
-  },
-): void {
-  db.prepare(
-    `INSERT INTO messages_in (id, seq, timestamp, status, tries, process_after, recurrence, kind, platform_id, channel_type, thread_id, content, series_id)
-     VALUES (@id, @seq, datetime('now'), 'pending', 0, @processAfter, @recurrence, 'task', @platformId, @channelType, @threadId, @content, @id)`,
-  ).run({
-    ...task,
-    seq: nextEvenSeq(db),
-  });
-}
-
-export function cancelTask(db: Database, taskId: string): void {
-  db.prepare(
-    "UPDATE messages_in SET status = 'completed', recurrence = NULL WHERE (id = ? OR series_id = ?) AND kind = 'task' AND status IN ('pending', 'paused')",
-  ).run(taskId, taskId);
-}
-
-export function pauseTask(db: Database, taskId: string): void {
-  db.prepare(
-    "UPDATE messages_in SET status = 'paused' WHERE (id = ? OR series_id = ?) AND kind = 'task' AND status = 'pending'",
-  ).run(taskId, taskId);
-}
-
-export function resumeTask(db: Database, taskId: string): void {
-  db.prepare(
-    "UPDATE messages_in SET status = 'pending' WHERE (id = ? OR series_id = ?) AND kind = 'task' AND status = 'paused'",
-  ).run(taskId, taskId);
-}
-
-export interface TaskUpdate {
-  prompt?: string;
-  script?: string | null;
-  recurrence?: string | null;
-  processAfter?: string;
-}
-
-// Merges content JSON in-place so callers can update prompt/script without
-// clobbering other fields. Matches by id OR series_id so the live next
-// occurrence of a recurring task is updated, not just the completed row the
-// agent last saw. Returns the number of rows touched.
-export function updateTask(db: Database, taskId: string, update: TaskUpdate): number {
-  const rows = db
-    .prepare(
-      "SELECT id, content FROM messages_in WHERE (id = ? OR series_id = ?) AND kind = 'task' AND status IN ('pending', 'paused')",
-    )
-    .all(taskId, taskId) as Array<{ id: string; content: string }>;
-
-  if (rows.length === 0) return 0;
-
-  const setProcessAfter = update.processAfter !== undefined;
-  const setRecurrence = update.recurrence !== undefined;
-  const mergeContent = update.prompt !== undefined || update.script !== undefined;
-
-  const tx = db.transaction(() => {
-    for (const row of rows) {
-      let content = row.content;
-      if (mergeContent) {
-        const parsed = JSON.parse(row.content) as Record<string, unknown>;
-        if (update.prompt !== undefined) parsed.prompt = update.prompt;
-        if (update.script !== undefined) parsed.script = update.script;
-        content = JSON.stringify(parsed);
-      }
-
-      // Build SET clause dynamically so callers can update fields independently.
-      const sets: string[] = ['content = ?'];
-      const params: unknown[] = [content];
-      if (setProcessAfter) {
-        sets.push('process_after = ?');
-        params.push(update.processAfter);
-      }
-      if (setRecurrence) {
-        sets.push('recurrence = ?');
-        params.push(update.recurrence);
-      }
-      params.push(row.id);
-
-      db.prepare(`UPDATE messages_in SET ${sets.join(', ')} WHERE id = ?`).run(...params);
-    }
-  });
-  tx();
-  return rows.length;
-}
-
-export interface RecurringMessage {
-  id: string;
-  kind: string;
-  content: string;
-  recurrence: string;
-  process_after: string | null;
-  platform_id: string | null;
-  channel_type: string | null;
-  thread_id: string | null;
-  series_id: string;
-}
-
-export function getCompletedRecurring(db: Database): RecurringMessage[] {
-  return db
-    .prepare("SELECT * FROM messages_in WHERE status = 'completed' AND recurrence IS NOT NULL")
-    .all() as RecurringMessage[];
-}
-
-export function insertRecurrence(db: Database, msg: RecurringMessage, newId: string, nextRun: string | null): void {
-  db.prepare(
-    `INSERT INTO messages_in (id, seq, kind, timestamp, status, process_after, recurrence, platform_id, channel_type, thread_id, content, series_id)
-     VALUES (?, ?, ?, datetime('now'), 'pending', ?, ?, ?, ?, ?, ?, ?)`,
-  ).run(
-    newId,
-    nextEvenSeq(db),
-    msg.kind,
-    nextRun,
-    msg.recurrence,
-    msg.platform_id,
-    msg.channel_type,
-    msg.thread_id,
-    msg.content,
-    msg.series_id,
-  );
-}
-
-export function clearRecurrence(db: Database, messageId: string): void {
-  db.prepare('UPDATE messages_in SET recurrence = NULL WHERE id = ?').run(messageId);
-}

package/src/modules/scheduling/index.ts

@@ -1,34 +0,0 @@
-/**
- * Scheduling module — one-shot and recurring tasks.
- *
- * Registers:
- *   - Five delivery action handlers: schedule_task, cancel_task, pause_task,
- *     resume_task, update_task. The container's scheduling MCP tools
- *     (container/agent-runner/src/mcp-tools/scheduling.ts) write system
- *     messages with these actions; the host applies them to inbound.db.
- *
- * Host integration points (filled by MODULE-HOOK markers, validated here
- * with the scheduling module shipping inline):
- *   - `src/host-sweep.ts` → MODULE-HOOK:scheduling-recurrence calls
- *     `handleRecurrence` each sweep tick.
- *   - `container/agent-runner/src/poll-loop.ts` → MODULE-HOOK:scheduling-pre-task
- *     runs `applyPreTaskScripts` before the provider call so tasks carrying
- *     a pre-agent script can gate their own execution.
- *
- * No DB migration — tasks are `messages_in` rows with `kind='task'`, so the
- * module piggybacks on the core schema.
- */
-import { registerDeliveryAction } from '../../delivery.js';
-import {
-  handleCancelTask,
-  handlePauseTask,
-  handleResumeTask,
-  handleScheduleTask,
-  handleUpdateTask,
-} from './actions.js';
-
-registerDeliveryAction('schedule_task', handleScheduleTask);
-registerDeliveryAction('cancel_task', handleCancelTask);
-registerDeliveryAction('pause_task', handlePauseTask);
-registerDeliveryAction('resume_task', handleResumeTask);
-registerDeliveryAction('update_task', handleUpdateTask);

package/src/modules/scheduling/recurrence.test.ts

@@ -1,98 +0,0 @@
-/**
- * Tests for `handleRecurrence` — specifically the timezone-aware cron
- * interpretation ported from v1 (src/v1/task-scheduler.ts).
- *
- * Core invariant: cron expressions are interpreted in the user's TIMEZONE,
- * not UTC. Without this, `"0 9 * * *"` fires at 09:00 UTC instead of 09:00
- * user-local — a recurring scheduling bug users can't diagnose.
- */
-import fs from 'fs';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { ensureSchema, openInboundDb } from '../../db/session-db.js';
-import { insertTask } from './db.js';
-import { handleRecurrence } from './recurrence.js';
-import type { Session } from '../../types.js';
-
-const TEST_DIR = '/tmp/paraclaw-recurrence-test';
-const DB_PATH = path.join(TEST_DIR, 'inbound.db');
-
-function freshDb() {
-  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-  fs.mkdirSync(TEST_DIR, { recursive: true });
-  ensureSchema(DB_PATH, 'inbound');
-  return openInboundDb(DB_PATH);
-}
-
-function fakeSession(): Session {
-  return {
-    id: 'sess-test',
-    agent_group_id: 'ag-test',
-    messaging_group_id: 'mg-test',
-    thread_id: null,
-    status: 'active',
-    created_at: new Date().toISOString(),
-    last_active: new Date().toISOString(),
-    container_status: 'stopped',
-  } as Session;
-}
-
-afterEach(() => {
-  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-});
-
-describe('handleRecurrence', () => {
-  it('clones a completed recurring task with a next-run in the future', async () => {
-    const db = freshDb();
-    insertTask(db, {
-      id: 'task-1',
-      processAfter: '2020-01-01T00:00:00.000Z',
-      recurrence: '0 9 * * *', // every day at 09:00 (user TZ)
-      platformId: null,
-      channelType: null,
-      threadId: null,
-      content: JSON.stringify({ prompt: 'daily digest' }),
-    });
-    db.prepare(`UPDATE messages_in SET status='completed' WHERE id='task-1'`).run();
-
-    await handleRecurrence(db, fakeSession());
-
-    const rows = db
-      .prepare(`SELECT id, status, process_after, recurrence, series_id FROM messages_in ORDER BY seq`)
-      .all() as Array<{
-      id: string;
-      status: string;
-      process_after: string;
-      recurrence: string | null;
-      series_id: string;
-    }>;
-    expect(rows).toHaveLength(2);
-    const original = rows.find((r) => r.id === 'task-1')!;
-    const follow = rows.find((r) => r.id !== 'task-1')!;
-    expect(original.recurrence).toBeNull();
-    expect(follow.status).toBe('pending');
-    expect(follow.recurrence).toBe('0 9 * * *');
-    expect(follow.series_id).toBe('task-1');
-    expect(new Date(follow.process_after).getTime()).toBeGreaterThan(Date.now());
-  });
-
-  it('does not clone rows whose recurrence is already cleared', async () => {
-    const db = freshDb();
-    insertTask(db, {
-      id: 'task-1',
-      processAfter: '2020-01-01T00:00:00.000Z',
-      recurrence: null,
-      platformId: null,
-      channelType: null,
-      threadId: null,
-      content: JSON.stringify({ prompt: 'one-off' }),
-    });
-    db.prepare(`UPDATE messages_in SET status='completed' WHERE id='task-1'`).run();
-
-    await handleRecurrence(db, fakeSession());
-
-    const count = (db.prepare(`SELECT COUNT(*) AS c FROM messages_in`).get() as { c: number }).c;
-    expect(count).toBe(1);
-  });
-});

package/src/modules/scheduling/recurrence.ts

@@ -1,54 +0,0 @@
-/**
- * Sweep hook for recurring tasks.
- *
- * Every sweep tick, find `messages_in` rows that are `completed` AND still
- * have a `recurrence` cron expression. For each, compute the next run via
- * cron-parser, insert a fresh pending row (copying series_id forward), then
- * clear the recurrence on the original so it isn't re-cloned next tick.
- *
- * Called from `src/host-sweep.ts` inside `MODULE-HOOK:scheduling-recurrence`.
- * When scheduling ships inline (current state through PR #7), the hook is a
- * direct dynamic import. When scheduling moves to the modules branch in
- * PR #8, the install skill re-fills the marker on install.
- */
-import type { Database } from '../../db/connection.js';
-
-import { TIMEZONE } from '../../config.js';
-import { log } from '../../log.js';
-import type { Session } from '../../types.js';
-import { clearRecurrence, getCompletedRecurring, insertRecurrence } from './db.js';
-
-export async function handleRecurrence(inDb: Database, session: Session): Promise<void> {
-  const recurring = getCompletedRecurring(inDb);
-
-  for (const msg of recurring) {
-    try {
-      const { CronExpressionParser } = await import('cron-parser');
-      // Interpret the cron expression in the user's timezone. v1 did this
-      // (src/v1/task-scheduler.ts:20-49); without it, a task written "0 9 * * *"
-      // by an agent running in a user's local TZ fires at 09:00 UTC instead of
-      // 09:00 user-local.
-      const interval = CronExpressionParser.parse(msg.recurrence, { tz: TIMEZONE });
-      const nextRun = interval.next().toISOString();
-      const prefix = msg.kind === 'task' ? 'task' : 'msg';
-      const newId = `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-
-      insertRecurrence(inDb, msg, newId, nextRun);
-      clearRecurrence(inDb, msg.id);
-
-      log.info('Inserted next recurrence', {
-        originalId: msg.id,
-        newId,
-        seriesId: msg.series_id,
-        nextRun,
-        sessionId: session.id,
-      });
-    } catch (err) {
-      log.error('Failed to compute next recurrence', {
-        messageId: msg.id,
-        recurrence: msg.recurrence,
-        err,
-      });
-    }
-  }
-}

package/src/modules/self-mod/agent.md

@@ -1,30 +0,0 @@
-# Self-modification
-
-You can install additional OS or npm packages or add new MCP servers — but
-only with admin approval.
-
-## Tools
-
-- `install_packages({ apt?: string[], npm?: string[], reason?: string })` —
-  adds the listed packages to your container config, rebuilds the image,
-  and restarts your container, all in a single admin approval step.
-  Package names are validated strictly (`[a-z0-9._+-]` for apt, standard
-  npm naming with optional scope). Max 20 packages per request.
-
-- `add_mcp_server({ name, command, args?, env? })` — adds a new MCP server
-  to your container config and restarts the container so the new server
-  is wired up on the next message. No image rebuild is required (bun runs
-  TS directly).
-
-## Flow
-
-You call one of these tools → the host asks an admin via DM → admin approves
-or rejects. On approve, the config is applied, the image is rebuilt if
-needed, and the container is killed; the host respawns it on the next
-message. You'll get a system chat message confirming the outcome (either
-"Packages installed..." or a failure reason).
-
-On reject you'll see "Your X request was rejected by admin."
-
-If no admin is configured or reachable, the request fails immediately with
-a chat notification explaining why.