@openparachute/agent 0.1.0

package/container/agent-runner/src/db/session-state.test.ts

@@ -0,0 +1,100 @@
+import { beforeEach, describe, expect, test } from 'bun:test';
+
+import { getOutboundDb, initTestSessionDb } from './connection.js';
+import {
+  clearContinuation,
+  getContinuation,
+  migrateLegacyContinuation,
+  setContinuation,
+} from './session-state.js';
+
+beforeEach(() => {
+  initTestSessionDb();
+});
+
+function seedLegacy(value: string): void {
+  getOutboundDb()
+    .prepare('INSERT INTO session_state (key, value, updated_at) VALUES (?, ?, ?)')
+    .run('sdk_session_id', value, new Date().toISOString());
+}
+
+describe('session-state — per-provider continuations', () => {
+  test('set/get round-trip, case-insensitive provider key', () => {
+    setContinuation('claude', 'claude-conv-1');
+    expect(getContinuation('claude')).toBe('claude-conv-1');
+    expect(getContinuation('Claude')).toBe('claude-conv-1');
+    expect(getContinuation('CLAUDE')).toBe('claude-conv-1');
+  });
+
+  test('providers are isolated — switching reads the right slot', () => {
+    setContinuation('claude', 'claude-conv-1');
+    setContinuation('codex', 'codex-thread-xyz');
+
+    expect(getContinuation('claude')).toBe('claude-conv-1');
+    expect(getContinuation('codex')).toBe('codex-thread-xyz');
+  });
+
+  test('clearContinuation only affects the specified provider', () => {
+    setContinuation('claude', 'keep-me');
+    setContinuation('codex', 'drop-me');
+
+    clearContinuation('codex');
+
+    expect(getContinuation('claude')).toBe('keep-me');
+    expect(getContinuation('codex')).toBeUndefined();
+  });
+
+  test('unknown provider returns undefined', () => {
+    expect(getContinuation('never-used')).toBeUndefined();
+  });
+});
+
+describe('session-state — legacy migration', () => {
+  test('adopts legacy value into current provider when current is empty', () => {
+    seedLegacy('old-session-id');
+
+    const adopted = migrateLegacyContinuation('claude');
+
+    expect(adopted).toBe('old-session-id');
+    expect(getContinuation('claude')).toBe('old-session-id');
+  });
+
+  test('always deletes legacy row regardless of migration outcome', () => {
+    seedLegacy('old-session-id');
+    setContinuation('claude', 'existing');
+
+    migrateLegacyContinuation('claude');
+
+    // After migration the legacy key must be gone, whether or not it was adopted.
+    // A subsequent migration for a different provider must not see it.
+    const resultAfterSecondCall = migrateLegacyContinuation('codex');
+    expect(resultAfterSecondCall).toBeUndefined();
+  });
+
+  test('prefers existing current-provider slot over legacy', () => {
+    seedLegacy('legacy-value');
+    setContinuation('claude', 'claude-value');
+
+    const result = migrateLegacyContinuation('claude');
+
+    expect(result).toBe('claude-value');
+    expect(getContinuation('claude')).toBe('claude-value');
+  });
+
+  test('no legacy row — returns current provider value (possibly undefined)', () => {
+    expect(migrateLegacyContinuation('claude')).toBeUndefined();
+
+    setContinuation('codex', 'codex-value');
+    expect(migrateLegacyContinuation('codex')).toBe('codex-value');
+  });
+
+  test('migration is idempotent on a second call (legacy already gone)', () => {
+    seedLegacy('once');
+
+    const first = migrateLegacyContinuation('claude');
+    expect(first).toBe('once');
+
+    const second = migrateLegacyContinuation('claude');
+    expect(second).toBe('once');
+  });
+});

package/container/agent-runner/src/db/session-state.ts

@@ -0,0 +1,79 @@
+/**
+ * Persistent key/value state for the container. Lives in outbound.db
+ * (container-owned, already scoped per channel/thread).
+ *
+ * Primary use: remember each provider's opaque continuation id so the
+ * agent's conversation resumes across container restarts. Keyed per
+ * provider because continuations are provider-private — a Claude
+ * conversation id means nothing to Codex and vice versa. Switching
+ * providers is therefore lossless: each provider's last thread stays
+ * on file and resumes cleanly if the user flips back.
+ */
+import { getOutboundDb } from './connection.js';
+
+const LEGACY_KEY = 'sdk_session_id';
+
+function continuationKey(providerName: string): string {
+  return `continuation:${providerName.toLowerCase()}`;
+}
+
+function getValue(key: string): string | undefined {
+  const row = getOutboundDb()
+    .prepare('SELECT value FROM session_state WHERE key = ?')
+    .get(key) as { value: string } | undefined;
+  return row?.value;
+}
+
+function setValue(key: string, value: string): void {
+  getOutboundDb()
+    .prepare('INSERT OR REPLACE INTO session_state (key, value, updated_at) VALUES (?, ?, ?)')
+    .run(key, value, new Date().toISOString());
+}
+
+function deleteValue(key: string): void {
+  getOutboundDb().prepare('DELETE FROM session_state WHERE key = ?').run(key);
+}
+
+/**
+ * One-time migration of the pre-per-provider continuation row.
+ *
+ * Before this was keyed per provider, continuations lived under the
+ * single key `sdk_session_id`. On container start, if that legacy row
+ * exists and the current provider has no continuation of its own, adopt
+ * the legacy value into the current provider's slot (best-guess — the
+ * legacy row was written by whatever provider ran last). The legacy row
+ * is always deleted so future provider flips never re-read a stale id
+ * through the wrong lens.
+ *
+ * Returns the continuation the caller should use at startup (either the
+ * current provider's existing value, the adopted legacy value, or
+ * undefined).
+ */
+export function migrateLegacyContinuation(providerName: string): string | undefined {
+  const legacy = getValue(LEGACY_KEY);
+  const currentKey = continuationKey(providerName);
+  const current = getValue(currentKey);
+
+  if (legacy === undefined) return current;
+
+  // Always drop the legacy row so no future provider reads it.
+  deleteValue(LEGACY_KEY);
+
+  // Prefer the current provider's own slot if one already exists.
+  if (current !== undefined) return current;
+
+  setValue(currentKey, legacy);
+  return legacy;
+}
+
+export function getContinuation(providerName: string): string | undefined {
+  return getValue(continuationKey(providerName));
+}
+
+export function setContinuation(providerName: string, id: string): void {
+  setValue(continuationKey(providerName), id);
+}
+
+export function clearContinuation(providerName: string): void {
+  deleteValue(continuationKey(providerName));
+}

package/container/agent-runner/src/destinations.ts

@@ -0,0 +1,135 @@
+/**
+ * Destination map — lives in inbound.db's `destinations` table.
+ *
+ * The host writes this table before every container wake AND on demand
+ * (e.g. when a new child agent is created mid-session). The container
+ * queries the table live on every lookup, so admin changes take effect
+ * immediately — no restart required.
+ *
+ * This table is BOTH the routing map and the container-visible ACL.
+ * The host re-validates on the delivery side against the central DB,
+ * so even if this table is stale the host's enforcement is authoritative.
+ */
+import { getInboundDb } from './db/connection.js';
+
+export interface DestinationEntry {
+  name: string;
+  displayName: string;
+  type: 'channel' | 'agent';
+  channelType?: string;
+  platformId?: string;
+  agentGroupId?: string;
+}
+
+interface DestRow {
+  name: string;
+  display_name: string | null;
+  type: 'channel' | 'agent';
+  channel_type: string | null;
+  platform_id: string | null;
+  agent_group_id: string | null;
+}
+
+function rowToEntry(row: DestRow): DestinationEntry {
+  return {
+    name: row.name,
+    displayName: row.display_name ?? row.name,
+    type: row.type,
+    channelType: row.channel_type ?? undefined,
+    platformId: row.platform_id ?? undefined,
+    agentGroupId: row.agent_group_id ?? undefined,
+  };
+}
+
+export function getAllDestinations(): DestinationEntry[] {
+  const rows = getInboundDb().prepare('SELECT * FROM destinations ORDER BY name').all() as DestRow[];
+  return rows.map(rowToEntry);
+}
+
+export function findByName(name: string): DestinationEntry | undefined {
+  const row = getInboundDb().prepare('SELECT * FROM destinations WHERE name = ?').get(name) as DestRow | undefined;
+  return row ? rowToEntry(row) : undefined;
+}
+
+/**
+ * Reverse lookup: given routing fields from an inbound message, find
+ * which destination they correspond to (what does this agent call the sender?).
+ */
+export function findByRouting(
+  channelType: string | null | undefined,
+  platformId: string | null | undefined,
+): DestinationEntry | undefined {
+  if (!channelType || !platformId) return undefined;
+  const db = getInboundDb();
+  const row =
+    channelType === 'agent'
+      ? (db
+          .prepare("SELECT * FROM destinations WHERE type = 'agent' AND agent_group_id = ?")
+          .get(platformId) as DestRow | undefined)
+      : (db
+          .prepare("SELECT * FROM destinations WHERE type = 'channel' AND channel_type = ? AND platform_id = ?")
+          .get(channelType, platformId) as DestRow | undefined);
+  return row ? rowToEntry(row) : undefined;
+}
+
+/**
+ * Generate the system-prompt addendum: agent identity + destination map.
+ *
+ * Identity is injected here (not in the shared CLAUDE.md) because it's
+ * per-agent-group and changes when the operator renames an agent, while
+ * the shared base is identical across all agents.
+ */
+export function buildSystemPromptAddendum(assistantName?: string): string {
+  const sections: string[] = [];
+
+  if (assistantName) {
+    sections.push(['# You are ' + assistantName, '', `Your name is **${assistantName}**. Use it when the channel asks who you are, when introducing yourself, and when signing any message that explicitly calls for a signature.`].join('\n'));
+  }
+
+  sections.push(buildDestinationsSection());
+
+  return sections.join('\n\n');
+}
+
+function buildDestinationsSection(): string {
+  const all = getAllDestinations();
+
+  if (all.length === 0) {
+    return [
+      '## Sending messages',
+      '',
+      'You currently have no configured destinations. You cannot send messages until an admin wires one up.',
+    ].join('\n');
+  }
+
+  // Single-destination shortcut: the agent just writes its response normally.
+  if (all.length === 1) {
+    const d = all[0];
+    const label = d.displayName && d.displayName !== d.name ? ` (${d.displayName})` : '';
+    return [
+      '## Sending messages',
+      '',
+      `Your messages are delivered to \`${d.name}\`${label}. Just write your response directly — no special wrapping needed.`,
+      '',
+      'To mark something as scratchpad (logged but not sent), wrap it in `<internal>...</internal>`.',
+      '',
+      'To send a message mid-response (e.g., an acknowledgment before a long task), call the `send_message` MCP tool.',
+    ].join('\n');
+  }
+
+  const lines = ['## Sending messages', '', 'You can send messages to the following destinations:', ''];
+  for (const d of all) {
+    const label = d.displayName && d.displayName !== d.name ? ` (${d.displayName})` : '';
+    lines.push(`- \`${d.name}\`${label}`);
+  }
+  lines.push('');
+  lines.push('To send a message, wrap it in a `<message to="name">...</message>` block.');
+  lines.push('You can include multiple `<message>` blocks in one response to send to multiple destinations.');
+  lines.push('Text outside of `<message>` blocks is scratchpad — logged but not sent anywhere.');
+  lines.push('Use `<internal>...</internal>` to make scratchpad intent explicit.');
+  lines.push('');
+  lines.push(
+    'To send a message mid-response (e.g., an acknowledgment before a long task), call the `send_message` MCP tool with the `to` parameter set to a destination name.',
+  );
+  return lines.join('\n');
+}

package/container/agent-runner/src/formatter.test.ts

@@ -0,0 +1,167 @@
+/**
+ * v1-parity tests for formatter behavior.
+ *
+ * Port of src/v1/formatting.test.ts (at commit 27c5220, parent of the v1
+ * deletion commit 86becf8). Covers: context timezone header, reply_to +
+ * quoted_message rendering, XML escaping, and stripInternalTags.
+ *
+ * Timestamp-format assertions use `formatLocalTime()` output format, which
+ * is host locale-dependent for decorators (month abbr, "," separator) but
+ * stable for the numeric parts we assert on (hour, minute, year).
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+
+import { initTestSessionDb, closeSessionDb, getInboundDb } from './db/connection.js';
+import { getPendingMessages } from './db/messages-in.js';
+import { formatMessages, stripInternalTags } from './formatter.js';
+import { TIMEZONE } from './timezone.js';
+
+beforeEach(() => {
+  initTestSessionDb();
+});
+
+afterEach(() => {
+  closeSessionDb();
+});
+
+function insertMessage(
+  id: string,
+  kind: string,
+  content: object,
+  opts?: { timestamp?: string },
+) {
+  const timestamp = opts?.timestamp ?? new Date().toISOString();
+  getInboundDb()
+    .prepare(
+      `INSERT INTO messages_in (id, kind, timestamp, status, content)
+       VALUES (?, ?, ?, 'pending', ?)`,
+    )
+    .run(id, kind, timestamp, JSON.stringify(content));
+}
+
+describe('context timezone header', () => {
+  it('prepends <context timezone="..."/> to formatted output', () => {
+    insertMessage('m1', 'chat', { sender: 'Alice', text: 'hello' });
+    const result = formatMessages(getPendingMessages());
+    expect(result).toContain(`<context timezone="${TIMEZONE}"`);
+  });
+
+  it('includes the header even when the message list is empty', () => {
+    const result = formatMessages([]);
+    expect(result).toContain(`<context timezone="${TIMEZONE}"`);
+  });
+
+  it('header comes before the <messages> block', () => {
+    insertMessage('m1', 'chat', { sender: 'Alice', text: 'one' });
+    insertMessage('m2', 'chat', { sender: 'Bob', text: 'two' });
+    const result = formatMessages(getPendingMessages());
+    const ctxIdx = result.indexOf('<context');
+    const msgsIdx = result.indexOf('<messages>');
+    expect(ctxIdx).toBeGreaterThanOrEqual(0);
+    expect(msgsIdx).toBeGreaterThan(ctxIdx);
+  });
+});
+
+describe('timestamp formatting', () => {
+  it('renders time via formatLocalTime (user TZ)', () => {
+    // 2026-06-15T12:00:00Z — timezone-agnostic assertions (year is stable)
+    insertMessage('m1', 'chat', { sender: 'Alice', text: 'hi' }, { timestamp: '2026-06-15T12:00:00.000Z' });
+    const result = formatMessages(getPendingMessages());
+    // formatLocalTime's format in en-US contains the year and a month abbrev
+    expect(result).toContain('2026');
+    expect(result).toMatch(/Jun/);
+  });
+
+  it('uses 12-hour AM/PM format', () => {
+    // 15:30 UTC — some hour will show with AM or PM depending on TZ
+    insertMessage('m1', 'chat', { sender: 'Alice', text: 'hi' }, { timestamp: '2026-06-15T15:30:00.000Z' });
+    const result = formatMessages(getPendingMessages());
+    expect(result).toMatch(/(AM|PM)/);
+  });
+});
+
+describe('reply_to + quoted_message rendering', () => {
+  it('renders reply_to attribute and quoted_message when all fields present', () => {
+    insertMessage('m1', 'chat', {
+      sender: 'Alice',
+      text: 'Yes, on my way!',
+      replyTo: { id: '42', sender: 'Bob', text: 'Are you coming tonight?' },
+    });
+    const result = formatMessages(getPendingMessages());
+    expect(result).toContain('reply_to="42"');
+    expect(result).toContain('<quoted_message from="Bob">Are you coming tonight?</quoted_message>');
+    expect(result).toContain('Yes, on my way!</message>');
+  });
+
+  it('omits reply_to and quoted_message when no reply context', () => {
+    insertMessage('m1', 'chat', { sender: 'Alice', text: 'plain' });
+    const result = formatMessages(getPendingMessages());
+    expect(result).not.toContain('reply_to');
+    expect(result).not.toContain('quoted_message');
+  });
+
+  it('renders reply_to but omits quoted_message when original content is missing', () => {
+    insertMessage('m1', 'chat', {
+      sender: 'Alice',
+      text: 'ack',
+      replyTo: { id: '42', sender: 'Bob' }, // no text
+    });
+    const result = formatMessages(getPendingMessages());
+    expect(result).toContain('reply_to="42"');
+    expect(result).not.toContain('quoted_message');
+  });
+
+  it('XML-escapes reply context', () => {
+    insertMessage('m1', 'chat', {
+      sender: 'Alice',
+      text: 'reply',
+      replyTo: { id: '1', sender: 'A & B', text: '<script>alert("xss")</script>' },
+    });
+    const result = formatMessages(getPendingMessages());
+    expect(result).toContain('from="A &amp; B"');
+    expect(result).toContain('&lt;script&gt;');
+    expect(result).toContain('&quot;xss&quot;');
+  });
+});
+
+describe('XML escaping', () => {
+  it('escapes <, >, &, " in sender and body', () => {
+    insertMessage('m1', 'chat', {
+      sender: 'A & B <Co>',
+      text: '<script>alert("xss")</script>',
+    });
+    const result = formatMessages(getPendingMessages());
+    expect(result).toContain('sender="A &amp; B &lt;Co&gt;"');
+    expect(result).toContain('&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;');
+  });
+});
+
+describe('stripInternalTags', () => {
+  it('strips single-line internal tags and trims', () => {
+    expect(stripInternalTags('hello <internal>secret</internal> world')).toBe('hello  world');
+  });
+
+  it('strips multi-line internal tags', () => {
+    expect(stripInternalTags('hello <internal>\nsecret\nstuff\n</internal> world')).toBe(
+      'hello  world',
+    );
+  });
+
+  it('strips multiple internal tag blocks', () => {
+    expect(stripInternalTags('<internal>a</internal>hello<internal>b</internal>')).toBe('hello');
+  });
+
+  it('returns empty string when input is only internal tags', () => {
+    expect(stripInternalTags('<internal>only this</internal>')).toBe('');
+  });
+
+  it('returns input unchanged when there are no internal tags', () => {
+    expect(stripInternalTags('hello world')).toBe('hello world');
+  });
+
+  it('preserves content that surrounds internal tags', () => {
+    expect(stripInternalTags('<internal>thinking</internal>The answer is 42')).toBe(
+      'The answer is 42',
+    );
+  });
+});