@hopgoldy/agent-bridge 0.1.1

package/dist/agent-bridge.js

@@ -0,0 +1,2019 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import process2 from "process";
+import { Command } from "commander";
+
+// src/config/prompt.ts
+import { cancel, confirm as clackConfirm, isCancel, password, select as clackSelect, text } from "@clack/prompts";
+function normalize(value) {
+  return value == null ? "" : String(value).trim();
+}
+function throwIfCancelled(value) {
+  if (isCancel(value)) {
+    cancel("Setup cancelled.");
+    throw new Error("Setup cancelled");
+  }
+}
+function createPromptContext() {
+  return {
+    async input(label, opts = {}) {
+      const { defaultValue, required = false, secret = false, validate } = opts;
+      const validateInput = (raw2) => {
+        const value = normalize(raw2) || normalize(defaultValue);
+        if (required && !value) {
+          return "This field is required.";
+        }
+        if (validate) {
+          return validate(value) ?? void 0;
+        }
+        return void 0;
+      };
+      const raw = secret ? await password({ message: label, validate: validateInput }) : await text({
+        message: label,
+        defaultValue: defaultValue || void 0,
+        placeholder: defaultValue,
+        validate: validateInput
+      });
+      throwIfCancelled(raw);
+      return normalize(raw) || normalize(defaultValue);
+    },
+    async select(label, options) {
+      if (options.length === 0) {
+        throw new Error("select() requires at least one option");
+      }
+      const value = await clackSelect({
+        message: label,
+        options: options.map((option) => ({ value: option.value, label: option.label }))
+      });
+      throwIfCancelled(value);
+      return value;
+    },
+    async confirm(label, defaultValue = false) {
+      const value = await clackConfirm({ message: label, initialValue: defaultValue });
+      throwIfCancelled(value);
+      return value;
+    },
+    close() {
+    }
+  };
+}
+
+// src/config/session-bindings.ts
+import { mkdir, readFile, unlink, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+var BINDINGS_DIR = path.join(os.homedir(), ".config", "agent-bridge", "session-bindings");
+function getSessionBindingStorePath(channelName) {
+  return path.join(BINDINGS_DIR, `${encodeURIComponent(channelName)}.json`);
+}
+async function removeSessionBindingStore(channelName) {
+  try {
+    await unlink(getSessionBindingStorePath(channelName));
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+function createFileSessionBindingStore(filePath) {
+  return {
+    async load() {
+      try {
+        const raw = await readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+          return {};
+        }
+        return parsed;
+      } catch (error) {
+        if (error?.code === "ENOENT") {
+          return {};
+        }
+        throw error;
+      }
+    },
+    async save(bindings) {
+      await mkdir(path.dirname(filePath), { recursive: true });
+      await writeFile(filePath, `${JSON.stringify(bindings, null, 2)}
+`, "utf8");
+    }
+  };
+}
+
+// src/config/store.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import os2 from "os";
+import path2 from "path";
+
+// src/config/defaults.ts
+var DEFAULTS = {
+  agentIdleTimeoutMs: 10 * 60 * 1e3
+};
+
+// src/config/store.ts
+var CONFIG_DIR = path2.join(os2.homedir(), ".config", "agent-bridge");
+var CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
+function normalizeChannelConfig(channel) {
+  if (!channel.client || !channel.agent) {
+    throw new Error("Invalid channel config shape");
+  }
+  return channel;
+}
+function mergeDefaults(config = {}) {
+  const channels = Object.fromEntries(
+    Object.entries(config.channels ?? {}).map(([name, channel]) => [name, normalizeChannelConfig(channel)])
+  );
+  return {
+    channels,
+    defaults: {
+      agentIdleTimeoutMs: config.defaults?.agentIdleTimeoutMs ?? DEFAULTS.agentIdleTimeoutMs
+    }
+  };
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+async function ensureConfigDir() {
+  await mkdir2(CONFIG_DIR, { recursive: true });
+}
+async function loadConfig() {
+  await ensureConfigDir();
+  try {
+    const raw = await readFile2(CONFIG_PATH, "utf8");
+    return mergeDefaults(JSON.parse(raw));
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return mergeDefaults();
+    }
+    throw error;
+  }
+}
+async function saveConfig(config) {
+  await ensureConfigDir();
+  const merged = mergeDefaults(config);
+  await writeFile2(CONFIG_PATH, `${JSON.stringify(merged, null, 2)}
+`, "utf8");
+}
+
+// src/core/logger.ts
+var LEVEL_ORDER = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function resolveMinLevel() {
+  const raw = (process.env.LOG_LEVEL ?? "info").toLowerCase();
+  return LEVEL_ORDER[raw] ?? LEVEL_ORDER.info;
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createLogger(scope) {
+  const prefix = () => `[${timestamp()}] [${scope}]`;
+  const log = (level, write) => {
+    return (...args) => {
+      if (LEVEL_ORDER[level] < resolveMinLevel()) return;
+      write(prefix(), ...args);
+    };
+  };
+  return {
+    debug: log("debug", console.debug),
+    info: log("info", console.log),
+    warn: log("warn", console.warn),
+    error: log("error", console.error)
+  };
+}
+
+// src/core/gateway-core.ts
+var GatewayCore = class {
+  #imAdapter;
+  #agentModule;
+  #agentConfig;
+  #agentIdleTimeoutMs;
+  #bindingStore;
+  #logger = createLogger("core");
+  #clientToAgentSession = /* @__PURE__ */ new Map();
+  #agentRuntimes = /* @__PURE__ */ new Map();
+  #started = false;
+  constructor({ imAdapter, agentModule, agentConfig, agentIdleTimeoutMs, bindingStore }) {
+    this.#imAdapter = imAdapter;
+    this.#agentModule = agentModule;
+    this.#agentConfig = agentConfig;
+    this.#agentIdleTimeoutMs = agentIdleTimeoutMs;
+    this.#bindingStore = bindingStore;
+  }
+  async start() {
+    if (this.#started) return;
+    this.#started = true;
+    if (this.#bindingStore) {
+      const bindings = await this.#bindingStore.load();
+      for (const [clientSessionId, agentSessionId] of Object.entries(bindings)) {
+        this.#clientToAgentSession.set(clientSessionId, agentSessionId);
+      }
+    }
+    await this.#imAdapter.start(async (event) => {
+      try {
+        await this.#handleClientOutput(event);
+      } catch (error) {
+        this.#logger.error("failed to process client output event:", error);
+      }
+    });
+  }
+  async stop() {
+    if (!this.#started) return;
+    this.#started = false;
+    for (const runtime of [...this.#agentRuntimes.values()]) {
+      await this.#stopRuntime(runtime);
+    }
+    await this.#imAdapter.stop();
+  }
+  async #handleClientOutput(event) {
+    if (event.type === "command.session.new") {
+      await this.#handleSessionNew(event.clientSessionId);
+      return;
+    }
+    if (event.type === "command.session.compact") {
+      await this.#handleSessionCompact(event.clientSessionId);
+      return;
+    }
+    if (event.type === "command.session.stop") {
+      await this.#handleSessionStop(event.clientSessionId);
+      return;
+    }
+    await this.#handleUserMessage(event.clientSessionId, event.text);
+  }
+  async #handleUserMessage(clientSessionId, text2) {
+    const runtime = await this.#getOrCreateActiveRuntime(clientSessionId);
+    this.#touchRuntime(runtime);
+    await runtime.agentAdapter.input({
+      type: "user.message",
+      text: text2
+    });
+  }
+  async #handleSessionCompact(clientSessionId) {
+    const runtime = await this.#getActiveRuntime(clientSessionId);
+    if (!runtime) {
+      await this.#deliverClientInput({
+        type: "assistant.message",
+        clientSessionId,
+        text: "No active agent session to compact."
+      });
+      return;
+    }
+    this.#touchRuntime(runtime);
+    await runtime.agentAdapter.input({
+      type: "command.session.compact"
+    });
+  }
+  async #handleSessionStop(clientSessionId) {
+    const runtime = await this.#getActiveRuntime(clientSessionId);
+    if (!runtime) {
+      await this.#deliverClientInput({
+        type: "assistant.message",
+        clientSessionId,
+        text: "No active agent session to stop."
+      });
+      return;
+    }
+    this.#touchRuntime(runtime);
+    if (!runtime.agentAdapter.abort) {
+      await this.#deliverClientInput({
+        type: "assistant.message",
+        clientSessionId,
+        text: "This agent session cannot be stopped right now."
+      });
+      return;
+    }
+    if (!await runtime.agentAdapter.isBusy()) {
+      await this.#deliverClientInput({
+        type: "assistant.message",
+        clientSessionId,
+        text: "No active agent run to stop."
+      });
+      return;
+    }
+    await runtime.agentAdapter.abort();
+  }
+  async #handleSessionNew(clientSessionId) {
+    const previousAgentSessionId = this.#clientToAgentSession.get(clientSessionId);
+    if (previousAgentSessionId) {
+      const previousRuntime = this.#agentRuntimes.get(previousAgentSessionId);
+      if (previousRuntime) {
+        await this.#stopRuntime(previousRuntime);
+      }
+    }
+    const runtime = await this.#createRuntimeForClient(clientSessionId);
+    this.#bindClientToAgent(clientSessionId, runtime.agentSessionId);
+    await this.#deliverClientInput({
+      type: "assistant.message",
+      clientSessionId,
+      text: "Started a new session."
+    });
+  }
+  async #deliverClientInput(event) {
+    try {
+      await this.#imAdapter.input(event);
+    } catch (error) {
+      this.#logger.error("failed to deliver client input event:", error);
+    }
+  }
+  async #getActiveRuntime(clientSessionId) {
+    const agentSessionId = this.#clientToAgentSession.get(clientSessionId);
+    if (!agentSessionId) {
+      return null;
+    }
+    return this.#getOrRestoreRuntime(clientSessionId, agentSessionId);
+  }
+  async #getOrCreateActiveRuntime(clientSessionId) {
+    const existing = await this.#getActiveRuntime(clientSessionId);
+    if (existing) {
+      return existing;
+    }
+    const runtime = await this.#createRuntimeForClient(clientSessionId);
+    this.#bindClientToAgent(clientSessionId, runtime.agentSessionId);
+    return runtime;
+  }
+  async #getOrRestoreRuntime(clientSessionId, agentSessionId) {
+    const existing = this.#agentRuntimes.get(agentSessionId);
+    if (existing) {
+      this.#touchRuntime(existing);
+      return existing;
+    }
+    if (this.#agentModule.resumeAgentSession) {
+      const agentAdapter = await this.#agentModule.resumeAgentSession({
+        config: this.#agentConfig,
+        agentSessionId
+      });
+      return this.#startRuntime(clientSessionId, agentSessionId, agentAdapter);
+    }
+    const runtime = await this.#createRuntimeForClient(clientSessionId);
+    this.#bindClientToAgent(clientSessionId, runtime.agentSessionId);
+    return runtime;
+  }
+  async #createRuntimeForClient(clientSessionId) {
+    const { agentSessionId, agentAdapter } = await this.#agentModule.createAgentSession({
+      config: this.#agentConfig
+    });
+    return this.#startRuntime(clientSessionId, agentSessionId, agentAdapter);
+  }
+  async #startRuntime(clientSessionId, agentSessionId, agentAdapter) {
+    await agentAdapter.start(async (event) => {
+      await this.#handleAgentOutput(event);
+    });
+    const runtime = {
+      agentSessionId,
+      clientSessionId,
+      agentAdapter,
+      lastActiveAt: Date.now(),
+      idleTimer: null
+    };
+    this.#agentRuntimes.set(agentSessionId, runtime);
+    this.#touchRuntime(runtime);
+    return runtime;
+  }
+  #bindClientToAgent(clientSessionId, agentSessionId) {
+    this.#clientToAgentSession.set(clientSessionId, agentSessionId);
+    void this.#persistBindings();
+  }
+  async #persistBindings() {
+    if (!this.#bindingStore) {
+      return;
+    }
+    try {
+      await this.#bindingStore.save(Object.fromEntries(this.#clientToAgentSession));
+    } catch (error) {
+      this.#logger.error("failed to persist session bindings:", error);
+    }
+  }
+  async #handleAgentOutput(event) {
+    const agentSessionId = event.agentSessionId;
+    const runtime = this.#agentRuntimes.get(agentSessionId);
+    if (!runtime) {
+      this.#logger.info(`dropping output from released agent session ${agentSessionId}`);
+      return;
+    }
+    const clientSessionId = runtime.clientSessionId;
+    const activeAgentSessionId = this.#clientToAgentSession.get(clientSessionId);
+    if (activeAgentSessionId !== agentSessionId) {
+      this.#logger.info(
+        `dropping late output from inactive agent session ${agentSessionId} for client ${clientSessionId}`
+      );
+      return;
+    }
+    this.#touchRuntime(runtime);
+    if (this.#isToolRelatedEvent(event)) {
+      this.#logger.info("forwarding tool event from agent", {
+        type: event.type,
+        agentSessionId,
+        clientSessionId,
+        toolName: "toolName" in event ? event.toolName : void 0,
+        text: event.text
+      });
+    }
+    if (event.type === "assistant.message") {
+      await this.#deliverClientInput({
+        type: "assistant.message",
+        clientSessionId,
+        text: event.text,
+        attachments: event.attachments
+      });
+      return;
+    }
+    await this.#deliverClientInput({
+      ...event,
+      clientSessionId
+    });
+  }
+  #isToolRelatedEvent(event) {
+    return event.type === "assistant.tool.running" || event.type === "assistant.tool.done" || event.type === "assistant.tool.error" || event.type === "session.compacting";
+  }
+  #touchRuntime(runtime) {
+    runtime.lastActiveAt = Date.now();
+    this.#scheduleIdleRelease(runtime);
+  }
+  #scheduleIdleRelease(runtime) {
+    if (runtime.idleTimer) {
+      clearTimeout(runtime.idleTimer);
+    }
+    if (this.#agentIdleTimeoutMs <= 0) {
+      runtime.idleTimer = null;
+      return;
+    }
+    runtime.idleTimer = setTimeout(() => {
+      void this.#releaseIdleRuntime(runtime.agentSessionId);
+    }, this.#agentIdleTimeoutMs);
+    runtime.idleTimer.unref?.();
+  }
+  async #releaseIdleRuntime(agentSessionId) {
+    const runtime = this.#agentRuntimes.get(agentSessionId);
+    if (!runtime) {
+      return;
+    }
+    const idleForMs = Date.now() - runtime.lastActiveAt;
+    if (idleForMs < this.#agentIdleTimeoutMs) {
+      this.#scheduleIdleRelease(runtime);
+      return;
+    }
+    if (await runtime.agentAdapter.isBusy()) {
+      this.#scheduleIdleRelease(runtime);
+      return;
+    }
+    await this.#stopRuntime(runtime);
+    this.#logger.info(`released idle agent session ${agentSessionId}`);
+  }
+  async #stopRuntime(runtime) {
+    if (runtime.idleTimer) {
+      clearTimeout(runtime.idleTimer);
+      runtime.idleTimer = null;
+    }
+    try {
+      if (runtime.agentAdapter.abort && await runtime.agentAdapter.isBusy()) {
+        try {
+          await runtime.agentAdapter.abort();
+        } catch (error) {
+          this.#logger.error(`abort failed for ${runtime.agentSessionId}:`, error);
+        }
+      }
+      await runtime.agentAdapter.stop();
+    } finally {
+      this.#agentRuntimes.delete(runtime.agentSessionId);
+    }
+  }
+};
+
+// src/modules/agent/pi-coding-agent/index.ts
+import { randomUUID } from "crypto";
+import os5 from "os";
+import path6 from "path";
+
+// src/modules/agent/pi-coding-agent/media-marker.ts
+import { existsSync, realpathSync } from "fs";
+import path3 from "path";
+import os3 from "os";
+var IMAGE_EXTS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "webp", "gif", "bmp"]);
+var DELIVERABLE_EXTS = /* @__PURE__ */ new Set([
+  ...IMAGE_EXTS,
+  "pdf",
+  "txt",
+  "md",
+  "csv",
+  "zip",
+  "docx",
+  "xlsx",
+  "pptx",
+  "json"
+]);
+var MEDIA_TAG_RE = /[`"']?MEDIA:\s*(`[^`\n]+`|"[^"\n]+"|'[^'\n]+'|(?:~\/|\/|[A-Za-z]:[/\\])[^\s`"']+\.\w+)[`"']?/gi;
+function maskProtectedSpans(text2) {
+  const chars = [...text2];
+  const maskRange = (re) => {
+    for (const match of text2.matchAll(re)) {
+      const start = match.index ?? 0;
+      const end = start + match[0].length;
+      for (let i = start; i < end; i++) {
+        if (chars[i] !== "\n") chars[i] = " ";
+      }
+    }
+  };
+  maskRange(/```[\s\S]*?```/g);
+  maskRange(/`[^`\n]+`/g);
+  return chars.join("");
+}
+function stripQuotes(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length >= 2 && trimmed[0] === trimmed.at(-1) && "`\"'".includes(trimmed[0])) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function resolveDeliverablePath(rawPath) {
+  const stripped = stripQuotes(rawPath);
+  const expanded = stripped.startsWith("~") ? path3.join(os3.homedir(), stripped.slice(1)) : stripped;
+  const candidate = path3.resolve(expanded);
+  const ext = candidate.split(".").pop()?.toLowerCase() ?? "";
+  if (!DELIVERABLE_EXTS.has(ext)) return null;
+  if (!existsSync(candidate)) return null;
+  try {
+    return realpathSync(candidate);
+  } catch {
+    return null;
+  }
+}
+function extractMediaMarkers(rawText) {
+  const scanText = maskProtectedSpans(rawText);
+  const attachments = [];
+  const spansToStrip = [];
+  for (const match of scanText.matchAll(MEDIA_TAG_RE)) {
+    const resolved = resolveDeliverablePath(match[1]);
+    if (!resolved) continue;
+    const ext = resolved.split(".").pop()?.toLowerCase() ?? "";
+    attachments.push({
+      kind: IMAGE_EXTS.has(ext) ? "image" : "file",
+      filePath: resolved
+    });
+    const start = match.index ?? 0;
+    spansToStrip.push([start, start + match[0].length]);
+  }
+  let cleaned = rawText;
+  for (const [start, end] of spansToStrip.reverse()) {
+    cleaned = cleaned.slice(0, start) + cleaned.slice(end);
+  }
+  return { text: cleaned.trim(), attachments };
+}
+
+// src/modules/agent/pi-coding-agent/adapter/pi-rpc-client.ts
+import { spawn } from "child_process";
+import { mkdir as mkdir3 } from "fs/promises";
+import os4 from "os";
+import path5 from "path";
+import { StringDecoder } from "string_decoder";
+
+// src/modules/agent/pi-coding-agent/adapter/pi-extension-path.ts
+import { existsSync as existsSync2 } from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+
+// src/config/env.ts
+function isDevelopmentEnv() {
+  return process.env.NODE_ENV === "development";
+}
+
+// src/modules/agent/pi-coding-agent/adapter/pi-extension-path.ts
+var MEDIA_PROMPT_RELATIVE_PATH = path4.join(
+  "src",
+  "modules",
+  "agent",
+  "pi-coding-agent",
+  "adapter",
+  "media-prompt.ts"
+);
+function resolveMediaPromptExtensionPath() {
+  const selfDir = path4.dirname(fileURLToPath(import.meta.url));
+  let dir = selfDir;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync2(path4.join(dir, "package.json"))) {
+      if (isDevelopmentEnv()) {
+        const sourceCandidate = path4.join(dir, MEDIA_PROMPT_RELATIVE_PATH);
+        if (existsSync2(sourceCandidate)) {
+          return sourceCandidate;
+        }
+        throw new Error(
+          `NODE_ENV=development but could not locate ${MEDIA_PROMPT_RELATIVE_PATH} relative to the agent-bridge package root`
+        );
+      }
+      const bundledCandidate = path4.join(selfDir, "media-prompt.js");
+      if (existsSync2(bundledCandidate)) {
+        return bundledCandidate;
+      }
+      throw new Error(
+        "NODE_ENV is not development, so agent-bridge expects a built dist/media-prompt.js next to the bundled runtime. Run npm run build before starting in production mode."
+      );
+    }
+    const parent = path4.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    "Could not locate the agent-bridge package root while resolving the media-prompt extension path"
+  );
+}
+
+// src/modules/agent/pi-coding-agent/adapter/pi-rpc-client.ts
+function serializeJsonLine(value) {
+  return `${JSON.stringify(value)}
+`;
+}
+function attachStrictJsonlReader(stream, onLine) {
+  const decoder = new StringDecoder("utf8");
+  let buffer = "";
+  const onData = (chunk) => {
+    buffer += typeof chunk === "string" ? chunk : decoder.write(chunk);
+    while (true) {
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) break;
+      let line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      if (line.endsWith("\r")) {
+        line = line.slice(0, -1);
+      }
+      if (line.length > 0) {
+        onLine(line);
+      }
+    }
+  };
+  const onEnd = () => {
+    buffer += decoder.end();
+    const tail = buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer;
+    if (tail.length > 0) {
+      onLine(tail);
+    }
+  };
+  stream.on("data", onData);
+  stream.on("end", onEnd);
+  return () => {
+    stream.off("data", onData);
+    stream.off("end", onEnd);
+  };
+}
+function defaultSessionDir() {
+  return path5.join(os4.homedir(), ".config", "agent-bridge", "pi-sessions");
+}
+var PiRpcClient = class {
+  #options;
+  #logger;
+  #process = null;
+  #stderr = "";
+  #requestId = 0;
+  #pendingRequests = /* @__PURE__ */ new Map();
+  #detachStdoutReader = null;
+  #settledWaiters = [];
+  #started = false;
+  #stopping = false;
+  #exitError = null;
+  #eventListeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.#options = {
+      agentSessionId: options.agentSessionId,
+      piSessionId: options.piSessionId,
+      cwd: options.cwd ?? process.cwd(),
+      sessionDir: options.sessionDir ?? defaultSessionDir(),
+      bin: options.bin ?? "pi",
+      model: options.model,
+      extraArgs: options.extraArgs ?? []
+    };
+    this.#logger = options.logger ?? createLogger("pi-rpc");
+  }
+  onEvent(listener) {
+    this.#eventListeners.add(listener);
+    return () => {
+      this.#eventListeners.delete(listener);
+    };
+  }
+  async start() {
+    if (this.#started) {
+      throw new Error("PiRpcClient already started");
+    }
+    await mkdir3(this.#options.sessionDir, { recursive: true });
+    const args = [
+      "--mode",
+      "rpc",
+      "--session-id",
+      this.#options.piSessionId,
+      "--session-dir",
+      this.#options.sessionDir,
+      "--extension",
+      resolveMediaPromptExtensionPath(),
+      ...this.#options.model ? ["--model", this.#options.model] : [],
+      ...this.#options.extraArgs
+    ];
+    const child = spawn(this.#options.bin, args, {
+      cwd: this.#options.cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.#logger.info(
+      `spawned pi process (pid=${child.pid} bin=${this.#options.bin} args=${args.join(" ")} cwd=${this.#options.cwd})`
+    );
+    this.#process = child;
+    this.#started = true;
+    this.#exitError = null;
+    child.stderr.on("data", (chunk) => {
+      this.#stderr += chunk.toString();
+      this.#logger.debug(`pi stderr: ${chunk.toString().trimEnd()}`);
+    });
+    child.once("error", (error) => {
+      const wrapped = new Error(`pi RPC process error: ${error.message}`);
+      this.#handleExitError(wrapped);
+    });
+    child.once("exit", (code, signal) => {
+      const detail = signal ? `signal ${signal}` : `code ${String(code)}`;
+      const stderr = this.#stderr.trim();
+      const message = stderr ? `pi RPC process exited (${detail}): ${stderr}` : `pi RPC process exited (${detail})`;
+      this.#handleExitError(new Error(message));
+    });
+    this.#detachStdoutReader = attachStrictJsonlReader(child.stdout, (line) => {
+      this.#handleLine(line);
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    if (this.#exitError) {
+      throw this.#exitError;
+    }
+    const state = await this.getState();
+    if (!state.sessionName) {
+      await this.setSessionName(this.#options.agentSessionId);
+    }
+  }
+  async stop() {
+    const child = this.#process;
+    if (!child) return;
+    this.#stopping = true;
+    this.#detachStdoutReader?.();
+    this.#detachStdoutReader = null;
+    await new Promise((resolve) => {
+      let finished = false;
+      const done = () => {
+        if (finished) return;
+        finished = true;
+        resolve();
+      };
+      child.once("exit", () => done());
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (child.exitCode === null && child.signalCode === null) {
+          this.#logger.warn("pi process did not exit after SIGTERM, sending SIGKILL");
+          child.kill("SIGKILL");
+        }
+        done();
+      }, 1e3);
+    });
+    this.#process = null;
+    this.#started = false;
+    this.#rejectPending(new Error("pi RPC client stopped"));
+  }
+  async prompt(message) {
+    await this.#send({ type: "prompt", message });
+  }
+  async abort() {
+    await this.#send({ type: "abort" });
+  }
+  async compact(customInstructions) {
+    const response = await this.#send({ type: "compact", customInstructions });
+    const data = response.data;
+    return data ?? {};
+  }
+  async getLastAssistantText() {
+    const response = await this.#send({ type: "get_last_assistant_text" });
+    const data = response.data;
+    return data?.text ?? null;
+  }
+  async getState() {
+    const response = await this.#send({ type: "get_state" });
+    return response.data ?? {};
+  }
+  async setSessionName(name) {
+    await this.#send({ type: "set_session_name", name });
+  }
+  waitForSettled(timeoutMs = 10 * 60 * 1e3) {
+    if (!this.#process) {
+      return Promise.reject(new Error("pi RPC client is not running"));
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Timed out waiting for pi agent to settle after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.#settledWaiters.push({
+        resolve: () => {
+          clearTimeout(timeout);
+          resolve();
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+    });
+  }
+  async #send(command) {
+    if (!this.#process?.stdin.writable) {
+      throw this.#exitError ?? new Error("pi RPC process is not writable");
+    }
+    const id = `req-${++this.#requestId}`;
+    const payload = { ...command, id };
+    this.#logger.debug(`sending command (id=${id} type=${command.type})`);
+    return new Promise((resolve, reject) => {
+      this.#pendingRequests.set(id, { resolve, reject });
+      this.#process.stdin.write(serializeJsonLine(payload), (error) => {
+        if (!error) return;
+        this.#pendingRequests.delete(id);
+        this.#logger.error(`failed to write command to pi RPC stdin (id=${id}):`, error);
+        reject(new Error(`Failed to write to pi RPC stdin: ${error.message}`));
+      });
+    }).then((response) => {
+      this.#logger.debug(`received response (id=${id} type=${command.type} success=${response.success})`);
+      if (!response.success) {
+        this.#logger.error(
+          `pi RPC command failed (id=${id} type=${response.command}): ${response.error ?? "unknown error"}`
+        );
+        throw new Error(response.error ?? `pi RPC command failed: ${response.command}`);
+      }
+      return response;
+    });
+  }
+  #handleLine(line) {
+    let payload;
+    try {
+      payload = JSON.parse(line);
+    } catch (error) {
+      this.#logger.error("failed to parse line:", error);
+      return;
+    }
+    if (payload.type === "response") {
+      const response = payload;
+      const id = response.id;
+      if (!id) {
+        this.#logger.warn("ignoring RPC response without id:", JSON.stringify(response).slice(0, 500));
+        return;
+      }
+      const pending = this.#pendingRequests.get(id);
+      if (!pending) {
+        this.#logger.warn(`ignoring RPC response with unknown id (id=${id})`);
+        return;
+      }
+      this.#pendingRequests.delete(id);
+      pending.resolve(response);
+      return;
+    }
+    const event = payload;
+    this.#logger.debug(`received event (type=${event.type})`);
+    for (const listener of this.#eventListeners) {
+      listener(event);
+    }
+    if (event.type === "agent_settled") {
+      const waiters = this.#settledWaiters.splice(0);
+      for (const waiter of waiters) {
+        waiter.resolve();
+      }
+    }
+  }
+  #handleExitError(error) {
+    if (this.#stopping) {
+      this.#logger.debug(`pi process exited during stop: ${error.message}`);
+    } else {
+      this.#logger.error(error.message);
+    }
+    this.#stopping = false;
+    this.#exitError = error;
+    this.#process = null;
+    this.#started = false;
+    this.#detachStdoutReader?.();
+    this.#detachStdoutReader = null;
+    this.#rejectPending(error);
+  }
+  #rejectPending(error) {
+    for (const [id, pending] of this.#pendingRequests) {
+      this.#pendingRequests.delete(id);
+      pending.reject(error);
+    }
+    const waiters = this.#settledWaiters.splice(0);
+    for (const waiter of waiters) {
+      waiter.reject(error);
+    }
+  }
+};
+
+// src/modules/agent/pi-coding-agent/adapter/pi-session-id.ts
+import crypto from "crypto";
+function trimToAlnumEdges(value) {
+  return value.replace(/^[^A-Za-z0-9]+/, "").replace(/[^A-Za-z0-9]+$/, "");
+}
+function toPiSessionId(agentSessionId) {
+  const normalized = trimToAlnumEdges(agentSessionId.replace(/[^A-Za-z0-9._-]+/g, "."));
+  if (normalized && /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(normalized)) {
+    return normalized;
+  }
+  const digest = crypto.createHash("sha256").update(agentSessionId).digest("hex").slice(0, 24);
+  return `agent-${digest}`;
+}
+
+// src/modules/agent/pi-coding-agent/adapter/pi-coding-agent-adapter.ts
+var PiCodingAgentAdapter = class {
+  #agentSessionId;
+  #piSessionId;
+  #cwd;
+  #sessionDir;
+  #bin;
+  #model;
+  #extraArgs;
+  #logger;
+  #client = null;
+  #onOutput = null;
+  #inputQueue = [];
+  #processing = false;
+  constructor({
+    agentSessionId,
+    cwd,
+    sessionDir,
+    bin,
+    model,
+    extraArgs,
+    logger: logger3
+  }) {
+    this.#agentSessionId = agentSessionId;
+    this.#piSessionId = toPiSessionId(agentSessionId);
+    this.#cwd = cwd ?? process.cwd();
+    this.#sessionDir = sessionDir;
+    this.#bin = bin ?? "pi";
+    this.#model = model;
+    this.#extraArgs = extraArgs ?? [];
+    this.#logger = logger3 ?? createLogger("pi-coding-agent");
+  }
+  async start(onOutput) {
+    this.#onOutput = onOutput;
+    this.#client = new PiRpcClient({
+      agentSessionId: this.#agentSessionId,
+      piSessionId: this.#piSessionId,
+      cwd: this.#cwd,
+      sessionDir: this.#sessionDir,
+      bin: this.#bin,
+      model: this.#model,
+      extraArgs: this.#extraArgs,
+      logger: this.#logger
+    });
+    this.#client.onEvent((rpcEvent) => {
+      void this.#handleRpcEvent(rpcEvent);
+      if (rpcEvent.type === "extension_error") {
+        this.#logger.error(`extension_error for ${this.#agentSessionId}:`, rpcEvent);
+      }
+    });
+    this.#logger.info(`starting agent instance (bin=${this.#bin} cwd=${this.#cwd})`);
+    await this.#client.start();
+    this.#logger.info(`session ${this.#agentSessionId} started (piSessionId=${this.#piSessionId})`);
+  }
+  async stop() {
+    this.#inputQueue.length = 0;
+    await this.#client?.stop();
+    this.#client = null;
+    this.#processing = false;
+    this.#onOutput = null;
+    this.#logger.info(`session ${this.#agentSessionId} stopped`);
+  }
+  async abort() {
+    this.#logger.info(`aborting agent turn (session=${this.#agentSessionId})`);
+    await this.#client?.abort();
+  }
+  async input(event) {
+    if (!this.#client || !this.#onOutput) {
+      throw new Error("PiCodingAgentAdapter is not started");
+    }
+    this.#inputQueue.push(event);
+    this.#logger.debug(
+      `input event queued (session=${this.#agentSessionId} type=${event.type} queueDepth=${this.#inputQueue.length})`
+    );
+    void this.#drainInputQueue();
+  }
+  async isBusy() {
+    return this.#processing || this.#inputQueue.length > 0;
+  }
+  async #drainInputQueue() {
+    if (this.#processing) {
+      return;
+    }
+    this.#processing = true;
+    try {
+      while (this.#client && this.#onOutput && this.#inputQueue.length > 0) {
+        const event = this.#inputQueue.shift();
+        if (!event) continue;
+        await this.#processEvent(event);
+      }
+    } finally {
+      this.#processing = false;
+    }
+  }
+  async #processEvent(event) {
+    if (!this.#client) {
+      throw new Error("PiCodingAgentAdapter is not started");
+    }
+    try {
+      if (event.type === "user.message") {
+        this.#logger.info(`sending prompt to agent (session=${this.#agentSessionId})`);
+        const startedAt = Date.now();
+        await this.#emitProgress({
+          type: "assistant.thinking",
+          agentSessionId: this.#agentSessionId,
+          text: "Processing request"
+        });
+        await this.#client.prompt(event.text);
+        await this.#client.waitForSettled();
+        const rawText = await this.#client.getLastAssistantText();
+        const { text: text2, attachments } = extractMediaMarkers(rawText ?? "(pi returned no assistant text)");
+        this.#logger.debug(
+          `prompt settled (session=${this.#agentSessionId} durationMs=${Date.now() - startedAt} replyLength=${text2.length} attachments=${attachments.length})`
+        );
+        await this.#emitAssistant(text2, attachments);
+        return;
+      }
+      this.#logger.info(`compacting context (session=${this.#agentSessionId})`);
+      await this.#emitProgress({
+        type: "session.compacting",
+        agentSessionId: this.#agentSessionId,
+        text: "Compacting context"
+      });
+      const result = await this.#client.compact();
+      this.#logger.debug(
+        `compact finished (session=${this.#agentSessionId} estimatedTokensAfter=${result.estimatedTokensAfter ?? "unknown"})`
+      );
+      const suffix = typeof result.estimatedTokensAfter === "number" ? ` Estimated tokens after: ${result.estimatedTokensAfter}.` : "";
+      await this.#emitAssistant(`Context compacted.${suffix}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.#logger.error(
+        `event processing failed (session=${this.#agentSessionId} type=${event.type}):`,
+        error
+      );
+      await this.#emitAssistant(`[pi-coding-agent error] ${message}`);
+    }
+  }
+  async #emitAssistant(text2, attachments) {
+    if (!this.#onOutput) {
+      this.#logger.error(`dropped assistant output for stopped session ${this.#agentSessionId}`);
+      return;
+    }
+    await this.#onOutput({
+      type: "assistant.message",
+      agentSessionId: this.#agentSessionId,
+      text: text2,
+      attachments
+    });
+  }
+  async #emitProgress(event) {
+    if (!this.#onOutput) {
+      return;
+    }
+    await this.#onOutput(event);
+  }
+  async #handleRpcEvent(rpcEvent) {
+    if (!this.#onOutput) {
+      return;
+    }
+    if (rpcEvent.type === "tool_execution_start") {
+      const toolName = typeof rpcEvent.toolName === "string" ? rpcEvent.toolName : "unknown";
+      await this.#emitProgress({
+        type: "assistant.tool.running",
+        agentSessionId: this.#agentSessionId,
+        toolName,
+        text: `Running ${toolName}`
+      });
+      return;
+    }
+    if (rpcEvent.type === "tool_execution_end") {
+      const toolName = typeof rpcEvent.toolName === "string" ? rpcEvent.toolName : "unknown";
+      const isError = Boolean(rpcEvent.isError);
+      await this.#emitProgress({
+        type: isError ? "assistant.tool.error" : "assistant.tool.done",
+        agentSessionId: this.#agentSessionId,
+        toolName,
+        text: isError ? `Failed ${toolName}` : `Finished ${toolName}`
+      });
+    }
+  }
+};
+
+// src/modules/agent/pi-coding-agent/index.ts
+var logger = createLogger("pi-coding-agent");
+function parseExtraArgs(raw) {
+  if (!raw) return [];
+  return raw.split(" ").map((part) => part.trim()).filter(Boolean);
+}
+function buildAdapter(config, agentSessionId) {
+  return new PiCodingAgentAdapter({
+    agentSessionId,
+    cwd: process.cwd(),
+    sessionDir: config.sessionDir ?? process.env.PI_SESSION_DIR ?? path6.join(os5.homedir(), ".config", "agent-bridge", "pi-sessions"),
+    bin: config.bin ?? process.env.PI_BIN ?? "pi",
+    model: config.model ?? process.env.PI_MODEL,
+    extraArgs: config.extraArgs ?? parseExtraArgs(process.env.PI_RPC_EXTRA_ARGS)
+  });
+}
+function createPiCodingAgentConfigCollector() {
+  return {
+    async collect(ctx) {
+      const model = await ctx.input("Pi model (leave empty for pi default)");
+      return model ? { model } : {};
+    },
+    validate(config) {
+      if (config.model !== void 0 && !config.model.trim()) {
+        throw new Error("Pi model must be non-empty when provided");
+      }
+    },
+    summarize(config) {
+      return `type=pi-coding-agent model=${config.model ?? "default"}`;
+    }
+  };
+}
+var piCodingAgentModule = {
+  type: "pi-coding-agent",
+  createConfigCollector: createPiCodingAgentConfigCollector,
+  async createAgentSession({ config }) {
+    const agentSessionId = `pi-coding-agent:${randomUUID()}`;
+    logger.info(`creating agent session ${agentSessionId}`);
+    return {
+      agentSessionId,
+      agentAdapter: buildAdapter(config, agentSessionId)
+    };
+  },
+  async resumeAgentSession({ config, agentSessionId }) {
+    logger.info(`resuming agent session ${agentSessionId}`);
+    return buildAdapter(config, agentSessionId);
+  }
+};
+
+// src/modules/agent/index.ts
+var registry = /* @__PURE__ */ new Map([[piCodingAgentModule.type, piCodingAgentModule]]);
+function listAgentModules() {
+  return [...registry.values()];
+}
+function getAgentModule(type) {
+  return registry.get(type);
+}
+function getTypedAgentModule(config) {
+  const module = registry.get(config.type);
+  if (!module) {
+    throw new Error(`Unsupported agent module type: ${config.type}`);
+  }
+  return module;
+}
+
+// src/modules/client/feishu/adapter/feishu-client.ts
+import * as Lark from "@larksuiteoapi/node-sdk";
+import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+import { tmpdir } from "os";
+var DEDUP_TTL_MS = 12 * 60 * 60 * 1e3;
+var DEDUP_MAX_ENTRIES = 5e3;
+var MESSAGE_EXPIRY_MS = 30 * 60 * 1e3;
+var DEDUP_SWEEP_INTERVAL_MS = 5 * 60 * 1e3;
+var REACTION_TYPING = "Typing";
+function createChannel(config, logger3) {
+  const domain = config.domain === "lark" ? Lark.Domain.Lark : Lark.Domain.Feishu;
+  return Lark.createLarkChannel({
+    appId: config.appId,
+    appSecret: config.appSecret,
+    domain,
+    logger: {
+      error: (...args) => logger3.error(...args),
+      warn: (...args) => logger3.warn(...args),
+      info: (...args) => logger3.info(...args),
+      debug: (...args) => logger3.debug(...args),
+      trace: (...args) => logger3.debug(...args)
+    },
+    loggerLevel: Lark.LoggerLevel.warn,
+    safety: {
+      dedup: {
+        ttl: DEDUP_TTL_MS,
+        maxEntries: DEDUP_MAX_ENTRIES,
+        sweepIntervalMs: DEDUP_SWEEP_INTERVAL_MS
+      },
+      staleMessageWindowMs: MESSAGE_EXPIRY_MS
+    },
+    policy: {
+      requireMention: false
+    },
+    webhook: {
+      encryptKey: config.encryptKey,
+      verificationToken: config.verificationToken
+    }
+  });
+}
+function createClient(config) {
+  const domain = config.domain === "lark" ? Lark.Domain.Lark : Lark.Domain.Feishu;
+  return new Lark.Client({
+    appId: config.appId,
+    appSecret: config.appSecret,
+    domain
+  });
+}
+function buildMarkdownCard(text2) {
+  return JSON.stringify({
+    schema: "2.0",
+    body: {
+      elements: [
+        {
+          tag: "markdown",
+          content: text2
+        }
+      ]
+    }
+  });
+}
+function buildCardPayload(card) {
+  return JSON.stringify(card);
+}
+var FeishuClient = class {
+  #logger;
+  #channel;
+  #client;
+  #onMessage = null;
+  #unsubscribe = [];
+  #typingReactionByChatId = /* @__PURE__ */ new Map();
+  constructor(config, logger3 = createLogger("feishu")) {
+    this.#logger = logger3;
+    this.#channel = createChannel(config, logger3);
+    this.#client = createClient(config);
+  }
+  setOnMessage(onMessage) {
+    this.#onMessage = onMessage;
+  }
+  async connect() {
+    this.#unsubscribe = [
+      this.#channel.on("message", (message) => {
+        void this.#handleMessage(message);
+      }),
+      this.#channel.on("reject", (event) => {
+        this.#logger.debug(
+          `channel rejected inbound message (reason=${event.reason} chatId=${event.chatId} messageId=${event.messageId})`
+        );
+      }),
+      this.#channel.on("error", (error) => {
+        this.#logger.error("channel error:", error);
+      }),
+      this.#channel.on("reconnecting", () => {
+        this.#logger.info("channel reconnecting");
+      }),
+      this.#channel.on("reconnected", () => {
+        this.#logger.info("channel reconnected");
+      })
+    ];
+    this.#logger.info("starting channel connection");
+    await this.#channel.connect();
+    this.#logger.info("channel connected");
+  }
+  async disconnect() {
+    for (const unsubscribe of this.#unsubscribe.splice(0)) {
+      try {
+        unsubscribe();
+      } catch (error) {
+        this.#logger.debug("ignored channel unsubscribe error:", error);
+      }
+    }
+    await this.#channel.disconnect();
+  }
+  async sendText(chatId, text2, replyToMessageId) {
+    await this.sendMarkdown(chatId, text2, replyToMessageId);
+  }
+  async sendMarkdown(chatId, text2, replyToMessageId) {
+    const content = buildMarkdownCard(text2);
+    await this.#sendInteractive(chatId, content, replyToMessageId);
+    this.#logger.debug(
+      `markdown message sent (chatId=${chatId} replyTo=${replyToMessageId ?? "none"} length=${text2.length})`
+    );
+  }
+  async sendCard(chatId, card, replyToMessageId) {
+    const content = buildCardPayload(card);
+    const response = await this.#sendInteractive(chatId, content, replyToMessageId);
+    return response.data?.message_id ?? null;
+  }
+  async updateCard(messageId, card) {
+    await this.#client.im.message.patch({
+      path: {
+        message_id: messageId
+      },
+      data: {
+        content: buildCardPayload(card)
+      }
+    });
+  }
+  /** Download an inbound image/file/audio/video resource to a local temp path. */
+  async downloadResource(messageId, fileKey, resourceType, fileName) {
+    try {
+      const resp = await this.#client.im.messageResource.get({
+        path: { message_id: messageId, file_key: fileKey },
+        params: { type: resourceType }
+      });
+      if (!resp) return null;
+      const ext = resourceType === "image" ? ".png" : resourceType === "audio" ? ".ogg" : "";
+      const safeName = fileName && fileName.length > 0 ? fileName.replace(/[^a-zA-Z0-9._-]/g, "_") : `${fileKey}${ext}`;
+      const dir = join(tmpdir(), "agent-bridge-feishu-media");
+      if (!existsSync3(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      const localPath = join(dir, `${Date.now()}-${safeName}`);
+      if (typeof resp.writeFile === "function") {
+        await resp.writeFile(localPath);
+        return localPath;
+      }
+      if (typeof resp.getReadableStream === "function") {
+        const chunks = [];
+        for await (const chunk of resp.getReadableStream()) {
+          chunks.push(Buffer.from(chunk));
+        }
+        writeFileSync(localPath, Buffer.concat(chunks));
+        return localPath;
+      }
+      this.#logger.warn(`resource response had neither writeFile nor getReadableStream (fileKey=${fileKey})`);
+      return null;
+    } catch (error) {
+      this.#logger.error(`failed to download resource (fileKey=${fileKey}):`, error);
+      return null;
+    }
+  }
+  /** Upload and send a local image/file as a native Feishu attachment. */
+  async sendAttachment(chatId, attachment, replyToMessageId) {
+    const input = attachment.kind === "image" ? { image: { source: attachment.filePath } } : {
+      file: {
+        source: attachment.filePath,
+        fileName: attachment.fileName ?? basename(attachment.filePath)
+      }
+    };
+    await this.#channel.send(chatId, input, replyToMessageId ? { replyTo: replyToMessageId } : void 0);
+  }
+  async #sendInteractive(chatId, content, replyToMessageId) {
+    try {
+      if (replyToMessageId) {
+        return await this.#client.im.message.reply({
+          path: {
+            message_id: replyToMessageId
+          },
+          data: {
+            content,
+            msg_type: "interactive"
+          }
+        });
+      }
+      return await this.#client.im.message.create({
+        params: {
+          receive_id_type: "chat_id"
+        },
+        data: {
+          receive_id: chatId,
+          content,
+          msg_type: "interactive"
+        }
+      });
+    } catch (error) {
+      if (replyToMessageId && (error?.code === 230011 || error?.code === 231003)) {
+        this.#logger.warn(
+          `reply target unavailable, falling back to create (chatId=${chatId} replyTo=${replyToMessageId})`
+        );
+        return await this.#client.im.message.create({
+          params: {
+            receive_id_type: "chat_id"
+          },
+          data: {
+            receive_id: chatId,
+            content,
+            msg_type: "interactive"
+          }
+        });
+      }
+      throw error;
+    }
+  }
+  async startTyping(chatId, messageId) {
+    try {
+      const response = await this.#client.im.messageReaction.create({
+        path: {
+          message_id: messageId
+        },
+        data: {
+          reaction_type: {
+            emoji_type: REACTION_TYPING
+          }
+        }
+      });
+      const reactionId = response.data?.reaction_id;
+      if (reactionId) {
+        this.#typingReactionByChatId.set(chatId, { messageId, reactionId });
+      }
+    } catch (error) {
+      this.#logger.debug(`failed to add typing reaction (chatId=${chatId} messageId=${messageId})`, error);
+    }
+  }
+  async stopTyping(chatId) {
+    const entry = this.#typingReactionByChatId.get(chatId);
+    if (!entry) {
+      return;
+    }
+    this.#typingReactionByChatId.delete(chatId);
+    try {
+      await this.#client.im.messageReaction.delete({
+        path: {
+          message_id: entry.messageId,
+          reaction_id: entry.reactionId
+        }
+      });
+    } catch (error) {
+      this.#logger.debug(
+        `failed to remove typing reaction (chatId=${chatId} messageId=${entry.messageId})`,
+        error
+      );
+    }
+  }
+  async #handleMessage(message) {
+    if (!message.content && message.resources.length === 0) {
+      this.#logger.debug(`dropping message with no content or resources (messageId=${message.messageId})`);
+      return;
+    }
+    let text2 = message.content ?? "";
+    for (const resource of message.resources) {
+      if (resource.type === "sticker") continue;
+      const localPath = await this.downloadResource(
+        message.messageId,
+        resource.fileKey,
+        resource.type,
+        resource.fileName
+      );
+      if (localPath) {
+        text2 += `
+[Received ${resource.type}: ${localPath}]`;
+      }
+    }
+    await this.#onMessage?.({
+      chatId: message.chatId,
+      chatType: message.chatType,
+      messageId: message.messageId,
+      text: text2,
+      mentionedBot: message.mentionedBot,
+      raw: message.raw
+    });
+  }
+};
+
+// src/modules/client/feishu/adapter/feishu-session.ts
+function buildFeishuSessionId(chatType, chatId) {
+  if (!chatId) {
+    throw new Error("chatId is required");
+  }
+  if (chatType === "p2p" || chatType === "dm") {
+    return `feishu:dm:${chatId}`;
+  }
+  if (chatType === "group") {
+    return `feishu:group:${chatId}`;
+  }
+  throw new Error(`Unsupported Feishu chat type: ${chatType}`);
+}
+function parseFeishuSessionId(clientSessionId) {
+  if (clientSessionId.startsWith("feishu:dm:")) {
+    return { platform: "feishu", chatType: "dm", chatId: clientSessionId.slice("feishu:dm:".length) };
+  }
+  if (clientSessionId.startsWith("feishu:group:")) {
+    return { platform: "feishu", chatType: "group", chatId: clientSessionId.slice("feishu:group:".length) };
+  }
+  throw new Error(`Unsupported clientSessionId: ${clientSessionId}`);
+}
+
+// src/modules/client/feishu/adapter/feishu-im-adapter.ts
+var MAX_TEXT_CHUNK = 4e3;
+function chunkText(text2, maxLen) {
+  if (text2.length <= maxLen) return [text2];
+  const chunks = [];
+  let remaining = text2;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLen) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitPos = remaining.lastIndexOf("\n", maxLen);
+    if (splitPos <= 0) {
+      splitPos = remaining.lastIndexOf(" ", maxLen);
+    }
+    if (splitPos <= 0) {
+      chunks.push(remaining.slice(0, maxLen));
+      remaining = remaining.slice(maxLen);
+      continue;
+    }
+    chunks.push(remaining.slice(0, splitPos + 1));
+    remaining = remaining.slice(splitPos + 1);
+  }
+  return chunks.filter((chunk) => chunk.length > 0);
+}
+var FeishuIMAdapter = class _FeishuIMAdapter {
+  #config;
+  #logger;
+  #onOutput = null;
+  #client = null;
+  #egressQueue = [];
+  #processing = false;
+  #lastInboundMessageIdBySession = /* @__PURE__ */ new Map();
+  #progressStateBySession = /* @__PURE__ */ new Map();
+  static buildProgressCard(lines, _status, collapsedCount = 0) {
+    return {
+      schema: "2.0",
+      body: {
+        elements: [
+          {
+            tag: "markdown",
+            content: _FeishuIMAdapter.progressBody(lines, collapsedCount)
+          }
+        ]
+      }
+    };
+  }
+  static progressBody(lines, collapsedCount) {
+    const contentLines = [];
+    if (collapsedCount > 0) {
+      contentLines.push(`- Collapsed ${collapsedCount} earlier updates.`);
+    }
+    if (lines.length > 0) {
+      contentLines.push(...lines);
+    }
+    return contentLines.length > 0 ? contentLines.join("\n") : "No progress yet.";
+  }
+  async #notifySendFailure(chatId, error) {
+    if (!this.#client) {
+      return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const text2 = `[agent-bridge error] Message delivery failed
+
+${message}`;
+    try {
+      await this.#client.sendText(chatId, text2);
+    } catch (notifyError) {
+      this.#logger.error("failed to notify send failure:", notifyError);
+    }
+  }
+  constructor(config, logger3 = createLogger("feishu")) {
+    this.#config = config;
+    this.#logger = logger3;
+  }
+  async start(onOutput) {
+    this.#onOutput = onOutput;
+    this.#client = new FeishuClient(this.#config, this.#logger);
+    this.#client.setOnMessage(async ({ chatId, chatType, text: text2, messageId, mentionedBot }) => {
+      if (!this.#onOutput) {
+        this.#logger.warn(`dropping inbound message, adapter not ready (chatId=${chatId})`);
+        return;
+      }
+      const clientSessionId = buildFeishuSessionId(chatType, chatId);
+      if (chatType === "group" && (this.#config.requireMentionInGroup ?? true) && !mentionedBot) {
+        this.#logger.debug(
+          `ignoring group message without bot mention (session=${clientSessionId} messageId=${messageId})`
+        );
+        return;
+      }
+      this.#lastInboundMessageIdBySession.set(clientSessionId, messageId);
+      this.#resetProgressState(clientSessionId);
+      await this.#client?.startTyping(chatId, messageId);
+      const normalizedText = text2.trim();
+      if (normalizedText === "/new") {
+        this.#logger.info(`received command /new (session=${clientSessionId})`);
+        await this.#onOutput({
+          type: "command.session.new",
+          clientSessionId
+        });
+        return;
+      }
+      if (normalizedText === "/compact") {
+        this.#logger.info(`received command /compact (session=${clientSessionId})`);
+        await this.#onOutput({
+          type: "command.session.compact",
+          clientSessionId
+        });
+        return;
+      }
+      if (normalizedText === "/stop") {
+        this.#logger.info(`received command /stop (session=${clientSessionId})`);
+        await this.#onOutput({
+          type: "command.session.stop",
+          clientSessionId
+        });
+        return;
+      }
+      this.#logger.info(`received user message (session=${clientSessionId}): ${normalizedText}`);
+      await this.#onOutput({
+        type: "user.message",
+        clientSessionId,
+        text: text2
+      });
+    });
+    await this.#client.connect();
+    this.#logger.info(`adapter started (domain=${this.#config.domain ?? "feishu"})`);
+  }
+  async stop() {
+    this.#egressQueue.length = 0;
+    if (this.#client) {
+      await this.#client.disconnect();
+      this.#client = null;
+    }
+    this.#processing = false;
+    this.#onOutput = null;
+    this.#logger.info("adapter stopped");
+  }
+  async input(event) {
+    if (!this.#client) {
+      throw new Error("FeishuIMAdapter is not started");
+    }
+    this.#egressQueue.push(event);
+    this.#logger.debug(
+      `egress event queued (session=${event.clientSessionId} queueDepth=${this.#egressQueue.length})`
+    );
+    void this.#drainEgressQueue();
+  }
+  async isBusy() {
+    return this.#processing || this.#egressQueue.length > 0;
+  }
+  async #drainEgressQueue() {
+    if (this.#processing) {
+      return;
+    }
+    this.#processing = true;
+    try {
+      while (this.#client && this.#egressQueue.length > 0) {
+        const event = this.#egressQueue.shift();
+        if (!event) continue;
+        try {
+          const target = parseFeishuSessionId(event.clientSessionId);
+          if (event.type !== "assistant.message") {
+            await this.#handleProgressEvent(target.chatId, event);
+            continue;
+          }
+          const replyToMessageId = this.#lastInboundMessageIdBySession.get(event.clientSessionId);
+          this.#logger.info(`sending reply (session=${event.clientSessionId})`);
+          if (event.text.trim().length > 0) {
+            const chunks = chunkText(event.text, MAX_TEXT_CHUNK);
+            for (const [index, chunk] of chunks.entries()) {
+              await this.#client.sendText(target.chatId, chunk, index === 0 ? replyToMessageId : void 0);
+            }
+          }
+          for (const attachment of event.attachments ?? []) {
+            try {
+              await this.#client.sendAttachment(target.chatId, attachment, replyToMessageId);
+            } catch (attachmentError) {
+              this.#logger.error("failed to send attachment:", attachmentError);
+              await this.#notifySendFailure(target.chatId, attachmentError);
+            }
+          }
+          await this.#client.stopTyping(target.chatId);
+          this.#logger.debug(`reply sent (session=${event.clientSessionId})`);
+        } catch (error) {
+          this.#logger.error("failed to send egress event:", error);
+          try {
+            const target = parseFeishuSessionId(event.clientSessionId);
+            await this.#client.stopTyping(target.chatId);
+            await this.#notifySendFailure(target.chatId, error);
+          } catch (notifyError) {
+            this.#logger.error("failed to handle egress send failure:", notifyError);
+          }
+        }
+      }
+    } finally {
+      this.#processing = false;
+    }
+  }
+  async #handleProgressEvent(chatId, event) {
+    if (!this.#client) {
+      return;
+    }
+    if (!this.#shouldRenderProgressEvent(event)) {
+      return;
+    }
+    const state = this.#progressStateBySession.get(event.clientSessionId) ?? {
+      messageId: null,
+      creating: false,
+      lines: [],
+      status: "running",
+      turnId: 0,
+      collapsedCount: 0
+    };
+    state.lines.push(this.#formatProgressLine(event));
+    if (state.lines.length > 10) {
+      state.collapsedCount += state.lines.length - 10;
+      state.lines.splice(0, state.lines.length - 10);
+    }
+    state.status = this.#progressStatus(event);
+    this.#progressStateBySession.set(event.clientSessionId, state);
+    const card = _FeishuIMAdapter.buildProgressCard(state.lines, state.status, state.collapsedCount);
+    if (state.messageId) {
+      await this.#client.updateCard(state.messageId, card);
+      return;
+    }
+    if (state.creating) {
+      return;
+    }
+    state.creating = true;
+    try {
+      state.messageId = await this.#client.sendCard(
+        chatId,
+        card,
+        this.#lastInboundMessageIdBySession.get(event.clientSessionId)
+      );
+    } finally {
+      state.creating = false;
+    }
+  }
+  #shouldRenderProgressEvent(event) {
+    return event.type !== "assistant.thinking";
+  }
+  #resetProgressState(clientSessionId) {
+    const previous = this.#progressStateBySession.get(clientSessionId);
+    this.#progressStateBySession.set(clientSessionId, {
+      messageId: null,
+      creating: false,
+      lines: [],
+      status: "running",
+      turnId: (previous?.turnId ?? 0) + 1,
+      collapsedCount: 0
+    });
+  }
+  #formatProgressLine(event) {
+    switch (event.type) {
+      case "assistant.thinking":
+        return "";
+      case "session.compacting":
+        return `- Compacting session${event.text ? `: ${event.text}` : ""}`;
+      case "assistant.tool.running":
+        return `- Running ${event.toolName}`;
+      case "assistant.tool.done":
+        return `- Finished ${event.toolName}`;
+      case "assistant.tool.error":
+        return this.#formatToolErrorLine(event.toolName, event.text);
+    }
+  }
+  #formatToolErrorLine(toolName, text2) {
+    const normalizedText = text2?.trim();
+    if (!normalizedText) {
+      return `- ${this.#humanizeToolError(toolName)}`;
+    }
+    const lowerText = normalizedText.toLowerCase();
+    const lowerToolName = toolName.toLowerCase();
+    if (lowerText === lowerToolName || lowerText === `failed ${lowerToolName}`) {
+      return `- ${this.#humanizeToolError(toolName)}`;
+    }
+    return `- ${this.#humanizeToolError(toolName)}: ${normalizedText}`;
+  }
+  #humanizeToolError(toolName) {
+    return `Failed ${toolName}`;
+  }
+  #progressStatus(event) {
+    switch (event.type) {
+      case "assistant.tool.error":
+        return "error";
+      case "assistant.tool.done":
+        return "done";
+      default:
+        return "running";
+    }
+  }
+};
+
+// src/modules/client/feishu/index.ts
+function createFeishuConfigCollector() {
+  return {
+    async collect(ctx) {
+      const appId = await ctx.input("Feishu App ID", {
+        required: true,
+        validate: (value) => value ? null : "App ID is required"
+      });
+      const appSecret = await ctx.input("Feishu App Secret", {
+        required: true,
+        secret: true,
+        validate: (value) => value ? null : "App Secret is required"
+      });
+      const domain = await ctx.select("Feishu domain", [
+        { label: "Feishu (default)", value: "feishu" },
+        { label: "Lark", value: "lark" }
+      ]);
+      const requireMentionInGroup = await ctx.confirm("Require @mention in group chats", true);
+      return {
+        appId,
+        appSecret,
+        domain,
+        requireMentionInGroup
+      };
+    },
+    validate(config) {
+      if (!config.appId.trim()) {
+        throw new Error("Feishu appId is required");
+      }
+      if (!config.appSecret.trim()) {
+        throw new Error("Feishu appSecret is required");
+      }
+      if (config.domain && !["feishu", "lark"].includes(config.domain)) {
+        throw new Error("Feishu domain must be feishu or lark");
+      }
+    },
+    summarize(config) {
+      const masked = config.appId.length > 8 ? `${config.appId.slice(0, 4)}****${config.appId.slice(-4)}` : "****";
+      return `type=feishu appId=${masked} domain=${config.domain ?? "feishu"} requireMentionInGroup=${config.requireMentionInGroup ?? true}`;
+    }
+  };
+}
+var feishuClientModule = {
+  type: "feishu",
+  createConfigCollector: createFeishuConfigCollector,
+  createClientAdapter(config) {
+    return new FeishuIMAdapter(config);
+  }
+};
+
+// src/modules/client/index.ts
+var registry2 = /* @__PURE__ */ new Map([
+  [feishuClientModule.type, feishuClientModule]
+]);
+function listClientModules() {
+  return [...registry2.values()];
+}
+function getClientModule(type) {
+  return registry2.get(type);
+}
+function getTypedClientModule(config) {
+  const module = registry2.get(config.type);
+  if (!module) {
+    throw new Error(`Unsupported client module type: ${config.type}`);
+  }
+  return module;
+}
+
+// src/core/channel-runner.ts
+var logger2 = createLogger("runner");
+async function runChannel({ channelName, channelConfig, defaults }) {
+  const clientModule = getTypedClientModule(channelConfig.client);
+  const agentModule = getTypedAgentModule(channelConfig.agent);
+  const imAdapter = clientModule.createClientAdapter(channelConfig.client.config);
+  const bindingStore = createFileSessionBindingStore(getSessionBindingStorePath(channelName));
+  const core = new GatewayCore({
+    imAdapter,
+    agentModule,
+    agentConfig: channelConfig.agent.config,
+    agentIdleTimeoutMs: defaults.agentIdleTimeoutMs,
+    bindingStore
+  });
+  await core.start();
+  logger2.info(`channel ${channelName} started`);
+  logger2.info("press Ctrl+C to stop");
+  return {
+    async stop() {
+      await core.stop();
+      logger2.info(`channel ${channelName} stopped`);
+    }
+  };
+}
+
+// src/cli.ts
+async function selectModuleType(label, modules, ctx) {
+  if (modules.length === 0) {
+    throw new Error(`No modules available for ${label}`);
+  }
+  return ctx.select(
+    label,
+    modules.map((module) => ({
+      label: module.type,
+      value: module.type
+    }))
+  );
+}
+async function collectModuleConfig(module, ctx) {
+  const collector = module.createConfigCollector?.();
+  if (!collector) {
+    return {};
+  }
+  const config = await collector.collect(ctx);
+  await collector.validate(config);
+  return config;
+}
+async function addChannel(config) {
+  const ctx = createPromptContext();
+  try {
+    const name = await ctx.input("Channel name", {
+      required: true,
+      validate: (value) => {
+        if (!value) return "Channel name is required";
+        if (config.channels[value]) return "Channel name already exists";
+        return null;
+      }
+    });
+    const clientType = await selectModuleType("Select client module", listClientModules(), ctx);
+    const clientModule = getClientModule(clientType);
+    if (!clientModule) {
+      throw new Error(`No client module for type: ${clientType}`);
+    }
+    const clientConfig = await collectModuleConfig(clientModule, ctx);
+    const agentType = await selectModuleType("Select agent module", listAgentModules(), ctx);
+    const agentModule = getAgentModule(agentType);
+    if (!agentModule) {
+      throw new Error(`No agent module for type: ${agentType}`);
+    }
+    const agentConfig = await collectModuleConfig(agentModule, ctx);
+    config.channels[name] = {
+      client: {
+        type: clientType,
+        config: clientConfig
+      },
+      agent: {
+        type: agentType,
+        config: agentConfig
+      }
+    };
+    await saveConfig(config);
+    console.log(`Saved channel ${name} to ${getConfigPath()}`);
+  } finally {
+    ctx.close();
+  }
+}
+function summarizeClient(module, channel) {
+  const summary = module?.createConfigCollector?.()?.summarize?.(channel.client.config);
+  return summary ?? `type=${channel.client.type}`;
+}
+function summarizeAgent(module, channel) {
+  const summary = module?.createConfigCollector?.()?.summarize?.(channel.agent.config);
+  return summary ?? `type=${channel.agent.type}`;
+}
+async function listChannels() {
+  const config = await loadConfig();
+  const names = Object.keys(config.channels).sort();
+  if (names.length === 0) {
+    console.log("No channels configured.");
+    return;
+  }
+  for (const name of names) {
+    const channel = config.channels[name];
+    const clientModule = getClientModule(channel.client.type);
+    const agentModule = getAgentModule(channel.agent.type);
+    const clientSummary = summarizeClient(clientModule, channel);
+    const agentSummary = summarizeAgent(agentModule, channel);
+    console.log(`${name}	client(${clientSummary})	agent(${agentSummary})`);
+  }
+}
+async function removeChannel(channelName) {
+  const config = await loadConfig();
+  if (!config.channels[channelName]) {
+    throw new Error(`Unknown channel: ${channelName}`);
+  }
+  delete config.channels[channelName];
+  await saveConfig(config);
+  await removeSessionBindingStore(channelName);
+  console.log(`Removed channel ${channelName}`);
+}
+async function startChannel(channelName) {
+  const config = await loadConfig();
+  const channelConfig = config.channels[channelName];
+  if (!channelConfig) {
+    throw new Error(`Unknown channel: ${channelName}`);
+  }
+  const runner = await runChannel({
+    channelName,
+    channelConfig,
+    defaults: config.defaults
+  });
+  let stopping = false;
+  const stop = async () => {
+    if (stopping) return;
+    stopping = true;
+    await runner.stop();
+    process2.exit(0);
+  };
+  process2.on("SIGINT", () => {
+    void stop();
+  });
+  process2.on("SIGTERM", () => {
+    void stop();
+  });
+  await new Promise(() => {
+  });
+}
+async function runCli(argv = process2.argv) {
+  const program = new Command();
+  program.name("agent-bridge").description("IM to Pi bridge CLI").version("0.1.0");
+  program.command("add").description("Interactively add a channel").action(async () => {
+    const config = await loadConfig();
+    await addChannel(config);
+  });
+  program.command("ls").description("List configured channels").action(async () => {
+    await listChannels();
+  });
+  program.command("remove").description("Remove a channel").argument("<channel-name>").action(async (channelName) => {
+    await removeChannel(channelName);
+  });
+  program.command("start").description("Start a configured channel").argument("<channel-name>").action(async (channelName) => {
+    await startChannel(channelName);
+  });
+  await program.parseAsync(argv);
+}
+
+// bin/agent-bridge.ts
+runCli().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});