@agfpd/iapeer 0.2.76 → 0.2.78

package/src/identity/identity.test.ts

@@ -1,279 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, rmSync, readFileSync, writeFileSync, mkdirSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import {
-  ensurePeerProfile,
-  readPeerProfile,
-  writePeerProfileAtomic,
-  resolveCallerIdentity,
-  type PeerProfileWrite,
-} from './index.ts'
-import { peerProfilePath } from '../storage/index.ts'
-import { isFoundationOwnedPlist, launchdPlistPath } from '../launch/index.ts'
-import { defaultIntelligenceForRuntime } from '../core/constants.ts'
-import type { PeersIndex } from '../registry/index.ts'
-
-let cwd: string
-beforeEach(() => {
-  cwd = mkdtempSync(join(tmpdir(), 'iapeer-identity-'))
-})
-afterEach(() => {
-  rmSync(cwd, { recursive: true, force: true })
-})
-
-function readDisk(): Record<string, unknown> {
-  return JSON.parse(readFileSync(peerProfilePath(cwd), 'utf8'))
-}
-
-// WITNESS: old writePeerProfileAtomic merged-builder (identity.ts:247-263) wrote
-// `intelligence: profile.intelligence` UNCONDITIONALLY. Reproduce the merge so a
-// call site that lost the existing intelligence (passing the runtime default)
-// would clobber a human profile.
-function oldMerged(existing: Record<string, unknown>, profile: {
-  personality: string; runtime: string; runtimes: string[]; description: string; intelligence: string
-}): Record<string, unknown> {
-  return {
-    ...existing,
-    personality: profile.personality,
-    runtime: profile.runtime,
-    runtimes: profile.runtimes,
-    description: profile.description, // empty wipes
-    intelligence: profile.intelligence, // unconditional overwrite
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// writePeerProfileAtomic — H1 preserve + unknown-field preservation
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('writePeerProfileAtomic H1 preserve', () => {
-  test('write WITHOUT intelligence does NOT downgrade a human profile on disk', () => {
-    // seed a human profile with a foreign (persistent-peer) section + interfaces
-    mkdirSync(join(cwd, '.iapeer'), { recursive: true })
-    writeFileSync(
-      peerProfilePath(cwd),
-      JSON.stringify({
-        personality: 'arthur',
-        runtime: 'telegram',
-        runtimes: ['telegram', 'claude'],
-        description: 'Артур — владелец.',
-        intelligence: 'human',
-        'persistent-peer': { initial_prompt: 'hi', aliases: { '/new': 'x' } },
-        interfaces: { telegram: { user_id: '409502965' } },
-      }),
-    )
-
-    // a runtimes-only update built WITHOUT re-asserting intelligence
-    const update: PeerProfileWrite = {
-      personality: 'arthur',
-      runtime: 'claude',
-      runtimes: ['telegram', 'claude'],
-    }
-    writePeerProfileAtomic(cwd, update)
-
-    const disk = readDisk()
-    // H1 + NO-MIGRATION: the legacy on-disk value is preserved VERBATIM (not
-    // downgraded, and NOT silently rewritten to 'natural' — that migration is a
-    // separate coordinated step that must not happen on a routine write).
-    expect(disk.intelligence).toBe('human')
-    // READ-COMPAT: but reading it back normalizes legacy human → contract natural
-    expect(readPeerProfile(cwd)!.intelligence).toBe('natural')
-    // WITNESS: old builder fed the claude runtime-default would write artificial
-    expect(oldMerged(disk, {
-      personality: 'arthur', runtime: 'claude', runtimes: ['claude'],
-      description: '', intelligence: defaultIntelligenceForRuntime('claude'),
-    }).intelligence).toBe('artificial')
-    // unknown foreign section preserved
-    expect(disk['persistent-peer']).toEqual({ initial_prompt: 'hi', aliases: { '/new': 'x' } })
-    // interfaces preserved
-    expect(disk.interfaces).toEqual({ telegram: { user_id: '409502965' } })
-    // empty description not written over the existing one
-    expect(disk.description).toBe('Артур — владелец.')
-  })
-
-  test('explicit intelligence in write IS applied', () => {
-    writePeerProfileAtomic(cwd, {
-      personality: 'p', runtime: 'webhook', runtimes: ['webhook'], intelligence: 'absent',
-    })
-    expect(readDisk().intelligence).toBe('absent')
-  })
-
-  test('new profile (no disk) without intelligence → runtime default', () => {
-    writePeerProfileAtomic(cwd, { personality: 'p', runtime: 'telegram', runtimes: ['telegram'] })
-    expect(readDisk().intelligence).toBe('natural') // telegram default
-  })
-
-  test('round-trips through readPeerProfile preserving foreign fields', () => {
-    writePeerProfileAtomic(cwd, {
-      personality: 'p', runtime: 'claude', runtimes: ['claude'],
-      description: 'desc', intelligence: 'artificial',
-    })
-    // inject a foreign field, then a second write must keep it
-    const disk = readDisk()
-    disk['persistent-peer'] = { initial_prompt: 'keep me' }
-    writeFileSync(peerProfilePath(cwd), JSON.stringify(disk))
-    writePeerProfileAtomic(cwd, { personality: 'p', runtime: 'claude', runtimes: ['claude', 'codex'] })
-    const after = readDisk()
-    expect(after['persistent-peer']).toEqual({ initial_prompt: 'keep me' })
-    expect(after.intelligence).toBe('artificial') // still preserved
-    expect(after.runtimes).toEqual(['claude', 'codex'])
-    const parsed = readPeerProfile(cwd)!
-    expect(parsed.intelligence).toBe('artificial')
-  })
-
-  test('wake_policy "ephemeral" parsed; unknown/absent → omitted (never throws)', () => {
-    mkdirSync(join(cwd, '.iapeer'), { recursive: true })
-    // honored enum value
-    writeFileSync(peerProfilePath(cwd), JSON.stringify({
-      personality: 'p', runtime: 'claude', runtimes: ['claude'], wake_policy: 'ephemeral',
-    }))
-    expect(readPeerProfile(cwd)!.wake_policy).toBe('ephemeral')
-    // absent → undefined
-    writeFileSync(peerProfilePath(cwd), JSON.stringify({ personality: 'p', runtime: 'claude', runtimes: ['claude'] }))
-    expect(readPeerProfile(cwd)!.wake_policy).toBeUndefined()
-    // unknown value → omitted (forward-compatible, no throw)
-    writeFileSync(peerProfilePath(cwd), JSON.stringify({
-      personality: 'p', runtime: 'claude', runtimes: ['claude'], wake_policy: 'persistent-future',
-    }))
-    expect(readPeerProfile(cwd)!.wake_policy).toBeUndefined()
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// resolveCallerIdentity — per-request, NO process.cwd()
-// ─────────────────────────────────────────────────────────────────────────────
-
-const index: PeersIndex = {
-  version: 2,
-  peers: [
-    {
-      personality: 'arthur',
-      runtime: 'telegram',
-      runtimes: ['telegram', 'claude'],
-      description: 'Артур — владелец.',
-      intelligence: 'natural',
-      cwd: '/Users/macmini/Peers/arthur',
-      interfaces: { telegram: { user_id: '409502965' } },
-    },
-    {
-      personality: 'boris',
-      runtime: 'claude',
-      runtimes: ['claude'],
-      description: 'Напарник.',
-      intelligence: 'artificial',
-      cwd: '/Users/macmini/Peers/boris',
-    },
-  ],
-}
-
-describe('resolveCallerIdentity (per-request)', () => {
-  test('resolves caller from registry record, builds address', () => {
-    const r = resolveCallerIdentity({ personality: 'boris', runtime: 'claude' }, index)
-    expect(r.address).toBe('claude-boris')
-    expect(r.cwd).toBe('/Users/macmini/Peers/boris')
-    expect(r.intelligence).toBe('artificial')
-  })
-
-  test('multi-runtime peer resolves each declared runtime to a distinct address', () => {
-    expect(resolveCallerIdentity({ personality: 'arthur', runtime: 'telegram' }, index).address).toBe(
-      'telegram-arthur',
-    )
-    expect(resolveCallerIdentity({ personality: 'arthur', runtime: 'claude' }, index).address).toBe(
-      'claude-arthur',
-    )
-  })
-
-  test('does NOT depend on process.cwd() — chdir does not change the result', () => {
-    const before = resolveCallerIdentity({ personality: 'arthur', runtime: 'claude' }, index)
-    const original = process.cwd()
-    const elsewhere = mkdtempSync(join(tmpdir(), 'iapeer-chdir-'))
-    try {
-      process.chdir(elsewhere)
-      const after = resolveCallerIdentity({ personality: 'arthur', runtime: 'claude' }, index)
-      expect(after).toEqual(before)
-      expect(after.cwd).toBe('/Users/macmini/Peers/arthur') // from registry, not process.cwd()
-    } finally {
-      process.chdir(original)
-      rmSync(elsewhere, { recursive: true, force: true })
-    }
-  })
-
-  test('unknown caller → throws (spoofing guard)', () => {
-    expect(() => resolveCallerIdentity({ personality: 'ghost', runtime: 'claude' }, index)).toThrow(
-      /unknown caller/,
-    )
-  })
-
-  test('undeclared runtime for a known caller → throws', () => {
-    // boris declares only claude; codex must be rejected
-    expect(() => resolveCallerIdentity({ personality: 'boris', runtime: 'codex' }, index)).toThrow(
-      /not declared/,
-    )
-  })
-
-  test('invalid personality format → throws', () => {
-    expect(() => resolveCallerIdentity({ personality: 'Bad Name', runtime: 'claude' }, index)).toThrow()
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// ensurePeerProfile — create-peer path installs the always-on plist for INFRA
-// runtimes (and ONLY those). Always under IAPEER_LAUNCHAGENTS_DIR so the suite
-// never writes into the real ~/Library/LaunchAgents.
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('ensurePeerProfile create-peer → always-on plist (infra only)', () => {
-  let root: string
-  beforeEach(() => {
-    root = mkdtempSync(join(tmpdir(), 'iapeer-provision-'))
-  })
-  afterEach(() => {
-    rmSync(root, { recursive: true, force: true })
-  })
-  const laEnv = () =>
-    // IAPEER_ROOT isolates the now-GLOBAL infra log dir (~/.iapeer/logs/<p>, Фаза §8)
-    // under the sandbox — without it installAlwaysOnPlist's log mkdir resolves to the
-    // real home.
-    ({ IAPEER_LAUNCHAGENTS_DIR: join(root, 'LaunchAgents'), IAPEER_ROOT: join(root, 'iapeer') }) as NodeJS.ProcessEnv
-
-  test('provisioning a NEW infra (notifier) peer installs a foundation-owned plist', () => {
-    const env = laEnv()
-    const peerCwd = join(root, 'timer') // basename → personality "timer"
-    const profile = ensurePeerProfile({ cwd: peerCwd, env, runtime: 'notifier' })
-    expect(profile.personality).toBe('timer')
-    expect(profile.intelligence).toBe('absent') // notifier zone default
-
-    const plist = launchdPlistPath('timer', env)
-    expect(existsSync(plist)).toBe(true)
-    expect(isFoundationOwnedPlist(plist)).toBe(true)
-    // and the profile was written (full provision)
-    expect(existsSync(peerProfilePath(peerCwd))).toBe(true)
-  })
-
-  test('provisioning a NEW warm-on-demand (claude) peer installs NO plist (unchanged)', () => {
-    const env = laEnv()
-    const peerCwd = join(root, 'worker') // personality "worker"
-    ensurePeerProfile({ cwd: peerCwd, env, runtime: 'claude' })
-    expect(existsSync(launchdPlistPath('worker', env))).toBe(false)
-    expect(existsSync(peerProfilePath(peerCwd))).toBe(true) // profile still created
-  })
-
-  test('infra provision whose Label collides with a FOREIGN plist is refused — no profile written', () => {
-    const env = laEnv()
-    const laDir = join(root, 'LaunchAgents')
-    mkdirSync(laDir, { recursive: true })
-    // a live persistent-peer "boris" already owns com.iapeer.boris.plist (no sentinel)
-    const foreign = '<?xml version="1.0"?>\n<plist><dict><key>Label</key><string>com.iapeer.boris</string></dict></plist>\n'
-    const plist = launchdPlistPath('boris', env)
-    writeFileSync(plist, foreign)
-
-    const peerCwd = join(root, 'boris') // would derive personality "boris" → collision
-    expect(() => ensurePeerProfile({ cwd: peerCwd, env, runtime: 'notifier' })).toThrow(
-      /foundation-managed|refus/i,
-    )
-    // the live PP plist is untouched, and the half-provision left NO peer-profile.json
-    expect(readFileSync(plist, 'utf8')).toBe(foreign)
-    expect(existsSync(peerProfilePath(peerCwd))).toBe(false)
-  })
-})

package/src/identity/profileStandard.test.ts

@@ -1,204 +0,0 @@
-// Profile-standard validator + index↔local self-heal (reconcile / reindex).
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { isConformant, migrateProfileRuntimeField, reconcileIndex, reindexFromLocals, validateProfileStandard } from './profileStandard.ts'
-import { readFileSync } from 'fs'
-import { readPeersIndex } from '../registry/index.ts'
-
-describe('validateProfileStandard', () => {
-  const cwd = '/Users/x/Peers/boris' // basename normalizes to "boris"
-
-  test('a conformant profile (contract field default_runtime) has no issues', () => {
-    const issues = validateProfileStandard(
-      { personality: 'boris', default_runtime: 'claude', runtimes: ['claude'], description: 'PM', intelligence: 'artificial' },
-      cwd,
-    )
-    expect(issues).toEqual([])
-    expect(isConformant(issues)).toBe(true)
-  })
-
-  test('legacy `runtime` field → WARN (not error), still conformant', () => {
-    const issues = validateProfileStandard(
-      { personality: 'boris', runtime: 'claude', runtimes: ['claude'], description: '', intelligence: 'artificial' },
-      cwd,
-    )
-    expect(isConformant(issues)).toBe(true)
-    expect(issues.find(i => i.field === 'default_runtime')?.severity).toBe('warn')
-  })
-
-  test('default_runtime + in-sync legacy mirror (Phase-2 write shape) → NO issues', () => {
-    const issues = validateProfileStandard(
-      { personality: 'boris', default_runtime: 'claude', runtime: 'claude', runtimes: ['claude'], description: 'PM', intelligence: 'artificial' },
-      cwd,
-    )
-    expect(issues).toEqual([])
-  })
-
-  test('DIVERGED legacy mirror → WARN on default_runtime, still conformant', () => {
-    const issues = validateProfileStandard(
-      { personality: 'boris', default_runtime: 'codex', runtime: 'claude', runtimes: ['codex', 'claude'], description: '', intelligence: 'artificial' },
-      cwd,
-    )
-    expect(isConformant(issues)).toBe(true)
-    const warn = issues.find(i => i.field === 'default_runtime')
-    expect(warn?.severity).toBe('warn')
-    expect(warn?.message).toContain('diverged')
-  })
-
-  test('aliases misfiled in interfaces.telegram → WARN (owner migration to expansion.aliases pending)', () => {
-    const issues = validateProfileStandard(
-      {
-        personality: 'boris', default_runtime: 'claude', runtimes: ['claude'], description: '', intelligence: 'artificial',
-        interfaces: { telegram: { bot: 'k', bot_username: 'x_bot', aliases: { '/alias-new': 'txt' } } },
-      },
-      cwd,
-    )
-    expect(isConformant(issues)).toBe(true)
-    expect(issues.some(i => i.field === 'interfaces.telegram.aliases' && i.severity === 'warn')).toBe(true)
-    // passport-only telegram section → silent
-    const clean = validateProfileStandard(
-      {
-        personality: 'boris', default_runtime: 'claude', runtimes: ['claude'], description: '', intelligence: 'artificial',
-        interfaces: { telegram: { bot: 'k', bot_username: 'x_bot' } },
-        expansion: { aliases: { '/alias-new': 'txt' } },
-      },
-      cwd,
-    )
-    expect(clean).toEqual([])
-  })
-
-  test('top-level aliases → WARN (owner migration pending), still conformant', () => {
-    const issues = validateProfileStandard(
-      { personality: 'boris', runtime: 'claude', runtimes: ['claude'], description: '', intelligence: 'artificial', aliases: { '/new': 'x' } },
-      cwd,
-    )
-    expect(isConformant(issues)).toBe(true)
-    expect(issues.some(i => i.field === 'aliases' && i.severity === 'warn')).toBe(true)
-  })
-
-  test('personality mirror disagreeing with cwd → WARN (self-heal), not error', () => {
-    const issues = validateProfileStandard(
-      { personality: 'WRONG', runtime: 'claude', runtimes: ['claude'], description: '', intelligence: 'artificial' },
-      cwd,
-    )
-    expect(isConformant(issues)).toBe(true)
-    expect(issues.some(i => i.field === 'personality' && i.severity === 'warn')).toBe(true)
-  })
-
-  test('ERRORS: bad runtime, runtimes missing the default, bad intelligence', () => {
-    // runtime ids carry NO hyphen (/^[a-z][a-z0-9]{0,31}$/) → a hyphenated value is an error
-    expect(isConformant(validateProfileStandard({ default_runtime: 'no-dash', runtimes: ['claude'], intelligence: 'artificial' }, cwd))).toBe(false)
-    const e1 = validateProfileStandard({ default_runtime: 'claude', runtimes: ['codex'], intelligence: 'artificial' }, cwd)
-    expect(isConformant(e1)).toBe(false) // runtimes does not include the default
-    const e2 = validateProfileStandard({ default_runtime: 'claude', runtimes: ['claude'], intelligence: 'bogus' }, cwd)
-    expect(isConformant(e2)).toBe(false)
-    const e3 = validateProfileStandard({ runtimes: ['claude'], intelligence: 'artificial' }, cwd)
-    expect(isConformant(e3)).toBe(false) // no runtime/default_runtime at all
-  })
-
-  test('intelligence accepts the live vocab + legacy on read', () => {
-    for (const v of ['artificial', 'natural', 'absent', 'human', 'scripted']) {
-      const issues = validateProfileStandard({ default_runtime: 'claude', runtimes: ['claude'], intelligence: v }, cwd)
-      expect(issues.some(i => i.field === 'intelligence')).toBe(false)
-    }
-  })
-})
-
-describe('reconcileIndex / reindexFromLocals (self-heal)', () => {
-  let root: string
-  const prevRoot = process.env.IAPEER_ROOT
-  let borisCwd: string
-
-  beforeEach(() => {
-    root = mkdtempSync(join(tmpdir(), 'iapeer-ps-'))
-    process.env.IAPEER_ROOT = root
-    // a local profile (source of truth) with a FRESH description + narrowed runtimes
-    borisCwd = join(root, 'peers', 'boris')
-    mkdirSync(join(borisCwd, '.iapeer'), { recursive: true })
-    writeFileSync(
-      join(borisCwd, '.iapeer', 'peer-profile.json'),
-      JSON.stringify({ personality: 'boris', runtime: 'claude', runtimes: ['claude'], description: 'FRESH local desc', intelligence: 'artificial' }),
-    )
-    // a STALE index: old description + an extra runtime the local no longer declares
-    writeFileSync(
-      join(root, 'peers-profiles.json'),
-      JSON.stringify({
-        version: 2,
-        peers: [{ personality: 'boris', runtime: 'claude', runtimes: ['claude', 'codex'], description: 'STALE index desc', intelligence: 'artificial', cwd: borisCwd }],
-      }),
-    )
-  })
-  afterEach(() => {
-    if (prevRoot === undefined) delete process.env.IAPEER_ROOT
-    else process.env.IAPEER_ROOT = prevRoot
-    rmSync(root, { recursive: true, force: true })
-  })
-
-  test('reconcile DETECTS the drift (description + runtimes) read-only', () => {
-    const r = reconcileIndex({ env: process.env })
-    const boris = r.find(e => e.personality === 'boris')
-    expect(boris?.drift).toContain('description')
-    expect(boris?.drift).toContain('runtimes')
-    // read-only: the index file is untouched
-    expect(readPeersIndex({ env: process.env }).peers[0].description).toBe('STALE index desc')
-  })
-
-  test('reindex SELF-HEALS the index from the local profile (REPLACE, not union)', async () => {
-    const { healed } = await reindexFromLocals({ env: process.env })
-    expect(healed.some(h => h.startsWith('boris:'))).toBe(true)
-    const rec = readPeersIndex({ env: process.env }).peers[0]
-    expect(rec.description).toBe('FRESH local desc')
-    expect(rec.runtimes).toEqual(['claude']) // codex DROPPED (reindex replaces, unlike upsert union)
-    // after the heal, reconcile is clean
-    expect(reconcileIndex({ env: process.env }).find(e => e.personality === 'boris')?.drift).toEqual([])
-  })
-
-  test('reindex writes the Phase-2 disk shape: default_runtime + in-sync legacy mirror', async () => {
-    await reindexFromLocals({ env: process.env })
-    const disk = JSON.parse(readFileSync(join(root, 'peers-profiles.json'), 'utf8'))
-    expect(disk.peers[0].default_runtime).toBe('claude')
-    expect(disk.peers[0].runtime).toBe('claude') // legacy mirror until Phase 3
-  })
-
-  test('migrateProfileRuntimeField: legacy-only profile → rewritten with default_runtime + mirror, owner fields preserved, idempotent', () => {
-    const profilePath = join(borisCwd, '.iapeer', 'peer-profile.json')
-    // enrich the legacy profile with owner-section + lifecycle fields that MUST survive
-    writeFileSync(
-      profilePath,
-      JSON.stringify({
-        personality: 'boris', runtime: 'claude', runtimes: ['claude'], description: 'd', intelligence: 'human',
-        initial_prompt: 'boot', wake_policy: 'ephemeral',
-        interfaces: { telegram: { bot: 'k' } },
-        expansion: { aliases: { '/alias-new': 'txt' } },
-        notifier: { triggers: [] },
-      }),
-    )
-    expect(migrateProfileRuntimeField(borisCwd)).toBe(true)
-    const after = JSON.parse(readFileSync(profilePath, 'utf8'))
-    expect(after.default_runtime).toBe('claude')
-    expect(after.runtime).toBe('claude') // in-sync legacy mirror
-    expect(after.intelligence).toBe('human') // legacy vocab preserved VERBATIM (no silent migration)
-    expect(after.initial_prompt).toBe('boot')
-    expect(after.wake_policy).toBe('ephemeral')
-    expect(after.interfaces).toEqual({ telegram: { bot: 'k' } })
-    expect(after.expansion).toEqual({ aliases: { '/alias-new': 'txt' } })
-    expect(after.notifier).toEqual({ triggers: [] })
-    // idempotent: already in shape → untouched
-    expect(migrateProfileRuntimeField(borisCwd)).toBe(false)
-  })
-
-  test('migrateProfileRuntimeField: DIVERGED mirror heals to default_runtime (the contract side wins)', () => {
-    const profilePath = join(borisCwd, '.iapeer', 'peer-profile.json')
-    writeFileSync(
-      profilePath,
-      JSON.stringify({ personality: 'boris', default_runtime: 'codex', runtime: 'claude', runtimes: ['codex', 'claude'], description: '', intelligence: 'artificial' }),
-    )
-    expect(migrateProfileRuntimeField(borisCwd)).toBe(true)
-    const after = JSON.parse(readFileSync(profilePath, 'utf8'))
-    expect(after.default_runtime).toBe('codex')
-    expect(after.runtime).toBe('codex') // mirror re-synced to the governing field
-  })
-})