@agfpd/iapeer 0.2.77 → 0.2.79

package/src/cli/listTui.test.ts

@@ -1,71 +0,0 @@
-// list TUI — the PURE render + key state-machine (the raw-mode loop is live-verified).
-
-import { describe, expect, test } from 'bun:test'
-import { filterRows, handleListKey, renderListPanel, type TuiState } from './listTui.ts'
-import type { PeerListing } from './index.ts'
-
-function row(over: Partial<PeerListing>): PeerListing {
-  return {
-    personality: 'p',
-    default_runtime: 'claude',
-    intelligence: 'artificial',
-    description: '',
-    cwd: '/tmp/p',
-    runtimes: [{ runtime: 'claude', status: 'asleep' }],
-    ...over,
-  }
-}
-const ROWS: PeerListing[] = [
-  row({ personality: 'arthur', default_runtime: 'telegram', description: 'owner' }),
-  row({ personality: 'boris', runtimes: [{ runtime: 'claude', status: 'live' }], last_active_runtime: 'claude' }),
-  row({ personality: 'doc' }),
-]
-const S0: TuiState = { cursor: 0, filter: '', filterMode: false }
-
-describe('filterRows', () => {
-  test('case-insensitive substring over personality + description', () => {
-    expect(filterRows(ROWS, 'BOR').map(r => r.personality)).toEqual(['boris'])
-    expect(filterRows(ROWS, 'owner').map(r => r.personality)).toEqual(['arthur']) // description match
-    expect(filterRows(ROWS, '').length).toBe(3) // empty → all
-  })
-})
-
-describe('renderListPanel', () => {
-  test('selected row carries the ❯ caret + reverse-video; others do not', () => {
-    const frame = renderListPanel(ROWS, { ...S0, cursor: 1 })
-    expect(frame).toContain('\x1b[7m❯ boris') // reverse + caret on the cursor row
-    expect(frame).toContain('arthur') // other rows present, no caret
-    expect(frame).not.toContain('❯ arthur')
-    expect(frame).toContain('● claude') // boris live glyph
-  })
-  test('filter narrows the rendered rows', () => {
-    const frame = renderListPanel(ROWS, { ...S0, filter: 'doc' })
-    expect(frame).toContain('doc')
-    expect(frame).not.toContain('arthur')
-  })
-})
-
-describe('handleListKey', () => {
-  const visible = ROWS
-  test('↓/↑ move the cursor, clamped to bounds', () => {
-    expect(handleListKey('\x1b[B', S0, visible).state.cursor).toBe(1) // down
-    expect(handleListKey('\x1b[A', S0, visible).state.cursor).toBe(0) // up clamped at 0
-    expect(handleListKey('\x1b[B', { ...S0, cursor: 2 }, visible).state.cursor).toBe(2) // down clamped at last
-  })
-  test('Enter → attach action with the selected peer', () => {
-    const r = handleListKey('\r', { ...S0, cursor: 1 }, visible)
-    expect(r.action).toEqual({ type: 'attach', personality: 'boris' })
-  })
-  test('q / Ctrl-C → quit', () => {
-    expect(handleListKey('q', S0, visible).action).toEqual({ type: 'quit' })
-    expect(handleListKey('\x03', S0, visible).action).toEqual({ type: 'quit' })
-  })
-  test('/ enters filter mode; typing edits the filter; Enter leaves it', () => {
-    const f = handleListKey('/', S0, visible)
-    expect(f.state.filterMode).toBe(true)
-    const typed = handleListKey('b', f.state, visible)
-    expect(typed.state.filter).toBe('b')
-    const left = handleListKey('\r', typed.state, visible)
-    expect(left.state.filterMode).toBe(false)
-  })
-})

package/src/codec/codec.test.ts

@@ -1,271 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { buildEnvelope, decodeEnvelope, extractEnvelopes, type EnvelopeInput } from './index.ts'
-
-// ─────────────────────────────────────────────────────────────────────────────
-// WITNESS: faithful copy of the OLD telegram-runtime decoder (cli.ts:867-935).
-// These reproduce the pre-fix behaviour so each adversarial test shows a real
-// delta: the witness FAILS the assertion the new codec PASSES. (Brief: "тест,
-// падающий ДО фикса и проходящий ПОСЛЕ".)
-// ─────────────────────────────────────────────────────────────────────────────
-
-function oldUnescapeAttr(value: string): string {
-  return value
-    .replace(/"/g, '"')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&amp;/g, '&')
-}
-function oldDecodeCdata(inner: string): string {
-  if (!inner.startsWith('<![CDATA[') || !inner.endsWith(']]>')) return inner
-  return inner.slice('<![CDATA['.length, -']]>'.length).replaceAll(']]]]><![CDATA[>', ']]>')
-}
-function oldTagContent(xml: string, tag: string): string | undefined {
-  const re = new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`)
-  const m = re.exec(xml)
-  return m ? oldDecodeCdata(m[1]) : undefined
-}
-function oldParseMessage(xml: string): string | undefined {
-  xml = xml.replace(/\r\n?/g, '\n') // the CR→LF fold the codec must NOT do
-  return oldTagContent(xml, 'message')
-}
-function oldExtractEnvelopes(buffer: string): { envelopes: string[]; rest: string } {
-  const envelopes: string[] = []
-  let rest = buffer
-  while (true) {
-    const start = rest.indexOf('<iap ')
-    if (start < 0) return { envelopes, rest: rest.slice(Math.max(0, rest.length - 8)) }
-    if (start > 0) rest = rest.slice(start)
-    const end = rest.indexOf('</iap>') // naive: not CDATA-aware
-    if (end < 0) return { envelopes, rest }
-    const envelopeEnd = end + '</iap>'.length
-    envelopes.push(rest.slice(0, envelopeEnd))
-    rest = rest.slice(envelopeEnd)
-  }
-}
-
-const base: Omit<EnvelopeInput, 'message'> = {
-  fromPersonality: 'arthur',
-  fromRuntime: 'telegram',
-  fromIntelligence: 'natural',
-  topic: 'Ф0 фундамента',
-}
-
-function roundTripMessage(message: string, extra: Partial<EnvelopeInput> = {}): string {
-  const xml = buildEnvelope({ ...base, ...extra, message })
-  const { envelopes, rest } = extractEnvelopes(xml)
-  expect(envelopes).toHaveLength(1)
-  expect(rest).toBe('')
-  return decodeEnvelope(envelopes[0]).message
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Basic round-trip
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('codec round-trip (field-semantic equivalence)', () => {
-  test('preserves all fields', () => {
-    const input: EnvelopeInput = {
-      fromPersonality: 'boris',
-      fromRuntime: 'claude',
-      fromIntelligence: 'artificial',
-      topic: 'checkpoint',
-      attachments: ['/tmp/a.txt', '/tmp/b with space.png'],
-      message: 'plain multi\nline\nmessage',
-    }
-    const decoded = decodeEnvelope(buildEnvelope(input))
-    expect(decoded.fromPersonality).toBe(input.fromPersonality)
-    expect(decoded.fromRuntime).toBe(input.fromRuntime)
-    expect(decoded.fromIntelligence).toBe(input.fromIntelligence)
-    expect(decoded.topic).toBe(input.topic)
-    expect(decoded.attachments).toEqual([...input.attachments!])
-    expect(decoded.message).toBe(input.message)
-  })
-
-  test('attr special chars (<, >, &, ") survive in personality and topic', () => {
-    const xml = buildEnvelope({
-      fromPersonality: 'arthur',
-      fromRuntime: 'telegram',
-      fromIntelligence: 'natural',
-      topic: 'a < b & c > d "quoted"',
-      message: 'hi',
-    })
-    const d = decodeEnvelope(xml)
-    expect(d.topic).toBe('a < b & c > d "quoted"')
-  })
-
-  test('empty message round-trips', () => {
-    expect(roundTripMessage('')).toBe('')
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Adversarial: message contains </iap>  → extractEnvelopes must not truncate
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('adversarial: </iap> in message', () => {
-  const message = 'see the closing tag </iap> right here'
-
-  test('NEW codec: single envelope, message intact', () => {
-    expect(roundTripMessage(message)).toBe(message)
-  })
-
-  test('WITNESS: old naive indexOf truncates the envelope', () => {
-    const xml = buildEnvelope({ ...base, message })
-    const oldFirst = oldExtractEnvelopes(xml).envelopes[0]
-    // old splits at the inner </iap>, producing a shorter, broken envelope
-    expect(oldFirst.length).toBeLessThan(xml.length)
-    // ...and the new extractor produces the full envelope
-    expect(extractEnvelopes(xml).envelopes[0]).toBe(xml)
-  })
-
-  test('NEW codec: two real envelopes, first message holds a fake </iap>', () => {
-    const e1 = buildEnvelope({ ...base, message: 'fake </iap> inside' })
-    const e2 = buildEnvelope({ ...base, fromPersonality: 'darwin', message: 'second' })
-    const { envelopes, rest } = extractEnvelopes(e1 + '\n' + e2)
-    expect(envelopes).toHaveLength(2)
-    expect(rest).toBe('')
-    expect(decodeEnvelope(envelopes[0]).message).toBe('fake </iap> inside')
-    expect(decodeEnvelope(envelopes[1]).message).toBe('second')
-    // witness: old truncates the first envelope at the inner </iap>, so its
-    // first fragment is NOT the real e1 (and no longer decodes to a message)
-    const oldFirst = oldExtractEnvelopes(e1 + '\n' + e2).envelopes[0]
-    expect(oldFirst).not.toBe(e1)
-    expect(oldTagContent(oldFirst, 'message')).toBeUndefined()
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Adversarial: message contains </message>  → tag-content must not truncate
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('adversarial: </message> in message', () => {
-  const message = 'a </message> b </message> c'
-
-  test('NEW codec: message intact', () => {
-    expect(roundTripMessage(message)).toBe(message)
-  })
-
-  test('WITNESS: old non-greedy regex truncates at inner </message>', () => {
-    const xml = buildEnvelope({ ...base, message })
-    expect(oldParseMessage(xml)).not.toBe(message)
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Adversarial: message contains ]]>  → CDATA split must reconstruct
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('adversarial: ]]> in message', () => {
-  test('NEW codec: literal ]]> reconstructed', () => {
-    expect(roundTripMessage('a]]>b')).toBe('a]]>b')
-    expect(roundTripMessage('edge ]]> at ]]> several ]]> places')).toBe(
-      'edge ]]> at ]]> several ]]> places',
-    )
-    expect(roundTripMessage(']]>')).toBe(']]>')
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Adversarial: literal CR  → codec must NOT fold (transport's job)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('adversarial: literal CR is preserved (no fold in codec)', () => {
-  const message = 'line1\rline2\r\nline3'
-
-  test('NEW codec: CR survives round-trip', () => {
-    expect(roundTripMessage(message)).toBe(message)
-  })
-
-  test('WITNESS: old decoder folds CR→LF and loses it', () => {
-    const xml = buildEnvelope({ ...base, message })
-    const folded = oldParseMessage(xml)
-    expect(folded).not.toBe(message)
-    expect(folded).toBe('line1\nline2\nline3') // proof of the lossy fold
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Headline: all four adversarial features at once
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('adversarial: combined </iap> </message> ]]> CR', () => {
-  const message = 'X </iap> Y </message> Z ]]> W\rtail\nend'
-
-  test('NEW codec: full round-trip by field semantics', () => {
-    const input: EnvelopeInput = {
-      ...base,
-      attachments: ['/path/with ]]> weird', '/second </iap> path'],
-      message,
-    }
-    const xml = buildEnvelope(input)
-    const { envelopes, rest } = extractEnvelopes(xml)
-    expect(envelopes).toHaveLength(1)
-    expect(rest).toBe('')
-    const d = decodeEnvelope(envelopes[0])
-    expect(d.message).toBe(message)
-    expect(d.attachments).toEqual(['/path/with ]]> weird', '/second </iap> path'])
-    expect(d.fromPersonality).toBe('arthur')
-    expect(d.fromIntelligence).toBe('natural')
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// extractEnvelopes streaming semantics
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('extractEnvelopes streaming', () => {
-  test('incomplete envelope kept in rest, completed on next chunk', () => {
-    const xml = buildEnvelope({ ...base, message: 'streamed' })
-    const cut = Math.floor(xml.length / 2)
-    const first = extractEnvelopes(xml.slice(0, cut))
-    expect(first.envelopes).toHaveLength(0)
-    const second = extractEnvelopes(first.rest + xml.slice(cut))
-    expect(second.envelopes).toHaveLength(1)
-    expect(decodeEnvelope(second.envelopes[0]).message).toBe('streamed')
-  })
-
-  test('mid-CDATA cut does not falsely close on inner </iap>', () => {
-    const xml = buildEnvelope({ ...base, message: 'pre </iap> post' })
-    // cut right after the inner </iap> but before the CDATA terminator
-    const innerIap = xml.indexOf('</iap>')
-    const cut = innerIap + 3
-    const first = extractEnvelopes(xml.slice(0, cut))
-    expect(first.envelopes).toHaveLength(0) // must NOT emit a truncated envelope
-    const second = extractEnvelopes(first.rest + xml.slice(cut))
-    expect(second.envelopes).toHaveLength(1)
-    expect(decodeEnvelope(second.envelopes[0]).message).toBe('pre </iap> post')
-  })
-
-  test('leading noise before <iap is discarded', () => {
-    const xml = buildEnvelope({ ...base, message: 'm' })
-    const { envelopes } = extractEnvelopes('garbage text\n' + xml)
-    expect(envelopes).toHaveLength(1)
-    expect(decodeEnvelope(envelopes[0]).message).toBe('m')
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Decoder error surface
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('decodeEnvelope errors', () => {
-  test('missing <iap throws', () => {
-    expect(() => decodeEnvelope('no envelope here')).toThrow()
-  })
-  test('missing message throws', () => {
-    expect(() => decodeEnvelope('<iap from-personality="a" from-runtime="claude"></iap>')).toThrow()
-  })
-  test('unknown from-intelligence is dropped, not invented', () => {
-    const xml =
-      '<iap from-personality="a" from-runtime="claude" from-intelligence="bogus">\n<message><![CDATA[x]]></message>\n</iap>'
-    const d = decodeEnvelope(xml)
-    expect(d.fromIntelligence).toBeUndefined()
-    expect(d.message).toBe('x')
-  })
-
-  test('READ-COMPAT: legacy from-intelligence="human" decodes to natural', () => {
-    const xml =
-      '<iap from-personality="arthur" from-runtime="telegram" from-intelligence="human">\n<message><![CDATA[hi]]></message>\n</iap>'
-    expect(decodeEnvelope(xml).fromIntelligence).toBe('natural')
-  })
-})

package/src/connect/connect.test.ts

@@ -1,163 +0,0 @@
-// connect telegram — the one-flow channel attachment (design §(в)). Sandboxed:
-// IAPEER_ROOT temp dirs, injected telegram-runtime runner + router restart. The
-// runner stub mimics the package: `bot add` writes bots/<alias>/.env (stable ABI).
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
-import { dirname } from 'path'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { botEnvPath, connectTelegram, type RestartOutcome, type TgRunner } from './index.ts'
-import { writeRuntimeManifest } from '../runtime/index.ts'
-import { upsertPeer } from '../registry/index.ts'
-
-const roots: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-connect-'))
-  roots.push(d)
-  return d
-}
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function envFor(root: string): NodeJS.ProcessEnv {
-  return {
-    IAPEER_ROOT: join(root, 'iapeer'),
-    IAPEER_LAUNCHAGENTS_DIR: join(root, 'LA'),
-    IAPEER_TEST_SANDBOX: '1',
-    HOME: root,
-  } as NodeJS.ProcessEnv
-}
-
-async function fixture(): Promise<{ env: NodeJS.ProcessEnv; calls: string[][]; runTg: TgRunner; restarts: string[] }> {
-  const env = envFor(mkTmp())
-  writeRuntimeManifest({ runtime: 'telegram', selfConfig: { command: '/stub/telegram-runtime', args: ['self-config'] } }, { env })
-  await upsertPeer({ personality: 'leo', runtime: 'claude', cwd: '/tmp/leo', intelligence: 'artificial' }, { env })
-  await upsertPeer({ personality: 'arthur', runtime: 'telegram', cwd: '/tmp/arthur', intelligence: 'natural' }, { env })
-  const calls: string[][] = []
-  const runTg: TgRunner = (args, e) => {
-    calls.push(args)
-    if (args[0] === 'bot' && args[1] === 'add') {
-      // the package's behavior: token → bots/<alias>/.env (incl. the username
-      // field — the RELIABLE source, live-host fact); stdout also prints one
-      const p = botEnvPath(args[2]!, e)
-      mkdirSync(dirname(p), { recursive: true })
-      writeFileSync(p, `TELEGRAM_BOT_TOKEN=${args[4]}\nTELEGRAM_BOT_USERNAME=leo_env_bot\n`)
-      return { status: 0, stdout: 'bot added: @leo_stdout_bot\n', stderr: '' }
-    }
-    return { status: 0, stdout: '', stderr: '' }
-  }
-  const restarts: string[] = []
-  return { env, calls, runTg, restarts }
-}
-
-const okRestart =
-  (restarts: string[]) =>
-  (human: string): RestartOutcome => {
-    restarts.push(human)
-    return { state: 'restarted' }
-  }
-
-describe('connectTelegram (one flow: bot add → interface → restart → activation)', () => {
-  test('happy path: adds the bot, interfaces the peer, restarts the HUMAN router, surfaces @username', async () => {
-    const { env, calls, runTg, restarts } = await fixture()
-    const r = await connectTelegram({ peer: 'leo', token: 'T1:abc', env, runTg, restart: okRestart(restarts) })
-    expect(r.state).toBe('connected')
-    expect(r.username).toBe('@leo_env_bot') // .env field WINS over the stdout match
-    expect(r.restart?.state).toBe('restarted')
-    expect(restarts).toEqual(['arthur']) // the router = the natural telegram peer, not leo
-    expect(calls[0]).toEqual(['bot', 'add', 'leo', '--token', 'T1:abc'])
-    expect(calls[1]).toEqual(['interface', 'bot', 'leo', '--peer', 'leo'])
-  })
-
-  test('IDEMPOTENT: the same token is a byte-stable no-op — router NOT restarted', async () => {
-    const { env, runTg, restarts } = await fixture()
-    expect((await connectTelegram({ peer: 'leo', token: 'T1:abc', env, runTg, restart: okRestart(restarts) })).state).toBe('connected')
-    const second = await connectTelegram({ peer: 'leo', token: 'T1:abc', env, runTg, restart: okRestart(restarts) })
-    expect(second.state).toBe('noop-same-token')
-    expect(restarts).toEqual(['arthur']) // exactly ONE restart — the first connect
-  })
-
-  test('a NEW token replaces and RESTARTS again (credentials load at start)', async () => {
-    const { env, runTg, restarts } = await fixture()
-    await connectTelegram({ peer: 'leo', token: 'T1:abc', env, runTg, restart: okRestart(restarts) })
-    const r = await connectTelegram({ peer: 'leo', token: 'T2:new', env, runTg, restart: okRestart(restarts) })
-    expect(r.state).toBe('connected')
-    expect(restarts).toEqual(['arthur', 'arthur'])
-  })
-
-  test('unregistered peer → refused BEFORE any bot add (interface precondition)', async () => {
-    const { env, calls, runTg } = await fixture()
-    const r = await connectTelegram({ peer: 'ghost', token: 'T', env, runTg })
-    expect(r.state).toBe('unregistered-peer')
-    expect(calls.length).toBe(0)
-  })
-
-  test('no telegram manifest → runtime-missing with the install recipe', async () => {
-    const env = envFor(mkTmp())
-    await upsertPeer({ personality: 'leo', runtime: 'claude', cwd: '/tmp/leo', intelligence: 'artificial' }, { env })
-    const r = await connectTelegram({ peer: 'leo', token: 'T', env })
-    expect(r.state).toBe('runtime-missing')
-    expect(r.detail).toContain('install-runtime telegram')
-  })
-
-  test('non-tty without --token → explicit refusal with the BotFather recipe', async () => {
-    const { env, runTg } = await fixture()
-    const r = await connectTelegram({ peer: 'leo', env, runTg, isTty: false })
-    expect(r.state).toBe('refused-no-token')
-    expect(r.detail).toContain('@BotFather')
-  })
-
-  test('tty prompt path: the asked token flows in; empty answer → refusal', async () => {
-    const { env, runTg, restarts } = await fixture()
-    const r = await connectTelegram({ peer: 'leo', env, runTg, isTty: true, ask: async () => 'T9:asked', restart: okRestart(restarts) })
-    expect(r.state).toBe('connected')
-    const r2 = await connectTelegram({ peer: 'leo', env, runTg, isTty: true, ask: async () => '' })
-    expect(r2.state).toBe('refused-no-token')
-  })
-
-  test('username falls back to the bot-add stdout when .env carries no username field', async () => {
-    const env = envFor(mkTmp())
-    writeRuntimeManifest({ runtime: 'telegram', selfConfig: '/stub/telegram-runtime self-config' }, { env })
-    await upsertPeer({ personality: 'leo', runtime: 'claude', cwd: '/tmp/leo', intelligence: 'artificial' }, { env })
-    await upsertPeer({ personality: 'arthur', runtime: 'telegram', cwd: '/tmp/arthur', intelligence: 'natural' }, { env })
-    const runTg: TgRunner = (args, e) => {
-      if (args[0] === 'bot') {
-        const p = botEnvPath('leo', e)
-        mkdirSync(dirname(p), { recursive: true })
-        writeFileSync(p, 'TELEGRAM_BOT_TOKEN=T\n') // no username field (older package)
-        return { status: 0, stdout: 'added @stdout_only_bot\n', stderr: '' }
-      }
-      return { status: 0, stdout: '', stderr: '' }
-    }
-    const r = await connectTelegram({ peer: 'leo', token: 'T', env, runTg, restart: okRestart([]) })
-    expect(r.username).toBe('@stdout_only_bot')
-  })
-
-  test('bot add failure (getMe refusal on a bad token) → bot-add-failed with the package detail', async () => {
-    const { env } = await fixture()
-    const failTg: TgRunner = args =>
-      args[0] === 'bot' ? { status: 1, stdout: '', stderr: 'getMe failed: 401 Unauthorized' } : { status: 0, stdout: '', stderr: '' }
-    const r = await connectTelegram({ peer: 'leo', token: 'bad', env, runTg: failTg })
-    expect(r.state).toBe('bot-add-failed')
-    expect(r.detail).toContain('401')
-  })
-
-  test('no natural telegram peer in the registry → connected but restart=no-router (loud)', async () => {
-    const env = envFor(mkTmp())
-    writeRuntimeManifest({ runtime: 'telegram', selfConfig: '/stub/telegram-runtime self-config' }, { env })
-    await upsertPeer({ personality: 'leo', runtime: 'claude', cwd: '/tmp/leo', intelligence: 'artificial' }, { env })
-    const runTg: TgRunner = (args, e) => {
-      if (args[0] === 'bot') {
-        const p = botEnvPath('leo', e)
-        mkdirSync(dirname(p), { recursive: true })
-        writeFileSync(p, 'TELEGRAM_BOT_TOKEN=T\n')
-      }
-      return { status: 0, stdout: '', stderr: '' }
-    }
-    const r = await connectTelegram({ peer: 'leo', token: 'T', env, runTg })
-    expect(r.state).toBe('connected')
-    expect(r.restart?.state).toBe('no-router')
-  })
-})

package/src/core/constants.test.ts

@@ -1,32 +0,0 @@
-// resolveSockDir — the ONE socket-dir resolver every socket-touching site shares
-// (transport scan/resolve, lifecycle, launchdRun). Regression guard against a site
-// re-hardcoding DEFAULT_SOCK_DIR, which made an IAPEER_SOCK_DIR sandbox lie (the
-// session created on the override dir, the resolver scanning /tmp → false offline).
-
-import { describe, expect, test } from 'bun:test'
-import { DEFAULT_SOCK_DIR, resolveSockDir } from './constants.ts'
-
-describe('resolveSockDir', () => {
-  test('no override → DEFAULT_SOCK_DIR (/tmp, contract sock convention)', () => {
-    expect(resolveSockDir({})).toBe(DEFAULT_SOCK_DIR)
-    expect(resolveSockDir({})).toBe('/tmp')
-  })
-  test('IAPEER_SOCK_DIR override is respected (host-wide, like IAPEER_ROOT)', () => {
-    expect(resolveSockDir({ IAPEER_SOCK_DIR: '/tmp/sbx/socks' })).toBe('/tmp/sbx/socks')
-  })
-  test('blank/whitespace override falls back to the default (not an empty dir)', () => {
-    expect(resolveSockDir({ IAPEER_SOCK_DIR: '   ' })).toBe(DEFAULT_SOCK_DIR)
-    expect(resolveSockDir({ IAPEER_SOCK_DIR: '' })).toBe(DEFAULT_SOCK_DIR)
-  })
-  test('IAPEER_ROOT implies socket isolation: <root>/socks (boris e2e find 10.06)', () => {
-    // An alt-root used to inherit GLOBAL /tmp — a sandboxed list saw PROD sessions
-    // live by name collision, and sandboxed stop/start would have hit prod.
-    expect(resolveSockDir({ IAPEER_ROOT: '/tmp/sbx/iapeer' })).toBe('/tmp/sbx/iapeer/socks')
-  })
-  test('explicit IAPEER_SOCK_DIR wins over the root-derived dir', () => {
-    expect(resolveSockDir({ IAPEER_ROOT: '/tmp/sbx/iapeer', IAPEER_SOCK_DIR: '/tmp/elsewhere' })).toBe('/tmp/elsewhere')
-  })
-  test('prod shape (no IAPEER_ROOT, no IAPEER_SOCK_DIR) stays on /tmp — untouched', () => {
-    expect(resolveSockDir({ HOME: '/Users/x' })).toBe('/tmp')
-  })
-})

package/src/core/normalize.test.ts

@@ -1,98 +0,0 @@
-// normalizeNameCandidate — the shared name normalizer (normalize = slug∘translit).
-// Covers the zone goldens, ASCII non-regression, writing systems (Cyrillic / Greek
-// / CJK), idempotency, the ICU `№` symbol-alignment, and the fail-to-explicit edge
-// (a non-transliterable / leading-digit / empty result is returned AS-IS and does
-// NOT satisfy NAME_RE, so the caller can reject it rather than invent a name).
-
-import { describe, expect, test } from 'bun:test'
-import { isValidName, NAME_RE, normalizeNameCandidate as normalize } from './constants.ts'
-
-describe('normalizeNameCandidate — zone goldens', () => {
-  test.each([
-    ['Café №2', 'cafe-no-2'], // accents + ICU `№ → No.` symbol alignment
-    ['项目', 'xiang-mu'], // Han → pinyin WITH syllable spacing
-    ['My Project', 'my-project'],
-  ])('%j → %j', (input, expected) => {
-    expect(normalize(input)).toBe(expected)
-  })
-})
-
-describe('normalizeNameCandidate — ASCII non-regression', () => {
-  test.each([
-    ['iapeer', 'iapeer'],
-    ['boris', 'boris'],
-    ['notifier-timer', 'notifier-timer'], // hyphen preserved, not collapsed
-    ['darwin', 'darwin'],
-  ])('%j → %j', (input, expected) => {
-    expect(normalize(input)).toBe(expected)
-  })
-})
-
-describe('normalizeNameCandidate — writing systems (ICU Any-Latin; Latin-ASCII)', () => {
-  test.each([
-    ['Артур', 'artur'], // Cyrillic
-    ['Борис', 'boris'],
-    ['Наталья', 'natalya'], // matches the live registered peer "natalya"
-    ['東京', 'dong-jing'], // CJK with syllable spacing
-    ['北京', 'bei-jing'],
-    ['Ω', 'o'], // Greek
-    ['naïve', 'naive'], // Latin diacritics
-    ['Köln', 'koln'],
-    ['Straße', 'strasse'],
-  ])('%j → %j', (input, expected) => {
-    expect(normalize(input)).toBe(expected)
-  })
-})
-
-describe('normalizeNameCandidate — slug rules', () => {
-  test('collapses non-alnum runs to a single hyphen and trims edges', () => {
-    expect(normalize('  a   b  ')).toBe('a-b')
-    expect(normalize('a___b...c')).toBe('a-b-c')
-    expect(normalize('--lead-and-trail--')).toBe('lead-and-trail')
-  })
-
-  test('caps length at 32 with no dangling trailing hyphen', () => {
-    const long = 'a'.repeat(40)
-    expect(normalize(long)).toBe('a'.repeat(32))
-    // a hyphen landing exactly at the cut must not survive as a trailing hyphen
-    const cut = `${'a'.repeat(31)}-bbb`
-    const out = normalize(cut)
-    expect(out.length).toBeLessThanOrEqual(32)
-    expect(out.endsWith('-')).toBe(false)
-  })
-})
-
-describe('normalizeNameCandidate — idempotency (normalize∘normalize === normalize)', () => {
-  test.each(['Café №2', '项目', 'My Project', 'Артур', 'boris', 'notifier-timer', '東京'])(
-    '%j is a fixed point of a second pass',
-    input => {
-      const once = normalize(input)
-      expect(normalize(once)).toBe(once)
-    },
-  )
-})
-
-describe('normalizeNameCandidate — fail-to-explicit edges (returned AS-IS, not mangled)', () => {
-  test.each([
-    ['', ''], // empty
-    ['①②③', ''], // non-transliterable circled digits → drop
-    ['😀', ''], // emoji → drop
-    ['---', ''], // only separators
-    ['2nd', '2nd'], // leading digit survives but is NOT a valid name
-    ['42', '42'],
-  ])('%j → %j', (input, expected) => {
-    expect(normalize(input)).toBe(expected)
-  })
-
-  test('edge results do NOT satisfy NAME_RE → caller fails-to-explicit', () => {
-    for (const bad of ['', '①②③', '😀', '---', '2nd', '42']) {
-      expect(isValidName(normalize(bad))).toBe(false)
-    }
-  })
-
-  test('valid goldens DO satisfy NAME_RE', () => {
-    for (const good of ['cafe-no-2', 'xiang-mu', 'my-project', 'iapeer', 'artur']) {
-      expect(NAME_RE.test(good)).toBe(true)
-    }
-  })
-})