@openparachute/agent 0.1.0

package/src/host-core.test.ts

@@ -0,0 +1,456 @@
+/**
+ * Integration tests for the v2 host core.
+ * Tests routing, session creation, message writing, and delivery
+ * without spawning actual containers.
+ */
+import { openDb } from './db/connection.js';
+import fs from 'fs';
+import path from 'path';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+import {
+  initTestDb,
+  closeDb,
+  runMigrations,
+  createAgentGroup,
+  createMessagingGroup,
+  createMessagingGroupAgent,
+} from './db/index.js';
+import {
+  resolveSession,
+  writeSessionMessage,
+  initSessionFolder,
+  sessionDir,
+  inboundDbPath,
+  outboundDbPath,
+} from './session-manager.js';
+import { getSession, findSession } from './db/sessions.js';
+import type { InboundEvent } from './channels/adapter.js';
+
+// Mock container runner to prevent actual Docker spawning
+vi.mock('./container-runner.js', () => ({
+  wakeContainer: vi.fn().mockResolvedValue(undefined),
+  isContainerRunning: vi.fn().mockReturnValue(false),
+  getActiveContainerCount: vi.fn().mockReturnValue(0),
+  killContainer: vi.fn(),
+}));
+
+// Override DATA_DIR for tests
+vi.mock('./config.js', async () => {
+  const actual = await vi.importActual('./config.js');
+  return { ...actual, DATA_DIR: '/tmp/paraclaw-test-host' };
+});
+
+function now() {
+  return new Date().toISOString();
+}
+
+const TEST_DIR = '/tmp/paraclaw-test-host';
+
+beforeEach(() => {
+  // Clean test directory
+  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
+  fs.mkdirSync(TEST_DIR, { recursive: true });
+
+  const db = initTestDb();
+  runMigrations(db);
+});
+
+afterEach(() => {
+  closeDb();
+  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
+});
+
+describe('session manager', () => {
+  beforeEach(() => {
+    createAgentGroup({
+      id: 'ag-1',
+      name: 'Test Agent',
+      folder: 'test-agent',
+      agent_provider: null,
+      created_at: now(),
+    });
+    createMessagingGroup({
+      id: 'mg-1',
+      channel_type: 'discord',
+      platform_id: 'chan-123',
+      name: 'General',
+      is_group: 1,
+      unknown_sender_policy: 'strict',
+      created_at: now(),
+    });
+  });
+
+  it('should create session folder and both DBs', () => {
+    initSessionFolder('ag-1', 'sess-test');
+    const dir = sessionDir('ag-1', 'sess-test');
+    expect(fs.existsSync(dir)).toBe(true);
+    expect(fs.existsSync(path.join(dir, 'outbox'))).toBe(true);
+
+    // Verify inbound.db
+    const inPath = inboundDbPath('ag-1', 'sess-test');
+    expect(fs.existsSync(inPath)).toBe(true);
+    const inDb = openDb(inPath);
+    const inTables = inDb.prepare("SELECT name FROM sqlite_master WHERE type='table'").all() as Array<{ name: string }>;
+    expect(inTables.map((t) => t.name)).toContain('messages_in');
+    expect(inTables.map((t) => t.name)).toContain('delivered');
+    inDb.close();
+
+    // Verify outbound.db
+    const outPath = outboundDbPath('ag-1', 'sess-test');
+    expect(fs.existsSync(outPath)).toBe(true);
+    const outDb = openDb(outPath);
+    const outTables = outDb.prepare("SELECT name FROM sqlite_master WHERE type='table'").all() as Array<{
+      name: string;
+    }>;
+    expect(outTables.map((t) => t.name)).toContain('messages_out');
+    expect(outTables.map((t) => t.name)).toContain('processing_ack');
+    outDb.close();
+  });
+
+  it('should resolve to existing session (shared mode)', () => {
+    const { session: s1, created: c1 } = resolveSession('ag-1', 'mg-1', null, 'shared');
+    expect(c1).toBe(true);
+
+    const { session: s2, created: c2 } = resolveSession('ag-1', 'mg-1', null, 'shared');
+    expect(c2).toBe(false);
+    expect(s2.id).toBe(s1.id);
+  });
+
+  it('should create separate sessions per thread (per-thread mode)', () => {
+    const { session: s1 } = resolveSession('ag-1', 'mg-1', 'thread-1', 'per-thread');
+    const { session: s2 } = resolveSession('ag-1', 'mg-1', 'thread-2', 'per-thread');
+    expect(s1.id).not.toBe(s2.id);
+  });
+
+  it('should reuse session for same thread', () => {
+    const { session: s1 } = resolveSession('ag-1', 'mg-1', 'thread-1', 'per-thread');
+    const { session: s2, created } = resolveSession('ag-1', 'mg-1', 'thread-1', 'per-thread');
+    expect(created).toBe(false);
+    expect(s2.id).toBe(s1.id);
+  });
+
+  it('should write message to inbound DB', () => {
+    const { session } = resolveSession('ag-1', 'mg-1', null, 'shared');
+
+    writeSessionMessage('ag-1', session.id, {
+      id: 'msg-1',
+      kind: 'chat',
+      timestamp: now(),
+      platformId: 'chan-123',
+      channelType: 'discord',
+      threadId: null,
+      content: JSON.stringify({ sender: 'User', text: 'Hello' }),
+    });
+
+    // Read from the inbound DB
+    const dbPath = inboundDbPath('ag-1', session.id);
+    const db = openDb(dbPath);
+    const rows = db.prepare('SELECT * FROM messages_in').all() as Array<{
+      id: string;
+      kind: string;
+      status: string;
+      content: string;
+    }>;
+    db.close();
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0].id).toBe('msg-1');
+    expect(rows[0].status).toBe('pending');
+    expect(JSON.parse(rows[0].content).text).toBe('Hello');
+  });
+
+  it('should update last_active on message write', () => {
+    const { session } = resolveSession('ag-1', 'mg-1', null, 'shared');
+    expect(getSession(session.id)!.last_active).toBeNull();
+
+    writeSessionMessage('ag-1', session.id, {
+      id: 'msg-1',
+      kind: 'chat',
+      timestamp: now(),
+      content: JSON.stringify({ text: 'hi' }),
+    });
+
+    expect(getSession(session.id)!.last_active).not.toBeNull();
+  });
+});
+
+describe('router', () => {
+  beforeEach(() => {
+    createAgentGroup({
+      id: 'ag-1',
+      name: 'Test Agent',
+      folder: 'test-agent',
+      agent_provider: null,
+      created_at: now(),
+    });
+    // Use 'public' policy so the router tests exercise routing, not the
+    // access gate. Dedicated access-gate tests live with the access module.
+    createMessagingGroup({
+      id: 'mg-1',
+      channel_type: 'discord',
+      platform_id: 'chan-123',
+      name: 'General',
+      is_group: 1,
+      unknown_sender_policy: 'public',
+      created_at: now(),
+    });
+    createMessagingGroupAgent({
+      id: 'mga-1',
+      messaging_group_id: 'mg-1',
+      agent_group_id: 'ag-1',
+      engage_mode: 'pattern',
+      engage_pattern: '.',
+      sender_scope: 'all',
+      ignored_message_policy: 'drop',
+      session_mode: 'shared',
+      priority: 0,
+      created_at: now(),
+    });
+  });
+
+  it('should route a message end-to-end', async () => {
+    const { routeInbound } = await import('./router.js');
+    const { wakeContainer } = await import('./container-runner.js');
+
+    const event: InboundEvent = {
+      channelType: 'discord',
+      platformId: 'chan-123',
+      threadId: null,
+      message: {
+        id: 'msg-in-1',
+        kind: 'chat',
+        content: JSON.stringify({ sender: 'User', text: 'Hello agent!' }),
+        timestamp: now(),
+      },
+    };
+
+    await routeInbound(event);
+
+    // Verify session was created
+    const session = findSession('mg-1', null);
+    expect(session).toBeDefined();
+
+    // Verify message was written to inbound DB
+    const dbPath = inboundDbPath('ag-1', session!.id);
+    const db = openDb(dbPath);
+    const rows = db.prepare('SELECT * FROM messages_in').all() as Array<{ id: string; content: string }>;
+    db.close();
+
+    expect(rows).toHaveLength(1);
+    expect(JSON.parse(rows[0].content).text).toBe('Hello agent!');
+
+    // Verify container was woken
+    expect(wakeContainer).toHaveBeenCalled();
+  });
+
+  it('auto-creates messaging group only when the bot is addressed (mention/DM)', async () => {
+    // The router's no-mg branch is escalation-gated: plain chatter on an
+    // unknown channel stays silent (no DB writes) so a bot that sits in
+    // many unwired channels doesn't bloat messaging_groups. Only explicit
+    // mentions and DMs trigger auto-create.
+    const { routeInbound } = await import('./router.js');
+    const { getMessagingGroupByPlatform } = await import('./db/messaging-groups.js');
+
+    // Plain message on unknown channel — should NOT auto-create.
+    await routeInbound({
+      channelType: 'slack',
+      platformId: 'C-PLAIN',
+      threadId: null,
+      message: {
+        id: 'msg-plain',
+        kind: 'chat',
+        content: JSON.stringify({ sender: 'User', text: 'Hi' }),
+        timestamp: now(),
+      },
+    });
+    expect(getMessagingGroupByPlatform('slack', 'C-PLAIN')).toBeUndefined();
+
+    // Mention on unknown channel — SHOULD auto-create (next step: channel-registration flow).
+    await routeInbound({
+      channelType: 'slack',
+      platformId: 'C-MENTIONED',
+      threadId: null,
+      message: {
+        id: 'msg-mentioned',
+        kind: 'chat',
+        content: JSON.stringify({ sender: 'User', text: '@bot hi' }),
+        timestamp: now(),
+        isMention: true,
+      },
+    });
+    expect(getMessagingGroupByPlatform('slack', 'C-MENTIONED')).toBeDefined();
+  });
+
+  it('should route multiple messages to the same session', async () => {
+    const { routeInbound } = await import('./router.js');
+
+    await routeInbound({
+      channelType: 'discord',
+      platformId: 'chan-123',
+      threadId: null,
+      message: { id: 'msg-a', kind: 'chat', content: JSON.stringify({ sender: 'A', text: 'First' }), timestamp: now() },
+    });
+
+    await routeInbound({
+      channelType: 'discord',
+      platformId: 'chan-123',
+      threadId: null,
+      message: {
+        id: 'msg-b',
+        kind: 'chat',
+        content: JSON.stringify({ sender: 'B', text: 'Second' }),
+        timestamp: now(),
+      },
+    });
+
+    // Both should be in the same session
+    const session = findSession('mg-1', null);
+    const dbPath = inboundDbPath('ag-1', session!.id);
+    const db = openDb(dbPath);
+    const rows = db.prepare('SELECT * FROM messages_in ORDER BY timestamp').all();
+    db.close();
+
+    expect(rows).toHaveLength(2);
+  });
+
+  it('fans out to every matching agent, each in its own session', async () => {
+    const { routeInbound } = await import('./router.js');
+    const { wakeContainer } = await import('./container-runner.js');
+    (wakeContainer as unknown as ReturnType<typeof vi.fn>).mockClear();
+
+    // Wire a second agent to the same messaging group.
+    createAgentGroup({
+      id: 'ag-2',
+      name: 'Secondary Agent',
+      folder: 'secondary-agent',
+      agent_provider: null,
+      created_at: now(),
+    });
+    createMessagingGroupAgent({
+      id: 'mga-2',
+      messaging_group_id: 'mg-1',
+      agent_group_id: 'ag-2',
+      engage_mode: 'pattern',
+      engage_pattern: '.',
+      sender_scope: 'all',
+      ignored_message_policy: 'drop',
+      session_mode: 'shared',
+      priority: 0,
+      created_at: now(),
+    });
+
+    await routeInbound({
+      channelType: 'discord',
+      platformId: 'chan-123',
+      threadId: null,
+      message: { id: 'msg-fan', kind: 'chat', content: JSON.stringify({ text: 'hello all' }), timestamp: now() },
+    });
+
+    // Both agents should now have their own session and be woken.
+    expect(wakeContainer).toHaveBeenCalledTimes(2);
+
+    const { getSessionsByAgentGroup } = await import('./db/sessions.js');
+    expect(getSessionsByAgentGroup('ag-1')).toHaveLength(1);
+    expect(getSessionsByAgentGroup('ag-2')).toHaveLength(1);
+  });
+
+  it('accumulates without waking when engage fails + ignored_message_policy=accumulate', async () => {
+    const { routeInbound } = await import('./router.js');
+    const { wakeContainer } = await import('./container-runner.js');
+    (wakeContainer as unknown as ReturnType<typeof vi.fn>).mockClear();
+
+    // Replace the seed row with a mention-only wiring whose accumulate
+    // policy should store context even when the message doesn't mention us.
+    const { updateMessagingGroupAgent } = await import('./db/messaging-groups.js');
+    updateMessagingGroupAgent('mga-1', {
+      engage_mode: 'mention',
+      ignored_message_policy: 'accumulate',
+    });
+
+    await routeInbound({
+      channelType: 'discord',
+      platformId: 'chan-123',
+      threadId: null,
+      message: {
+        id: 'msg-nomatch',
+        kind: 'chat',
+        content: JSON.stringify({ text: 'no mention here' }),
+        timestamp: now(),
+      },
+    });
+
+    expect(wakeContainer).not.toHaveBeenCalled();
+
+    const session = findSession('mg-1', null);
+    expect(session).toBeDefined();
+    const db = openDb(inboundDbPath('ag-1', session!.id));
+    const rows = db.prepare('SELECT id, trigger FROM messages_in').all() as Array<{
+      id: string;
+      trigger: number;
+    }>;
+    db.close();
+    expect(rows).toHaveLength(1);
+    expect(rows[0].trigger).toBe(0);
+  });
+
+  it('drops silently when engage fails + ignored_message_policy=drop', async () => {
+    const { routeInbound } = await import('./router.js');
+    const { wakeContainer } = await import('./container-runner.js');
+    (wakeContainer as unknown as ReturnType<typeof vi.fn>).mockClear();
+
+    const { updateMessagingGroupAgent } = await import('./db/messaging-groups.js');
+    updateMessagingGroupAgent('mga-1', { engage_mode: 'mention' }); // drop is the default
+
+    await routeInbound({
+      channelType: 'discord',
+      platformId: 'chan-123',
+      threadId: null,
+      message: { id: 'msg-drop', kind: 'chat', content: JSON.stringify({ text: 'ignored' }), timestamp: now() },
+    });
+
+    expect(wakeContainer).not.toHaveBeenCalled();
+    // No session should have been created for this agent.
+    expect(findSession('mg-1', null)).toBeUndefined();
+  });
+});
+
+describe('delivery', () => {
+  it('should detect undelivered messages in outbound DB', () => {
+    createAgentGroup({
+      id: 'ag-1',
+      name: 'Agent',
+      folder: 'agent',
+      agent_provider: null,
+      created_at: now(),
+    });
+    createMessagingGroup({
+      id: 'mg-test',
+      channel_type: 'discord',
+      platform_id: 'chan-test',
+      name: 'Test',
+      is_group: 0,
+      unknown_sender_policy: 'strict',
+      created_at: now(),
+    });
+
+    const { session } = resolveSession('ag-1', 'mg-test', null, 'shared');
+
+    // Write a response to the outbound DB (simulating what the agent-runner does)
+    const dbPath = outboundDbPath('ag-1', session.id);
+    const db = openDb(dbPath);
+    db.prepare(
+      `INSERT INTO messages_out (id, timestamp, kind, platform_id, channel_type, content)
+       VALUES ('out-1', datetime('now'), 'chat', 'chan-123', 'discord', ?)`,
+    ).run(JSON.stringify({ text: 'Agent response' }));
+
+    const undelivered = db.prepare('SELECT * FROM messages_out').all() as Array<{
+      id: string;
+      content: string;
+    }>;
+    db.close();
+
+    expect(undelivered).toHaveLength(1);
+    expect(JSON.parse(undelivered[0].content).text).toBe('Agent response');
+  });
+});

package/src/host-sweep.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Unit tests for the stuck-container decision logic introduced by
+ * ACTION-ITEMS item 9. Lives on the pure helper `decideStuckAction` so we
+ * don't have to mock the filesystem or the container runner.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { ABSOLUTE_CEILING_MS, CLAIM_STUCK_MS, decideStuckAction } from './host-sweep.js';
+
+const BASE = Date.parse('2026-04-20T12:00:00.000Z');
+
+function claim(id: string, offsetMs: number) {
+  return { message_id: id, status_changed: new Date(BASE - offsetMs).toISOString() };
+}
+
+describe('decideStuckAction', () => {
+  it('returns ok when heartbeat is fresh and no claims', () => {
+    expect(
+      decideStuckAction({
+        now: BASE,
+        heartbeatMtimeMs: BASE - 5_000,
+        containerState: null,
+        claims: [],
+      }),
+    ).toEqual({ action: 'ok' });
+  });
+
+  it('returns kill-ceiling when heartbeat older than 30 min', () => {
+    const heartbeatMtimeMs = BASE - ABSOLUTE_CEILING_MS - 1_000;
+    const res = decideStuckAction({
+      now: BASE,
+      heartbeatMtimeMs,
+      containerState: null,
+      claims: [],
+    });
+    expect(res.action).toBe('kill-ceiling');
+    if (res.action !== 'kill-ceiling') return;
+    expect(res.ceilingMs).toBe(ABSOLUTE_CEILING_MS);
+    expect(res.heartbeatAgeMs).toBeGreaterThan(ABSOLUTE_CEILING_MS);
+  });
+
+  it('skips the ceiling check when no heartbeat file exists (fresh container not yet ticked)', () => {
+    // A freshly-spawned container hasn't produced any SDK events yet, so no
+    // heartbeat. Prior behavior treated this as infinitely stale and killed
+    // every container within seconds of spawn. With no claims either, we
+    // should conclude everything is fine.
+    const res = decideStuckAction({
+      now: BASE,
+      heartbeatMtimeMs: 0,
+      containerState: null,
+      claims: [],
+    });
+    expect(res.action).toBe('ok');
+  });
+
+  it('kills on claim-stuck when heartbeat is absent AND a claim has aged past tolerance', () => {
+    // Hanging fresh container: spawned, picked up a message (claim recorded
+    // in processing_ack), but never wrote a heartbeat. Falls through the
+    // skipped ceiling check into claim-stuck — which correctly fires.
+    const claimedAgeMs = CLAIM_STUCK_MS + 5_000;
+    const res = decideStuckAction({
+      now: BASE,
+      heartbeatMtimeMs: 0,
+      containerState: null,
+      claims: [claim('msg-1', claimedAgeMs)],
+    });
+    expect(res.action).toBe('kill-claim');
+  });
+
+  it('extends the ceiling when Bash has a declared timeout longer than 30 min', () => {
+    const twoHrMs = 2 * 60 * 60 * 1000;
+    const res = decideStuckAction({
+      now: BASE,
+      // 45 min — over the default ceiling, but under the Bash timeout
+      heartbeatMtimeMs: BASE - 45 * 60 * 1000,
+      containerState: {
+        current_tool: 'Bash',
+        tool_declared_timeout_ms: twoHrMs,
+        tool_started_at: new Date(BASE - 45 * 60 * 1000).toISOString(),
+      },
+      claims: [],
+    });
+    expect(res.action).toBe('ok');
+  });
+
+  it('returns kill-claim when a claim is past 60s and heartbeat has not moved', () => {
+    const claimedAgeMs = CLAIM_STUCK_MS + 10_000;
+    const res = decideStuckAction({
+      now: BASE,
+      heartbeatMtimeMs: BASE - claimedAgeMs - 5_000, // older than the claim
+      containerState: null,
+      claims: [claim('msg-1', claimedAgeMs)],
+    });
+    expect(res.action).toBe('kill-claim');
+    if (res.action !== 'kill-claim') return;
+    expect(res.messageId).toBe('msg-1');
+    expect(res.toleranceMs).toBe(CLAIM_STUCK_MS);
+  });
+
+  it('does not kill when heartbeat has been touched since the claim', () => {
+    const claimedAgeMs = CLAIM_STUCK_MS + 10_000;
+    const res = decideStuckAction({
+      now: BASE,
+      heartbeatMtimeMs: BASE - 2_000, // fresh, updated after the claim
+      containerState: null,
+      claims: [claim('msg-1', claimedAgeMs)],
+    });
+    expect(res.action).toBe('ok');
+  });
+
+  it('does not kill when claim age is below tolerance', () => {
+    const res = decideStuckAction({
+      now: BASE,
+      heartbeatMtimeMs: BASE - CLAIM_STUCK_MS - 10_000, // old, but claim is recent
+      containerState: null,
+      claims: [claim('msg-1', 5_000)],
+    });
+    expect(res.action).toBe('ok');
+  });
+
+  it('widens per-claim tolerance for a running Bash with long timeout', () => {
+    const tenMinMs = 10 * 60 * 1000;
+    const res = decideStuckAction({
+      now: BASE,
+      // 5 min since claim, over the 60s default but under the declared Bash timeout
+      heartbeatMtimeMs: BASE - 5 * 60 * 1000 - 5_000,
+      containerState: {
+        current_tool: 'Bash',
+        tool_declared_timeout_ms: tenMinMs,
+        tool_started_at: new Date(BASE - 5 * 60 * 1000).toISOString(),
+      },
+      claims: [claim('msg-1', 5 * 60 * 1000)],
+    });
+    expect(res.action).toBe('ok');
+  });
+
+  it('ignores claims with unparseable timestamps', () => {
+    const res = decideStuckAction({
+      now: BASE,
+      heartbeatMtimeMs: BASE - 5_000,
+      containerState: null,
+      claims: [{ message_id: 'x', status_changed: 'not-a-date' }],
+    });
+    expect(res.action).toBe('ok');
+  });
+});