switchroom 0.16.46 → 0.17.0

package/telegram-plugin/tests/resolve-calling-subagent.test.ts

@@ -1,269 +0,0 @@
-/**
- * Unit tests for resolveCallingSubagent (issue #305 Option A).
- *
- * The resolver picks which sub-agent's row body should host the
- * progress_update narrative when called from a sub-agent context.
- * Resolution priority:
- *   1. agentIdHint  → exact match on subagents.jsonl_agent_id
- *   2. toolUseIdHint → exact match on subagents.id
- *   3. Heuristic   → most-recently-started running sub-agent in the active turn
- *
- * Tests run against an in-memory bun:sqlite DB with the same schema that
- * production uses (turns + subagents tables). Run via:
- *   bun test telegram-plugin/tests/resolve-calling-subagent.test.ts
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
-import {
-  openSubagentsDbInMemory,
-  recordSubagentStart,
-} from '../registry/subagents-schema.js'
-import { resolveCallingSubagent } from '../gateway/resolve-calling-subagent.js'
-
-type Db = ReturnType<typeof openSubagentsDbInMemory>
-
-function insertOpenTurn(db: Db, turnKey: string, chatId: string, startedAt: number): void {
-  db.prepare(`
-    INSERT INTO turns
-      (turn_key, chat_id, thread_id, started_at, last_user_msg_id, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `).run(turnKey, chatId, null, startedAt, 'msg-1', startedAt, startedAt)
-}
-
-describe('resolveCallingSubagent', () => {
-  let db: Db
-
-  beforeEach(() => {
-    db = openSubagentsDbInMemory()
-  })
-
-  afterEach(() => {
-    db.close()
-  })
-
-  it('returns null when db is null', () => {
-    const result = resolveCallingSubagent({
-      db: null,
-      chatId: 'c1',
-      agentIdHint: 'jsonl-1',
-      toolUseIdHint: null,
-    })
-    expect(result).toBeNull()
-  })
-
-  it('matches by agentIdHint (jsonl_agent_id)', () => {
-    insertOpenTurn(db, 'c1:1', 'c1', 1000)
-    recordSubagentStart(db, {
-      id: 'toolu_alpha',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: 'jsonl-alpha',
-      background: false,
-      startedAt: 1100,
-    })
-    recordSubagentStart(db, {
-      id: 'toolu_beta',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: 'jsonl-beta',
-      background: false,
-      startedAt: 1200,
-    })
-
-    const result = resolveCallingSubagent({
-      db,
-      chatId: 'c1',
-      agentIdHint: 'jsonl-alpha',
-      toolUseIdHint: null,
-    })
-    expect(result).toEqual({ agentId: 'jsonl-alpha' })
-  })
-
-  it('agentIdHint miss on completed sub-agent does NOT match (only running rows)', () => {
-    insertOpenTurn(db, 'c1:1', 'c1', 1000)
-    recordSubagentStart(db, {
-      id: 'toolu_done',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: 'jsonl-done',
-      background: false,
-      startedAt: 1100,
-    })
-    // Mark as completed via direct SQL.
-    db.prepare("UPDATE subagents SET status = 'completed', ended_at = 2000 WHERE id = ?")
-      .run('toolu_done')
-
-    const result = resolveCallingSubagent({
-      db,
-      chatId: 'c1',
-      agentIdHint: 'jsonl-done',
-      toolUseIdHint: null,
-    })
-    expect(result).toBeNull()
-  })
-
-  it('matches by toolUseIdHint (subagents.id) when agentIdHint absent', () => {
-    insertOpenTurn(db, 'c1:1', 'c1', 1000)
-    recordSubagentStart(db, {
-      id: 'toolu_via_id',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: 'jsonl-via-id',
-      background: false,
-      startedAt: 1100,
-    })
-
-    const result = resolveCallingSubagent({
-      db,
-      chatId: 'c1',
-      agentIdHint: null,
-      toolUseIdHint: 'toolu_via_id',
-    })
-    expect(result).toEqual({ agentId: 'jsonl-via-id' })
-  })
-
-  it('heuristic fallback: returns most-recently-started running sub-agent in active turn', () => {
-    insertOpenTurn(db, 'c1:1', 'c1', 1000)
-    recordSubagentStart(db, {
-      id: 'toolu_old',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: 'jsonl-old',
-      background: false,
-      startedAt: 1100,
-    })
-    recordSubagentStart(db, {
-      id: 'toolu_new',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: 'jsonl-new',
-      background: false,
-      startedAt: 1500, // strictly newer
-    })
-
-    const result = resolveCallingSubagent({
-      db,
-      chatId: 'c1',
-      agentIdHint: null,
-      toolUseIdHint: null,
-    })
-    expect(result).toEqual({ agentId: 'jsonl-new' })
-  })
-
-  it('heuristic skips sub-agents without jsonl_agent_id', () => {
-    insertOpenTurn(db, 'c1:1', 'c1', 1000)
-    recordSubagentStart(db, {
-      id: 'toolu_nojson',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: null,
-      background: false,
-      startedAt: 1500,
-    })
-    recordSubagentStart(db, {
-      id: 'toolu_withjson',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: 'jsonl-resolved',
-      background: false,
-      startedAt: 1100,
-    })
-
-    const result = resolveCallingSubagent({
-      db,
-      chatId: 'c1',
-      agentIdHint: null,
-      toolUseIdHint: null,
-    })
-    expect(result).toEqual({ agentId: 'jsonl-resolved' })
-  })
-
-  it('heuristic returns null when no active turn exists', () => {
-    // Insert an ENDED turn.
-    db.prepare(`
-      INSERT INTO turns
-        (turn_key, chat_id, thread_id, started_at, ended_at, last_user_msg_id, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run('c1:1', 'c1', null, 1000, 2000, 'msg-1', 1000, 2000)
-    recordSubagentStart(db, {
-      id: 'toolu_orphan',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: 'jsonl-orphan',
-      background: false,
-      startedAt: 1100,
-    })
-
-    const result = resolveCallingSubagent({
-      db,
-      chatId: 'c1',
-      agentIdHint: null,
-      toolUseIdHint: null,
-    })
-    expect(result).toBeNull()
-  })
-
-  it('heuristic returns null when no running sub-agents in active turn', () => {
-    insertOpenTurn(db, 'c1:1', 'c1', 1000)
-    // No sub-agents inserted.
-    const result = resolveCallingSubagent({
-      db,
-      chatId: 'c1',
-      agentIdHint: null,
-      toolUseIdHint: null,
-    })
-    expect(result).toBeNull()
-  })
-
-  it('heuristic ignores sub-agents from a different chat', () => {
-    insertOpenTurn(db, 'c1:1', 'c1', 1000)
-    insertOpenTurn(db, 'c2:1', 'c2', 1000)
-    recordSubagentStart(db, {
-      id: 'toolu_other',
-      parentTurnKey: 'c2:1',
-      jsonlAgentId: 'jsonl-other-chat',
-      background: false,
-      startedAt: 1100,
-    })
-
-    const result = resolveCallingSubagent({
-      db,
-      chatId: 'c1',
-      agentIdHint: null,
-      toolUseIdHint: null,
-    })
-    expect(result).toBeNull()
-  })
-
-  it('agentIdHint takes priority over toolUseIdHint and heuristic', () => {
-    insertOpenTurn(db, 'c1:1', 'c1', 1000)
-    recordSubagentStart(db, {
-      id: 'toolu_priority',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: 'jsonl-priority',
-      background: false,
-      startedAt: 1100,
-    })
-    recordSubagentStart(db, {
-      id: 'toolu_other',
-      parentTurnKey: 'c1:1',
-      jsonlAgentId: 'jsonl-other',
-      background: false,
-      startedAt: 1500, // newer; would win heuristic
-    })
-
-    const result = resolveCallingSubagent({
-      db,
-      chatId: 'c1',
-      agentIdHint: 'jsonl-priority',
-      toolUseIdHint: 'toolu_other',
-    })
-    expect(result).toEqual({ agentId: 'jsonl-priority' })
-  })
-
-  it('returns null on SQL error (broken db.prepare)', () => {
-    const brokenDb = {
-      prepare: (): never => {
-        throw new Error('boom')
-      },
-    }
-    const result = resolveCallingSubagent({
-      db: brokenDb as unknown as Parameters<typeof resolveCallingSubagent>[0]['db'],
-      chatId: 'c1',
-      agentIdHint: 'whatever',
-      toolUseIdHint: null,
-    })
-    expect(result).toBeNull()
-  })
-})

package/telegram-plugin/tests/silent-reply-guard.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-// Import directly from the helper module (not server.js), so this test
-// doesn't boot the full MCP server — server.ts has top-level side
-// effects (env load, TELEGRAM_BOT_TOKEN check, session-tail spawn) that
-// kill the test process when run under bun-test without a real env.
-import { guardSilentReply, isSilentReplyMarker } from '../silent-reply.js'
-
-/**
- * Regression coverage for sprint1 review finding #6: the reply /
- * stream_reply tool handlers must call `assertAllowedChat(chat_id)`
- * BEFORE returning the silent-reply ack, so an unauthorised chat
- * cannot bypass the outbound allowlist by having the agent emit
- * `NO_REPLY` / `HEARTBEAT_OK`.
- *
- * We exercise the extracted `guardSilentReply` helper directly rather
- * than the full MCP tool handler; the handler scaffolding (IPC + Bot
- * harness + history DB) is heavy, and the ordering contract — "assert
- * first, then ack" — lives entirely inside the helper.
- */
-describe('guardSilentReply — allowlist ordering', () => {
-  it('asserts the allowlist BEFORE returning a silent ack (NO_REPLY)', () => {
-    const assertAllowed = vi.fn()
-    const result = guardSilentReply({
-      chat_id: '123',
-      text: 'NO_REPLY',
-      hasFiles: false,
-      assertAllowed,
-    })
-    expect(assertAllowed).toHaveBeenCalledOnce()
-    expect(assertAllowed).toHaveBeenCalledWith('123')
-    expect(result).toEqual({ kind: 'silent', markerText: 'NO_REPLY' })
-  })
-
-  it('recognises HEARTBEAT_OK as a silent marker and still gates on allowlist', () => {
-    const assertAllowed = vi.fn()
-    const result = guardSilentReply({
-      chat_id: '456',
-      text: '  heartbeat_ok  ',
-      hasFiles: false,
-      assertAllowed,
-    })
-    expect(assertAllowed).toHaveBeenCalledWith('456')
-    expect(result).toEqual({ kind: 'silent', markerText: 'heartbeat_ok' })
-  })
-
-  it('throws (does NOT return a silent ack) when the chat is disallowed', () => {
-    // This is the exact bypass the fix prevents: an unauthorised chat_id
-    // using NO_REPLY must NOT receive a successful silent-reply ack.
-    const assertAllowed = vi.fn((chat_id: string) => {
-      throw new Error(`chat ${chat_id} is not allowlisted`)
-    })
-    expect(() =>
-      guardSilentReply({
-        chat_id: '999',
-        text: 'NO_REPLY',
-        hasFiles: false,
-        assertAllowed,
-      }),
-    ).toThrow(/not allowlisted/)
-    expect(assertAllowed).toHaveBeenCalledOnce()
-  })
-
-  it('does not short-circuit (or call assertAllowed) when files are attached', () => {
-    // Silent-reply semantics are text-only; a NO_REPLY payload with files
-    // is a real send and must flow through the normal allowlist path
-    // inside the send codepath, not the silent short-circuit.
-    const assertAllowed = vi.fn()
-    const result = guardSilentReply({
-      chat_id: '123',
-      text: 'NO_REPLY',
-      hasFiles: true,
-      assertAllowed,
-    })
-    expect(assertAllowed).not.toHaveBeenCalled()
-    expect(result).toEqual({ kind: 'continue' })
-  })
-
-  it('does not short-circuit for normal prose that merely mentions the marker', () => {
-    const assertAllowed = vi.fn()
-    const result = guardSilentReply({
-      chat_id: '123',
-      text: 'the agent suggested NO_REPLY earlier',
-      hasFiles: false,
-      assertAllowed,
-    })
-    expect(assertAllowed).not.toHaveBeenCalled()
-    expect(result).toEqual({ kind: 'continue' })
-  })
-
-  it('does not short-circuit on undefined/empty text', () => {
-    const assertAllowed = vi.fn()
-    expect(
-      guardSilentReply({
-        chat_id: '123',
-        text: undefined,
-        hasFiles: false,
-        assertAllowed,
-      }),
-    ).toEqual({ kind: 'continue' })
-    expect(
-      guardSilentReply({
-        chat_id: '123',
-        text: '',
-        hasFiles: false,
-        assertAllowed,
-      }),
-    ).toEqual({ kind: 'continue' })
-    expect(assertAllowed).not.toHaveBeenCalled()
-  })
-
-  // Sanity: the helper the guard delegates to is exported for direct
-  // marker-recognition testing. Keep a thin smoke assertion so future
-  // marker-set tweaks break here rather than at the ordering layer.
-  it('isSilentReplyMarker recognises the documented marker set', () => {
-    expect(isSilentReplyMarker('NO_REPLY')).toBe(true)
-    expect(isSilentReplyMarker('HEARTBEAT_OK')).toBe(true)
-    expect(isSilentReplyMarker('no_reply')).toBe(true)
-    expect(isSilentReplyMarker('hello')).toBe(false)
-    expect(isSilentReplyMarker(undefined)).toBe(false)
-  })
-})