@openparachute/agent 0.1.2 → 0.2.2

package/src/host-core.test.ts

@@ -1,456 +0,0 @@
-/**
- * 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

@@ -1,146 +0,0 @@
-/**
- * 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');
-  });
-});