@three333/termbuddy 0.1.0 → 0.1.1

package/src/components/tool/createInteractionTool.ts

@@ -0,0 +1,67 @@
+import { tool } from "langchain";
+import type {
+  ProjectileDirection,
+  ProjectileKind,
+} from "../sprite/ProjectileThrowSprite.js";
+
+const KIND_ALIASES: Array<{ kind: ProjectileKind; keys: string[] }> = [
+  { kind: "ROSE", keys: ["rose", "花", "玫瑰", "🌹", "love"] },
+  { kind: "POOP", keys: ["poop", "屎", "💩", "大便"] },
+  { kind: "HAMMER", keys: ["hammer", "锤", "🔨", "敲", "打"] },
+];
+
+function normalizeKind(raw: unknown): ProjectileKind | null {
+  if (typeof raw !== "string") return null;
+  const upper = raw.toUpperCase().trim();
+  if (upper === "ROSE" || upper === "POOP" || upper === "HAMMER") return upper;
+
+  const lower = raw.toLowerCase();
+  for (const item of KIND_ALIASES) {
+    if (item.keys.some((k) => lower.includes(k))) return item.kind;
+  }
+  return null;
+}
+
+function normalizeDirection(raw: unknown): ProjectileDirection | null {
+  if (typeof raw !== "string") return null;
+  const upper = raw.toUpperCase().trim();
+  if (upper === "LEFT_TO_RIGHT" || upper === "RIGHT_TO_LEFT") return upper;
+  return null;
+}
+
+export function createInteractionTool(options: {
+  onThrow?: (kind: ProjectileKind, direction: ProjectileDirection) => void;
+}) {
+  return tool(
+    async (input: { kind?: string; direction?: string; message?: string }) => {
+      const kind = normalizeKind(input.kind ?? "") ?? "ROSE";
+      const direction = normalizeDirection(input.direction) ?? "LEFT_TO_RIGHT";
+      options.onThrow?.(kind, direction);
+      const msg = (input.message ?? "").trim();
+      return msg ? `已投掷 ${kind}：${msg}` : `已投掷 ${kind}。`;
+    },
+    {
+      name: "throw_projectile",
+      description: "和同桌互动：投掷一个小物品（🌹/💩/🔨）。",
+      schema: {
+        type: "object",
+        properties: {
+          kind: {
+            type: "string",
+            description:
+              "投掷物类型（ROSE/POOP/HAMMER，或任意描述如“玫瑰/锤子/💩”）",
+          },
+          direction: {
+            type: "string",
+            enum: ["LEFT_TO_RIGHT", "RIGHT_TO_LEFT"],
+            description: "飞行方向",
+          },
+          message: { type: "string", description: "附带一句话（可选）" },
+        },
+        required: [],
+        additionalProperties: false,
+      },
+    }
+  );
+}
+

package/src/components/tool/createSessionInfoTool.ts

@@ -0,0 +1,29 @@
+import { tool } from "langchain";
+
+export function createSessionInfoTool(options: {
+  localName: string;
+  peerName: string;
+}) {
+  return tool(
+    async () => {
+      return JSON.stringify(
+        {
+          localName: options.localName,
+          peerName: options.peerName,
+        },
+        null,
+        2
+      );
+    },
+    {
+      name: "session_info",
+      description: "获取当前会话上下文（本地昵称、同桌昵称）。",
+      schema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false,
+      },
+    }
+  );
+}
+

package/src/components/tool/index.ts

@@ -0,0 +1,4 @@
+export { createCountdownTool } from "./createCountdownTool.js";
+export { createInteractionTool } from "./createInteractionTool.js";
+export { createSessionInfoTool } from "./createSessionInfoTool.js";
+

package/src/hooks/globalKeyboard.ts

@@ -0,0 +1,146 @@
+import { spawn } from "node:child_process";
+
+export type GlobalKeyboardBackend = "uiohook" | "xinput";
+
+type Listener = () => void;
+
+let backend: GlobalKeyboardBackend | null = null;
+let started = false;
+let starting: Promise<GlobalKeyboardBackend | null> | null = null;
+let stopBackend: (() => void) | null = null;
+
+const listeners = new Set<Listener>();
+
+function emitKeydown() {
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch {
+      // ignore
+    }
+  }
+}
+
+async function tryStartUiohook(): Promise<GlobalKeyboardBackend | null> {
+  try {
+    const mod = (await import("uiohook-napi")) as unknown as {
+      uIOhook?: {
+        on: (event: "keydown", listener: () => void) => unknown;
+        removeListener?: (event: "keydown", listener: () => void) => unknown;
+        start: () => void;
+        stop: () => void;
+      };
+      default?: { uIOhook?: unknown };
+    };
+
+    const uIOhook =
+      mod.uIOhook ??
+      ((mod.default as { uIOhook?: unknown } | undefined)?.uIOhook as
+        | {
+            on: (event: "keydown", listener: () => void) => unknown;
+            removeListener?: (event: "keydown", listener: () => void) => unknown;
+            start: () => void;
+            stop: () => void;
+          }
+        | undefined);
+    if (!uIOhook) return null;
+
+    const onKeydown = () => emitKeydown();
+    uIOhook.on("keydown", onKeydown);
+    uIOhook.start();
+
+    stopBackend = () => {
+      uIOhook.removeListener?.("keydown", onKeydown);
+      uIOhook.stop();
+    };
+
+    return "uiohook";
+  } catch {
+    return null;
+  }
+}
+
+function tryStartXinput(): Promise<GlobalKeyboardBackend | null> {
+  if (process.platform !== "linux") return Promise.resolve(null);
+  if (!process.env.DISPLAY) return Promise.resolve(null);
+
+  return new Promise((resolve) => {
+    let resolved = false;
+    const child = spawn("xinput", ["test-xi2", "--root"], {
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+
+    const resolveOnce = (value: GlobalKeyboardBackend | null) => {
+      if (resolved) return;
+      resolved = true;
+      resolve(value);
+    };
+
+    child.once("error", () => {
+      resolveOnce(null);
+    });
+
+    // If we got here, treat it as started; parsing may continue.
+    resolveOnce("xinput");
+
+    let buf = "";
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk: string) => {
+      buf += chunk;
+      while (true) {
+        const idx = buf.indexOf("\n");
+        if (idx === -1) break;
+        const line = buf.slice(0, idx);
+        buf = buf.slice(idx + 1);
+        if (/KeyPress/.test(line)) emitKeydown();
+      }
+    });
+
+    stopBackend = () => {
+      child.stdout?.removeAllListeners();
+      child.removeAllListeners();
+      child.kill();
+    };
+  });
+}
+
+export async function ensureGlobalKeyboard(): Promise<GlobalKeyboardBackend | null> {
+  if (started) return backend;
+  if (starting) return starting;
+
+  starting = (async () => {
+    const uiohook = await tryStartUiohook();
+    if (uiohook) return uiohook;
+    return await tryStartXinput();
+  })();
+
+  backend = await starting;
+  started = backend !== null;
+  if (!started) stopBackend = null;
+  starting = null;
+
+  return backend;
+}
+
+function stopIfIdle() {
+  if (listeners.size > 0) return;
+  if (!started) return;
+  started = false;
+  backend = null;
+  const stop = stopBackend;
+  stopBackend = null;
+  try {
+    stop?.();
+  } catch {
+    // ignore
+  }
+}
+
+export function subscribeGlobalKeydown(listener: Listener): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+    stopIfIdle();
+  };
+}
+

package/src/hooks/index.ts

@@ -1,7 +1,5 @@
-export {useActivityMonitor} from './useActivityMonitor.js';
-export {useAiAgent} from './useAiAgent.js';
-export {useBroadcaster} from './useBroadcaster.js';
-export {useCountdown} from './useCountdown.js';
-export {useScanner} from './useScanner.js';
-export {useTcpSync} from './useTcpSync.js';
-
+export { useActivityMonitor } from "./useActivityMonitor.js";
+export { useAiAgent } from "./useAiAgent.js";
+export { useBroadcaster } from "./useBroadcaster.js";
+export { useScanner } from "./useScanner.js";
+export { useTcpSync } from "./useTcpSync.js";

package/src/hooks/useActivityMonitor.ts

@@ -1,25 +1,62 @@
-import {useEffect, useRef, useState} from 'react';
-import {useInput} from 'ink';
-import type {ActivityState} from '../protocol.js';
-
-export function useActivityMonitor(options?: {idleAfterMs?: number}): {state: ActivityState} {
-	const idleAfterMs = options?.idleAfterMs ?? 1500;
-	const [state, setState] = useState<ActivityState>('IDLE');
-
-	const lastActivityRef = useRef<number>(Date.now());
-
-	useInput(() => {
-		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};
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useInput } from "ink";
+import type { ActivityState } from "../protocol.js";
+import {
+  ensureGlobalKeyboard,
+  subscribeGlobalKeydown,
+} from "./globalKeyboard.js";
+
+export function useActivityMonitor(options?: {
+  idleAfterMs?: number;
+  source?: "ink" | "keyboard";
+}): {
+  state: ActivityState;
+} {
+  const idleAfterMs = options?.idleAfterMs ?? 1500;
+  const [state, setState] = useState<ActivityState>("IDLE");
+
+  const lastActivityRef = useRef<number>(Date.now());
+
+  const markActive = useCallback(() => {
+    lastActivityRef.current = Date.now();
+    setState("TYPING");
+  }, []);
+
+  useInput(() => {
+    markActive();
+  });
+
+  // Optional global keyboard activity.
+  useEffect(() => {
+    const rawSource =
+      options?.source ?? process.env.TERMBUDDY_ACTIVITY_SOURCE ?? "ink";
+
+    // Back-compat: previous env value.
+    const source = rawSource === "xinput" ? "keyboard" : rawSource;
+    if (source !== "keyboard") return;
+
+    let cancelled = false;
+    let unsub: (() => void) | null = null;
+    void (async () => {
+      const ok = await ensureGlobalKeyboard();
+      if (cancelled) return;
+      if (!ok) return;
+      unsub = subscribeGlobalKeydown(markActive);
+    })();
+
+    return () => {
+      cancelled = true;
+      unsub?.();
+    };
+  }, [markActive, options?.source]);
+
+  useEffect(() => {
+    const id = setInterval(() => {
+      const delta = Date.now() - lastActivityRef.current;
+      if (delta >= idleAfterMs) setState("IDLE");
+    }, 200);
+    return () => clearInterval(id);
+  }, [idleAfterMs]);
+
+  return { state };
 }