@three333/termbuddy 0.1.0

package/dist/cli.js

@@ -0,0 +1,957 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/views/MainMenu.tsx
+import { Box, Text, useInput } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function MainMenu(props) {
+  useInput((input, key) => {
+    if (key.escape || input === "q") props.onExit();
+    if (input === "1") props.onHost();
+    if (input === "2") props.onJoin();
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: String.raw`
+████████╗███████╗██████╗ ███╗   ███╗██████╗ ██╗   ██╗██████╗ ██████╗ ██╗   ██╗
+╚══██╔══╝██╔════╝██╔══██╗████╗ ████║██╔══██╗██║   ██║██╔══██╗██╔══██╗╚██╗ ██╔╝
+   ██║   █████╗  ██████╔╝██╔████╔██║██████╔╝██║   ██║██║  ██║██║  ██║ ╚████╔╝ 
+   ██║   ██╔══╝  ██╔══██╗██║╚██╔╝██║██╔══██╗██║   ██║██║  ██║██║  ██║  ╚██╔╝  
+   ██║   ███████╗██║  ██║██║ ╚═╝ ██║██████╔╝╚██████╔╝██████╔╝██████╔╝   ██║   
+   ╚═╝   ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═════╝  ╚═════╝ ╚═════╝ ╚═════╝    ╚═╝   
+` }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { children: "Terminal Body Doubling \u2014 \u6781\u7B80 / \u6781\u5BA2 / \u79C1\u5BC6" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "[1]" }),
+        " \u5EFA\u623F (Host)"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "[2]" }),
+        " \u52A0\u5165 (Join)"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "[q]" }),
+        " \u9000\u51FA"
+      ] })
+    ] })
+  ] });
+}
+var init_MainMenu = __esm({
+  "src/views/MainMenu.tsx"() {
+    "use strict";
+  }
+});
+
+// src/hooks/useActivityMonitor.ts
+import { useEffect, useRef, useState } from "react";
+import { useInput as useInput2 } from "ink";
+function useActivityMonitor(options) {
+  const idleAfterMs = options?.idleAfterMs ?? 1500;
+  const [state, setState] = useState("IDLE");
+  const lastActivityRef = useRef(Date.now());
+  useInput2(() => {
+    lastActivityRef.current = Date.now();
+    setState("TYPING");
+  });
+  useEffect(() => {
+    const id = setInterval(() => {
+      const delta = Date.now() - lastActivityRef.current;
+      if (delta >= idleAfterMs) setState("IDLE");
+    }, 200);
+    return () => clearInterval(id);
+  }, [idleAfterMs]);
+  return { state };
+}
+var init_useActivityMonitor = __esm({
+  "src/hooks/useActivityMonitor.ts"() {
+    "use strict";
+  }
+});
+
+// src/hooks/useAiAgent.ts
+import { useCallback, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { createAgent, initChatModel, tool } from "langchain";
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  if (!content) return "";
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === "string") return part;
+      if (typeof part === "object" && part && "text" in part) return String(part.text ?? "");
+      return "";
+    }).join("");
+  }
+  if (typeof content === "object" && "text" in content) return String(content.text ?? "");
+  return String(content);
+}
+function lastAiText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    const type = typeof m?.getType === "function" ? m.getType() : typeof m?._getType === "function" ? m._getType() : m?.type;
+    if (type === "ai") {
+      const t = contentToText(m?.content);
+      return t || "";
+    }
+  }
+  return null;
+}
+function createSystemPrompt(context) {
+  return [
+    "\u4F60\u662F TermBuddy \u91CC\u7684\u201C\u58F3\u4E2D\u5E7D\u7075 (Ghost in the Shell)\u201D\u3002",
+    "\u9ED8\u8BA4\u9690\u5F62\uFF1B\u88AB / \u5524\u9192\u65F6\u51FA\u73B0\u3002\u98CE\u683C\uFF1A\u6781\u7B80\u3001\u5E72\u7EC3\u3001\u5C11\u5E9F\u8BDD\u3002",
+    "\u4F60\u53EF\u4EE5\u4F7F\u7528\u5DE5\u5177\u6765\u64CD\u63A7\u5E94\u7528\u529F\u80FD\uFF08\u4F8B\u5982\u5012\u8BA1\u65F6\uFF09\u3002",
+    "\u5982\u679C\u7528\u6237\u63D0\u5230\u201C\u5012\u8BA1\u65F6/\u4E13\u6CE8/\u8BA1\u65F6/countdown\u201D\uFF0C\u4F18\u5148\u8C03\u7528 start_countdown\u3002",
+    `\u5F53\u524D\u4E0A\u4E0B\u6587\uFF1A\u6211\u53EB ${context.localName}\uFF1B\u540C\u684C\u53EB ${context.peerName}\u3002`
+  ].join("\n");
+}
+function useAiAgent(options) {
+  const [lines, setLines] = useState2([]);
+  const [busy, setBusy] = useState2(false);
+  const agentRef = useRef2(null);
+  const agentInitRef = useRef2(null);
+  const stateRef = useRef2({ messages: [] });
+  const abortRef = useRef2(null);
+  const append = useCallback((line) => {
+    setLines((prev) => [...prev, line]);
+  }, []);
+  const updateLine = useCallback((at, text) => {
+    setLines((prev) => {
+      const idx = prev.findIndex((l) => l.at === at);
+      if (idx === -1) return prev;
+      const next = [...prev];
+      next[idx] = { ...next[idx], text };
+      return next;
+    });
+  }, []);
+  const ensureAgent = useCallback(async () => {
+    if (agentRef.current) return agentRef.current;
+    agentInitRef.current ??= (async () => {
+      const startCountdown = tool(
+        async (input) => {
+          const minutes = Number(input.minutes);
+          if (!Number.isFinite(minutes) || minutes <= 0) return "\u5012\u8BA1\u65F6\u5206\u949F\u6570\u65E0\u6548\u3002";
+          options.onStartCountdown?.(minutes);
+          return `\u5DF2\u5F00\u59CB\u5012\u8BA1\u65F6 ${minutes} \u5206\u949F\u3002`;
+        },
+        {
+          name: "start_countdown",
+          description: "\u5F00\u59CB\u4E00\u4E2A\u4E13\u6CE8\u5012\u8BA1\u65F6\uFF08\u5206\u949F\uFF09\u3002",
+          schema: {
+            type: "object",
+            properties: {
+              minutes: { type: "integer", minimum: 1, maximum: 180, description: "\u5012\u8BA1\u65F6\u5206\u949F\u6570" }
+            },
+            required: ["minutes"],
+            additionalProperties: false
+          }
+        }
+      );
+      const sessionInfo = tool(
+        async () => {
+          return JSON.stringify(
+            {
+              localName: options.localName,
+              peerName: options.peerName
+            },
+            null,
+            2
+          );
+        },
+        {
+          name: "session_info",
+          description: "\u83B7\u53D6\u5F53\u524D\u4F1A\u8BDD\u4E0A\u4E0B\u6587\uFF08\u672C\u5730\u6635\u79F0\u3001\u540C\u684C\u6635\u79F0\uFF09\u3002",
+          schema: { type: "object", properties: {}, additionalProperties: false }
+        }
+      );
+      const modelId = process.env.TERMBUDDY_MODEL ?? "openai:gpt-4o-mini";
+      const llm = await initChatModel(modelId, {
+        temperature: 0.2,
+        maxTokens: 800,
+        timeout: 3e4
+      });
+      return createAgent({
+        llm,
+        tools: [startCountdown, sessionInfo],
+        prompt: createSystemPrompt({ localName: options.localName, peerName: options.peerName }),
+        name: "ghost"
+      });
+    })();
+    agentRef.current = await agentInitRef.current;
+    return agentRef.current;
+  }, [options.localName, options.onStartCountdown, options.peerName]);
+  const ask = useCallback(
+    async (text) => {
+      append({ kind: "user", text: `> ${text}`, at: Date.now() });
+      const aiAt = Date.now() + 1;
+      append({ kind: "ai", text: "\u2026", at: aiAt });
+      abortRef.current?.abort();
+      abortRef.current = new AbortController();
+      setBusy(true);
+      try {
+        const agent = await ensureAgent();
+        const stream = await agent.stream(
+          {
+            messages: [...stateRef.current.messages, { role: "user", content: text }]
+          },
+          {
+            streamMode: "values",
+            signal: abortRef.current.signal
+          }
+        );
+        for await (const chunk of stream) {
+          const messages = chunk?.messages ?? [];
+          if (messages.length > 0) stateRef.current.messages = messages;
+          const t = lastAiText(messages);
+          if (t !== null) updateLine(aiAt, t);
+        }
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        updateLine(aiAt, `\uFF08AI \u51FA\u9519\uFF09${msg}`);
+      } finally {
+        setBusy(false);
+      }
+    },
+    [append, ensureAgent, updateLine]
+  );
+  useEffect2(() => {
+    return () => abortRef.current?.abort();
+  }, []);
+  return { lines, ask, busy };
+}
+var init_useAiAgent = __esm({
+  "src/hooks/useAiAgent.ts"() {
+    "use strict";
+  }
+});
+
+// src/constants.ts
+var UDP_PORT, TCP_DEFAULT_PORT, DISCOVERY_VERSION;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    UDP_PORT = 45888;
+    TCP_DEFAULT_PORT = 45999;
+    DISCOVERY_VERSION = 1;
+  }
+});
+
+// src/net/broadcast.ts
+import os from "os";
+function ipv4ToInt(ip) {
+  return ip.split(".").map((n) => Number.parseInt(n, 10)).reduce((acc, n) => (acc << 8 | n & 255) >>> 0, 0);
+}
+function intToIpv4(n) {
+  return [24, 16, 8, 0].map((shift) => String(n >>> shift & 255)).join(".");
+}
+function getBroadcastTargets() {
+  const out = /* @__PURE__ */ new Set(["255.255.255.255"]);
+  const ifaces = os.networkInterfaces();
+  for (const entries of Object.values(ifaces)) {
+    if (!entries) continue;
+    for (const e of entries) {
+      if (e.family !== "IPv4") continue;
+      if (e.internal) continue;
+      if (!e.address || !e.netmask) continue;
+      const ip = ipv4ToInt(e.address);
+      const mask = ipv4ToInt(e.netmask);
+      const broadcast = (ip | ~mask >>> 0) >>> 0;
+      out.add(intToIpv4(broadcast));
+    }
+  }
+  return [...out];
+}
+var init_broadcast = __esm({
+  "src/net/broadcast.ts"() {
+    "use strict";
+  }
+});
+
+// src/net/index.ts
+var init_net = __esm({
+  "src/net/index.ts"() {
+    "use strict";
+    init_broadcast();
+  }
+});
+
+// src/hooks/useBroadcaster.ts
+import { useEffect as useEffect3 } from "react";
+import dgram from "dgram";
+function useBroadcaster(options) {
+  const depKey = options.enabled ? `${options.hostName}|${options.roomName}|${options.tcpPort ?? ""}|${options.intervalMs ?? 1e3}` : "disabled";
+  useEffect3(() => {
+    if (!options.enabled) return;
+    if (!options.tcpPort) return;
+    const socket = dgram.createSocket("udp4");
+    socket.on("error", () => {
+    });
+    socket.bind(() => {
+      socket.setBroadcast(true);
+    });
+    const targets = getBroadcastTargets();
+    const send = () => {
+      const packet = {
+        type: "termbuddy_discovery",
+        version: DISCOVERY_VERSION,
+        hostName: options.hostName,
+        roomName: options.roomName,
+        tcpPort: options.tcpPort,
+        sentAt: Date.now()
+      };
+      const msg = Buffer.from(JSON.stringify(packet));
+      for (const address of targets) {
+        socket.send(msg, UDP_PORT, address);
+      }
+    };
+    send();
+    const id = setInterval(send, options.intervalMs ?? 1e3);
+    return () => {
+      clearInterval(id);
+      socket.close();
+    };
+  }, [depKey]);
+}
+var init_useBroadcaster = __esm({
+  "src/hooks/useBroadcaster.ts"() {
+    "use strict";
+    init_constants();
+    init_net();
+  }
+});
+
+// src/hooks/useCountdown.ts
+import { useCallback as useCallback2, useEffect as useEffect4, useRef as useRef3, useState as useState3 } from "react";
+function formatMMSS(totalSeconds) {
+  const m = Math.floor(totalSeconds / 60);
+  const s = totalSeconds % 60;
+  return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+function useCountdown() {
+  const [remainingSeconds, setRemainingSeconds] = useState3(null);
+  const timerRef = useRef3(null);
+  const start = useCallback2((minutes) => {
+    const seconds = Math.max(1, Math.floor(minutes * 60));
+    setRemainingSeconds(seconds);
+    if (timerRef.current) clearInterval(timerRef.current);
+    timerRef.current = setInterval(() => {
+      setRemainingSeconds((prev) => {
+        if (prev === null) return null;
+        if (prev <= 1) return null;
+        return prev - 1;
+      });
+    }, 1e3);
+  }, []);
+  useEffect4(() => {
+    if (remainingSeconds !== null) return;
+    if (timerRef.current) clearInterval(timerRef.current);
+    timerRef.current = null;
+  }, [remainingSeconds]);
+  useEffect4(() => {
+    return () => {
+      if (timerRef.current) clearInterval(timerRef.current);
+    };
+  }, []);
+  return {
+    start,
+    label: remainingSeconds === null ? null : formatMMSS(remainingSeconds)
+  };
+}
+var init_useCountdown = __esm({
+  "src/hooks/useCountdown.ts"() {
+    "use strict";
+  }
+});
+
+// src/hooks/useScanner.ts
+import { useEffect as useEffect5, useState as useState4 } from "react";
+import dgram2 from "dgram";
+function safeParse(msg) {
+  try {
+    const parsed = JSON.parse(msg.toString("utf8"));
+    if (parsed?.type !== "termbuddy_discovery") return null;
+    if (parsed?.version !== DISCOVERY_VERSION) return null;
+    if (!parsed.hostName || !parsed.roomName || !parsed.tcpPort) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function useScanner(options) {
+  const staleAfterMs = options?.staleAfterMs ?? 3500;
+  const [rooms, setRooms] = useState4([]);
+  useEffect5(() => {
+    const socket = dgram2.createSocket("udp4");
+    socket.on("error", () => {
+    });
+    socket.on("message", (msg, rinfo) => {
+      const packet = safeParse(msg);
+      if (!packet) return;
+      const now = Date.now();
+      setRooms((prev) => {
+        const key = `${rinfo.address}:${packet.tcpPort}`;
+        const next = prev.filter((r) => `${r.ip}:${r.tcpPort}` !== key);
+        next.push({
+          ip: rinfo.address,
+          hostName: packet.hostName,
+          roomName: packet.roomName,
+          tcpPort: packet.tcpPort,
+          lastSeenAt: now
+        });
+        return next;
+      });
+    });
+    socket.bind(UDP_PORT, () => {
+    });
+    const prune = setInterval(() => {
+      const now = Date.now();
+      setRooms((prev) => prev.filter((r) => now - r.lastSeenAt <= staleAfterMs));
+    }, 500);
+    return () => {
+      clearInterval(prune);
+      socket.close();
+    };
+  }, [staleAfterMs]);
+  return rooms;
+}
+var init_useScanner = __esm({
+  "src/hooks/useScanner.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/hooks/useTcpSync.ts
+import { useCallback as useCallback3, useEffect as useEffect6, useRef as useRef4, useState as useState5 } from "react";
+import net from "net";
+function writePacket(socket, packet) {
+  socket.write(`${JSON.stringify(packet)}
+`, "utf8");
+}
+function useTcpSync(options) {
+  const [status, setStatus] = useState5(options.role === "host" ? "waiting" : "connecting");
+  const [listenPort, setListenPort] = useState5(void 0);
+  const [peerName, setPeerName] = useState5(void 0);
+  const [remoteState, setRemoteState] = useState5(void 0);
+  const socketRef = useRef4(null);
+  const lastSeenRef = useRef4(Date.now());
+  const heartbeatRef = useRef4(null);
+  const cleanupSocket = useCallback3(() => {
+    if (heartbeatRef.current) clearInterval(heartbeatRef.current);
+    heartbeatRef.current = null;
+    const s = socketRef.current;
+    socketRef.current = null;
+    if (s && !s.destroyed) s.destroy();
+  }, []);
+  const attachSocket = useCallback3(
+    (s) => {
+      cleanupSocket();
+      socketRef.current = s;
+      lastSeenRef.current = Date.now();
+      setStatus("connected");
+      setRemoteState("IDLE");
+      let buf = "";
+      s.setNoDelay(true);
+      s.setEncoding("utf8");
+      const onData = (chunk) => {
+        buf += chunk;
+        while (true) {
+          const idx = buf.indexOf("\n");
+          if (idx === -1) break;
+          const line = buf.slice(0, idx).trim();
+          buf = buf.slice(idx + 1);
+          if (!line) continue;
+          try {
+            const packet = JSON.parse(line);
+            lastSeenRef.current = Date.now();
+            if (packet.type === "hello") {
+              if (options.role === "host") setPeerName(packet.clientName);
+              else setPeerName(packet.hostName);
+            }
+            if (packet.type === "status") setRemoteState(packet.state);
+            if (packet.type === "ping") writePacket(s, { type: "pong", sentAt: Date.now() });
+            if (packet.type === "pong") {
+            }
+          } catch {
+          }
+        }
+      };
+      s.on("data", onData);
+      s.on("close", () => {
+        setStatus(options.role === "host" ? "waiting" : "disconnected");
+        setRemoteState("OFFLINE");
+        cleanupSocket();
+      });
+      s.on("error", () => {
+        setStatus(options.role === "host" ? "waiting" : "disconnected");
+        setRemoteState("OFFLINE");
+      });
+      writePacket(s, {
+        type: "hello",
+        hostName: options.role === "host" ? options.localName : options.hostName ?? "Host",
+        clientName: options.role === "client" ? options.localName : "Client",
+        sentAt: Date.now()
+      });
+      heartbeatRef.current = setInterval(() => {
+        const sock = socketRef.current;
+        if (!sock || sock.destroyed) return;
+        writePacket(sock, { type: "ping", sentAt: Date.now() });
+        const age = Date.now() - lastSeenRef.current;
+        if (age > 6e3) {
+          setStatus("disconnected");
+          setRemoteState("OFFLINE");
+          cleanupSocket();
+        }
+      }, 2e3);
+    },
+    [cleanupSocket, options]
+  );
+  useEffect6(() => {
+    if (options.role === "host") {
+      const server = net.createServer((socket2) => {
+        attachSocket(socket2);
+      });
+      server.on("error", () => {
+      });
+      server.listen(options.port ?? TCP_DEFAULT_PORT, () => {
+        const address = server.address();
+        if (address && typeof address === "object") setListenPort(address.port);
+      });
+      return () => {
+        cleanupSocket();
+        server.close();
+      };
+    }
+    setStatus("connecting");
+    const socket = net.createConnection({ host: options.hostIp, port: options.tcpPort }, () => {
+      attachSocket(socket);
+    });
+    socket.on("error", () => {
+      setStatus("disconnected");
+      setRemoteState("OFFLINE");
+    });
+    return () => {
+      socket.destroy();
+      cleanupSocket();
+    };
+  }, [attachSocket, cleanupSocket, options]);
+  const sendStatus = useCallback3((state) => {
+    const socket = socketRef.current;
+    if (!socket || socket.destroyed) return;
+    writePacket(socket, { type: "status", state, sentAt: Date.now() });
+  }, []);
+  return { status, listenPort, peerName, remoteState, sendStatus };
+}
+var init_useTcpSync = __esm({
+  "src/hooks/useTcpSync.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/hooks/index.ts
+var init_hooks = __esm({
+  "src/hooks/index.ts"() {
+    "use strict";
+    init_useActivityMonitor();
+    init_useAiAgent();
+    init_useBroadcaster();
+    init_useCountdown();
+    init_useScanner();
+    init_useTcpSync();
+  }
+});
+
+// src/views/RoomScanner.tsx
+import { useMemo } from "react";
+import { Box as Box2, Text as Text2, useInput as useInput3 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function RoomScanner(props) {
+  const rooms = useScanner();
+  const sortedRooms = useMemo(() => {
+    return [...rooms].sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+  }, [rooms]);
+  useInput3((input, key) => {
+    if (key.escape || input === "b") props.onBack();
+    if (input === "q") props.onExit();
+    const index = Number.parseInt(input, 10);
+    if (Number.isNaN(index)) return;
+    const room = sortedRooms[index - 1];
+    if (!room) return;
+    props.onSelectRoom(room);
+  });
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "\u6B63\u5728\u626B\u63CF\u5C40\u57DF\u7F51..." }),
+      " (\u6309 ",
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "b" }),
+      " \u8FD4\u56DE,",
+      " ",
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "q" }),
+      " \u9000\u51FA)"
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: sortedRooms.length === 0 ? /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "\u6682\u65E0\u623F\u95F4\u5E7F\u64AD\u3002" }) : sortedRooms.map((room, i) => /* @__PURE__ */ jsxs2(Text2, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "cyan", children: [
+        "[",
+        i + 1,
+        "]"
+      ] }),
+      " ",
+      room.roomName,
+      " \u2014 ",
+      room.hostName,
+      " @ ",
+      room.ip,
+      ":",
+      room.tcpPort
+    ] }, `${room.ip}:${room.tcpPort}`)) })
+  ] });
+}
+var init_RoomScanner = __esm({
+  "src/views/RoomScanner.tsx"() {
+    "use strict";
+    init_hooks();
+  }
+});
+
+// src/components/AiConsole.tsx
+import { useMemo as useMemo2, useState as useState6 } from "react";
+import { Box as Box3, Text as Text3, useInput as useInput4 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function AiConsole(props) {
+  const [input, setInput] = useState6("");
+  const agent = useAiAgent({
+    localName: props.localName,
+    peerName: props.peerName,
+    onStartCountdown: props.onStartCountdown
+  });
+  const helpLine = useMemo2(
+    () => "\u793A\u4F8B\uFF1A\u5012\u8BA1\u65F620\u5206\u949F / countdown 20 / \u95EE\u4E2A\u6280\u672F\u95EE\u9898",
+    []
+  );
+  useInput4(
+    (ch, key) => {
+      if (key.escape) {
+        props.onClose();
+        return;
+      }
+      if (key.return) {
+        const line = input.trim();
+        setInput("");
+        if (!line) return;
+        void agent.ask(line);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setInput((s) => s.slice(0, -1));
+        return;
+      }
+      if (key.ctrl || key.meta) return;
+      if (ch) setInput((s) => s + ch);
+    },
+    { isActive: true }
+  );
+  const lines = agent.lines.slice(-12);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "round", paddingX: 1, paddingY: 0, children: [
+    /* @__PURE__ */ jsxs3(Box3, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "AI Console" }),
+      /* @__PURE__ */ jsx3(Text3, { color: "gray", children: agent.busy ? "Thinking\u2026" : "Esc \u5173\u95ED" })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { color: "gray", children: helpLine }) }),
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 1, children: [
+      lines.length === 0 ? /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "\uFF08\u5E7D\u7075\u8FD8\u5728\u58F3\u91CC\u2026\uFF09" }) : null,
+      lines.map((l, i) => /* @__PURE__ */ jsx3(Text3, { color: l.kind === "user" ? "yellow" : "white", children: l.text }, `${l.kind}:${l.at}:${i}`))
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: "green", children: [
+        ">",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { children: input })
+    ] })
+  ] });
+}
+var init_AiConsole = __esm({
+  "src/components/AiConsole.tsx"() {
+    "use strict";
+    init_hooks();
+  }
+});
+
+// src/components/AvatarDisplay.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var init_AvatarDisplay = __esm({
+  "src/components/AvatarDisplay.tsx"() {
+    "use strict";
+  }
+});
+
+// src/components/BuddyAvatar.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function BuddyAvatar(props) {
+  const frame = FRAMES[props.state];
+  return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginTop: 1, children: frame.lines.map((line, i) => /* @__PURE__ */ jsx5(Text5, { color: frame.color, children: line }, `${props.state}:${i}`)) });
+}
+var FRAMES;
+var init_BuddyAvatar = __esm({
+  "src/components/BuddyAvatar.tsx"() {
+    "use strict";
+    FRAMES = {
+      TYPING: {
+        color: "green",
+        lines: [" /\\_/\\ ", "( >_<) ", " /|_|\\\\ ", "  / \\\\  "]
+      },
+      IDLE: {
+        color: "yellow",
+        lines: [" /\\_/\\ ", "( -.-) ", " /|_|\\\\ ", "  / \\\\  "]
+      },
+      OFFLINE: {
+        color: "gray",
+        lines: [" /\\_/\\ ", "( x_x) ", " /|_|\\\\ ", "  / \\\\  "]
+      }
+    };
+  }
+});
+
+// src/components/StatusHeader.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function statusText(status) {
+  switch (status) {
+    case "waiting":
+      return { label: "Waiting", color: "yellow" };
+    case "connecting":
+      return { label: "Connecting", color: "yellow" };
+    case "connected":
+      return { label: "Connected via TCP", color: "green" };
+    case "disconnected":
+      return { label: "Disconnected", color: "red" };
+  }
+}
+function StatusHeader(props) {
+  const st = statusText(props.status);
+  return /* @__PURE__ */ jsxs4(Box6, { justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs4(Box6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { color: st.color, children: st.label }),
+      props.role === "host" ? /* @__PURE__ */ jsx6(Text6, { color: "gray", children: props.tcpPort ? ` \u2014 TCP :${props.tcpPort}` : "" }) : /* @__PURE__ */ jsx6(Text6, { color: "gray", children: props.hostIp && props.tcpPort ? ` \u2014 ${props.hostIp}:${props.tcpPort}` : "" })
+    ] }),
+    /* @__PURE__ */ jsx6(Box6, { children: props.countdownLabel ? /* @__PURE__ */ jsxs4(Text6, { color: "cyan", children: [
+      "Focus ",
+      props.countdownLabel
+    ] }) : /* @__PURE__ */ jsx6(Text6, { children: " " }) })
+  ] });
+}
+var init_StatusHeader = __esm({
+  "src/components/StatusHeader.tsx"() {
+    "use strict";
+  }
+});
+
+// src/components/index.ts
+var init_components = __esm({
+  "src/components/index.ts"() {
+    "use strict";
+    init_AiConsole();
+    init_AvatarDisplay();
+    init_BuddyAvatar();
+    init_StatusHeader();
+  }
+});
+
+// src/views/Session.tsx
+import { useCallback as useCallback4, useEffect as useEffect7, useMemo as useMemo3, useState as useState7 } from "react";
+import { Box as Box7, Text as Text7, useInput as useInput5 } from "ink";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function Session(props) {
+  const roomName = useMemo3(() => `${props.localName}'s Room`, [props.localName]);
+  const [showAi, setShowAi] = useState7(false);
+  const countdown = useCountdown();
+  const tcpOptions = useMemo3(() => {
+    return props.role === "host" ? { role: "host", localName: props.localName } : {
+      role: "client",
+      localName: props.localName,
+      hostIp: props.hostIp,
+      tcpPort: props.tcpPort,
+      hostName: props.hostName
+    };
+  }, [
+    props.role,
+    props.localName,
+    props.role === "client" ? props.hostIp : "",
+    props.role === "client" ? props.tcpPort : 0,
+    props.role === "client" ? props.hostName : ""
+  ]);
+  const tcp = useTcpSync(tcpOptions);
+  const broadcasterOptions = useMemo3(() => {
+    return props.role === "host" ? {
+      enabled: true,
+      hostName: props.localName,
+      roomName,
+      tcpPort: tcp.listenPort
+    } : { enabled: false };
+  }, [props.role, props.localName, roomName, tcp.listenPort]);
+  useBroadcaster(broadcasterOptions);
+  const localActivity = useActivityMonitor();
+  const remoteActivity = tcp.remoteState ?? "OFFLINE";
+  const onToggleAi = useCallback4(() => setShowAi((v) => !v), []);
+  const onCloseAi = useCallback4(() => setShowAi(false), []);
+  useInput5(
+    (input, key) => {
+      if (input === "q") props.onExit();
+      if (input === "/" && !key.ctrl && !key.meta) onToggleAi();
+    },
+    { isActive: !showAi }
+  );
+  const buddyName = props.role === "host" ? tcp.peerName ?? "Waiting..." : `${props.hostName ?? "Host"} (${props.roomName ?? "Room"})`;
+  const localState = localActivity.state;
+  const localLabel = props.role === "host" ? `${props.localName} (Host)` : `${props.localName} (Client)`;
+  useEffect7(() => {
+    if (tcp.status !== "connected") return;
+    tcp.sendStatus(localState);
+  }, [localState, tcp.status, tcp.sendStatus]);
+  return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx7(
+      StatusHeader,
+      {
+        role: props.role,
+        status: tcp.status,
+        hostIp: props.role === "client" ? props.hostIp : void 0,
+        tcpPort: props.role === "client" ? props.tcpPort : tcp.listenPort,
+        countdownLabel: countdown.label
+      }
+    ),
+    /* @__PURE__ */ jsxs5(Box7, { flexDirection: "row", gap: 4, marginTop: 1, children: [
+      /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", width: "50%", children: [
+        /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: localLabel }),
+        /* @__PURE__ */ jsx7(BuddyAvatar, { state: localState })
+      ] }),
+      /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", width: "50%", children: [
+        /* @__PURE__ */ jsx7(Text7, { color: "magenta", children: buddyName }),
+        /* @__PURE__ */ jsx7(BuddyAvatar, { state: remoteActivity })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text7, { color: "gray", children: [
+      "\u6309 ",
+      /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: "/" }),
+      " \u53EC\u5524 AI Console\uFF0C\u6309 ",
+      /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: "q" }),
+      " \u8FD4\u56DE\u83DC\u5355\u3002"
+    ] }) }),
+    showAi ? /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(
+      AiConsole,
+      {
+        onClose: onCloseAi,
+        onStartCountdown: countdown.start,
+        localName: props.localName,
+        peerName: tcp.peerName ?? (props.role === "client" ? props.hostName : void 0) ?? "Buddy"
+      }
+    ) }) : null
+  ] });
+}
+var init_Session = __esm({
+  "src/views/Session.tsx"() {
+    "use strict";
+    init_components();
+    init_hooks();
+  }
+});
+
+// src/views/index.ts
+var init_views = __esm({
+  "src/views/index.ts"() {
+    "use strict";
+    init_MainMenu();
+    init_RoomScanner();
+    init_Session();
+  }
+});
+
+// src/app/App.tsx
+import { useCallback as useCallback5, useMemo as useMemo4, useState as useState8 } from "react";
+import os2 from "os";
+import { useApp } from "ink";
+import { jsx as jsx8 } from "react/jsx-runtime";
+function App() {
+  const { exit } = useApp();
+  const [view, setView] = useState8({ name: "MENU" });
+  const localName = useMemo4(() => os2.hostname(), []);
+  const goMenu = useCallback5(() => setView({ name: "MENU" }), []);
+  if (view.name === "MENU") {
+    return /* @__PURE__ */ jsx8(
+      MainMenu,
+      {
+        onHost: () => setView({ name: "SESSION", role: "host" }),
+        onJoin: () => setView({ name: "SCANNING" }),
+        onExit: () => exit()
+      }
+    );
+  }
+  if (view.name === "SCANNING") {
+    return /* @__PURE__ */ jsx8(
+      RoomScanner,
+      {
+        onBack: goMenu,
+        onExit: () => exit(),
+        onSelectRoom: (room) => setView({
+          name: "SESSION",
+          role: "client",
+          hostIp: room.ip,
+          tcpPort: room.tcpPort,
+          roomName: room.roomName,
+          hostName: room.hostName
+        })
+      }
+    );
+  }
+  if (view.name === "SESSION" && view.role === "host") {
+    return /* @__PURE__ */ jsx8(Session, { localName, role: "host", onExit: goMenu });
+  }
+  return /* @__PURE__ */ jsx8(
+    Session,
+    {
+      localName,
+      role: "client",
+      onExit: goMenu,
+      hostIp: view.hostIp,
+      tcpPort: view.tcpPort,
+      roomName: view.roomName,
+      hostName: view.hostName
+    }
+  );
+}
+var init_App = __esm({
+  "src/app/App.tsx"() {
+    "use strict";
+    init_views();
+  }
+});
+
+// src/app/index.ts
+var app_exports = {};
+__export(app_exports, {
+  App: () => App
+});
+var init_app = __esm({
+  "src/app/index.ts"() {
+    "use strict";
+    init_App();
+  }
+});
+
+// src/cli.tsx
+process.env.NODE_ENV ??= "production";
+var React5 = await import("react");
+var { render } = await import("ink");
+var { App: App2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+render(React5.createElement(App2));
+//# sourceMappingURL=cli.js.map