@agfpd/iapeer 0.2.99 → 0.3.0

package/README.md

@@ -22,19 +22,33 @@ recipient peer  — asleep? the daemon wakes it and delivers on wake
 
 ## Quick start
 
-Requirements: **macOS**, [bun](https://bun.sh) on `PATH`, `~/.local/bin` on `PATH`, and at least one agent runtime installed — Claude Code or Codex CLI (each AI peer is a live session of one).
+Requirements: **macOS** (Linux is on the [Roadmap](#roadmap)) and at least one agent runtime — Claude Code or Codex CLI (each AI peer is a live session of one). The installer handles the rest ([bun](https://bun.sh) and `~/.local/bin` on `PATH`).
+
+**Install — one line.** Installs bun if missing, builds the `iapeer` binary, then hands off to the interactive `onboard`:
+
+```sh
+curl -fsSL https://agfpd.github.io/iapeer/install.sh | sh
+```
+
+**Prefer not to pipe a script into your shell?** Run the same steps by hand (needs [bun](https://bun.sh) on `PATH`):
 
 ```sh
-# 1. install — the iapeer binary and the ~/.iapeer layout
-npx @agfpd/iapeer
+# install — the iapeer binary and the ~/.iapeer layout
+npx @agfpd/iapeer            # or: bunx @agfpd/iapeer
 
-# 2. set up the host — starts the router daemon, then adds scheduler peers, Telegram, and shared memory
+# set up the host — router daemon, scheduler peers, Telegram, shared memory
 iapeer onboard
+```
+
+Either path runs `onboard` interactively: it surfaces the security checks (runtime sign-in, macOS Full Disk Access) and asks before installing the memory provider — nothing is auto-approved behind your back. You can read [`install.sh`](./install.sh) before running it, or preview every step with `IAPEER_INSTALL_DRYRUN=1`.
 
-# 3. create your first agent
+**Then create your first agent and talk to it:**
+
+```sh
+# create your first agent
 iapeer create assistant --runtime claude
 
-# 4. talk to it live in your terminal — detach with Ctrl-] (or just close it; the agent keeps running)
+# talk to it live in your terminal — detach with Ctrl-] (or just close it; the agent keeps running)
 iapeer attach assistant
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.99",
+  "version": "0.3.0",
   "description": "Foundation core for the iapeer multi-agent ecosystem: identity, registry, storage, codec.",
   "license": "Apache-2.0",
   "author": "agfpd",
@@ -56,13 +56,17 @@
     "@modelcontextprotocol/sdk": "1.29.0",
     "@xterm/addon-serialize": "0.14.0",
     "@xterm/headless": "6.0.0",
+    "ink": "^7.1.0",
     "proper-lockfile": "^4.1.2",
+    "react": "^19.2.7",
+    "react-devtools-core": "^7.0.1",
     "transliteration": "^2.6.1"
   },
   "devDependencies": {
     "@types/bun": "latest",
     "@types/node": "^22.0.0",
     "@types/proper-lockfile": "^4.1.4",
+    "@types/react": "^19.2.17",
     "typescript": "^5.6.0"
   }
 }

package/src/cli/index.ts

@@ -1002,6 +1002,26 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
   try {
     switch (verb) {
       case 'onboard': {
+        // Interactive TUI wizard (Фаза TUI-редизайн) — the DEFAULT for an
+        // interactive `iapeer onboard`. Routed ONLY in a real interactive terminal
+        // and never for an automation path (--accept-risk / --dry-run / --no-memory
+        // / --infra), which stay on the deterministic linear flow below. Escape
+        // hatch: IAPEER_ONBOARD_WIZARD=0 forces the linear path (recovery / scripts
+        // that want the old flow). The wizard owns its own gate screen, so we route
+        // BEFORE the readline gate. It fails closed: no real TTY →
+        // WIZARD_NOT_INTERACTIVE → fall through to linear.
+        const wizardOptOut = /^(0|false|no)$/i.test((env.IAPEER_ONBOARD_WIZARD ?? '').trim())
+        const automationFlag =
+          flags['accept-risk'] === true ||
+          flags['dry-run'] === true ||
+          flags['no-memory'] === true ||
+          typeof flags.infra === 'string'
+        if (!wizardOptOut && !automationFlag && process.stdin.isTTY === true && process.stdout.isTTY === true) {
+          const { runOnboardWizard, WIZARD_NOT_INTERACTIVE } = await import('../tui/onboard/run.tsx')
+          const wc = await runOnboardWizard({ env })
+          if (wc !== WIZARD_NOT_INTERACTIVE) return wc
+          // not a real interactive TTY after all → linear path below
+        }
         // SECURITY GATE (pre-release): the operator must consciously accept the risk of
         // beta infra with live agents BEFORE onboard mutates the host. --accept-risk /
         // IAPEER_ACCEPT_RISK accepts non-interactively (one-liner installers / CI); a

package/src/tui/onboard/app.tsx

@@ -0,0 +1,260 @@
+// OnboardApp — the interactive onboard wizard (Ink). Owns the interactive +
+// live-progress part and EXITS; the inherited-stdio memory install + the final
+// summary run post-Ink (see run.tsx). Drives the SAME backend functions as the
+// linear non-interactive path (no logic duplication), honoring the phase
+// principles: explicit prompts (what to press), visible progress on otherwise
+// silent steps (daemon start), and a clear next-step instead of a cryptic code.
+
+import React, { useEffect, useState } from 'react'
+import { Box, Text, useApp, useInput, useStdin } from 'ink'
+import { ONBOARD_SECURITY_WARNING } from '../../onboard/risk.ts'
+import { onboardHost, runtimeAuthNote, tccFullDiskAccessNote, type OnboardRuntime } from '../../onboard/index.ts'
+import { probeFullDiskAccess } from '../../status/index.ts'
+import { ensureDaemonStarted } from '../../daemon/main.ts'
+import { iapeerBinPath } from '../../install/index.ts'
+
+/** What the wizard hands back to run.tsx for the post-Ink phase (memory install +
+ *  summary). */
+export interface WizardResult {
+  code: number
+  memoryConsent: boolean
+  advisories: string[]
+  summary: string[]
+}
+
+type Phase = 'gate' | 'running' | 'memory' | 'declined' | 'finishing'
+type StepStatus = 'pending' | 'running' | 'ok' | 'warn' | 'fail'
+interface Step {
+  key: string
+  label: string
+  status: StepStatus
+  detail?: string
+}
+
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+
+function useSpinnerFrame(active: boolean): string {
+  const [i, setI] = useState(0)
+  useEffect(() => {
+    if (!active) return
+    const t = setInterval(() => setI(n => (n + 1) % SPINNER.length), 80)
+    return () => clearInterval(t)
+  }, [active])
+  return SPINNER[i]
+}
+
+function glyph(status: StepStatus, spin: string): string {
+  switch (status) {
+    case 'running':
+      return spin
+    case 'ok':
+      return '✓'
+    case 'warn':
+      return '!'
+    case 'fail':
+      return '✗'
+    default:
+      return '·'
+  }
+}
+
+function color(status: StepStatus): string {
+  switch (status) {
+    case 'ok':
+      return 'green'
+    case 'warn':
+      return 'yellow'
+    case 'fail':
+      return 'red'
+    case 'running':
+      return 'cyan'
+    default:
+      return 'gray'
+  }
+}
+
+export function OnboardApp({
+  env,
+  onResult,
+}: {
+  env: NodeJS.ProcessEnv
+  onResult: (r: WizardResult) => void
+}): React.ReactElement {
+  const { exit } = useApp()
+  const { isRawModeSupported } = useStdin()
+  const [phase, setPhase] = useState<Phase>('gate')
+  const [steps, setSteps] = useState<Step[]>([])
+  const [advisories, setAdvisories] = useState<string[]>([])
+  const spin = useSpinnerFrame(phase === 'running')
+
+  const finish = (memoryConsent: boolean): void => {
+    const failed = steps.some(s => s.status === 'fail')
+    const summary = steps.map(s => {
+      const mark = s.status === 'ok' ? '✓' : s.status === 'warn' ? '!' : s.status === 'fail' ? '✗' : '·'
+      return `  ${mark} ${s.label}${s.detail ? ` — ${s.detail}` : ''}`
+    })
+    summary.unshift(failed ? 'Onboard finished with errors:' : 'Onboard complete:')
+    onResult({ code: failed ? 1 : 0, memoryConsent, advisories, summary })
+    setPhase('finishing')
+    setTimeout(() => exit(), 30)
+  }
+
+  // Gate input — explicit y/N.
+  useInput(
+    (input, key) => {
+      if (input === 'y' || input === 'Y') setPhase('running')
+      else if (input === 'n' || input === 'N' || key.escape) setPhase('declined')
+    },
+    { isActive: phase === 'gate' },
+  )
+
+  // Memory consent — DEFAULT-YES ([Y/n]: Enter or y → install).
+  useInput(
+    (input, key) => {
+      if (input === 'n' || input === 'N') finish(false)
+      else if (input === 'y' || input === 'Y' || key.return) finish(true)
+    },
+    { isActive: phase === 'memory' },
+  )
+
+  // Declined → exit 1 (no host mutation).
+  useEffect(() => {
+    if (phase !== 'declined') return
+    onResult({ code: 1, memoryConsent: false, advisories: [], summary: ['onboard aborted — risk not accepted.'] })
+    const t = setTimeout(() => exit(), 30)
+    return () => clearTimeout(t)
+  }, [phase, onResult, exit])
+
+  // Running phase — drive the backend steps sequentially with live status.
+  useEffect(() => {
+    if (phase !== 'running') return
+    let cancelled = false
+    const set = (k: string, patch: Partial<Step>) =>
+      setSteps(prev => prev.map(s => (s.key === k ? { ...s, ...patch } : s)))
+    setSteps([
+      { key: 'daemon', label: 'Start router daemon', status: 'pending' },
+      { key: 'market', label: 'Register marketplace (claude, codex)', status: 'pending' },
+      { key: 'auth', label: 'Check runtime sign-in', status: 'pending' },
+      { key: 'fda', label: 'Check macOS Full Disk Access', status: 'pending' },
+    ])
+
+    // Backend steps use synchronous spawnSync (launchctl, runtime plugin list) —
+    // those block the event loop, so we yield (tick) after each status change so
+    // Ink flushes a frame and steps paint as they progress, not all at once.
+    // (Intra-step spinner can't animate while a single spawnSync blocks — a known
+    // limitation until those backend calls go async; the step still shows.)
+    const tick = () => new Promise<void>(r => setTimeout(r, 0))
+
+    void (async () => {
+      const adv: string[] = []
+      set('daemon', { status: 'running' })
+      await tick()
+      try {
+        const d = await ensureDaemonStarted({ env })
+        const ok = d.state !== 'failed' && d.healthy !== false
+        set('daemon', { status: ok ? 'ok' : 'fail', detail: d.detail ?? d.state })
+      } catch (e) {
+        set('daemon', { status: 'fail', detail: e instanceof Error ? e.message : String(e) })
+      }
+      if (cancelled) return
+      await tick()
+
+      set('market', { status: 'running' })
+      await tick()
+      const r = onboardHost({ env })
+      const installed: OnboardRuntime[] = []
+      for (const m of r.marketplaces) if (m.state !== 'runtime-missing') installed.push(m.runtime)
+      const mFail = r.marketplaces.some(m => m.state === 'failed')
+      set('market', {
+        status: mFail ? 'fail' : 'ok',
+        detail: r.marketplaces.map(m => `${m.runtime}:${m.state}`).join(' '),
+      })
+      if (cancelled) return
+      await tick()
+
+      set('auth', { status: 'running' })
+      await tick()
+      if (installed.length === 0) {
+        set('auth', { status: 'warn', detail: 'no runtime installed' })
+        adv.push(
+          '⚠ SETUP INCOMPLETE — no agent runtime found. iapeer needs Claude Code or Codex CLI\n' +
+            '  to run peers. Install one, sign in, then re-run `iapeer onboard`.',
+        )
+      } else {
+        const notes = installed.map(rt => runtimeAuthNote(rt, env)).filter((n): n is string => n != null)
+        set('auth', {
+          status: notes.length ? 'warn' : 'ok',
+          detail: notes.length ? `${notes.length} runtime(s) not signed in` : installed.join(', '),
+        })
+        adv.push(...notes)
+      }
+      if (cancelled) return
+
+      set('fda', { status: 'running' })
+      await tick()
+      const fda = probeFullDiskAccess(env)
+      const tcc = tccFullDiskAccessNote({ fda, binPath: iapeerBinPath(env) })
+      set('fda', { status: tcc ? 'warn' : 'ok', detail: fda === true ? 'granted' : tcc ? 'not granted' : 'n/a' })
+      if (tcc) adv.push(tcc)
+      if (cancelled) return
+
+      setAdvisories(adv)
+      setPhase('memory')
+    })()
+
+    return () => {
+      cancelled = true
+    }
+  }, [phase, env])
+
+  if (isRawModeSupported === false) {
+    return (
+      <Text color="yellow">
+        iapeer onboard needs an interactive terminal. Open a normal terminal and run: iapeer onboard
+      </Text>
+    )
+  }
+
+  if (phase === 'gate') {
+    return (
+      <Box flexDirection="column">
+        <Box borderStyle="round" borderColor="yellow" paddingX={1} flexDirection="column">
+          <Text color="yellow" bold>
+            Security warning — please read.
+          </Text>
+          <Text>{ONBOARD_SECURITY_WARNING.replace(/^Security warning — please read\.\n\n/, '')}</Text>
+        </Box>
+        <Box marginTop={1}>
+          <Text bold>Continue? </Text>
+          <Text dimColor>[y/N] </Text>
+        </Box>
+      </Box>
+    )
+  }
+
+  if (phase === 'declined') {
+    return <Text color="red">onboard aborted — risk not accepted.</Text>
+  }
+
+  // running | memory | finishing
+  return (
+    <Box flexDirection="column">
+      <Text bold>Setting up the host…</Text>
+      <Box flexDirection="column" marginTop={1}>
+        {steps.map(s => (
+          <Box key={s.key}>
+            <Text color={color(s.status)}>{glyph(s.status, spin)} </Text>
+            <Text>{s.label}</Text>
+            {s.detail ? <Text dimColor> — {s.detail}</Text> : null}
+          </Box>
+        ))}
+      </Box>
+      {phase === 'memory' ? (
+        <Box marginTop={1} flexDirection="column">
+          <Text>Install the shared-memory provider (@agfpd/iapeer-memory)?</Text>
+          <Text dimColor>It gives your agents a shared knowledge vault. [Y/n] </Text>
+        </Box>
+      ) : null}
+    </Box>
+  )
+}

package/src/tui/onboard/run.tsx

@@ -0,0 +1,72 @@
+// runOnboardWizard — the Ink entry point for the interactive onboard wizard.
+//
+// Boundary (контракт «интерактив только в реальном TTY», фаза TUI-редизайн):
+// the wizard runs ONLY in a real interactive terminal. The CLI routes here only
+// when stdin AND stdout are TTYs and no non-interactive flag is set; install.sh
+// never launches it (it prints a next-step to open a normal terminal). As a
+// belt-and-suspenders guard against the readline-class wedge (Bun raw-mode on a
+// redirect-opened /dev/tty reports isTTY=true but never receives input), we also
+// fail CLOSED here: no real TTY → return WIZARD_NOT_INTERACTIVE so the caller
+// falls back to the linear non-interactive path instead of rendering raw and
+// hanging.
+//
+// Structure: Ink owns the interactive + live-progress part (gate, daemon/
+// marketplace/auth/FDA steps, memory consent) and EXITS. The memory provider
+// install — an INHERITED-STDIO subprocess (it owns its own tty questions) — runs
+// AFTER Ink has unmounted, so the two never share the terminal at once. The final
+// summary is plain text post-Ink (it folds in the memory outcome).
+
+import React from 'react'
+import { render } from 'ink'
+import { OnboardApp, type WizardResult } from './app.tsx'
+
+/** Sentinel: the environment is not a real interactive TTY — caller should fall
+ *  back to the linear non-interactive onboard path (never render raw + hang). */
+export const WIZARD_NOT_INTERACTIVE = -1
+
+export interface OnboardWizardOptions {
+  env?: NodeJS.ProcessEnv
+}
+
+/** Render the interactive onboard wizard. Resolves with the process exit code, or
+ *  WIZARD_NOT_INTERACTIVE when there is no real TTY to drive it. */
+export async function runOnboardWizard(opts: OnboardWizardOptions = {}): Promise<number> {
+  const env = opts.env ?? process.env
+  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+    return WIZARD_NOT_INTERACTIVE
+  }
+
+  let result: WizardResult = { code: 0, memoryConsent: false, advisories: [], summary: [] }
+  try {
+    const app = render(<OnboardApp env={env} onResult={r => (result = r)} />)
+    await app.waitUntilExit()
+  } catch {
+    return WIZARD_NOT_INTERACTIVE
+  }
+
+  // Post-Ink: the memory provider install owns the terminal (inherited stdio).
+  // Ink is fully unmounted now, so there is no contention.
+  if (result.memoryConsent) {
+    const { onboardMemoryProvider } = await import('../../onboard/memory.ts')
+    process.stdout.write('\nInstalling shared-memory provider (@agfpd/iapeer-memory)…\n')
+    try {
+      const mem = await onboardMemoryProvider({ env })
+      const label = mem.provider ? `${mem.provider.provider} ${mem.provider.version}` : 'none'
+      process.stdout.write(`memory: ${mem.state}${mem.detail ? ` — ${mem.detail}` : ''} (slot: ${label})\n`)
+    } catch (e) {
+      process.stdout.write(`memory: step failed — ${e instanceof Error ? e.message : String(e)}\n`)
+    }
+  } else {
+    process.stdout.write('\nmemory: skipped — set it up later with `iapeer onboard` or `npx @agfpd/iapeer-memory init`\n')
+  }
+
+  // Final summary (plain text, post-Ink).
+  process.stdout.write('\n')
+  for (const line of result.summary) process.stdout.write(line + '\n')
+  if (result.advisories.length > 0) {
+    process.stdout.write('\n')
+    for (const a of result.advisories) process.stdout.write(a + '\n')
+  }
+  process.stdout.write('\nNext: create your first agent — `iapeer create <name> --runtime claude`\n')
+  return result.code
+}

package/tsconfig.json

@@ -4,6 +4,8 @@
     "module": "ESNext",
     "moduleResolution": "bundler",
     "allowImportingTsExtensions": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "react",
     "verbatimModuleSyntax": true,
     "noEmit": true,
     "strict": true,
@@ -14,5 +16,5 @@
     "types": ["bun", "node"],
     "lib": ["ESNext"]
   },
-  "include": ["src/**/*.ts"]
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
 }