@openparachute/agent 0.1.2 → 0.2.2

package/src/session-manager.attachments.test.ts

@@ -1,171 +0,0 @@
-/**
- * Regression coverage for paraclaw#96 — silent file clobber on mutated
- * replays. After paraclaw#92 / #95 made duplicate-dispatch
- * (sender-approval replay etc.) a warm path, the attachment-extraction
- * step in writeSessionMessage must run only AFTER the row commits, or a
- * mutated replay rewrites the on-disk file under the original
- * messages_in.id while the DB row stays unchanged.
- *
- * Real session DBs (no execSync mock) — file-clobber-class hazards are
- * easy to fake green with mocked filesystem state.
- */
-import fs from 'fs';
-import path from 'path';
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-
-import { openDb } from './db/connection.js';
-import { initTestDb, closeDb, runMigrations, createAgentGroup } from './db/index.js';
-import { initSessionFolder, inboundDbPath, sessionDir, writeSessionMessage } from './session-manager.js';
-
-vi.mock('./config.js', async () => {
-  const actual = await vi.importActual('./config.js');
-  return { ...actual, DATA_DIR: '/tmp/paraclaw-test-attachments' };
-});
-
-const TEST_DIR = '/tmp/paraclaw-test-attachments';
-const AG = 'ag-1';
-const SESS = 'sess-attachments';
-
-function nowIso(): string {
-  return new Date().toISOString();
-}
-
-function readRowContent(): string {
-  const db = openDb(inboundDbPath(AG, SESS));
-  const row = db.prepare('SELECT content FROM messages_in WHERE id = ?').get('msg-1') as { content: string };
-  db.close();
-  return row.content;
-}
-
-function inboxFilePath(filename: string): string {
-  return path.join(sessionDir(AG, SESS), 'inbox', 'msg-1', filename);
-}
-
-function makeMessageWithAttachment(dataB64: string) {
-  return {
-    id: 'msg-1',
-    kind: 'chat',
-    timestamp: nowIso(),
-    platformId: 'chan-1',
-    channelType: 'discord',
-    threadId: null as string | null,
-    content: JSON.stringify({
-      text: 'see attachment',
-      attachments: [{ name: 'photo.jpg', type: 'image', size: 9, data: dataB64 }],
-    }),
-  };
-}
-
-const ORIGINAL_BYTES = Buffer.from('first-pic');
-const MUTATED_BYTES = Buffer.from('CLOBBERED');
-
-beforeEach(() => {
-  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-  fs.mkdirSync(TEST_DIR, { recursive: true });
-
-  const db = initTestDb();
-  runMigrations(db);
-
-  createAgentGroup({
-    id: AG,
-    name: 'Test Agent',
-    folder: 'test-agent',
-    agent_provider: null,
-    created_at: nowIso(),
-  });
-  // Fresh-start a session manually — we don't need a messaging group for
-  // these tests, just the session folder + DBs.
-  const sessRow = {
-    id: SESS,
-    agent_group_id: AG,
-    messaging_group_id: null,
-    thread_id: null,
-    agent_provider: null,
-    status: 'active' as const,
-    container_status: 'stopped' as const,
-    last_active: null,
-    created_at: nowIso(),
-  };
-  db.prepare(
-    `INSERT INTO sessions (id, agent_group_id, messaging_group_id, thread_id, agent_provider,
-       status, container_status, last_active, created_at)
-     VALUES (@id, @agent_group_id, @messaging_group_id, @thread_id, @agent_provider,
-       @status, @container_status, @last_active, @created_at)`,
-  ).run(sessRow);
-  initSessionFolder(AG, SESS);
-});
-
-afterEach(() => {
-  closeDb();
-  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-});
-
-describe('writeSessionMessage — attachment extraction order (paraclaw#96)', () => {
-  it('fresh insert with attachment: row content has localPath, file written to inbox', () => {
-    writeSessionMessage(AG, SESS, makeMessageWithAttachment(ORIGINAL_BYTES.toString('base64')));
-
-    const parsed = JSON.parse(readRowContent());
-    expect(parsed.attachments).toHaveLength(1);
-    expect(parsed.attachments[0].localPath).toBe('inbox/msg-1/photo.jpg');
-    expect(parsed.attachments[0].data).toBeUndefined();
-
-    const onDisk = fs.readFileSync(inboxFilePath('photo.jpg'));
-    expect(onDisk.equals(ORIGINAL_BYTES)).toBe(true);
-  });
-
-  it('fresh insert without attachments: row content unchanged, no inbox dir created', () => {
-    writeSessionMessage(AG, SESS, {
-      id: 'msg-1',
-      kind: 'chat',
-      timestamp: nowIso(),
-      content: JSON.stringify({ text: 'no attachments here' }),
-    });
-
-    expect(JSON.parse(readRowContent()).text).toBe('no attachments here');
-    expect(fs.existsSync(path.join(sessionDir(AG, SESS), 'inbox'))).toBe(false);
-  });
-
-  it('duplicate dispatch with identical bytes: silently absorbed, file untouched', () => {
-    const msg = makeMessageWithAttachment(ORIGINAL_BYTES.toString('base64'));
-
-    writeSessionMessage(AG, SESS, msg);
-    const firstMtime = fs.statSync(inboxFilePath('photo.jpg')).mtimeMs;
-
-    // Sleep just enough to make a re-write detectable in mtime resolution.
-    const wait = Date.now() + 20;
-    while (Date.now() < wait) {
-      /* spin */
-    }
-
-    writeSessionMessage(AG, SESS, msg);
-
-    // File was NOT re-written — mtime unchanged.
-    expect(fs.statSync(inboxFilePath('photo.jpg')).mtimeMs).toBe(firstMtime);
-    expect(fs.readFileSync(inboxFilePath('photo.jpg')).equals(ORIGINAL_BYTES)).toBe(true);
-  });
-
-  it('duplicate dispatch with MUTATED bytes (replay hazard): on-disk file preserved byte-for-byte', () => {
-    // The exact failure shape paraclaw#96 calls out: a replay that re-uses
-    // the same messages_in.id but carries different attachment bytes. Pre-fix,
-    // the second call's extractAttachmentFiles ran before the dup-check and
-    // would have overwritten photo.jpg with MUTATED_BYTES while the DB row
-    // still pointed at the original commit.
-    writeSessionMessage(AG, SESS, makeMessageWithAttachment(ORIGINAL_BYTES.toString('base64')));
-    const rowAfterFirst = readRowContent();
-
-    writeSessionMessage(AG, SESS, makeMessageWithAttachment(MUTATED_BYTES.toString('base64')));
-
-    // 1. On-disk file is byte-for-byte the original — NO clobber.
-    const onDisk = fs.readFileSync(inboxFilePath('photo.jpg'));
-    expect(onDisk.equals(ORIGINAL_BYTES)).toBe(true);
-    expect(onDisk.equals(MUTATED_BYTES)).toBe(false);
-
-    // 2. Only the original row exists; the replay didn't slip a new row in.
-    const db = openDb(inboundDbPath(AG, SESS));
-    const rows = db.prepare('SELECT id, content FROM messages_in').all() as Array<{ id: string; content: string }>;
-    db.close();
-    expect(rows).toHaveLength(1);
-    expect(rows[0].content).toBe(rowAfterFirst);
-  });
-});

package/src/session-manager.dup-skip.test.ts

@@ -1,173 +0,0 @@
-/**
- * Integration coverage for paraclaw#97 — writeSessionMessage's dup-skip
- * side effects beyond the SQL-layer assertions in #95.
- *
- * After paraclaw#92 / #95, ON CONFLICT(id) DO NOTHING absorbs the second
- * INSERT, and writeSessionMessage gates two side effects on inserted=true:
- *   1. session.last_active is NOT bumped on the dup
- *   2. extractAttachmentFiles never runs (paraclaw#96 / #120)
- *   3. A debug log fires so drops are observable
- *
- * The session-manager.attachments.test.ts file already covers #2 with
- * sequential pairs. This file adds the integration-level invariants the
- * issue calls out as still untested at the writeSessionMessage layer:
- * last_active discipline, debug log shape, and dup-skip behavior under
- * realistic dispatcher pressure (Promise.all'd same-id calls).
- *
- * Real session DBs + real fs — last_active and file invariants are the
- * kind that mocks can fake green.
- */
-import fs from 'fs';
-import path from 'path';
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-
-import { openDb } from './db/connection.js';
-import { initTestDb, closeDb, runMigrations, createAgentGroup, getSession } from './db/index.js';
-import { log } from './log.js';
-import { initSessionFolder, inboundDbPath, sessionDir, writeSessionMessage } from './session-manager.js';
-
-vi.mock('./config.js', async () => {
-  const actual = await vi.importActual('./config.js');
-  return { ...actual, DATA_DIR: '/tmp/paraclaw-test-dup-skip' };
-});
-
-const TEST_DIR = '/tmp/paraclaw-test-dup-skip';
-const AG = 'ag-1';
-const SESS = 'sess-dup';
-
-function nowIso(): string {
-  return new Date().toISOString();
-}
-
-function rowsInMessagesIn(): Array<{ id: string }> {
-  const db = openDb(inboundDbPath(AG, SESS));
-  const rows = db.prepare('SELECT id FROM messages_in').all() as Array<{ id: string }>;
-  db.close();
-  return rows;
-}
-
-function makeMessage(id: string) {
-  return {
-    id,
-    kind: 'chat',
-    timestamp: nowIso(),
-    platformId: 'chan-1',
-    channelType: 'discord',
-    threadId: null as string | null,
-    content: JSON.stringify({
-      text: 'hello',
-      attachments: [{ name: 'doc.bin', type: 'file', size: 4, data: Buffer.from('aaaa').toString('base64') }],
-    }),
-  };
-}
-
-beforeEach(() => {
-  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-  fs.mkdirSync(TEST_DIR, { recursive: true });
-
-  const db = initTestDb();
-  runMigrations(db);
-
-  createAgentGroup({
-    id: AG,
-    name: 'Test Agent',
-    folder: 'test-agent',
-    agent_provider: null,
-    created_at: nowIso(),
-  });
-  db.prepare(
-    `INSERT INTO sessions (id, agent_group_id, messaging_group_id, thread_id, agent_provider,
-       status, container_status, last_active, created_at)
-     VALUES (@id, @agent_group_id, @messaging_group_id, @thread_id, @agent_provider,
-       @status, @container_status, @last_active, @created_at)`,
-  ).run({
-    id: SESS,
-    agent_group_id: AG,
-    messaging_group_id: null,
-    thread_id: null,
-    agent_provider: null,
-    status: 'active' as const,
-    container_status: 'stopped' as const,
-    last_active: null,
-    created_at: nowIso(),
-  });
-  initSessionFolder(AG, SESS);
-});
-
-afterEach(() => {
-  closeDb();
-  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
-  vi.restoreAllMocks();
-});
-
-describe('writeSessionMessage — dup-skip side effects (paraclaw#97)', () => {
-  it('does NOT bump session.last_active on a duplicate dispatch', async () => {
-    writeSessionMessage(AG, SESS, makeMessage('msg-1'));
-
-    const firstActive = getSession(SESS)!.last_active;
-    expect(firstActive).not.toBeNull();
-
-    // Sleep enough for any new ISO timestamp to differ from the first.
-    await new Promise((r) => setTimeout(r, 25));
-
-    writeSessionMessage(AG, SESS, makeMessage('msg-1'));
-
-    const secondActive = getSession(SESS)!.last_active;
-    expect(secondActive).toBe(firstActive);
-
-    expect(rowsInMessagesIn()).toHaveLength(1);
-  });
-
-  it('emits a debug log on dup-skip with the expected payload', () => {
-    const debugSpy = vi.spyOn(log, 'debug');
-
-    writeSessionMessage(AG, SESS, makeMessage('msg-2'));
-    writeSessionMessage(AG, SESS, makeMessage('msg-2'));
-
-    const dupCalls = debugSpy.mock.calls.filter(
-      ([msg]) => typeof msg === 'string' && msg.includes('messages_in id already present'),
-    );
-    expect(dupCalls).toHaveLength(1);
-
-    const [, fields] = dupCalls[0]!;
-    expect(fields).toMatchObject({
-      agentGroupId: AG,
-      sessionId: SESS,
-      messageId: 'msg-2',
-    });
-  });
-
-  it('absorbs N near-concurrent same-id dispatches: one row, one file, no spurious sibling files', async () => {
-    // Promise.all-style dispatcher pressure. better-sqlite3 is synchronous so
-    // these serialize on the event loop, but the test shape captures what a
-    // future async refactor would have to preserve: same-id calls collapse
-    // to a single row + a single attachment file regardless of fan-in.
-    const calls = Array.from({ length: 6 }, () => writeSessionMessage(AG, SESS, makeMessage('msg-burst')));
-    await Promise.all(calls);
-
-    expect(rowsInMessagesIn()).toHaveLength(1);
-
-    const inboxDir = path.join(sessionDir(AG, SESS), 'inbox', 'msg-burst');
-    expect(fs.existsSync(inboxDir)).toBe(true);
-    const files = fs.readdirSync(inboxDir);
-    expect(files).toEqual(['doc.bin']);
-  });
-
-  it('different ids in the same burst all land — dup-skip is keyed on id, not on burst', async () => {
-    // Sanity check that the dup-skip absorption is NOT overly broad — distinct
-    // messages_in.id values still get their own rows + their own inbox dirs.
-    await Promise.all([
-      writeSessionMessage(AG, SESS, makeMessage('msg-a')),
-      writeSessionMessage(AG, SESS, makeMessage('msg-b')),
-      writeSessionMessage(AG, SESS, makeMessage('msg-c')),
-    ]);
-
-    const ids = rowsInMessagesIn()
-      .map((r) => r.id)
-      .sort();
-    expect(ids).toEqual(['msg-a', 'msg-b', 'msg-c']);
-
-    expect(fs.readdirSync(path.join(sessionDir(AG, SESS), 'inbox')).sort()).toEqual(['msg-a', 'msg-b', 'msg-c']);
-  });
-});

package/src/session-manager.migrate.test.ts

@@ -1,59 +0,0 @@
-/**
- * Coverage for migrateSessionsDir — operator-data-loss-prevention helper that
- * relocates `data/v2-sessions/` to `data/sessions/` on first boot after the
- * rename. Three cases pinned: fresh install, existing legacy, both present.
- */
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { migrateSessionsDir } from './session-manager.js';
-
-let tmp: string;
-let legacy: string;
-let current: string;
-
-beforeEach(() => {
-  tmp = mkdtempSync(join(tmpdir(), 'paraclaw-sessions-migrate-'));
-  legacy = join(tmp, 'v2-sessions');
-  current = join(tmp, 'sessions');
-});
-
-afterEach(() => {
-  rmSync(tmp, { recursive: true, force: true });
-});
-
-describe('migrateSessionsDir', () => {
-  it('fresh install — no legacy, no current — is a noop', () => {
-    migrateSessionsDir(legacy, current);
-    expect(existsSync(legacy)).toBe(false);
-    expect(existsSync(current)).toBe(false);
-  });
-
-  it('existing legacy — renames to current and preserves contents', () => {
-    mkdirSync(join(legacy, 'sess-abc'), { recursive: true });
-    writeFileSync(join(legacy, 'sess-abc', 'inbound.db'), 'marker');
-
-    migrateSessionsDir(legacy, current);
-
-    expect(existsSync(legacy)).toBe(false);
-    expect(existsSync(current)).toBe(true);
-    expect(readdirSync(current)).toEqual(['sess-abc']);
-    expect(existsSync(join(current, 'sess-abc', 'inbound.db'))).toBe(true);
-  });
-
-  it('both present — current wins, legacy left untouched (no clobber)', () => {
-    mkdirSync(join(legacy, 'sess-old'), { recursive: true });
-    writeFileSync(join(legacy, 'sess-old', 'inbound.db'), 'old');
-    mkdirSync(join(current, 'sess-new'), { recursive: true });
-    writeFileSync(join(current, 'sess-new', 'inbound.db'), 'new');
-
-    migrateSessionsDir(legacy, current);
-
-    expect(existsSync(legacy)).toBe(true);
-    expect(readdirSync(legacy)).toEqual(['sess-old']);
-    expect(readdirSync(current)).toEqual(['sess-new']);
-  });
-});