lark-coding-assistant 0.1.1

package/dist/cli.js

@@ -0,0 +1,963 @@
+// src/cli.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { access, readFile as readFile3 } from "fs/promises";
+import { spawn as spawn3 } from "child_process";
+import { fileURLToPath } from "url";
+import { resolve } from "path";
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import { registerApp } from "@larksuite/channel";
+import qrcode from "qrcode-terminal";
+
+// src/core/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function resolveAppPaths(root = process.env.LARK_CODING_ASSISTANT_HOME) {
+  const base = root || join(homedir(), ".lark-coding-assistant");
+  return {
+    root: base,
+    config: join(base, "config.json"),
+    secrets: join(base, "secrets.json"),
+    state: join(base, "state.json"),
+    logsDir: join(base, "logs"),
+    logFile: join(base, "logs", "assistant.log"),
+    runtimeDir: join(base, "runtime"),
+    socket: join(base, "runtime", "daemon.sock"),
+    pid: join(base, "runtime", "daemon.pid")
+  };
+}
+
+// src/core/store.ts
+import { randomBytes, scryptSync, timingSafeEqual } from "crypto";
+import { chmod as chmod2, mkdir as mkdir2 } from "fs/promises";
+
+// src/core/model.ts
+function emptyState(now = Date.now()) {
+  return { schemaVersion: 2, sessions: {}, updatedAt: now };
+}
+
+// src/core/atomic-json.ts
+import { chmod, mkdir, open, readFile, rename } from "fs/promises";
+import { dirname } from "path";
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function writeJsonAtomic(path, value, mode = 384) {
+  const parent = dirname(path);
+  await mkdir(parent, { recursive: true, mode: 448 });
+  await chmod(parent, 448).catch(() => void 0);
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  const file = await open(temporary, "w", mode);
+  try {
+    await file.writeFile(`${JSON.stringify(value, null, 2)}
+`, "utf8");
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+  await rename(temporary, path);
+  await chmod(path, mode);
+}
+
+// src/core/store.ts
+var AppStore = class {
+  constructor(paths2) {
+    this.paths = paths2;
+  }
+  paths;
+  async ensure() {
+    await mkdir2(this.paths.root, { recursive: true, mode: 448 });
+    await mkdir2(this.paths.runtimeDir, { recursive: true, mode: 448 });
+    await mkdir2(this.paths.logsDir, { recursive: true, mode: 448 });
+    await Promise.all([
+      chmod2(this.paths.root, 448),
+      chmod2(this.paths.runtimeDir, 448),
+      chmod2(this.paths.logsDir, 448)
+    ]);
+  }
+  loadConfig() {
+    return readJson(this.paths.config);
+  }
+  saveConfig(config) {
+    return writeJsonAtomic(this.paths.config, config);
+  }
+  loadSecrets() {
+    return readJson(this.paths.secrets);
+  }
+  saveSecrets(secrets) {
+    return writeJsonAtomic(this.paths.secrets, secrets);
+  }
+  async loadState() {
+    return await readJson(this.paths.state) ?? emptyState();
+  }
+  saveState(state) {
+    return writeJsonAtomic(this.paths.state, state);
+  }
+};
+
+// src/platform/process.ts
+import { execFile, spawn } from "child_process";
+function runFile(file, args, options = {}) {
+  return new Promise((resolve2, reject) => {
+    execFile(
+      file,
+      [...args],
+      {
+        cwd: options.cwd,
+        timeout: options.timeoutMs ?? 1e4,
+        encoding: "utf8",
+        maxBuffer: 4 * 1024 * 1024
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(Object.assign(error, { stdout, stderr }));
+          return;
+        }
+        resolve2({ stdout, stderr });
+      }
+    );
+  });
+}
+
+// src/daemon/client.ts
+import { randomUUID } from "crypto";
+import { createConnection } from "net";
+function requestDaemon(socketPath, request, timeoutMs = 5e3) {
+  return new Promise((resolve2, reject) => {
+    const id = randomUUID();
+    const socket = createConnection(socketPath);
+    let buffer = "";
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(new Error("daemon request timed out"));
+    }, timeoutMs);
+    socket.setEncoding("utf8");
+    socket.once("connect", () => socket.write(`${JSON.stringify({ ...request, id })}
+`));
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const newline = buffer.indexOf("\n");
+      if (newline === -1) return;
+      clearTimeout(timer);
+      socket.destroy();
+      try {
+        resolve2(JSON.parse(buffer.slice(0, newline)));
+      } catch (error) {
+        reject(error);
+      }
+    });
+    socket.once("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+
+// src/agents/resume.ts
+function resolveResumeOption(options) {
+  const modes = [options.resume !== void 0, options.resumeLast, options.resumeAll].filter(Boolean).length;
+  if (modes > 1) throw new Error("--resume, --resume-last, and --resume-all cannot be used together");
+  if (options.resumeLast) return { mode: "last" };
+  if (options.resumeAll) return { mode: "picker", all: true };
+  if (typeof options.resume === "string") return { mode: "session", sessionId: options.resume };
+  if (options.resume) return { mode: "picker" };
+  return void 0;
+}
+function resumeArgs(resume) {
+  if (!resume) return [];
+  if (resume.mode === "last") return ["resume", "--last"];
+  if (resume.mode === "session") return ["resume", resume.sessionId];
+  return resume.all ? ["resume", "--all"] : ["resume"];
+}
+function claudeResumeArgs(resume) {
+  if (!resume) return [];
+  if (resume.mode === "last") return ["--continue"];
+  if (resume.mode === "session") return ["--resume", resume.sessionId];
+  return ["--resume"];
+}
+
+// src/screen/detector.ts
+import { createHash } from "crypto";
+
+// src/screen/normalize.ts
+var ANSI = /\u001b(?:\][^\u0007]*(?:\u0007|\u001b\\)|\[[0-?]*[ -/]*[@-~]|[@-_])/g;
+function stripAnsi(raw) {
+  return raw.replace(ANSI, "");
+}
+function normalizeScreen(raw) {
+  return stripAnsi(raw).replace(/\r/g, "").split("\n").map((line) => line.replace(/\u00a0|\u3000/g, " ").replace(/\t/g, "  ").replace(/ +$/g, "")).filter((line, index, all) => line !== "" || all[index - 1] !== "").join("\n").trim();
+}
+
+// src/screen/dialects.ts
+var commonHeaders = [
+  /^\s*(?:Would you like to|Do you want to|Approval required|Allow command|.*requires approval)/i
+];
+var commonFooters = [
+  /(?:press\s+)?enter\s+to\s+(?:confirm|submit(?:\s+answer)?|select|choose|continue)/i,
+  /esc\s+to\s+cancel.*(?:tab\s+to\s+amend|ctrl\+e\s+to\s+explain)/i
+];
+var CODEX_DIALECT = {
+  id: "codex",
+  headerPatterns: [...commonHeaders, /^\s*Question\s+\d+\/\d+/i],
+  footerPatterns: commonFooters,
+  submitControls: [/^(?:submit|confirm)$/i],
+  customInputControls: [/^(?:type something|none of the above|add notes)$/i],
+  chatControls: [/^chat about this$/i]
+};
+var TRAE_DIALECT = {
+  ...CODEX_DIALECT,
+  id: "trae-cli",
+  headerPatterns: [...commonHeaders, /^\s*Question\s+\d+\/\d+/i],
+  customInputControls: [/^(?:other|none of the above|add notes)$/i]
+};
+var CLAUDE_DIALECT = {
+  id: "claude-code",
+  headerPatterns: [
+    ...commonHeaders,
+    /^\s*(?:←\s*)?[☐☑☒]\s+.+?(?:\s+✔\s+Submit\s*→)?\s*$/i,
+    /^\s*[☐☑☒]\s+\S/
+  ],
+  footerPatterns: commonFooters,
+  footerlessChoiceHeaders: [/^ready to submit your answers\?$/i],
+  submitControls: [/^(?:submit|confirm)$/i],
+  customInputControls: [/^(?:type(?:\s+.+)?|add notes)\.?$/i, /^notes:\s*press\s+n\s+to\s+add\b/i],
+  directInputControls: [/^type(?:\s+.+)?\.?$/i],
+  customInputValuePattern: /^type\s+(.+?)\.?$/i,
+  chatControls: [/^chat about this$/i]
+};
+
+// src/screen/detector.ts
+function detectCodexScreen(raw, paneAlive = true, cursor) {
+  return detectAgentScreen(raw, paneAlive, {
+    brandPattern: /OpenAI Codex|codex/i,
+    brandEvidence: "codex",
+    failurePattern: /fatal error|panicked at|segmentation fault|codex exited/i,
+    dialect: CODEX_DIALECT
+  }, cursor);
+}
+function detectTraeScreen(raw, paneAlive = true, cursor) {
+  return detectAgentScreen(raw, paneAlive, {
+    brandPattern: /TraeCode CLI|traecli/i,
+    brandEvidence: "trae-cli",
+    failurePattern: /fatal error|panicked at|segmentation fault|traecli exited/i,
+    dialect: TRAE_DIALECT
+  }, cursor);
+}
+function detectClaudeScreen(raw, paneAlive = true, cursor) {
+  return detectAgentScreen(raw, paneAlive, {
+    brandPattern: /Claude Code/i,
+    brandEvidence: "claude-code",
+    failurePattern: /fatal error|segmentation fault|Claude Code exited/i,
+    dialect: CLAUDE_DIALECT
+  }, cursor);
+}
+function detectAgentScreen(raw, paneAlive, options, cursor) {
+  const normalized = normalizeScreen(raw);
+  const lines = normalized.split("\n").slice(-80);
+  const tail = lines.join("\n");
+  const bottom = lines.slice(-16);
+  const bottomTail = bottom.join("\n");
+  const fingerprint = createHash("sha256").update(tail).digest("hex");
+  if (!paneAlive) return result("exited", 1, normalized, fingerprint, ["pane exited"]);
+  if (options.failurePattern.test(bottomTail)) {
+    return result("failed", 0.95, normalized, fingerprint, matching(bottom, /fatal|panic|exited/i));
+  }
+  const choice = parseChoiceInteraction(lines.slice(-60), options.dialect);
+  if (choice) {
+    const choiceFingerprint = choice.interaction?.interactionId ?? createHash("sha256").update(choice.evidence.join("\n")).digest("hex");
+    return { ...choice, normalized, fingerprint: choiceFingerprint, hasDraftInput: false };
+  }
+  const inputEvidence = matching(bottom, /(?:select an option|choose one|enter your answer|provide .*input|request_user_input|do you trust|trust the contents)/i);
+  if (inputEvidence.length > 0) return result("input", 0.72, normalized, fingerprint, inputEvidence);
+  const activeRunningPattern = /(?:model:\s+loading|esc to interrupt|running\s+.+?hooks?|^\s*[•◦◆◇◈✦✻▍]?\s*(?:working|thinking|executing)(?:…|\s*\(|$))/i;
+  const activeRunningEvidence = matching(bottom, activeRunningPattern);
+  if (activeRunningEvidence.length > 0) return result("running", 0.85, normalized, fingerprint, activeRunningEvidence);
+  const runningPattern = /(?:waiting for)/i;
+  const runningEvidence = matching(bottom, runningPattern);
+  const lastRunningIndex = lastMatchingIndex(bottom, runningPattern);
+  const lastPromptIndex = lastMatchingIndex(bottom, /^\s*[›>❯]\s?/);
+  if (lastRunningIndex > lastPromptIndex) return result("running", 0.75, normalized, fingerprint, runningEvidence);
+  const promptLines = bottom.slice(-4).filter((line) => /^\s*[›>❯]\s?/.test(line));
+  if (promptLines.length > 0) {
+    const last = promptLines.at(-1) ?? "";
+    const content = last.replace(/^\s*[›>❯]\s?/, "").trim();
+    const rawPrompt = raw.split("\n").filter((line) => /^\s*[›>❯]\s?/.test(stripAnsi(line))).at(-1) ?? "";
+    const draft = content.length > 0 && !promptContentIsDim(rawPrompt) && !cursorIsAtPromptStart(rawPrompt, cursor?.x);
+    return { ...result("idle", 0.8, normalized, fingerprint, [last]), hasDraftInput: draft };
+  }
+  if (runningEvidence.length > 0) return result("running", 0.75, normalized, fingerprint, runningEvidence);
+  if (options.brandPattern.test(tail)) {
+    return result("starting", 0.55, normalized, fingerprint, [options.brandEvidence]);
+  }
+  return result("unknown", 0.2, normalized, fingerprint, []);
+}
+function cursorIsAtPromptStart(rawLine, cursorX) {
+  if (cursorX === void 0) return false;
+  const visible = stripAnsi(rawLine);
+  const marker = visible.search(/[›>❯]/);
+  if (marker === -1) return false;
+  let contentStart = marker + 1;
+  while (/\s/.test(visible[contentStart] ?? "")) contentStart += 1;
+  return cursorX === contentStart;
+}
+function promptContentIsDim(rawLine) {
+  let dim = false;
+  let visible = "";
+  const dimAt = [];
+  const sgr = /\u001b\[([0-9;]*)m/g;
+  let cursor = 0;
+  for (const match of rawLine.matchAll(sgr)) {
+    const index = match.index ?? cursor;
+    const text = rawLine.slice(cursor, index);
+    visible += text;
+    dimAt.push(...Array.from(text, () => dim));
+    const params = (match[1] || "0").split(";").map(Number);
+    if (params.includes(0)) dim = false;
+    if (params.includes(2)) dim = true;
+    if (params.includes(22)) dim = false;
+    cursor = index + match[0].length;
+  }
+  const rest = rawLine.slice(cursor);
+  visible += rest;
+  dimAt.push(...Array.from(rest, () => dim));
+  const marker = visible.search(/[›>❯]/);
+  if (marker === -1) return false;
+  let contentStart = marker + 1;
+  while (/\s/.test(visible[contentStart] ?? "")) contentStart += 1;
+  const contentEnd = visible.trimEnd().length;
+  return contentEnd > contentStart && dimAt.slice(contentStart, contentEnd).every(Boolean);
+}
+function parseChoiceInteraction(lines, dialect) {
+  const explicitFooterIndex = lastMatchingIndex(lines, new RegExp(dialect.footerPatterns.map(({ source }) => `(?:${source})`).join("|"), "i"));
+  const footerlessHeaderIndex = dialect.footerlessChoiceHeaders ? lastMatchingIndex(lines, new RegExp(dialect.footerlessChoiceHeaders.map(({ source }) => `(?:${source})`).join("|"), "i")) : -1;
+  if (explicitFooterIndex === -1 && footerlessHeaderIndex === -1) return void 0;
+  const footerIndex = explicitFooterIndex >= 0 ? explicitFooterIndex : lines.length;
+  if (explicitFooterIndex >= 0 && lines.slice(footerIndex + 1).some((line) => /^\s*[›>❯]\s?/.test(line))) return void 0;
+  const allStarts = lines.slice(0, footerIndex).map((line, index) => choiceOptionStart(line) ? index : -1).filter((index) => index >= 0);
+  if (allStarts.length < 2) return void 0;
+  const optionStarts = latestOptionGroup(allStarts);
+  if (optionStarts.length < 2) return void 0;
+  if (explicitFooterIndex === -1 && (optionStarts[0] ?? -1) <= footerlessHeaderIndex) return void 0;
+  const firstOption = optionStarts[0] ?? 0;
+  const beforeOptions = lines.slice(0, firstOption);
+  const knownHeader = lastMatchingIndex(beforeOptions, new RegExp(dialect.headerPatterns.map(({ source }) => `(?:${source})`).join("|"), "i"));
+  const hardBoundary = lastMatchingIndex(beforeOptions, /^(?:\s*[-─━═]{8,}\s*|\s*[›>❯]\s+.+|\s*[✻◆◦•]\s+.+)$/);
+  const contextStart = knownHeader > hardBoundary ? knownHeader : hardBoundary >= 0 ? hardBoundary + 1 : Math.max(0, firstOption - 12);
+  const context = lines.slice(contextStart, firstOption).filter((line) => Boolean(line) && !/^\s*[-─━═]{8,}\s*$/.test(line));
+  const footer = lines[footerIndex] ?? "";
+  const indexedActions = optionStarts.flatMap((start, optionIndex) => {
+    const firstLine = lines[start] ?? "";
+    const parsed = parseChoiceOptionLine(firstLine);
+    if (!parsed) return [];
+    const end = optionStarts[optionIndex + 1] ?? footerIndex;
+    const rawLabel = parsed.label;
+    const marker = selectionMarker(parsed.marker);
+    const segments = [
+      rawLabel,
+      ...lines.slice(start + 1, end).map((line) => line.trim()).filter((line) => Boolean(line) && !/^[-─━═]{3,}$/.test(line) && !matchesAny(withoutFocusMarker(line), dialect.submitControls) && !isSidePanelLine(line) && !matchesAny(withoutFocusMarker(line), dialect.customInputControls) && !matchesAny(withoutFocusMarker(line), dialect.chatControls) && !/^notes$/i.test(line) && !/^\[[^\]]+\]$/.test(line))
+    ];
+    const shortcutMatch = segments.join(" ").match(/\(([^()\s]{1,16})\)\s*$/);
+    if (shortcutMatch) {
+      const last = segments.length - 1;
+      segments[last] = (segments[last] ?? "").replace(/\s*\([^()\s]{1,16}\)\s*$/, "").trim();
+    }
+    const parts = (segments.shift() ?? "").split(/\s{2,}/).map((part) => part.trim()).filter(Boolean);
+    const label = parts.shift();
+    if (!label) return [];
+    const continuation = segments.join(" ").replace(/\bnotes:\s*press\s+n\s+to\s+add\s+notes\b/gi, "").trim();
+    let description = parts.filter((part) => !isSidePanelLine(part)).join(" ").trim();
+    let fullLabel = label;
+    if (continuation && marker) {
+      description = [description, continuation].filter(Boolean).join(" ");
+    } else if (continuation) {
+      if (description) description = `${description} ${continuation}`;
+      else fullLabel = `${fullLabel} ${continuation}`;
+    }
+    const role = controlRole(fullLabel, dialect);
+    const customValue = role === "custom-input" ? dialect.customInputValuePattern?.exec(fullLabel)?.[1]?.trim() : void 0;
+    const inputValue = customValue && !/^something\.?$/i.test(customValue) ? customValue : void 0;
+    if (role === "custom-input" && /^type\b/i.test(fullLabel)) fullLabel = "Type something";
+    const risk = choiceRisk(`${fullLabel} ${description}`);
+    const editor = role === "custom-input" ? /(?:notes?\s*\(tab\)|tab\s+to\s+(?:add|edit)\s+notes?)/i.test(`${description} ${footer}`) ? { openKey: "Tab", submitKey: "Enter", commitsInteraction: true } : dialect.directInputControls && matchesAny(fullLabel, dialect.directInputControls) ? { submitKey: "Enter", commitsInteraction: true } : void 0 : void 0;
+    return [{ index: start, action: {
+      id: `option-${parsed.key}`,
+      label: fullLabel,
+      key: parsed.key,
+      description: description || void 0,
+      inputValue,
+      shortcut: shortcutMatch?.[1]?.toLowerCase(),
+      editor,
+      focused: parsed.focused,
+      marker,
+      role,
+      risk,
+      danger: risk === "persistent" || risk === "privileged"
+    } }];
+  });
+  const standaloneControls = lines.slice(firstOption, footerIndex).flatMap((line, relativeIndex) => {
+    const visible = line.replace(/^\s*[›>❯]\s*/, "").trim();
+    const role = matchesAny(visible, dialect.submitControls) ? "submit" : matchesAny(visible, dialect.customInputControls) ? "custom-input" : matchesAny(visible, dialect.chatControls) ? "chat" : void 0;
+    if (!role) return [];
+    const id = role === "submit" ? "submit" : role === "chat" ? "chat" : "custom-input";
+    const label = /^notes:/i.test(visible) ? "Add notes" : visible;
+    return [{ index: firstOption + relativeIndex, action: {
+      id,
+      key: id,
+      label,
+      role,
+      shortcut: /^notes:/i.test(visible) ? "n" : void 0,
+      focused: /^\s*[›>❯]/.test(line),
+      risk: "normal",
+      danger: false
+    } }];
+  });
+  const actions = [...indexedActions, ...standaloneControls].sort((left, right) => left.index - right.index).map(({ action }) => action);
+  const submitIndex = actions.findIndex(({ role }) => role === "submit");
+  const inlineCustomIndex = submitIndex - 1;
+  const inlineCustom = actions[inlineCustomIndex];
+  if (inlineCustom?.role === "answer" && (inlineCustom.marker === "checked" || inlineCustom.marker === "unchecked") && !inlineCustom.description && actions.slice(0, inlineCustomIndex).some(({ description, marker }) => Boolean(description && marker))) {
+    const value = inlineCustom.label.trim();
+    inlineCustom.role = "custom-input";
+    inlineCustom.inputValue = /^(?:type something|其他|其它|other)$/i.test(value) ? void 0 : value;
+    inlineCustom.label = "Type something";
+  }
+  if (actions.length < 2 || actions.filter(({ focused }) => focused).length !== 1) return void 0;
+  const kind = classifyChoice(context, actions, footer);
+  const semantics = selectionSemantics(actions, footer);
+  const canonical = actions.map(({ key, label, description, role, editor }) => ({ key, label, description, role, editor }));
+  const identityContext = context.map((line) => line.replace(/([←\s]*)[☐☑☒]/, "$1\u2610"));
+  const interactionId = createHash("sha256").update(JSON.stringify([kind, identityContext, canonical])).digest("hex");
+  const revision = createHash("sha256").update(JSON.stringify([
+    interactionId,
+    actions.map(({ key, marker, inputValue }) => ({ key, marker, inputValue }))
+  ])).digest("hex");
+  const questionContext = context.filter((line) => !matchesAny(line, dialect.headerPatterns));
+  const questionTitle = [...questionContext].reverse().find((line) => /[?？]/.test(line)) ?? questionContext.at(-1);
+  return {
+    state: kind === "approval" ? "approval" : "input",
+    confidence: kind === "question" ? 0.92 : kind === "approval" ? 0.9 : 0.85,
+    evidence: lines.slice(contextStart, footerIndex + 1).filter(Boolean),
+    actions,
+    interaction: {
+      kind,
+      title: questionTitle?.trim() || context[0]?.trim() || "\u8BF7\u9009\u62E9\u4E00\u4E2A\u9009\u9879",
+      context,
+      interactionId,
+      revision,
+      semantics,
+      contentConfidence: knownHeader >= 0 || hardBoundary >= 0 ? 0.95 : 0.65,
+      actionConfidence: semantics ? semantics.confidence : 0.55
+    }
+  };
+}
+function selectionMarker(value) {
+  if (!value) return void 0;
+  if (value === "[ ]" || value === "\u2610") return "unchecked";
+  if (/^\[[xX✓✔]\]$/.test(value) || value === "\u2611") return "checked";
+  if (value === "\u25CB") return "unselected";
+  if (value === "\u25CF") return "selected";
+  return void 0;
+}
+function matchesAny(value, patterns) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+function withoutFocusMarker(value) {
+  return value.replace(/^\s*[›>❯]\s*/, "").trim();
+}
+function isSidePanelLine(value) {
+  return /[│┌┐└┘├┤┬┴┼╔╗╚╝╠╣╦╩╬║═]/.test(value);
+}
+function controlRole(label, dialect) {
+  if (matchesAny(label, dialect.customInputControls)) return "custom-input";
+  if (matchesAny(label, dialect.chatControls)) return "chat";
+  return "answer";
+}
+function selectionSemantics(actions, footer) {
+  const answers = actions.filter(({ role }) => role === "answer");
+  const submit = actions.find(({ role }) => role === "submit");
+  const hasCheckbox = answers.length > 0 && answers.every(({ marker }) => marker === "checked" || marker === "unchecked");
+  const hasRadio = answers.length > 0 && answers.every(({ marker }) => marker === "selected" || marker === "unselected");
+  if (hasCheckbox || hasRadio) {
+    const commit = submit ? { mode: "explicit", controlId: submit.id } : /ctrl\+enter\s+to\s+(?:submit|confirm)/i.test(footer) ? { mode: "key", key: "C-Enter" } : /enter\s+to\s+(?:submit|confirm)(?:\s+answer)?/i.test(footer) ? { mode: "key", key: "Enter" } : void 0;
+    if (!commit) return void 0;
+    const toggleKey = /space\s+to\s+toggle/i.test(footer) ? "Space" : "Enter";
+    return {
+      cardinality: hasCheckbox ? "many" : "one",
+      activation: "toggle",
+      toggleKey,
+      commit,
+      confidence: 0.97,
+      evidence: [hasCheckbox ? "answer controls use checkbox markers" : "answer controls use radio markers", "an explicit commit mechanism exists"]
+    };
+  }
+  if (answers.some(({ marker }) => marker)) return void 0;
+  return {
+    cardinality: "one",
+    activation: "submit",
+    commit: { mode: "immediate" },
+    confidence: 0.9,
+    evidence: ["numbered controls use a single focus marker and no persistent selection markers"]
+  };
+}
+function latestOptionGroup(starts) {
+  const group = [starts.at(-1)];
+  for (let index = starts.length - 2; index >= 0; index -= 1) {
+    const start = starts[index];
+    if (group[0] - start > 8) break;
+    group.unshift(start);
+  }
+  return group;
+}
+function classifyChoice(context, actions, footer) {
+  const contextText = context.join(" ");
+  if (/(?:^|\s)[☐☑☒]\s+\S|Question\s+\d+\/\d+/i.test(contextText) || /submit answer|add notes/i.test(footer)) return "question";
+  const optionText = actions.map(({ label, description }) => `${label} ${description ?? ""}`).join(" ");
+  if (/(?:Would you like to|Do you want to).*(?:run|edit|grant|access)|approval required|allow command|requires approval/i.test(contextText) || /full access|don't ask again|do not ask again|always allow|auto mode|permissions?\b/i.test(optionText)) return "approval";
+  return "choice";
+}
+function choiceOptionStart(line) {
+  return Boolean(parseChoiceOptionLine(line));
+}
+function parseChoiceOptionLine(line) {
+  const match = line.match(/^\s*([›>❯])?\s*(?:(\[[ xX✓✔]\]|[☐☑○●])\s*)?(\d+)[.)]\s+(?:(\[[ xX✓✔]\]|[☐☑○●])\s*)?(.+?)\s*$/);
+  if (!match?.[3] || !match[5]) return void 0;
+  return { focused: Boolean(match[1]), marker: match[2] ?? match[4], key: match[3], label: match[5] };
+}
+function choiceRisk(text) {
+  if (/full access|bypass|without sandbox|dangerously/i.test(text)) return "privileged";
+  if (/always|don't ask again|do not ask again|auto mode|persist/i.test(text)) return "persistent";
+  if (/^\s*no\b|reject|deny|cancel|do differently/i.test(text)) return "reject";
+  return "normal";
+}
+function result(state, confidence, normalized, fingerprint, evidence) {
+  return { state, confidence, normalized, fingerprint, evidence, actions: [], hasDraftInput: false };
+}
+function matching(lines, pattern) {
+  return lines.filter((line) => pattern.test(line)).slice(-4);
+}
+function lastMatchingIndex(lines, pattern) {
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (pattern.test(lines[index] ?? "")) return index;
+  }
+  return -1;
+}
+
+// src/agents/stop-hook.ts
+function codexStyleStopHookArgs(command) {
+  const hook = `{hooks=[{type="command",command=${JSON.stringify(command)},timeout=5}]}`;
+  return ["--dangerously-bypass-hook-trust", "-c", `hooks.Stop=[${hook}]`];
+}
+function claudeStopHookArgs(command) {
+  return ["--settings", JSON.stringify({
+    hooks: {
+      Stop: [{ hooks: [{ type: "command", command, timeout: 5 }] }]
+    }
+  })];
+}
+
+// src/agents/codex.ts
+var codexAdapter = {
+  id: "codex",
+  displayName: "Codex",
+  groupOrder: 10,
+  binary: (config) => config.agentBinaries.codex,
+  versionArgs: ["--version"],
+  buildLaunchArgs: ({ resume, stopHookCommand }) => [
+    ...codexStyleStopHookArgs(stopHookCommand),
+    ...resumeArgs(resume)
+  ],
+  detectScreen: detectCodexScreen
+};
+
+// src/agents/trae-cli.ts
+var traeCliAdapter = {
+  id: "trae-cli",
+  displayName: "Trae CLI",
+  groupOrder: 20,
+  binary: (config) => config.agentBinaries["trae-cli"],
+  versionArgs: ["--version"],
+  buildLaunchArgs: ({ resume, stopHookCommand }) => [
+    ...codexStyleStopHookArgs(stopHookCommand),
+    ...resumeArgs(resume)
+  ],
+  detectScreen: detectTraeScreen
+};
+
+// src/agents/claude-code.ts
+var claudeCodeAdapter = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  groupOrder: 30,
+  binary: (config) => config.agentBinaries["claude-code"],
+  versionArgs: ["--version"],
+  buildLaunchArgs: ({ resume, stopHookCommand }) => [
+    ...claudeStopHookArgs(stopHookCommand),
+    ...claudeResumeArgs(resume)
+  ],
+  detectScreen: detectClaudeScreen
+};
+
+// src/agents/types.ts
+var AGENT_IDS = ["codex", "trae-cli", "claude-code"];
+
+// src/agents/registry.ts
+var adapters = /* @__PURE__ */ new Map([
+  [codexAdapter.id, codexAdapter],
+  [traeCliAdapter.id, traeCliAdapter],
+  [claudeCodeAdapter.id, claudeCodeAdapter]
+]);
+function getAgentAdapter(id) {
+  const adapter = adapters.get(id);
+  if (!adapter) throw new Error(`unsupported coding agent: ${id}`);
+  return adapter;
+}
+function isAgentId(value) {
+  return AGENT_IDS.includes(value);
+}
+
+// src/daemon/lifecycle.ts
+import { mkdir as mkdir3, open as open2, readFile as readFile2 } from "fs/promises";
+import { spawn as spawn2 } from "child_process";
+async function daemonInfo(paths2, timeoutMs = 500) {
+  try {
+    const response = await requestDaemon(paths2.socket, { method: "ping" }, timeoutMs);
+    if (!response.ok) return void 0;
+    return isDaemonInfo(response.value) ? response.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function startDaemonProcess(paths2, daemonEntry, readyTimeoutMs = 5e3) {
+  const existing = await daemonInfo(paths2);
+  if (existing) return existing;
+  await Promise.all([
+    mkdir3(paths2.runtimeDir, { recursive: true, mode: 448 }),
+    mkdir3(paths2.logsDir, { recursive: true, mode: 448 })
+  ]);
+  const log2 = await open2(paths2.logFile, "a", 384);
+  const child = spawn2(process.execPath, [daemonEntry], {
+    detached: true,
+    stdio: ["ignore", log2.fd, log2.fd],
+    env: process.env
+  });
+  let spawnError;
+  child.once("error", (error) => {
+    spawnError = error;
+  });
+  await log2.close();
+  child.unref();
+  const deadline = Date.now() + readyTimeoutMs;
+  while (Date.now() < deadline) {
+    if (spawnError) throw spawnError;
+    await delay(100);
+    const info = await daemonInfo(paths2, 300);
+    if (info) return info;
+  }
+  throw new Error("daemon did not become ready");
+}
+async function stopDaemonProcess(paths2) {
+  const info = await daemonInfo(paths2);
+  if (!info) return stopDaemonByPid(paths2);
+  try {
+    const response = await requestDaemon(paths2.socket, { method: "shutdown" }, 1e3);
+    if (!response.ok) throw new Error(response.error);
+  } catch {
+    signalDaemon(info.pid);
+  }
+  await waitUntilStopped(paths2, info.pid);
+  return true;
+}
+async function stopDaemonByPid(paths2) {
+  const pid = Number.parseInt(await readFile2(paths2.pid, "utf8").catch(() => ""), 10);
+  if (!validPid(pid) || !processIsAlive(pid)) return false;
+  if (!await isCurrentDaemonProcess(pid)) {
+    throw new Error(`PID ${pid} is alive but is not a lark-coding-assistant daemon; refusing to signal it`);
+  }
+  signalDaemon(pid);
+  await waitUntilStopped(paths2, pid);
+  return true;
+}
+async function isCurrentDaemonProcess(pid) {
+  try {
+    const command = (await runFile("ps", ["-p", String(pid), "-o", "command="])).stdout.trim();
+    return command.includes("lark-coding-assistant") && /(?:^|\/)daemon-entry\.js(?:\s|$)/.test(command);
+  } catch {
+    return false;
+  }
+}
+async function waitUntilStopped(paths2, pid) {
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    if (!processIsAlive(pid) && !await daemonInfo(paths2, 200)) return;
+    await delay(100);
+  }
+  throw new Error(`daemon PID ${pid} did not stop within 5 seconds`);
+}
+function signalDaemon(pid) {
+  if (!validPid(pid) || pid === process.pid) throw new Error("refusing to signal invalid daemon PID");
+  process.kill(pid, "SIGTERM");
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+}
+function validPid(pid) {
+  return Number.isInteger(pid) && pid > 1;
+}
+function isDaemonInfo(value) {
+  if (!value || typeof value !== "object") return false;
+  const info = value;
+  return typeof info.version === "string" && typeof info.pid === "number";
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/lark/registration.ts
+var registrationDomains = {
+  domain: "accounts.feishu.cn",
+  larkDomain: "accounts.larksuite.com"
+};
+
+// src/cli.ts
+var program = new Command();
+var paths = resolveAppPaths();
+var store = new AppStore(paths);
+var packageInfo = JSON.parse(
+  await readFile3(new URL("../package.json", import.meta.url), "utf8")
+);
+program.name("lark-coding-assistant").version(packageInfo.version);
+program.command("init").description("Configure Feishu/Lark PersonalAgent").action(runInit);
+program.command("start").option("-n, --name <name>", "Session name", "default").option("--agent <agent>", "Coding agent (codex, trae-cli, or claude-code)", parseAgentId, "codex").option("--cwd <path>", "Coding agent working directory").option("--resume [session-id]", "Resume agent session; omit the ID to open the picker").option("--resume-last", "Resume the most recent agent session in this working directory").option("--resume-all", "Show all agent sessions in the resume picker").action(runStart);
+program.command("attach").argument("[name]", "Session name", "default").description("Attach local terminal to coding-agent tmux session").action(runAttach);
+program.command("bind-code").description("Generate a new one-time Lark binding code").action(runBindCode);
+program.command("status").argument("[name]", "Session name").description("Show daemon and session status").action(runStatus);
+program.command("stop").argument("[name]", "Session name").description("Stop managed coding-agent/tmux session").action(runStop);
+program.command("logs").option("-n, --lines <count>", "Number of lines", "100").action(runLogs);
+program.command("reset-owner").description("Clear persistent Lark owner").action(runResetOwner);
+var daemonCommand = program.command("daemon").description("Manage the Lark bridge daemon");
+daemonCommand.command("start").description("Start the bridge daemon").action(runDaemonStart);
+daemonCommand.command("stop").description("Stop the bridge daemon without stopping coding-agent sessions").action(runDaemonStop);
+daemonCommand.command("restart").description("Restart the bridge daemon without stopping coding-agent sessions").action(runDaemonRestart);
+daemonCommand.command("status").description("Show bridge daemon status and version").action(runDaemonStatus);
+await program.parseAsync();
+async function runInit() {
+  await store.ensure();
+  const tenantAnswer = await p.select({
+    message: "\u9009\u62E9\u5E73\u53F0",
+    options: [
+      { value: "feishu", label: "\u98DE\u4E66" },
+      { value: "lark", label: "Lark" }
+    ]
+  });
+  if (p.isCancel(tenantAnswer)) return p.cancel("\u5DF2\u53D6\u6D88");
+  const tenant = tenantAnswer;
+  p.log.info("\u8BF7\u4F7F\u7528\u98DE\u4E66/Lark \u626B\u63CF\u4E0B\u9762\u7684\u4E8C\u7EF4\u7801\uFF0C\u521B\u5EFA\u6216\u9009\u62E9 PersonalAgent\u3002");
+  const registration = await registerApp({
+    ...registrationDomains,
+    source: "lark-coding-assistant",
+    appPreset: {
+      name: "Coding Assistant",
+      desc: "Bridge local coding-agent tmux sessions to private chat"
+    },
+    addons: {
+      scopes: { tenant: ["im:message", "im:message:send_as_bot"] },
+      events: { items: { tenant: ["im.message.receive_v1"] } },
+      callbacks: { items: ["card.action.trigger"] }
+    },
+    onQRCodeReady: ({ url, expireIn }) => {
+      qrcode.generate(url, { small: true }, (output) => console.log(output));
+      console.log(`\u4E8C\u7EF4\u7801 ${Math.ceil(expireIn / 60)} \u5206\u949F\u5185\u6709\u6548\u3002\u82E5\u7EC8\u7AEF\u65E0\u6CD5\u626B\u7801\uFF0C\u8BF7\u6253\u5F00\uFF1A
+${url}
+`);
+    },
+    onStatusChange: ({ status }) => {
+      if (status === "domain_switched") p.log.info("\u5DF2\u8BC6\u522B\u8D26\u53F7\u57DF\uFF0C\u7B49\u5F85\u5B8C\u6210\u5E94\u7528\u786E\u8BA4\u2026");
+    }
+  });
+  const registeredTenant = registration.user_info?.tenant_brand ?? tenant;
+  const config = {
+    tenant: registeredTenant,
+    appId: registration.client_id,
+    tmuxBinary: "tmux",
+    agentBinaries: { codex: "codex", "trae-cli": "trae-cli", "claude-code": "claude" },
+    pollIntervalMs: 650
+  };
+  const previousState = await store.loadState();
+  const registeredOwnerOpenId = registration.user_info?.open_id;
+  const ownerChanged = Boolean(
+    registeredOwnerOpenId && previousState.ownerOpenId && registeredOwnerOpenId !== previousState.ownerOpenId
+  );
+  await Promise.all([
+    store.saveConfig(config),
+    store.saveSecrets({
+      appSecret: registration.client_secret,
+      callbackSecret: randomBytes2(32).toString("base64url")
+    }),
+    store.saveState({
+      ...previousState,
+      ownerOpenId: registeredOwnerOpenId ?? previousState.ownerOpenId,
+      boundChatId: ownerChanged ? void 0 : previousState.boundChatId,
+      autoBindDisabled: false,
+      updatedAt: Date.now()
+    })
+  ]);
+  p.outro("PersonalAgent \u914D\u7F6E\u5DF2\u4FDD\u5B58\u3002");
+}
+async function runStart(options) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const resume = resolveResumeOption(options);
+  await access(cwd);
+  await ensureInitialized();
+  await preflight(options.agent);
+  await ensureDaemon();
+  const response = await requestDaemon(paths.socket, {
+    method: "start",
+    cwd,
+    sessionId: options.name,
+    agent: options.agent,
+    resume
+  });
+  if (!response.ok) throw new Error(response.error);
+  const value = response.value;
+  if (value.binding.mode === "reused") {
+    console.log("\n\u5DF2\u81EA\u52A8\u6CBF\u7528\u539F\u6709\u98DE\u4E66/Lark \u79C1\u804A\u7ED1\u5B9A\u3002\n");
+  } else if (value.binding.mode === "awaiting-owner-message") {
+    console.log("\n\u6253\u5F00\u98DE\u4E66/Lark \u79C1\u804A\u5E76\u76F4\u63A5\u53D1\u9001\u6D88\u606F\u5373\u53EF\u81EA\u52A8\u8FDE\u63A5\uFF0C\u65E0\u9700\u7ED1\u5B9A\u7801\u3002\n");
+  } else {
+    console.log(`
+\u98DE\u4E66/Lark \u79C1\u804A\u7ED1\u5B9A\u547D\u4EE4\uFF08${value.binding.expiresInSeconds / 60} \u5206\u949F\u6709\u6548\uFF09\uFF1A`);
+    console.log(`  /attach ${value.binding.bindCode}
+`);
+  }
+  if (!value.active) {
+    console.log(`\u98DE\u4E66\u5F53\u524D\u4ECD\u8FDE\u63A5\u5176\u5B83 session\uFF1B\u53D1\u9001 /use ${options.name} \u540E\u5207\u6362\u5230\u672C session\u3002
+`);
+  }
+  await attachLocal(options.name);
+}
+async function runAttach(name) {
+  await attachLocal(name);
+}
+async function runBindCode() {
+  await ensureInitialized();
+  await ensureDaemon();
+  const response = await requestDaemon(paths.socket, { method: "bindCode" });
+  if (!response.ok) throw new Error(response.error);
+  const value = response.value;
+  console.log(`\u98DE\u4E66/Lark \u79C1\u804A\u7ED1\u5B9A\u547D\u4EE4\uFF08${value.expiresInSeconds / 60} \u5206\u949F\u6709\u6548\uFF09\uFF1A`);
+  console.log(`/attach ${value.bindCode}`);
+}
+async function attachLocal(name) {
+  const state = await store.loadState();
+  const config = await store.loadConfig();
+  const session = state.sessions?.[name];
+  if (!session) throw new Error(`no managed session: ${name}`);
+  if (!config) throw new Error("not initialized");
+  const child = spawn3(config.tmuxBinary, ["attach-session", "-t", `=${session.sessionName}`], { stdio: "inherit" });
+  const code = await new Promise((resolveExit, reject) => {
+    child.once("error", reject);
+    child.once("exit", resolveExit);
+  });
+  if (code && code !== 0) process.exitCode = code;
+}
+async function runStatus(name) {
+  try {
+    const response = await requestDaemon(paths.socket, { method: "status", sessionId: name });
+    if (!response.ok) throw new Error(response.error);
+    console.log(JSON.stringify(response.value, null, 2));
+  } catch {
+    const state = await store.loadState();
+    console.log(JSON.stringify({ daemon: "stopped", state }, null, 2));
+  }
+}
+async function runStop(name) {
+  const response = await requestDaemon(paths.socket, { method: "stop", sessionId: name });
+  if (!response.ok) throw new Error(response.error);
+  console.log(`Coding-agent tmux session stopped${name ? `: ${name}` : "."}`);
+}
+async function runResetOwner() {
+  const response = await requestDaemon(paths.socket, { method: "resetOwner" });
+  if (!response.ok) throw new Error(response.error);
+  console.log("Owner cleared.");
+}
+async function runLogs(options) {
+  const count = Math.max(1, Math.min(1e3, Number.parseInt(options.lines, 10) || 100));
+  const content = await readFile3(paths.logFile, "utf8").catch(() => "");
+  console.log(content.split("\n").slice(-count).join("\n"));
+}
+async function runDaemonStart() {
+  await ensureInitialized();
+  const before = await daemonInfo(paths);
+  if (before?.version === packageInfo.version) {
+    console.log(`Bridge daemon is already running (PID ${before.pid}, version ${before.version}).`);
+    return;
+  }
+  if (before) await stopDaemonProcess(paths);
+  const info = await startDaemonProcess(paths, daemonEntryPath());
+  console.log(`Bridge daemon started (PID ${info.pid}, version ${info.version}).`);
+}
+async function runDaemonStop() {
+  const stopped = await stopDaemonProcess(paths);
+  console.log(stopped ? "Bridge daemon stopped. Coding-agent/tmux sessions were preserved." : "Bridge daemon is not running.");
+}
+async function runDaemonRestart() {
+  await ensureInitialized();
+  await stopDaemonProcess(paths);
+  const info = await startDaemonProcess(paths, daemonEntryPath());
+  console.log(`Bridge daemon restarted (PID ${info.pid}, version ${info.version}). Coding-agent/tmux sessions were preserved.`);
+}
+async function runDaemonStatus() {
+  const info = await daemonInfo(paths);
+  if (!info) {
+    console.log(`Bridge daemon: stopped
+CLI version: ${packageInfo.version}`);
+    return;
+  }
+  console.log([
+    "Bridge daemon: running",
+    `PID: ${info.pid}`,
+    `Daemon version: ${info.version}`,
+    `CLI version: ${packageInfo.version}`,
+    `Up to date: ${info.version === packageInfo.version ? "yes" : "no"}`
+  ].join("\n"));
+}
+async function ensureInitialized() {
+  if (!await store.loadConfig() || !await store.loadSecrets()) {
+    throw new Error("not initialized; run lark-coding-assistant init first");
+  }
+}
+async function preflight(agentId) {
+  const config = await store.loadConfig();
+  const adapter = getAgentAdapter(agentId);
+  await Promise.all([
+    runFile(config.tmuxBinary, ["-V"]),
+    runFile(adapter.binary(config), [...adapter.versionArgs])
+  ]);
+}
+function parseAgentId(value) {
+  if (!isAgentId(value)) throw new Error(`unsupported coding agent: ${value}`);
+  return value;
+}
+async function ensureDaemon() {
+  const info = await daemonInfo(paths);
+  if (info?.version === packageInfo.version) return;
+  if (info) {
+    console.log(`\u68C0\u6D4B\u5230 bridge daemon \u7248\u672C ${info.version}\uFF0C\u6B63\u5728\u66F4\u65B0\u5230 ${packageInfo.version}\u2026`);
+    await stopDaemonProcess(paths);
+  }
+  await startDaemonProcess(paths, daemonEntryPath());
+}
+function daemonEntryPath() {
+  return fileURLToPath(new URL("./daemon-entry.js", import.meta.url));
+}
+//# sourceMappingURL=cli.js.map