piu-piu-cli 0.1.0

package/bin/piu-piu.mjs

@@ -0,0 +1,428 @@
+#!/usr/bin/env node
+// piu-piu: a 3D office for your Claude Code agents.
+// This command sets it up (hooks, channel, background service) and runs it.
+import { spawn, spawnSync } from 'node:child_process';
+import { accessSync, constants, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { homedir, platform } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+const PKG = resolve(import.meta.dirname, '..');
+const VERSION = JSON.parse(readFileSync(join(PKG, 'package.json'), 'utf8')).version;
+const DAEMON = join(PKG, 'dist', 'daemon.mjs');
+const CHANNEL = join(PKG, 'dist', 'channel.mjs');
+const HOME = process.env.PIU_PIU_HOME ?? join(homedir(), '.piu-piu');
+const PORT = Number(process.env.PIU_PIU_PORT ?? 7777);
+const URL = `http://127.0.0.1:${PORT}`;
+const MAC = platform() === 'darwin';
+
+const LABEL = 'io.piupiu.daemon';
+const LEGACY_LABEL = 'io.mazestudio.office'; // the service before the rename
+const PLIST = join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+const UNIT = join(homedir(), '.config', 'systemd', 'user', 'piu-piu.service');
+const LOG = MAC ? join(homedir(), 'Library', 'Logs', 'piu-piu.log') : join(HOME, 'piu-piu.log');
+const SETTINGS = join(homedir(), '.claude', 'settings.json');
+const HOOK_MARKER = 'piu-piu';
+const LEGACY_MARKER = 'maze-office';
+const HOOK_EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'Notification', 'Stop', 'SubagentStart', 'SubagentStop', 'SessionEnd'];
+
+const c = process.stdout.isTTY ? { b: (s) => `\x1b[1m${s}\x1b[0m`, dim: (s) => `\x1b[2m${s}\x1b[0m`, ok: (s) => `\x1b[32m${s}\x1b[0m`, bad: (s) => `\x1b[31m${s}\x1b[0m`, warn: (s) => `\x1b[33m${s}\x1b[0m` } : { b: String, dim: String, ok: String, bad: String, warn: String };
+const say = (...a) => console.log(...a);
+const fail = (msg) => {
+  console.error(c.bad(`✗ ${msg}`));
+  process.exit(1);
+};
+const quiet = (cmd, args) => spawnSync(cmd, args, { stdio: 'pipe', encoding: 'utf8' });
+
+function claudeBinary() {
+  for (const p of [join(homedir(), '.local', 'bin', 'claude'), '/opt/homebrew/bin/claude', '/usr/local/bin/claude']) if (existsSync(p)) return p;
+  const which = quiet('which', ['claude']);
+  return which.status === 0 ? which.stdout.trim() : undefined;
+}
+
+async function state() {
+  try {
+    const res = await fetch(`${URL}/api/state`, { signal: AbortSignal.timeout(1500) });
+    return res.ok ? await res.json() : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function waitUp(ms = 15000) {
+  for (const end = Date.now() + ms; Date.now() < end; await new Promise((r) => setTimeout(r, 400))) if (await state()) return true;
+  return false;
+}
+
+// Restarting stops agents mid-task: refuse unless nobody is busy (or --force).
+async function guardBusy(action) {
+  if (process.argv.includes('--force')) return;
+  const s = await state();
+  const busy = [...(s?.running ?? []), ...(s?.terminals ?? [])];
+  if (busy.length) fail(`${busy.join(', ')} ${busy.length === 1 ? 'is' : 'are'} working in the office (chat or terminal). ${action} would stop them. Try again later, or add --force.`);
+}
+
+// ---------------------------------------------------------------- hooks
+
+function hooks(install) {
+  if (!existsSync(SETTINGS)) {
+    mkdirSync(dirname(SETTINGS), { recursive: true });
+    writeFileSync(SETTINGS, '{}\n');
+  }
+  const settings = JSON.parse(readFileSync(SETTINGS, 'utf8'));
+  copyFileSync(SETTINGS, `${SETTINGS}.bak-piu-piu`);
+  settings.hooks ??= {};
+  const ours = (h) => [HOOK_MARKER, LEGACY_MARKER].some((m) => String(h.command ?? '').includes(`# ${m}`));
+  for (const event of new Set([...HOOK_EVENTS, ...Object.keys(settings.hooks)])) {
+    const groups = (settings.hooks[event] ?? []).map((g) => ({ ...g, hooks: (g.hooks ?? []).filter((h) => !ours(h)) })).filter((g) => g.hooks.length > 0);
+    if (install && HOOK_EVENTS.includes(event)) {
+      groups.push({
+        ...(event.endsWith('ToolUse') ? { matcher: '*' } : {}),
+        hooks: [
+          {
+            type: 'command',
+            // gives up after 1s so a stopped office never slows Claude Code down;
+            // $PPID (the Claude process) lets the office match the session to its channel
+            command: `curl -s --max-time 1 -X POST -H 'Content-Type: application/json' -H "X-Claude-Pid: $PPID" --data-binary @- http://127.0.0.1:${PORT}/hooks/${event} >/dev/null 2>&1 || true # ${HOOK_MARKER}`,
+            timeout: 2,
+          },
+        ],
+      });
+    }
+    if (groups.length) settings.hooks[event] = groups;
+    else delete settings.hooks[event];
+  }
+  if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  writeFileSync(SETTINGS, JSON.stringify(settings, null, 2) + '\n');
+  say(c.ok('✓'), install ? `Hooks installed in ${SETTINGS}` : `Hooks removed from ${SETTINGS}`, c.dim('(backup: settings.json.bak-piu-piu)'));
+}
+
+const hooksInstalled = () => {
+  try {
+    return readFileSync(SETTINGS, 'utf8').includes(`# ${HOOK_MARKER}`);
+  } catch {
+    return false;
+  }
+};
+
+// ---------------------------------------------------------------- channel
+
+function channel(install) {
+  const claude = claudeBinary();
+  if (!claude) fail('Claude Code is not installed (claude not found). Install it first: https://docs.claude.com/claude-code');
+  for (const name of ['piu-piu', 'maze-office']) quiet(claude, ['mcp', 'remove', '-s', 'user', name]);
+  if (!install) return say(c.ok('✓'), 'Channel removed from Claude Code');
+  const r = quiet(claude, ['mcp', 'add', '-s', 'user', 'piu-piu', '--', process.execPath, CHANNEL]);
+  if (r.status !== 0) fail(`Could not register the channel: ${r.stderr || r.stdout}`);
+  say(c.ok('✓'), 'Channel registered with Claude Code. To talk to an open terminal session from the office, start it with:');
+  say(`    ${c.b('claude --dangerously-load-development-channels server:piu-piu')}`);
+}
+
+const channelInstalled = () => {
+  try {
+    return Boolean(JSON.parse(readFileSync(join(homedir(), '.claude.json'), 'utf8')).mcpServers?.['piu-piu']);
+  } catch {
+    return false;
+  }
+};
+
+// ---------------------------------------------------------------- service
+
+const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;');
+const servicePath = () => [dirname(process.execPath), join(homedir(), '.local', 'bin'), '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin', '/usr/sbin', '/sbin'].join(':');
+const passEnv = () => Object.entries(process.env).filter(([k]) => k.startsWith('PIU_PIU_'));
+
+function serviceInstall() {
+  if (!existsSync(DAEMON)) fail(`The daemon isn't built (${DAEMON} is missing).`);
+  mkdirSync(HOME, { recursive: true, mode: 0o700 });
+  if (MAC) {
+    const domain = `gui/${process.getuid()}`;
+    // the pre-rename service, if this Mac still has it
+    quiet('launchctl', ['bootout', `${domain}/${LEGACY_LABEL}`]);
+    rmSync(join(homedir(), 'Library', 'LaunchAgents', `${LEGACY_LABEL}.plist`), { force: true });
+    quiet('launchctl', ['bootout', `${domain}/${LABEL}`]);
+    const env = [['PATH', servicePath()], ['HOME', homedir()], ...passEnv()].map(([k, v]) => `    <key>${esc(k)}</key><string>${esc(v)}</string>`).join('\n');
+    mkdirSync(dirname(PLIST), { recursive: true });
+    mkdirSync(dirname(LOG), { recursive: true });
+    writeFileSync(
+      PLIST,
+      `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${esc(process.execPath)}</string>
+    <string>${esc(DAEMON)}</string>
+  </array>
+  <key>WorkingDirectory</key><string>${esc(HOME)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+${env}
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>ThrottleInterval</key><integer>10</integer>
+  <key>StandardOutPath</key><string>${esc(LOG)}</string>
+  <key>StandardErrorPath</key><string>${esc(LOG)}</string>
+</dict>
+</plist>
+`,
+    );
+    const r = quiet('launchctl', ['bootstrap', domain, PLIST]);
+    if (r.status !== 0) fail(`launchctl could not start the service: ${r.stderr}`);
+  } else {
+    if (quiet('systemctl', ['--user', '--version']).status !== 0) fail('No systemd user session here. Run the office in the foreground instead: piu-piu run');
+    mkdirSync(dirname(UNIT), { recursive: true });
+    const env = [['PATH', servicePath()], ...passEnv()].map(([k, v]) => `Environment="${k}=${v}"`).join('\n');
+    writeFileSync(
+      UNIT,
+      `[Unit]
+Description=piu-piu, a 3D office for your Claude Code agents
+After=network.target
+
+[Service]
+ExecStart=${process.execPath} ${DAEMON}
+WorkingDirectory=${HOME}
+${env}
+Restart=always
+RestartSec=5
+StandardOutput=append:${LOG}
+StandardError=append:${LOG}
+
+[Install]
+WantedBy=default.target
+`,
+    );
+    quiet('systemctl', ['--user', 'daemon-reload']);
+    const r = quiet('systemctl', ['--user', 'enable', '--now', 'piu-piu.service']);
+    if (r.status !== 0) fail(`systemctl could not start the service: ${r.stderr}`);
+  }
+  say(c.ok('✓'), `Service installed: piu-piu starts at login and restarts if it stops. Logs: ${LOG}`);
+}
+
+function serviceUninstall() {
+  if (MAC) {
+    quiet('launchctl', ['bootout', `gui/${process.getuid()}/${LABEL}`]);
+    rmSync(PLIST, { force: true });
+  } else {
+    quiet('systemctl', ['--user', 'disable', '--now', 'piu-piu.service']);
+    rmSync(UNIT, { force: true });
+    quiet('systemctl', ['--user', 'daemon-reload']);
+  }
+  say(c.ok('✓'), 'Service removed');
+}
+
+const serviceInstalled = () => existsSync(MAC ? PLIST : UNIT);
+
+function serviceRestart() {
+  if (MAC) quiet('launchctl', ['kickstart', '-k', `gui/${process.getuid()}/${LABEL}`]);
+  else quiet('systemctl', ['--user', 'restart', 'piu-piu.service']);
+}
+
+// ---------------------------------------------------------------- commands
+
+function open() {
+  const r = quiet(MAC ? 'open' : 'xdg-open', [URL]);
+  if (r.status !== 0) say(`Open ${c.b(URL)} in your browser.`);
+}
+
+async function start() {
+  if (await state()) return say(c.ok('✓'), `piu-piu is running at ${c.b(URL)}`);
+  if (!serviceInstalled()) serviceInstall();
+  else if (MAC) quiet('launchctl', ['bootstrap', `gui/${process.getuid()}`, PLIST]);
+  else quiet('systemctl', ['--user', 'start', 'piu-piu.service']);
+  if (!(await waitUp())) fail(`piu-piu didn't come up. Check the logs: piu-piu logs`);
+  say(c.ok('✓'), `piu-piu is running at ${c.b(URL)}`);
+}
+
+async function stop() {
+  await guardBusy('Stopping');
+  if (MAC) quiet('launchctl', ['bootout', `gui/${process.getuid()}/${LABEL}`]);
+  else quiet('systemctl', ['--user', 'stop', 'piu-piu.service']);
+  say(c.ok('✓'), 'piu-piu stopped. Start it again with: piu-piu start');
+}
+
+async function restart() {
+  await guardBusy('Restarting');
+  if (!serviceInstalled()) return start();
+  serviceRestart();
+  await new Promise((r) => setTimeout(r, 800));
+  if (!(await waitUp())) fail('piu-piu did not come back. Check the logs: piu-piu logs');
+  say(c.ok('✓'), `piu-piu restarted at ${c.b(URL)}`);
+}
+
+async function status() {
+  const s = await state();
+  if (!s) {
+    say(c.bad('●'), `piu-piu is not running ${c.dim(`(${URL})`)}. Start it with: piu-piu start`);
+    process.exitCode = 1;
+    return;
+  }
+  const sessions = s.sessions.filter((x) => !(x.background && x.source !== 'sdk'));
+  const count = (st) => sessions.filter((x) => x.status === st).length;
+  const runs = (s.subagents ?? []).filter((r) => r.status === 'working');
+  say(c.ok('●'), `piu-piu ${VERSION} is running at ${c.b(URL)}`);
+  say(`  sessions     ${sessions.length} open · ${count('working')} working · ${count('waiting')} waiting for you`);
+  say(`  specialists  ${runs.length} working${runs.length ? ` (${runs.map((r) => r.type).join(', ')})` : ''}`);
+  say(`  approvals    ${s.approvals.length} waiting in the inbox`);
+  say(`  terminals    ${s.terminals?.length ?? 0} open`);
+  say(`  data         ${HOME}`);
+}
+
+function logs() {
+  if (!existsSync(LOG)) fail(`No log yet at ${LOG}`);
+  const follow = process.argv.includes('-f') || process.argv.includes('--follow');
+  spawn('tail', [follow ? '-f' : '-n', ...(follow ? [] : ['80']), LOG], { stdio: 'inherit' });
+}
+
+async function run() {
+  if (await state()) fail(`Something is already running at ${URL} (the background service?). Stop it first: piu-piu stop`);
+  await import(DAEMON);
+}
+
+async function doctor() {
+  let ok = true;
+  const line = (good, label, hint) => {
+    if (!good) ok = false;
+    say(good ? c.ok('✓') : c.bad('✗'), label, good || !hint ? '' : c.dim(`→ ${hint}`));
+  };
+  const [major] = process.versions.node.split('.').map(Number);
+  line(major >= 24, `Node.js ${process.versions.node}`, 'piu-piu needs Node.js 24 or newer');
+  const claude = claudeBinary();
+  const version = claude ? quiet(claude, ['--version']).stdout.trim() : '';
+  line(Boolean(claude), claude ? `Claude Code ${version} (${claude})` : 'Claude Code', 'install Claude Code and log in');
+  line(existsSync(join(PKG, 'dist', 'office', 'index.html')) && existsSync(DAEMON), 'Office and daemon built', 'reinstall: npm i -g piu-piu-cli');
+  let pty = false;
+  try {
+    const require = createRequire(import.meta.url);
+    const prebuilds = join(dirname(require.resolve('node-pty/package.json')), 'prebuilds');
+    pty = !existsSync(prebuilds) || readdirSync(prebuilds).every((a) => !existsSync(join(prebuilds, a, 'spawn-helper')) || (accessSync(join(prebuilds, a, 'spawn-helper'), constants.X_OK), true));
+  } catch {
+    pty = false;
+  }
+  line(pty, 'Terminal support (node-pty)', MAC ? 'npm i -g piu-piu-cli' : 'install build-essential and python3, then: npm i -g piu-piu-cli --allow-scripts=node-pty');
+  line(hooksInstalled(), 'Hooks in ~/.claude/settings.json', 'piu-piu hooks install');
+  line(channelInstalled(), 'Channel registered with Claude Code', 'piu-piu channel install');
+  line(serviceInstalled(), 'Background service', 'piu-piu start');
+  const s = await state();
+  line(Boolean(s), `Office answering at ${URL}`, 'piu-piu start, then piu-piu logs if it fails');
+  if (!MAC) line(quiet('which', ['lsof']).status === 0, 'lsof (verifies hook and channel connections)', 'apt install lsof');
+  say(ok ? c.ok('\nAll good.') : c.warn('\nSome things need attention (see →).'));
+  if (!ok) process.exitCode = 1;
+}
+
+async function setup() {
+  say(c.b(`piu-piu ${VERSION} setup\n`));
+  if (!claudeBinary()) fail('Claude Code is not installed (claude not found). Install it first: https://docs.claude.com/claude-code');
+  hooks(true);
+  channel(true);
+  await restartOrStart();
+  open();
+  say(`\nThe office is at ${c.b(URL)}. Every Claude Code session on this machine shows up there.`);
+}
+
+// setup after an upgrade: restart so the new version runs (if nobody is busy)
+async function restartOrStart() {
+  const s = await state();
+  if (s && [...(s.running ?? []), ...(s.terminals ?? [])].length) {
+    return say(c.warn('!'), 'piu-piu is running but agents are busy, so it was not restarted. Run piu-piu restart later to switch to this version.');
+  }
+  if (!serviceInstalled() || !s) {
+    serviceInstall();
+    if (!(await waitUp())) fail('piu-piu did not come up. Check the logs: piu-piu logs');
+    return say(c.ok('✓'), `piu-piu is running at ${c.b(URL)}`);
+  }
+  serviceInstall(); // rewrites the service for this install and restarts it
+  if (!(await waitUp())) fail('piu-piu did not come up. Check the logs: piu-piu logs');
+  say(c.ok('✓'), `piu-piu is running at ${c.b(URL)}`);
+}
+
+async function uninstall() {
+  await guardBusy('Uninstalling');
+  serviceUninstall();
+  hooks(false);
+  channel(false);
+  say(`\nRemoved the service, hooks and channel. Your data stays in ${HOME} (delete it to start over).`);
+  say(`Remove the command itself with: ${c.b('npm rm -g piu-piu-cli')}`);
+}
+
+const HELP = `${c.b('piu-piu')} ${VERSION}: a 3D office for your Claude Code agents
+
+${c.b('Usage')}
+  piu-piu setup                 install hooks, channel and background service, then open the office
+  piu-piu open                  open the office in your browser (${URL})
+  piu-piu status                what's running right now
+  piu-piu start | stop | restart   the background service (stop/restart refuse while agents work; --force)
+  piu-piu run                   run in the foreground instead of the service
+  piu-piu logs [-f]             show (or follow) the service log
+  piu-piu hooks install|uninstall     Claude Code hooks for real-time status
+  piu-piu channel install|uninstall   talk to open terminal sessions from the office
+  piu-piu service install|uninstall   start at login
+  piu-piu doctor                check the setup
+  piu-piu uninstall             remove service, hooks and channel (keeps your data)
+
+${c.b('Environment')}
+  PIU_PIU_PORT (7777)  PIU_PIU_HOST (127.0.0.1)  PIU_PIU_HOME (~/.piu-piu)
+`;
+
+if (process.argv.slice(2).some((a) => a === '--version' || a === '-v')) {
+  say(VERSION);
+  process.exit(0);
+}
+
+const [cmd, sub] = process.argv.slice(2).filter((a) => !a.startsWith('-') || a === '-f');
+const subcommand = (name, on, off) => {
+  if (sub === 'install') return on();
+  if (sub === 'uninstall' || sub === 'remove') return off();
+  fail(`Usage: piu-piu ${name} install|uninstall`);
+};
+
+switch (cmd) {
+  case 'setup':
+    await setup();
+    break;
+  case 'open':
+    open();
+    break;
+  case 'status':
+    await status();
+    break;
+  case 'start':
+    await start();
+    break;
+  case 'stop':
+    await stop();
+    break;
+  case 'restart':
+    await restart();
+    break;
+  case 'run':
+    await run();
+    break;
+  case 'logs':
+    logs();
+    break;
+  case 'hooks':
+    subcommand('hooks', () => hooks(true), () => hooks(false));
+    break;
+  case 'channel':
+    subcommand('channel', () => channel(true), () => channel(false));
+    break;
+  case 'service':
+    subcommand('service', serviceInstall, serviceUninstall);
+    break;
+  case 'doctor':
+    await doctor();
+    break;
+  case 'uninstall':
+    await uninstall();
+    break;
+  case undefined:
+  case 'help':
+    say(HELP);
+    break;
+  default:
+    fail(`Unknown command "${cmd}". Run piu-piu help.`);
+}

package/dist/channel.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+// piu-piu channel: a Claude Code channel (MCP server over stdio) that links
+// one terminal session to the office. Messages you type in the office chat for
+// this session arrive here from the daemon and are pushed into the session;
+// Claude answers with the `reply` tool, which goes back to the office panel.
+// Permission prompts are relayed to the office too, so you can approve there.
+//
+// Claude Code starts this process for every session (it's a user-level MCP
+// server), but it only does anything when the session was started with
+//   claude --dangerously-load-development-channels server:piu-piu
+// Otherwise Claude Code would silently drop the events, so it stays quiet.
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+const DAEMON = process.env.PIU_PIU_URL ?? process.env.MAZE_OFFICE_URL ?? 'ws://127.0.0.1:7777/channel';
+// Written by the daemon (mode 600); proves this process runs as the same user.
+const TOKEN_PATH = join(process.env.PIU_PIU_HOME ?? join(homedir(), '.piu-piu'), 'channel-token');
+const token = () => {
+  try {
+    return readFileSync(TOKEN_PATH, 'utf8').trim();
+  } catch {
+    return '';
+  }
+};
+const claudePid = process.ppid;
+
+// Was this session started with our channel enabled? Read the parent's arguments.
+function channelEnabled() {
+  try {
+    const args = execFileSync('ps', ['-o', 'args=', '-p', String(claudePid)], { encoding: 'utf8' });
+    return /--(dangerously-load-development-)?channels\b[^]*\bserver:(piu-piu|maze-office)\b/.test(args);
+  } catch {
+    return false;
+  }
+}
+
+const enabled = channelEnabled();
+
+const mcp = new Server(
+  { name: 'piu-piu', version: '0.1.0' },
+  {
+    capabilities: {
+      experimental: enabled ? { 'claude/channel': {}, 'claude/channel/permission': {} } : {},
+      tools: {},
+    },
+    instructions: enabled
+      ? 'The user can also talk to you from the piu-piu office. Their messages arrive as <channel source="piu-piu" chat_id="...">. ' +
+        'Treat them exactly like messages typed in the terminal. Always answer them with the reply tool, passing the chat_id from the tag, ' +
+        'so the answer shows up in the dashboard; keep replies short and plain.'
+      : undefined,
+  },
+);
+
+// --- connection to the office daemon -----------------------------------------
+let ws;
+let retry = 0;
+const outbox = [];
+function sendToDaemon(msg) {
+  const data = JSON.stringify(msg);
+  if (ws?.readyState === WebSocket.OPEN) ws.send(data);
+  else outbox.push(data);
+}
+
+function connect() {
+  ws = new WebSocket(DAEMON);
+  ws.onopen = () => {
+    retry = 0;
+    ws.send(JSON.stringify({ type: 'hello', pid: claudePid, cwd: process.cwd(), token: token() }));
+    while (outbox.length) ws.send(outbox.shift());
+  };
+  ws.onmessage = async (event) => {
+    let msg;
+    try {
+      msg = JSON.parse(String(event.data));
+    } catch {
+      return;
+    }
+    if (msg.type === 'message' && typeof msg.text === 'string') {
+      await mcp.notification({
+        method: 'notifications/claude/channel',
+        params: { content: msg.text, meta: { chat_id: String(msg.chatId), sender: 'office' } },
+      });
+    } else if (msg.type === 'verdict' && /^[a-km-z]{5}$/.test(msg.requestId)) {
+      await mcp.notification({
+        method: 'notifications/claude/channel/permission',
+        params: { request_id: msg.requestId, behavior: msg.behavior === 'allow' ? 'allow' : 'deny' },
+      });
+    }
+  };
+  ws.onclose = () => setTimeout(connect, Math.min(30_000, 1000 * 2 ** retry++));
+  ws.onerror = () => {}; // onclose handles reconnection
+}
+
+// --- reply tool --------------------------------------------------------------
+mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: enabled
+    ? [
+        {
+          name: 'reply',
+          description: 'Answer a message that came from the piu-piu office. Pass the chat_id from the <channel> tag.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              chat_id: { type: 'string', description: 'chat_id from the incoming <channel> tag' },
+              text: { type: 'string', description: 'Your reply, in plain text or simple Markdown' },
+            },
+            required: ['chat_id', 'text'],
+          },
+        },
+      ]
+    : [],
+}));
+
+mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
+  if (req.params.name !== 'reply' || !enabled) throw new Error(`unknown tool: ${req.params.name}`);
+  const { chat_id, text } = req.params.arguments ?? {};
+  sendToDaemon({ type: 'reply', chatId: String(chat_id), text: String(text ?? '') });
+  return { content: [{ type: 'text', text: 'Delivered to the piu-piu office chat.' }] };
+});
+
+// --- permission relay ----------------------------------------------------------
+mcp.setNotificationHandler(
+  z.object({
+    method: z.literal('notifications/claude/channel/permission_request'),
+    params: z.object({ request_id: z.string(), tool_name: z.string(), description: z.string(), input_preview: z.string() }),
+  }),
+  async ({ params }) => {
+    sendToDaemon({
+      type: 'permission',
+      requestId: params.request_id,
+      tool: params.tool_name,
+      description: params.description,
+      preview: params.input_preview,
+    });
+  },
+);
+
+await mcp.connect(new StdioServerTransport());
+if (enabled) connect();