@openparachute/agent 0.1.0

package/scripts/sanity-live-poll.ts

@@ -0,0 +1,95 @@
+/**
+ * Cross-mount visibility regression test for the two-DB session architecture.
+ *
+ * What this catches: any change that breaks host→container write propagation
+ * across the Docker bind mount. The v2 session DB design relies on three
+ * invariants working together:
+ *
+ *   1. journal_mode = DELETE on every session DB (not WAL)
+ *   2. Host opens-writes-closes the DB file on every write
+ *   3. One writer per file (inbound = host, outbound = container)
+ *
+ * This script exercises a long-lived container-side reader polling a DB
+ * while the host writes. If visibility is working, the reader sees each
+ * write within one poll period. If any of the invariants regresses, the
+ * reader either sees nothing, sees only the first write, or sees updates
+ * only after the host closes its connection for good.
+ *
+ * Expected passing output (DELETE mode, close-per-write):
+ *   reader sees each seq within ~1s of it being written.
+ * Anything else is a regression — investigate BEFORE assuming it's flaky.
+ *
+ * Keep this around. It ran for ~20 minutes once to map the failure modes
+ * and it takes about 60s to run — cheap insurance.
+ *
+ * Requires: Docker Desktop running, parachute-agent-image-<slug>:latest built.
+ */
+
+import { spawn, spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { mkdirSync, rmSync } from "node:fs";
+import Database from "better-sqlite3";
+
+const dbDir = join("/tmp", `parachute-agent-live-${Date.now()}`);
+mkdirSync(dbDir, { recursive: true });
+spawnSync("chmod", ["777", dbDir]);
+const dbPath = join(dbDir, "live.db");
+
+for (const journalMode of ["DELETE", "WAL"]) {
+  console.log(`\n=== ${journalMode} ===`);
+  rmSync(dbPath, { force: true });
+  rmSync(dbPath + "-wal", { force: true });
+  rmSync(dbPath + "-shm", { force: true });
+  rmSync(dbPath + "-journal", { force: true });
+
+  const db = new Database(dbPath);
+  db.pragma(`journal_mode = ${journalMode}`);
+  db.pragma("synchronous = FULL");
+  db.exec("CREATE TABLE msgs (seq INTEGER PRIMARY KEY, content TEXT)");
+  db.close();
+
+  // Start container poller in background
+  const contProc = spawn("docker", [
+    "run", "--rm", "-w", "/app",
+    "-v", `${dbDir}:/workspace`,
+    "--entrypoint", "node",
+    // Resolve the per-checkout image name produced by container/build.sh.
+    // Hardcoded for diagnostics only; not in the build chain.
+    `parachute-agent-image-${process.env.INSTALL_SLUG ?? "unknown"}:latest`,
+    "-e",
+    `const Database = require('better-sqlite3');
+     const db = new Database('/workspace/live.db', { readonly: true });
+     db.pragma('busy_timeout = 2000');
+     const stmt = db.prepare('SELECT COUNT(*) as n, MAX(seq) as hi FROM msgs');
+     let count = 0;
+     const timer = setInterval(() => {
+       const r = stmt.get();
+       console.log('poll t=' + (Date.now() % 100000) + ' count=' + r.n + ' max=' + r.hi);
+       if (++count >= 10) { clearInterval(timer); db.close(); }
+     }, 1000);`,
+  ], { stdio: ["ignore", "pipe", "pipe"] });
+
+  contProc.stdout.on("data", (d) => process.stdout.write(`  [cont] ${d}`));
+  contProc.stderr.on("data", (d) => process.stderr.write(`  [cont-err] ${d}`));
+
+  // Give container a moment to start
+  const waitUntil = Date.now() + 2000;
+  while (Date.now() < waitUntil) {}
+
+  // Host opens, writes, CLOSES each time (matches production session-manager pattern)
+  for (let i = 1; i <= 8; i++) {
+    const h = new Database(dbPath);
+    h.pragma(`journal_mode = ${journalMode}`);
+    h.pragma("synchronous = FULL");
+    h.prepare("INSERT INTO msgs (seq, content) VALUES (?, ?)").run(i, `msg-${i}`);
+    h.close();
+    console.log(`  [host] wrote+closed seq=${i} t=${Date.now() % 100000}`);
+    const sleepUntil = Date.now() + 1000;
+    while (Date.now() < sleepUntil) {}
+  }
+
+  // Wait for container to finish
+  await new Promise<void>((res) => contProc.once("exit", () => res()));
+}
+
+rmSync(dbDir, { recursive: true, force: true });

package/scripts/seed-discord.ts

@@ -0,0 +1,79 @@
+/**
+ * Seed the v2 central DB with a Discord agent group + messaging group.
+ *
+ * Usage: pnpm exec tsx scripts/seed-discord.ts
+ */
+import { CENTRAL_DB_PATH } from '../src/config.js';
+import { initDb, migrateCentralDbLocation } from '../src/db/connection.js';
+import { runMigrations } from '../src/db/migrations/index.js';
+import { createAgentGroup, getAgentGroup } from '../src/db/agent-groups.js';
+import {
+  createMessagingGroup,
+  createMessagingGroupAgent,
+  getMessagingGroup,
+} from '../src/db/messaging-groups.js';
+
+migrateCentralDbLocation();
+const db = initDb(CENTRAL_DB_PATH);
+runMigrations(db);
+
+const AGENT_GROUP_ID = 'ag-main';
+const MESSAGING_GROUP_ID = 'mg-discord';
+const CHANNEL_ID = 'discord:1470188214710046894:1491569326447132673';
+
+// Agent group
+if (!getAgentGroup(AGENT_GROUP_ID)) {
+  createAgentGroup({
+    id: AGENT_GROUP_ID,
+    name: 'Main',
+    folder: 'main',
+    agent_provider: 'claude',
+    created_at: new Date().toISOString(),
+  });
+  console.log('Created agent group:', AGENT_GROUP_ID);
+} else {
+  console.log('Agent group already exists:', AGENT_GROUP_ID);
+}
+
+// Messaging group
+if (!getMessagingGroup(MESSAGING_GROUP_ID)) {
+  createMessagingGroup({
+    id: MESSAGING_GROUP_ID,
+    channel_type: 'discord',
+    platform_id: CHANNEL_ID,
+    name: 'Discord Test',
+    is_group: 1,
+    unknown_sender_policy: 'strict',
+    created_at: new Date().toISOString(),
+  });
+  console.log('Created messaging group:', MESSAGING_GROUP_ID);
+} else {
+  console.log('Messaging group already exists:', MESSAGING_GROUP_ID);
+}
+
+// Link
+try {
+  createMessagingGroupAgent({
+    id: 'mga-discord',
+    messaging_group_id: MESSAGING_GROUP_ID,
+    agent_group_id: AGENT_GROUP_ID,
+    // Discord group channel → mention-sticky default. Mention once, stay
+    // subscribed to the thread. Admins can tune via /manage-channels.
+    engage_mode: 'mention-sticky',
+    engage_pattern: null,
+    sender_scope: 'all',
+    ignored_message_policy: 'drop',
+    session_mode: 'shared',
+    priority: 0,
+    created_at: new Date().toISOString(),
+  });
+  console.log('Created messaging_group_agent link');
+} catch (err: any) {
+  if (err.message?.includes('UNIQUE')) {
+    console.log('Messaging group agent link already exists');
+  } else {
+    throw err;
+  }
+}
+
+console.log('Done! Run: pnpm run build && node dist/index.js');

package/scripts/test-v2-agent.ts

@@ -0,0 +1,106 @@
+/**
+ * Quick integration test: create a session DB, insert a message,
+ * run the v2 poll loop with the Claude provider, verify output.
+ *
+ * Usage: pnpm exec tsx scripts/test-v2-agent.ts
+ */
+import Database from 'better-sqlite3';
+import fs from 'fs';
+
+const TEST_DIR = '/tmp/paraclaw-v2-test';
+const DB_PATH = `${TEST_DIR}/session.db`;
+
+// Clean up
+if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
+fs.mkdirSync(TEST_DIR, { recursive: true });
+
+// Create session DB
+const db = new Database(DB_PATH);
+db.pragma('journal_mode = WAL');
+db.exec(`
+  CREATE TABLE messages_in (
+    id TEXT PRIMARY KEY, kind TEXT NOT NULL, timestamp TEXT NOT NULL,
+    status TEXT DEFAULT 'pending', status_changed TEXT, process_after TEXT,
+    recurrence TEXT, tries INTEGER DEFAULT 0, platform_id TEXT,
+    channel_type TEXT, thread_id TEXT, content TEXT NOT NULL
+  );
+  CREATE TABLE messages_out (
+    id TEXT PRIMARY KEY, in_reply_to TEXT, timestamp TEXT NOT NULL,
+    delivered INTEGER DEFAULT 0, deliver_after TEXT, recurrence TEXT,
+    kind TEXT NOT NULL, platform_id TEXT, channel_type TEXT,
+    thread_id TEXT, content TEXT NOT NULL
+  );
+`);
+
+// Insert test message
+db.prepare(`INSERT INTO messages_in (id, kind, timestamp, status, content) VALUES (?, 'chat', datetime('now'), 'pending', ?)`).run(
+  'test-1',
+  JSON.stringify({ sender: 'Gavriel', text: 'Say "Hello from v2!" and nothing else. Do not use any tools.' }),
+);
+console.log('✓ Session DB created with test message');
+db.close();
+
+// Set env and run the poll loop
+process.env.SESSION_DB_PATH = DB_PATH;
+process.env.AGENT_PROVIDER = 'claude';
+
+const { getSessionDb, closeSessionDb } = await import('../container/agent-runner/src/db/connection.js');
+const { getUndeliveredMessages } = await import('../container/agent-runner/src/db/messages-out.js');
+const { getPendingMessages } = await import('../container/agent-runner/src/db/messages-in.js');
+const { createProvider } = await import('../container/agent-runner/src/providers/factory.js');
+const { runPollLoop } = await import('../container/agent-runner/src/poll-loop.js');
+
+const provider = createProvider('claude');
+
+console.log('✓ Claude provider created');
+console.log('⏳ Starting poll loop (will timeout after 60s)...');
+
+// Run with timeout
+const timeout = setTimeout(() => {
+  console.log('\n✗ Timed out after 60s');
+  printResults();
+  process.exit(1);
+}, 60_000);
+
+// Poll for results in parallel
+const resultChecker = setInterval(() => {
+  try {
+    const out = getUndeliveredMessages();
+    if (out.length > 0) {
+      clearTimeout(timeout);
+      clearInterval(resultChecker);
+      console.log('\n✓ Got response!');
+      printResults();
+      process.exit(0);
+    }
+  } catch {
+    // DB might be locked, retry
+  }
+}, 500);
+
+function printResults() {
+  const db2 = new Database(DB_PATH, { readonly: true });
+  const inRows = db2.prepare('SELECT * FROM messages_in').all() as Array<Record<string, unknown>>;
+  const outRows = db2.prepare('SELECT * FROM messages_out').all() as Array<Record<string, unknown>>;
+  console.log('\n--- messages_in ---');
+  for (const r of inRows) {
+    console.log(`  [${r.id}] status=${r.status} kind=${r.kind} content=${r.content}`);
+  }
+  console.log('\n--- messages_out ---');
+  for (const r of outRows) {
+    console.log(`  [${r.id}] kind=${r.kind} content=${r.content}`);
+  }
+  db2.close();
+}
+
+// Start the poll loop (runs forever, we exit from the checker above)
+try {
+  await runPollLoop({
+    provider,
+    cwd: TEST_DIR,
+    mcpServers: {},
+    env: { ...process.env },
+  });
+} catch (err) {
+  // Expected — we force exit
+}

package/scripts/test-v2-channel-e2e.ts

@@ -0,0 +1,265 @@
+/**
+ * End-to-end test of v2 channel adapter pipeline:
+ *
+ * Mock adapter → onInbound → router → session DB → Docker container →
+ * agent-runner → Claude → messages_out → delivery → mock adapter.deliver()
+ *
+ * Usage: pnpm exec tsx scripts/test-v2-channel-e2e.ts
+ */
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import path from 'path';
+
+const TEST_DIR = '/tmp/paraclaw-v2-channel-e2e';
+if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
+fs.mkdirSync(TEST_DIR, { recursive: true });
+
+// --- Step 1: Init central DB ---
+console.log('\n=== Step 1: Init central DB ===');
+
+import { initDb } from '../src/db/connection.js';
+import { runMigrations } from '../src/db/migrations/index.js';
+import { createAgentGroup } from '../src/db/agent-groups.js';
+import { createMessagingGroup, createMessagingGroupAgent } from '../src/db/messaging-groups.js';
+
+const centralDb = initDb(path.join(TEST_DIR, 'v2.db'));
+runMigrations(centralDb);
+
+// Create groups dir for agent folder mount
+const groupsDir = path.resolve(process.cwd(), 'groups');
+const testGroupDir = path.join(groupsDir, 'test-channel-e2e');
+fs.mkdirSync(testGroupDir, { recursive: true });
+fs.writeFileSync(path.join(testGroupDir, 'CLAUDE.md'), '# Test Agent\nYou are a test agent. Be brief.\n');
+
+createAgentGroup({
+  id: 'ag-chan',
+  name: 'Channel E2E Agent',
+  folder: 'test-channel-e2e',
+  agent_provider: 'claude',
+  created_at: new Date().toISOString(),
+});
+
+createMessagingGroup({
+  id: 'mg-chan',
+  channel_type: 'mock',
+  platform_id: 'mock-channel-1',
+  name: 'Mock Channel',
+  is_group: 0,
+  unknown_sender_policy: 'public',
+  created_at: new Date().toISOString(),
+});
+
+createMessagingGroupAgent({
+  id: 'mga-chan',
+  messaging_group_id: 'mg-chan',
+  agent_group_id: 'ag-chan',
+  engage_mode: 'pattern',
+  engage_pattern: '.',
+  sender_scope: 'all',
+  ignored_message_policy: 'drop',
+  session_mode: 'shared',
+  priority: 0,
+  created_at: new Date().toISOString(),
+});
+
+console.log('✓ Central DB initialized');
+
+// --- Step 2: Set up mock channel adapter + delivery ---
+console.log('\n=== Step 2: Set up mock channel adapter & delivery ===');
+
+import { routeInbound } from '../src/router.js';
+import { setDeliveryAdapter, startActiveDeliveryPoll, stopDeliveryPolls } from '../src/delivery.js';
+import { getChannelAdapter, registerChannelAdapter, initChannelAdapters } from '../src/channels/channel-registry.js';
+import { findSession } from '../src/db/sessions.js';
+import { sessionDbPath } from '../src/session-manager.js';
+import type { ChannelAdapter, ChannelSetup, OutboundMessage } from '../src/channels/adapter.js';
+
+// Track delivered messages
+const deliveredMessages: Array<{ platformId: string; threadId: string | null; message: OutboundMessage }> = [];
+let lastDeliveryTime = 0;
+const startTime = Date.now();
+
+// Create mock adapter
+const mockAdapter: ChannelAdapter = {
+  name: 'mock',
+  channelType: 'mock',
+
+  async setup(config: ChannelSetup) {
+    console.log(`  ✓ Mock adapter setup with ${config.conversations.length} conversations`);
+  },
+
+  async deliver(platformId, threadId, message) {
+    deliveredMessages.push({ platformId, threadId, message });
+    lastDeliveryTime = Date.now();
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    const content = message.content as Record<string, unknown>;
+    const text = ((content.text as string) || '').slice(0, 120);
+    console.log(`  ✓ [${elapsed}s] Delivered #${deliveredMessages.length}: ${text}...`);
+  },
+
+  async setTyping() {},
+  async teardown() {},
+  isConnected() { return true; },
+};
+
+// Register mock adapter
+registerChannelAdapter('mock', { factory: () => mockAdapter });
+
+// Init channel adapters — this calls setup() with conversation configs from central DB
+await initChannelAdapters((adapter) => ({
+  conversations: [
+    {
+      platformId: 'mock-channel-1',
+      agentGroupId: 'ag-chan',
+      engageMode: 'pattern',
+      engagePattern: '.',
+      sessionMode: 'shared',
+    },
+  ],
+  onInbound(platformId, threadId, message) {
+    routeInbound({
+      channelType: adapter.channelType,
+      platformId,
+      threadId,
+      message: {
+        id: message.id,
+        kind: message.kind,
+        content: JSON.stringify(message.content),
+        timestamp: message.timestamp,
+      },
+    }).catch((err) => console.error('Route error:', err));
+  },
+  onMetadata() {},
+}));
+
+// Set up delivery adapter bridge
+setDeliveryAdapter({
+  async deliver(channelType, platformId, threadId, kind, content) {
+    const adapter = getChannelAdapter(channelType);
+    if (!adapter) return;
+    await adapter.deliver(platformId, threadId, { kind, content: JSON.parse(content) });
+  },
+});
+
+// Start delivery polling
+startActiveDeliveryPoll();
+console.log('✓ Mock adapter & delivery configured');
+
+// --- Step 3: Simulate inbound message through adapter ---
+console.log('\n=== Step 3: Simulate inbound message ===');
+
+// This is what a real adapter would do when receiving a platform message
+const adapterSetup = (mockAdapter as { _setup?: ChannelSetup })._setup;
+
+// Call routeInbound directly (simulating onInbound callback)
+await routeInbound({
+  channelType: 'mock',
+  platformId: 'mock-channel-1',
+  threadId: null,
+  message: {
+    id: 'msg-chan-1',
+    kind: 'chat',
+    content: JSON.stringify({
+      sender: 'Gavriel',
+      text: 'Call the send_message tool 3 times: text="Update 1", text="Update 2", text="Update 3". Make each call separately. After all 3, say "Done".',
+    }),
+    timestamp: new Date().toISOString(),
+  },
+});
+
+const session = findSession('mg-chan', null);
+if (!session) {
+  console.log('✗ No session created!');
+  cleanup();
+  process.exit(1);
+}
+console.log(`✓ Session: ${session.id}`);
+console.log(`✓ Container status: ${session.container_status}`);
+
+import { execSync } from 'child_process';
+const checkContainerLogs = () => {
+  try {
+    const containers = execSync('docker ps -a --filter name=paraclaw-v2-test-channel --format "{{.Names}}"').toString().trim();
+    for (const name of containers.split('\n').filter(Boolean)) {
+      console.log(`\nContainer logs (${name}):`);
+      console.log(execSync(`docker logs ${name} 2>&1`).toString());
+    }
+  } catch { /* ignore */ }
+};
+
+const sessDbPath = sessionDbPath('ag-chan', session.id);
+console.log(`✓ Session DB: ${sessDbPath}`);
+
+// --- Step 4: Wait for delivery through mock adapter ---
+console.log('\n=== Step 4: Waiting for delivery through mock adapter... ===');
+const TIMEOUT_MS = 300_000;
+
+// Wait for deliveries — resolve when no new ones for 30s after first delivery
+await new Promise<void>((resolve) => {
+  const poll = () => {
+    if (lastDeliveryTime > 0 && Date.now() - lastDeliveryTime > 30_000) {
+      resolve();
+      return;
+    }
+    if (Date.now() - startTime > TIMEOUT_MS) {
+      console.log(`\n✗ Timed out after ${TIMEOUT_MS / 1000}s`);
+      // Check session DB directly
+      try {
+        const db = new Database(sessDbPath, { readonly: true });
+        const out = db.prepare('SELECT * FROM messages_out').all();
+        console.log(`  messages_out rows: ${out.length}`);
+        if (out.length > 0) console.log('  (messages exist but delivery failed)');
+        db.close();
+      } catch { /* ignore */ }
+      checkContainerLogs();
+      cleanup();
+      process.exit(1);
+    }
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    if (elapsed > 0 && elapsed % 10 === 0) {
+      process.stdout.write(`  ${elapsed}s...`);
+    }
+    setTimeout(poll, 1000);
+  };
+  poll();
+});
+
+// --- Step 5: Print results ---
+console.log('\n\n=== Results ===');
+
+console.log('\nSession DB:');
+try {
+  const db = new Database(sessDbPath, { readonly: true });
+  const inRows = db.prepare('SELECT * FROM messages_in').all() as Array<Record<string, unknown>>;
+  const outRows = db.prepare('SELECT * FROM messages_out').all() as Array<Record<string, unknown>>;
+  db.close();
+
+  console.log(`  messages_in: ${inRows.length} row(s)`);
+  for (const r of inRows) {
+    console.log(`    [${r.id}] status=${r.status} kind=${r.kind}`);
+  }
+  console.log(`  messages_out: ${outRows.length} row(s)`);
+  for (const r of outRows) {
+    const content = JSON.parse(r.content as string);
+    console.log(`    [${r.id}] kind=${r.kind} delivered=${r.delivered}`);
+    console.log(`    → ${content.text}`);
+  }
+} catch (err) {
+  console.log(`  (could not read session DB: ${err})`);
+}
+
+console.log('\nDelivered through mock adapter:');
+for (const d of deliveredMessages) {
+  const content = d.message.content as Record<string, unknown>;
+  console.log(`  → [${d.platformId}] ${content.text}`);
+}
+
+console.log('\n✓ Full channel adapter pipeline verified!');
+
+cleanup();
+process.exit(0);
+
+function cleanup() {
+  stopDeliveryPolls();
+  fs.rmSync(testGroupDir, { recursive: true, force: true });
+}