@agfpd/iapeer 0.1.0

package/bin/iapeer

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# npx @agfpd/iapeer bootstrap.
+#
+# Runs the iapeer foundation CLI from the package SOURCE via bun (the foundation is a
+# bun project; there is no precompiled JS shipped). A BARE invocation (`npx
+# @agfpd/iapeer`, no args) runs the `install` verb — compile the stable
+# ~/.local/bin/iapeer binary + the global ~/.iapeer scaffold + the daemon plist —
+# implementing the `npx @agfpd/iapeer` install contract. Any args pass straight through
+# to the CLI (`npx @agfpd/iapeer onboard`, `… create <p>`, …).
+set -euo pipefail
+
+PKG_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+CLI="$PKG_ROOT/src/cli/index.ts"
+
+if ! command -v bun >/dev/null 2>&1; then
+  echo "iapeer: 'bun' is required on PATH to run the foundation CLI — install it from https://bun.sh" >&2
+  exit 1
+fi
+
+if [ "$#" -eq 0 ]; then
+  # Bare bootstrap → install the foundation (binary + scaffold + daemon plist).
+  exec bun "$CLI" install
+fi
+
+exec bun "$CLI" "$@"

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@agfpd/iapeer",
+  "version": "0.1.0",
+  "description": "Foundation core for the IAPeer multi-agent ecosystem: identity, registry, storage, codec.",
+  "type": "module",
+  "bin": {
+    "iapeer": "bin/iapeer"
+  },
+  "files": [
+    "src",
+    "bin",
+    "tsconfig.json"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./core": "./src/core/index.ts",
+    "./storage": "./src/storage/index.ts",
+    "./identity": "./src/identity/index.ts",
+    "./registry": "./src/registry/index.ts",
+    "./codec": "./src/codec/index.ts"
+  },
+  "scripts": {
+    "test": "IAPEER_TEST_SANDBOX=1 bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "proper-lockfile": "^4.1.2",
+    "transliteration": "^2.6.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^22.0.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "typescript": "^5.6.0"
+  }
+}

package/src/cli/cli.test.ts

@@ -0,0 +1,130 @@
+// iapeer CLI verbs — list / stop / start (C1 + fleet guard) / send validation.
+// No tmux: killSession on a non-existent session is a no-op, the C1 flag is the
+// observable. The FLEET GUARD (H4) is the safety-critical case — a foreign
+// persistent-peer launchd plist must be refused.
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { mkdtempSync, rmSync, writeFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { formatListTable, listPeers, parseArgs, sendMessage, startPeer, stopPeer } from './index.ts'
+import { upsertPeer } from '../registry/index.ts'
+import { isStopped, loadLifecycleConfig, setStopped } from '../lifecycle/index.ts'
+import { launchdPlistPath } from '../launch/launchd.ts'
+
+let root: string
+let laDir: string
+function env(): NodeJS.ProcessEnv {
+  const e: NodeJS.ProcessEnv = {
+    ...process.env,
+    IAPEER_ROOT: root,
+    IAPEER_LAUNCHAGENTS_DIR: laDir,
+    IAPEER_SOCK_DIR: join(root, 'socks'),
+  }
+  delete e.PEER_PERSONALITY
+  delete e.PEER_IDENTITY
+  delete e.PEER_RUNTIME
+  return e
+}
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), 'iapeer-cli-root-'))
+  laDir = mkdtempSync(join(tmpdir(), 'iapeer-cli-la-'))
+})
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true })
+  rmSync(laDir, { recursive: true, force: true })
+})
+
+async function register(personality: string, runtime = 'claude', intelligence: 'artificial' | 'natural' | 'absent' = 'artificial'): Promise<void> {
+  await upsertPeer({ personality, runtime, cwd: `/tmp/${personality}`, intelligence }, { rootDir: root })
+}
+
+describe('list', () => {
+  test('lists registered peers with per-runtime liveness (asleep / stopped)', async () => {
+    await register('alpha')
+    await register('beta')
+    const e = env()
+    setStopped(loadLifecycleConfig(e), 'claude-beta')
+    const rows = listPeers({ env: e })
+    const alpha = rows.find(r => r.personality === 'alpha')!
+    const beta = rows.find(r => r.personality === 'beta')!
+    expect(alpha.runtimes[0]).toEqual({ runtime: 'claude', status: 'asleep' })
+    expect(beta.runtimes[0]).toEqual({ runtime: 'claude', status: 'stopped' })
+    expect(formatListTable(rows)).toContain('alpha')
+    expect(formatListTable(rows)).toContain('✕ claude') // stopped glyph for beta
+  })
+  test('empty registry → friendly message', () => {
+    expect(formatListTable(listPeers({ env: env() }))).toBe('no peers registered\n')
+  })
+})
+
+describe('stop / start (C1 durable flag, warm runtime)', () => {
+  test('stop sets the durable flag; start clears it', async () => {
+    await register('gamma')
+    const e = env()
+    const cfg = loadLifecycleConfig(e)
+    expect(isStopped(cfg, 'claude-gamma')).toBe(false)
+    expect(stopPeer('gamma', undefined, { env: e })[0].action).toBe('stopped')
+    expect(isStopped(cfg, 'claude-gamma')).toBe(true)
+    expect(startPeer('gamma', undefined, { env: e })[0].action).toBe('started')
+    expect(isStopped(cfg, 'claude-gamma')).toBe(false)
+  })
+  test('stop an unregistered peer → throws', () => {
+    expect(() => stopPeer('nobody', undefined, { env: env() })).toThrow(/not registered/)
+  })
+})
+
+describe('FLEET GUARD (H4) — foreign persistent-peer launchd plist is off-limits', () => {
+  test('stop refuses a peer whose com.iapeer.<p>.plist is NOT foundation-owned', async () => {
+    await register('boris')
+    // a live PP peer owns com.iapeer.boris.plist WITHOUT the foundation sentinel
+    writeFileSync(launchdPlistPath('boris', env()), '<?xml version="1.0"?>\n<plist><dict><key>Label</key><string>com.iapeer.boris</string></dict></plist>\n')
+    const e = env()
+    const out = stopPeer('boris', undefined, { env: e })
+    expect(out[0].action).toBe('refused-foreign-launchd')
+    // the durable flag was NOT set — the foundation did not touch the PP peer
+    expect(isStopped(loadLifecycleConfig(e), 'claude-boris')).toBe(false)
+    // start likewise refuses
+    expect(startPeer('boris', undefined, { env: e })[0].action).toBe('refused-foreign-launchd')
+  })
+})
+
+describe('send validation', () => {
+  test('invalid --from identity → throws', async () => {
+    await register('alpha')
+    await expect(
+      sendMessage({ from: 'notanidentity', target: 'alpha', message: 'hi', env: env() }),
+    ).rejects.toThrow(/invalid/)
+  })
+  test('unknown --from caller → throws (not registered)', async () => {
+    await register('alpha')
+    await expect(
+      sendMessage({ from: 'claude-ghost', target: 'alpha', message: 'hi', env: env() }),
+    ).rejects.toThrow(/unknown caller|not registered/)
+  })
+  test('target not in registry → throws before any wake', async () => {
+    await register('alpha')
+    await expect(
+      sendMessage({ from: 'claude-alpha', target: 'nobody', message: 'hi', env: env() }),
+    ).rejects.toThrow(/not in the IAPeer peers index|self/)
+  })
+})
+
+describe('parseArgs (audit #27 — value beginning with --)', () => {
+  test('--key=value preserves a value that starts with --', () => {
+    expect(parseArgs(['send', 'boris', '--message=--look', '--topic=re: x']).flags).toMatchObject({
+      message: '--look',
+      topic: 're: x',
+    })
+  })
+  test('look-ahead --key value still works; a following --flag is not consumed as a value', () => {
+    const { flags, positionals } = parseArgs(['send', 'boris', '--message', 'hi', '--json'])
+    expect(positionals).toEqual(['send', 'boris'])
+    expect(flags.message).toBe('hi')
+    expect(flags.json).toBe(true)
+  })
+  test('empty value via = stays a string, not true', () => {
+    expect(parseArgs(['x', '--description=']).flags.description).toBe('')
+  })
+})