switchroom 0.14.45 → 0.14.47

package/telegram-plugin/tests/permission-title.test.ts

@@ -87,6 +87,35 @@ describe('naturalAction — MCP tools', () => {
       'list files (Google Workspace)',
     )
   })
+
+  // Clarity fix: REST-wrapper MCP tools (brevo/meta/postiz via rest-server.mjs)
+  // take a `path` — surface it so "post (Brevo)" becomes "POST /smtp/email
+  // (Brevo)" and the operator can see WHICH endpoint is being written.
+  test('REST-wrapper write names the endpoint with an uppercased HTTP verb', () => {
+    expect(
+      naturalAction('mcp__brevo__post', JSON.stringify({ path: '/smtp/email', body: { to: 'x' } })),
+    ).toBe('POST /smtp/email (Brevo)')
+    expect(
+      naturalAction('mcp__brevo__put', JSON.stringify({ path: '/contacts/123', body: {} })),
+    ).toBe('PUT /contacts/123 (Brevo)')
+  })
+
+  test('REST-wrapper read surfaces the path too', () => {
+    expect(
+      naturalAction('mcp__brevo__get', JSON.stringify({ path: '/contacts', query: { limit: 10 } })),
+    ).toBe('GET /contacts (Brevo)')
+  })
+
+  test('falls back to the plain verb phrase when there is no resource key', () => {
+    // No path → today's behavior, unchanged (defensive for unknown shapes).
+    expect(naturalAction('mcp__brevo__post', undefined)).toBe('post (Brevo)')
+    expect(naturalAction('mcp__brevo__post', JSON.stringify({ foo: 1 }))).toBe('post (Brevo)')
+  })
+
+  test('internal REST-ish tool is NOT endpoint-enriched (stays a bare verb)', () => {
+    // hostd is internal → no "(Server)" tag, no path enrichment.
+    expect(naturalAction('mcp__hostd__do_thing', JSON.stringify({ path: '/x' }))).toBe('do thing')
+  })
 })
 
 describe('formatPermissionCardBody', () => {
@@ -156,6 +185,56 @@ describe('formatPermissionCardBody', () => {
     })
     expect(body).toContain('why: <i>first second paragraph</i>')
   })
+
+  // Clarity fix: the card gains a third "↳" line summarizing the REST
+  // payload so the operator can see WHAT is being written, not just the
+  // endpoint. Values are redaction-passed + truncated; nested objects show
+  // as a bare key name.
+  test('REST write card: endpoint in the title + a payload summary line', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__brevo__post',
+      inputPreview: JSON.stringify({
+        path: '/smtp/email',
+        body: { subject: 'Priority access', templateId: 12, to: [{ email: 'lisa@example.com' }] },
+      }),
+      description: 'HIGH RISK: write to the brevo API (POST).',
+      agentName: 'marko',
+    })
+    const lines = body.split('\n')
+    expect(lines[0]).toBe('🔐 <b>Marko</b> wants to POST /smtp/email (Brevo)')
+    expect(lines[1]).toBe('why: <i>HIGH RISK: write to the brevo API (POST).</i>')
+    // Third line: scalar keys show value; the nested `to` array shows key-only.
+    expect(lines[2]).toContain('↳')
+    expect(lines[2]).toContain('subject: Priority access')
+    expect(lines[2]).toContain('templateId: 12')
+    expect(lines[2]).toContain('to') // key-only, not the email object dumped
+    expect(lines[2]).not.toContain('lisa@example.com')
+  })
+
+  test('no payload → no third line (DM / non-REST cards unchanged)', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'Edit',
+      inputPreview: JSON.stringify({ file_path: '/a/b.md' }),
+      description: 'edit it',
+      agentName: 'clerk',
+    })
+    expect(body.split('\n')).toHaveLength(2)
+    expect(body).not.toContain('↳')
+  })
+
+  test('redaction is load-bearing: a token in the payload is masked, never shown', () => {
+    // Build the fake token at runtime so the source file never holds a
+    // contiguous token literal (repo push-protection rule).
+    const fakeToken = 'sk-ant-' + 'api03-' + 'A'.repeat(48)
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__brevo__post',
+      inputPreview: JSON.stringify({ path: '/contacts', body: { apiKey: fakeToken, name: 'Lisa' } }),
+      description: 'create a contact',
+      agentName: 'marko',
+    })
+    expect(body).not.toContain(fakeToken)
+    expect(body).toContain('name: Lisa') // benign value still surfaces
+  })
 })
 
 describe('describeGrant — phrased from the chosen scope', () => {

package/telegram-plugin/tests/vault-grant-inbound-builders.test.ts

@@ -16,7 +16,11 @@ import { describe, it, expect } from 'vitest'
 import {
   buildVaultGrantApprovedInbound,
   buildVaultGrantDeniedInbound,
+  buildVaultSaveCompletedInbound,
+  buildVaultSaveFailedInbound,
+  buildVaultSaveDiscardedInbound,
   type VaultGrantInboundContext,
+  type VaultSaveInboundContext,
 } from '../gateway/vault-grant-inbound-builders.js'
 
 const FIXED_NOW = 1_700_000_000_000
@@ -224,3 +228,83 @@ describe('approve vs deny shape invariants', () => {
     expect(String(deny.meta?.source)).toMatch(/^vault_grant_denied$/)
   })
 })
+
+// ── Supergroup topic routing (gap #2) ──────────────────────────────────────
+//
+// When the agent requested the credential from inside a forum topic, the
+// grant/save-outcome inbound must carry that topic so the resumed turn's
+// reply lands back in it — not General. The carrier is two-fold and BOTH
+// halves are load-bearing:
+//   - top-level `threadId` → the gateway's per-topic busy-key / deliver-
+//     until-acked keying (markClaudeBusyForInbound reads it).
+//   - `meta.message_thread_id` (stringified) → rendered into the
+//     `<channel message_thread_id="…">` XML, which session-tail's
+//     parseChannelMeta re-extracts to set currentTurn.sessionThreadId, which
+//     the reply tool defaults to. Drop either and the reply mis-routes.
+//
+// DM / non-topic requests must leave BOTH absent (an empty-string or 0
+// thread is a Telegram 400 "message thread not found").
+describe('grant/save outcome topic routing', () => {
+  const SAVE_CTX: VaultSaveInboundContext = {
+    agent: 'marko',
+    key: 'brevo/api-key',
+    chat_id: '-1001234567890',
+  }
+  const THREAD = 4242
+
+  const grantBuilders = [
+    {
+      name: 'approved',
+      build: (ctx: VaultGrantInboundContext) =>
+        buildVaultGrantApprovedInbound({ ctx, grantId: 'vg_x', stageId: 's', operatorId: '1' }),
+    },
+    {
+      name: 'denied',
+      build: (ctx: VaultGrantInboundContext) =>
+        buildVaultGrantDeniedInbound({ ctx, stageId: 's', operatorId: '1' }),
+    },
+  ]
+  const saveBuilders = [
+    {
+      name: 'save-completed',
+      build: (ctx: VaultSaveInboundContext) =>
+        buildVaultSaveCompletedInbound({ ctx, stageId: 's', operatorId: '1' }),
+    },
+    {
+      name: 'save-failed',
+      build: (ctx: VaultSaveInboundContext) =>
+        buildVaultSaveFailedInbound({ ctx, stageId: 's', operatorId: '1', reason: 'disk full' }),
+    },
+    {
+      name: 'save-discarded',
+      build: (ctx: VaultSaveInboundContext) =>
+        buildVaultSaveDiscardedInbound({ ctx, stageId: 's', operatorId: '1' }),
+    },
+  ]
+
+  for (const { name, build } of grantBuilders) {
+    it(`${name}: threadId set → top-level threadId + meta.message_thread_id (stringified)`, () => {
+      const msg = build({ ...CTX_READ, threadId: THREAD })
+      expect(msg.threadId).toBe(THREAD)
+      expect(msg.meta?.message_thread_id).toBe(String(THREAD))
+    })
+    it(`${name}: threadId absent → both omitted (DM stays thread-less)`, () => {
+      const msg = build(CTX_READ)
+      expect(msg.threadId).toBeUndefined()
+      expect(msg.meta?.message_thread_id).toBeUndefined()
+    })
+  }
+
+  for (const { name, build } of saveBuilders) {
+    it(`${name}: threadId set → top-level threadId + meta.message_thread_id (stringified)`, () => {
+      const msg = build({ ...SAVE_CTX, threadId: THREAD })
+      expect(msg.threadId).toBe(THREAD)
+      expect(msg.meta?.message_thread_id).toBe(String(THREAD))
+    })
+    it(`${name}: threadId absent → both omitted (DM stays thread-less)`, () => {
+      const msg = build(SAVE_CTX)
+      expect(msg.threadId).toBeUndefined()
+      expect(msg.meta?.message_thread_id).toBeUndefined()
+    })
+  }
+})