feishu-codex-connector 0.1.6

package/dist/chunk-AOVT2UMM.js

@@ -0,0 +1,3876 @@
+// src/config/paths.ts
+import { homedir, tmpdir } from "os";
+import { dirname, join, resolve, sep } from "path";
+var DEFAULT_HOME_DIR = "~/.feishu-codex";
+function expandTilde(path, home = homedir()) {
+  if (path === "~") return home;
+  if (path.startsWith(`~${sep}`) || path.startsWith("~/")) {
+    return join(home, path.slice(2));
+  }
+  return path;
+}
+function getBridgeHome(env = process.env) {
+  return resolve(expandTilde(env.FEISHU_CODEX_HOME || DEFAULT_HOME_DIR));
+}
+function bridgePaths(home = getBridgeHome()) {
+  return {
+    home,
+    configFile: join(home, "config.json"),
+    activeProfileFile: join(home, "active-profile"),
+    registryDir: join(home, "registry"),
+    profilesDir: join(home, "profiles")
+  };
+}
+function profilePaths(profile, home = getBridgeHome()) {
+  const root = join(bridgePaths(home).profilesDir, profile);
+  return {
+    root,
+    config: join(root, "config.json"),
+    sessions: join(root, "sessions.json"),
+    sessionCatalog: join(root, "session-catalog.json"),
+    workspaces: join(root, "workspaces.json"),
+    mediaDir: join(root, "media"),
+    logsDir: join(root, "logs"),
+    secretsKey: join(root, "secrets.key"),
+    secretsStore: join(root, "secrets.enc"),
+    codexHome: join(root, "codex-home"),
+    feishuCliDir: join(root, "feishu-cli")
+  };
+}
+function parentDir(path) {
+  return dirname(path);
+}
+function tempRoot() {
+  return resolve(tmpdir());
+}
+
+// src/config/keystore.ts
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes2 } from "crypto";
+import { readFile as readFile2, writeFile as writeFile2, chmod as chmod2 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+
+// src/platform/atomic.ts
+import { randomBytes } from "crypto";
+import { mkdir, readFile, rename, writeFile, chmod } from "fs/promises";
+import { dirname as dirname2 } from "path";
+async function ensureDir(path, mode = 448) {
+  await mkdir(path, { recursive: true, mode });
+  await chmod(path, mode).catch(() => void 0);
+}
+async function readJsonFile(path, fallback) {
+  try {
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw error;
+  }
+}
+async function writeTextAtomic(path, content, mode = 384) {
+  await ensureDir(dirname2(path));
+  const tmp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  await writeFile(tmp, content, { mode });
+  await chmod(tmp, mode).catch(() => void 0);
+  await rename(tmp, path);
+}
+async function writeJsonAtomic(path, value, mode = 384) {
+  await writeTextAtomic(path, `${JSON.stringify(value, null, 2)}
+`, mode);
+}
+
+// src/config/keystore.ts
+var LocalKeystore = class {
+  constructor(paths) {
+    this.paths = paths;
+  }
+  paths;
+  async set(id, value) {
+    const store = await this.readPlain();
+    store[id] = value;
+    await this.writePlain(store);
+  }
+  async get(id) {
+    return (await this.readPlain())[id];
+  }
+  async delete(id) {
+    const store = await this.readPlain();
+    delete store[id];
+    await this.writePlain(store);
+  }
+  async export(includeSecrets = false) {
+    const store = await this.readPlain();
+    if (includeSecrets) return store;
+    return Object.fromEntries(Object.keys(store).map((id) => [id, "<redacted>"]));
+  }
+  async key() {
+    try {
+      const raw = await readFile2(this.paths.secretsKey);
+      if (raw.length !== 32) throw new Error("invalid keystore key length");
+      return raw;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      await ensureDir(dirname3(this.paths.secretsKey));
+      const key = randomBytes2(32);
+      await writeFile2(this.paths.secretsKey, key, { mode: 384 });
+      await chmod2(this.paths.secretsKey, 384).catch(() => void 0);
+      return key;
+    }
+  }
+  async readPlain() {
+    const encrypted = await readJsonFile(this.paths.secretsStore, null);
+    if (!encrypted) return {};
+    const key = await this.key();
+    const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(encrypted.iv, "base64url"));
+    decipher.setAuthTag(Buffer.from(encrypted.tag, "base64url"));
+    const plain = Buffer.concat([
+      decipher.update(Buffer.from(encrypted.ciphertext, "base64url")),
+      decipher.final()
+    ]);
+    return JSON.parse(plain.toString("utf8"));
+  }
+  async writePlain(store) {
+    const key = await this.key();
+    const iv = randomBytes2(12);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const ciphertext = Buffer.concat([cipher.update(JSON.stringify(store), "utf8"), cipher.final()]);
+    const encrypted = {
+      version: 1,
+      iv: iv.toString("base64url"),
+      tag: cipher.getAuthTag().toString("base64url"),
+      ciphertext: ciphertext.toString("base64url")
+    };
+    await writeJsonAtomic(this.paths.secretsStore, encrypted);
+  }
+};
+
+// src/config/schema.ts
+function createDefaultProfileConfig(input2) {
+  const paths = profilePaths(input2.name, input2.home);
+  return normalizeProfileConfig({
+    schemaVersion: 1,
+    name: input2.name,
+    tenant: input2.tenant,
+    app: {
+      id: input2.appId,
+      secret: input2.appSecret
+    },
+    codex: {
+      backend: input2.codexBackend ?? "sdk",
+      auth: input2.codexAuth,
+      codexHome: paths.codexHome,
+      inheritUserCodexHome: input2.codexAuth.mode === "inherit-user",
+      ...input2.codexPath ? { codexPath: input2.codexPath } : {}
+    },
+    feishuCli: {
+      enabled: true,
+      identityPreset: "bot-only",
+      configDir: paths.feishuCliDir
+    },
+    permissions: {
+      defaultAccess: "workspace",
+      maxAccess: "workspace",
+      networkAccess: false
+    },
+    access: {
+      allowedUsers: [],
+      allowedChats: [],
+      admins: [],
+      requireMentionInGroup: true,
+      allowUserCliInGroups: false
+    },
+    preferences: {
+      replyMode: "card",
+      showToolCalls: true,
+      maxConcurrency: 2,
+      debounceMs: 600
+    },
+    attachments: {
+      maxCount: 10,
+      maxBytes: 100 * 1024 * 1024,
+      maxFileBytes: 25 * 1024 * 1024,
+      imageMaxBytes: 25 * 1024 * 1024,
+      cacheTtlMs: 24 * 60 * 60 * 1e3
+    },
+    workspaces: input2.workspace ? { default: input2.workspace } : {}
+  });
+}
+function normalizeProfileConfig(value) {
+  if (!isRecord(value)) throw new Error("profile config must be an object");
+  if (value.schemaVersion !== 1) throw new Error("profile schemaVersion must be 1");
+  const name = stringRequired(value.name, "name");
+  const tenant = value.tenant === "feishu" || value.tenant === "lark" ? value.tenant : fail("tenant must be feishu or lark");
+  const app = normalizeApp(value.app);
+  const codex = normalizeCodex(value.codex, name);
+  const feishuCli = normalizeFeishuCli(value.feishuCli, name);
+  return {
+    schemaVersion: 1,
+    name,
+    tenant,
+    app,
+    codex,
+    feishuCli,
+    permissions: normalizePermissions(value.permissions),
+    access: normalizeAccess(value.access),
+    preferences: normalizePreferences(value.preferences),
+    attachments: normalizeAttachments(value.attachments),
+    workspaces: normalizeWorkspaces(value.workspaces)
+  };
+}
+function isSecretRef(value) {
+  if (!isRecord(value) || typeof value.source !== "string") return false;
+  if (value.source === "keystore") return typeof value.id === "string" && value.id.length > 0;
+  if (value.source === "env") return typeof value.name === "string" && value.name.length > 0;
+  if (value.source === "file") return typeof value.path === "string" && value.path.length > 0;
+  if (value.source === "exec") {
+    return typeof value.command === "string" && (!value.args || Array.isArray(value.args) && stringArray(value.args).length === value.args.length);
+  }
+  return false;
+}
+function redactProfileConfig(profile) {
+  return JSON.parse(
+    JSON.stringify(profile, (_key, value) => {
+      if (isSecretRef(value)) return { ...value, redacted: true };
+      return value;
+    })
+  );
+}
+function normalizeApp(value) {
+  if (!isRecord(value)) throw new Error("app config is required");
+  const id = stringRequired(value.id, "app.id");
+  if (!isSecretRef(value.secret)) throw new Error("app.secret must be a secret reference");
+  return { id, secret: value.secret };
+}
+function normalizeCodex(value, name) {
+  if (!isRecord(value)) throw new Error("codex config is required");
+  const backend = value.backend === "sdk" || value.backend === "exec-json" || value.backend === "app-server" ? value.backend : "sdk";
+  const auth = normalizeCodexAuth(value.auth);
+  const paths = profilePaths(name);
+  return {
+    backend,
+    auth,
+    codexHome: typeof value.codexHome === "string" ? value.codexHome : paths.codexHome,
+    inheritUserCodexHome: Boolean(value.inheritUserCodexHome),
+    ...typeof value.codexPath === "string" ? { codexPath: value.codexPath } : {},
+    ...typeof value.baseUrl === "string" ? { baseUrl: value.baseUrl } : {},
+    ...isRecord(value.config) ? { config: value.config } : {}
+  };
+}
+function normalizeCodexAuth(value) {
+  if (!isRecord(value)) throw new Error("codex.auth is required");
+  if (value.mode === "api-key") {
+    if (!isSecretRef(value.apiKey)) throw new Error("codex.auth.apiKey must be a secret reference");
+    return { mode: "api-key", apiKey: value.apiKey };
+  }
+  if (value.mode === "codex-home") return { mode: "codex-home" };
+  if (value.mode === "inherit-user") return { mode: "inherit-user" };
+  throw new Error("codex.auth.mode must be api-key, codex-home, or inherit-user");
+}
+function normalizeFeishuCli(value, name) {
+  const paths = profilePaths(name);
+  if (!isRecord(value)) {
+    return { enabled: true, identityPreset: "bot-only", configDir: paths.feishuCliDir };
+  }
+  const preset = value.identityPreset === "user-default" || value.identityPreset === "disabled" ? value.identityPreset : "bot-only";
+  return {
+    enabled: value.enabled !== false && preset !== "disabled",
+    identityPreset: preset,
+    configDir: typeof value.configDir === "string" ? value.configDir : paths.feishuCliDir
+  };
+}
+function normalizePermissions(value) {
+  const raw = isRecord(value) ? value : {};
+  return {
+    defaultAccess: accessMode(raw.defaultAccess, "workspace"),
+    maxAccess: accessMode(raw.maxAccess, "workspace"),
+    networkAccess: Boolean(raw.networkAccess)
+  };
+}
+function normalizeAccess(value) {
+  const raw = isRecord(value) ? value : {};
+  return {
+    allowedUsers: stringArray(raw.allowedUsers),
+    allowedChats: stringArray(raw.allowedChats),
+    admins: stringArray(raw.admins),
+    requireMentionInGroup: raw.requireMentionInGroup !== false,
+    allowUserCliInGroups: Boolean(raw.allowUserCliInGroups)
+  };
+}
+function normalizePreferences(value) {
+  const raw = isRecord(value) ? value : {};
+  return {
+    replyMode: raw.replyMode === "markdown" || raw.replyMode === "text" ? raw.replyMode : "card",
+    showToolCalls: raw.showToolCalls !== false,
+    maxConcurrency: positiveInt(raw.maxConcurrency, 2),
+    debounceMs: positiveInt(raw.debounceMs, 600),
+    ...typeof raw.idleTimeoutMinutes === "number" ? { idleTimeoutMinutes: raw.idleTimeoutMinutes } : {}
+  };
+}
+function normalizeAttachments(value) {
+  const raw = isRecord(value) ? value : {};
+  return {
+    maxCount: positiveInt(raw.maxCount, 10),
+    maxBytes: positiveInt(raw.maxBytes, 100 * 1024 * 1024),
+    maxFileBytes: positiveInt(raw.maxFileBytes, 25 * 1024 * 1024),
+    imageMaxBytes: positiveInt(raw.imageMaxBytes, 25 * 1024 * 1024),
+    cacheTtlMs: positiveInt(raw.cacheTtlMs, 24 * 60 * 60 * 1e3)
+  };
+}
+function normalizeWorkspaces(value) {
+  const raw = isRecord(value) ? value : {};
+  return typeof raw.default === "string" && raw.default.length > 0 ? { default: raw.default } : {};
+}
+function accessMode(value, fallback) {
+  return value === "read-only" || value === "workspace" || value === "full" ? value : fallback;
+}
+function positiveInt(value, fallback) {
+  return Number.isInteger(value) && Number(value) > 0 ? Number(value) : fallback;
+}
+function stringRequired(value, label) {
+  if (typeof value === "string" && value.length > 0) return value;
+  throw new Error(`${label} is required`);
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function fail(message) {
+  throw new Error(message);
+}
+
+// src/config/profile-store.ts
+import { constants } from "fs";
+import { access, cp, mkdir as mkdir2, readdir, readFile as readFile3, rm, rename as rename2, stat } from "fs/promises";
+import { basename, join as join2 } from "path";
+var ProfileStore = class {
+  constructor(home = bridgePaths().home) {
+    this.home = home;
+    this.paths = bridgePaths(home);
+  }
+  home;
+  paths;
+  profilePaths(name) {
+    return profilePaths(name, this.home);
+  }
+  keystore(name) {
+    return new LocalKeystore(this.profilePaths(name));
+  }
+  async init() {
+    await ensureDir(this.paths.home);
+    await ensureDir(this.paths.profilesDir);
+    await ensureDir(this.paths.registryDir);
+  }
+  async create(input2) {
+    await this.init();
+    const paths = this.profilePaths(input2.name);
+    await ensureDir(paths.root);
+    await ensureDir(paths.mediaDir);
+    await ensureDir(paths.logsDir);
+    await ensureDir(paths.codexHome);
+    await ensureDir(paths.feishuCliDir);
+    const keystore = this.keystore(input2.name);
+    const appSecretRef = { source: "keystore", id: `app-${input2.appId}` };
+    await keystore.set(appSecretRef.id, input2.appSecret);
+    let auth;
+    if (input2.codexAuthMode === "api-key") {
+      if (!input2.codexApiKey) throw new Error("codexApiKey is required for api-key auth mode");
+      const apiKeyRef = { source: "keystore", id: `openai-api-key-${input2.name}` };
+      await keystore.set(apiKeyRef.id, input2.codexApiKey);
+      auth = { mode: "api-key", apiKey: apiKeyRef };
+    } else {
+      auth = { mode: input2.codexAuthMode };
+    }
+    const profile = createDefaultProfileConfig({
+      name: input2.name,
+      tenant: input2.tenant,
+      appId: input2.appId,
+      appSecret: appSecretRef,
+      codexAuth: auth,
+      workspace: input2.workspace,
+      home: this.home,
+      codexBackend: input2.codexBackend,
+      codexPath: input2.codexPath
+    });
+    await writeJsonAtomic(paths.config, profile);
+    await writeJsonAtomic(paths.sessions, {});
+    await writeJsonAtomic(paths.sessionCatalog, { schemaVersion: 1, entries: [] });
+    await writeJsonAtomic(paths.workspaces, { schemaVersion: 1, currentByScope: {}, aliases: {} });
+    if (input2.setActive !== false) await this.use(input2.name);
+    await this.writeRootConfig();
+    return profile;
+  }
+  async read(name) {
+    const profileName = name ?? await this.activeProfile();
+    if (!profileName) throw new Error("no active profile");
+    const raw = await readJsonFile(this.profilePaths(profileName).config, null);
+    if (!raw) throw new Error(`profile not found: ${profileName}`);
+    return normalizeProfileConfig(raw);
+  }
+  async write(profile) {
+    await writeJsonAtomic(this.profilePaths(profile.name).config, normalizeProfileConfig(profile));
+    await this.writeRootConfig();
+  }
+  async list() {
+    await this.init();
+    const active = await this.activeProfile().catch(() => void 0);
+    const entries = await readdir(this.paths.profilesDir, { withFileTypes: true }).catch(() => []);
+    const summaries = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      try {
+        const profile = await this.read(entry.name);
+        summaries.push({
+          name: profile.name,
+          active: profile.name === active,
+          tenant: profile.tenant,
+          appIdSuffix: suffix(profile.app.id),
+          workspaceStatus: profile.workspaces.default ? "configured" : "missing",
+          backend: profile.codex.backend,
+          codexAuthMode: profile.codex.auth.mode,
+          feishuCliIdentity: profile.feishuCli.identityPreset
+        });
+      } catch {
+      }
+    }
+    return summaries.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async use(name) {
+    await this.assertExists(name);
+    await writeTextAtomic(this.paths.activeProfileFile, `${name}
+`);
+    await this.writeRootConfig(name);
+  }
+  async activeProfile() {
+    try {
+      const raw = await readFile3(this.paths.activeProfileFile, "utf8");
+      const value = raw.trim();
+      return value.length > 0 ? value : void 0;
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    }
+  }
+  async remove(name, opts = {}) {
+    const paths = this.profilePaths(name);
+    await this.assertExists(name);
+    if (opts.purge) {
+      if (!opts.yes) throw new Error("profile purge requires --yes");
+      await rm(paths.root, { recursive: true, force: true });
+      await this.clearActiveIf(name);
+      await this.writeRootConfig();
+      return "purged";
+    }
+    const archived = `${paths.root}.archived-${Date.now()}`;
+    await rename2(paths.root, archived);
+    await this.clearActiveIf(name);
+    await this.writeRootConfig();
+    return archived;
+  }
+  async export(name, opts = {}) {
+    const profile = await this.read(name);
+    if (!opts.includeSecrets) return redactProfileConfig(profile);
+    return {
+      profile,
+      secrets: await this.keystore(name).export(true)
+    };
+  }
+  async importFilesFrom(name, sourceDir) {
+    const target = this.profilePaths(name).root;
+    await mkdir2(target, { recursive: true });
+    await cp(sourceDir, target, { recursive: true, force: true });
+  }
+  async assertExists(name) {
+    await access(this.profilePaths(name).config, constants.R_OK);
+  }
+  async writeRootConfig(activeOverride) {
+    await this.init();
+    const entries = await readdir(this.paths.profilesDir, { withFileTypes: true }).catch(() => []);
+    const profiles = {};
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      try {
+        profiles[entry.name] = await this.read(entry.name);
+      } catch {
+      }
+    }
+    const activeProfile = activeOverride ?? await this.activeProfile().catch(() => void 0);
+    const root = {
+      schemaVersion: 1,
+      ...activeProfile ? { activeProfile } : {},
+      profiles
+    };
+    await writeJsonAtomic(this.paths.configFile, root);
+  }
+  async clearActiveIf(name) {
+    const active = await this.activeProfile();
+    if (active !== name) return;
+    const next = (await this.list()).find((summary) => summary.name !== name);
+    if (next) {
+      await this.use(next.name);
+    } else {
+      await writeTextAtomic(this.paths.activeProfileFile, "");
+    }
+  }
+};
+async function profileExists(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function suffix(value) {
+  return value.length <= 6 ? value : value.slice(-6);
+}
+function profileNameFromPath(path) {
+  return basename(path);
+}
+function profileLogPath(paths, kind) {
+  return join2(paths.logsDir, `${kind}.jsonl`);
+}
+
+// src/config/secret-resolver.ts
+import { readFile as readFile4 } from "fs/promises";
+import { spawn } from "child_process";
+var SecretResolver = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.env = options.env ?? process.env;
+  }
+  options;
+  env;
+  async resolve(ref) {
+    if (ref.source === "keystore") {
+      const value = await this.options.keystore?.get(ref.id);
+      if (!value) throw new Error(`secret not found: ${ref.id}`);
+      return value;
+    }
+    if (ref.source === "env") {
+      const value = this.env[ref.name];
+      if (!value) throw new Error(`environment secret not set: ${ref.name}`);
+      return value;
+    }
+    if (ref.source === "file") {
+      return (await readFile4(expandTilde(ref.path), "utf8")).trim();
+    }
+    return runSecretCommand(ref.command, ref.args ?? []);
+  }
+};
+function runSecretCommand(command, args) {
+  return new Promise((resolve3, reject3) => {
+    const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.on("error", reject3);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve3(Buffer.concat(stdout).toString("utf8").trim());
+      } else {
+        reject3(new Error(`secret exec failed with code ${code}: ${Buffer.concat(stderr).toString("utf8").trim()}`));
+      }
+    });
+  });
+}
+
+// src/gateway/normalizer.ts
+import { createHash } from "crypto";
+function scopeForChat(input2) {
+  if (input2.fileToken && input2.documentLevel) return `doc:${hashId(input2.fileToken)}`;
+  if (input2.fileToken && input2.commentId) {
+    return `comment:${hashId(input2.fileToken)}:${hashId(input2.commentId)}:${input2.nonce ?? "default"}`;
+  }
+  if (!input2.chatId) throw new Error("chatId is required for chat scope");
+  if (input2.threadId) return `topic:${input2.chatId}:${input2.threadId}`;
+  return `chat:${input2.chatId}`;
+}
+function messageRequiresMention(message, botOpenId) {
+  if (message.chatType === "private") return false;
+  return !hasRealBotMention(message.mentions, botOpenId);
+}
+function hasRealBotMention(mentions, botOpenId) {
+  return mentions.some((mention) => !mention.isAll && (mention.isBot || botOpenId && mention.id === botOpenId));
+}
+function hashId(value) {
+  return createHash("sha256").update(value).digest("base64url").slice(0, 16);
+}
+
+// src/runtime/locks.ts
+import { mkdir as mkdir3, readFile as readFile5, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { join as join3 } from "path";
+var RuntimeLock = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  locked = false;
+  async acquire() {
+    await ensureDir(join3(this.path, ".."));
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        await mkdir3(this.path, { mode: 448 });
+        await writeFile3(join3(this.path, "pid"), String(process.pid), { mode: 384 });
+        this.locked = true;
+        return;
+      } catch (error) {
+        if (error.code === "EEXIST" && attempt === 0 && await this.isStale()) {
+          await rm2(this.path, { recursive: true, force: true });
+          continue;
+        }
+        if (error.code === "EEXIST") {
+          throw new Error(`runtime lock already held: ${this.path}`);
+        }
+        throw error;
+      }
+    }
+  }
+  async release() {
+    if (!this.locked) return;
+    await rm2(this.path, { recursive: true, force: true });
+    this.locked = false;
+  }
+  async isStale() {
+    try {
+      const pid = Number((await readFile5(join3(this.path, "pid"), "utf8")).trim());
+      if (!Number.isInteger(pid) || pid <= 0) return true;
+      try {
+        process.kill(pid, 0);
+        return false;
+      } catch {
+        return true;
+      }
+    } catch {
+      return true;
+    }
+  }
+};
+function profileLock(profile, home = bridgePaths().home) {
+  return new RuntimeLock(join3(bridgePaths(home).registryDir, "locks", `profile-${profile}.lock`));
+}
+function appLock(appId, home = bridgePaths().home) {
+  return new RuntimeLock(join3(bridgePaths(home).registryDir, "locks", `app-${appId}.lock`));
+}
+
+// src/runtime/registry.ts
+import { randomBytes as randomBytes3 } from "crypto";
+import { hostname, platform } from "os";
+import { join as join4 } from "path";
+var RuntimeRegistry = class {
+  path;
+  constructor(home = bridgePaths().home) {
+    this.path = join4(bridgePaths(home).registryDir, "processes.json");
+  }
+  async register(record3) {
+    await ensureDir(join4(this.path, ".."));
+    const file = await this.read();
+    const next = {
+      id: record3.id ?? shortId(),
+      pid: record3.pid ?? process.pid,
+      profile: record3.profile,
+      tenant: record3.tenant,
+      appId: record3.appId,
+      botName: record3.botName,
+      startedAt: record3.startedAt ?? Date.now(),
+      host: hostname(),
+      platform: platform(),
+      logPath: record3.logPath
+    };
+    file.processes = file.processes.filter((entry) => isAlive(entry.pid) && entry.pid !== next.pid && entry.id !== next.id);
+    file.processes.push(next);
+    await this.write(file);
+    return next;
+  }
+  async unregister(idOrPid) {
+    const file = await this.read();
+    file.processes = file.processes.filter((entry) => entry.id !== String(idOrPid) && entry.pid !== Number(idOrPid));
+    await this.write(file);
+  }
+  async list() {
+    const file = await this.read();
+    const live = file.processes.filter((entry) => isAlive(entry.pid));
+    if (live.length !== file.processes.length) await this.write({ ...file, processes: live });
+    return live;
+  }
+  async find(idOrPid) {
+    const needle = String(idOrPid);
+    return (await this.list()).find((entry) => entry.id === needle || String(entry.pid) === needle);
+  }
+  async kill(idOrPid, signal = "SIGTERM") {
+    const entry = await this.find(idOrPid);
+    if (!entry) return void 0;
+    process.kill(entry.pid, signal);
+    return entry;
+  }
+  async read() {
+    const file = await readJsonFile(this.path, { schemaVersion: 1, processes: [] });
+    return { schemaVersion: 1, processes: Array.isArray(file.processes) ? file.processes : [] };
+  }
+  write(file) {
+    return writeJsonAtomic(this.path, file);
+  }
+};
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function shortId() {
+  return randomBytes3(2).toString("hex");
+}
+
+// src/runner/sdk-translator.ts
+var SdkEventTranslator = class {
+  textByItem = /* @__PURE__ */ new Map();
+  translate(event) {
+    if (event.type === "thread.started") return [{ type: "thread", threadId: event.thread_id }];
+    if (event.type === "turn.completed") {
+      return [usageEvent(event.usage), { type: "done", reason: "normal" }];
+    }
+    if (event.type === "turn.failed") {
+      return [{ type: "error", message: event.error.message }];
+    }
+    if (event.type === "error") return [{ type: "error", message: event.message }];
+    if (event.type === "item.started") return this.itemStarted(event.item);
+    if (event.type === "item.updated") return this.itemUpdated(event.item);
+    if (event.type === "item.completed") return this.itemCompleted(event.item);
+    return [];
+  }
+  itemStarted(item) {
+    if (item.type === "command_execution") {
+      return [{ type: "tool_start", id: item.id, name: "shell", input: { command: item.command } }];
+    }
+    if (item.type === "mcp_tool_call") {
+      return [{ type: "tool_start", id: item.id, name: `${item.server}.${item.tool}`, input: item.arguments }];
+    }
+    if (item.type === "web_search") {
+      return [{ type: "tool_start", id: item.id, name: "web_search", input: { query: item.query } }];
+    }
+    if (item.type === "file_change") {
+      return [{ type: "tool_start", id: item.id, name: "file_change", input: item.changes }];
+    }
+    if (item.type === "todo_list") {
+      return [{ type: "tool_start", id: item.id, name: "todo_list", input: item.items }];
+    }
+    return this.textDelta(item);
+  }
+  itemUpdated(item) {
+    if (item.type === "command_execution" && item.status === "completed") {
+      return [{ type: "tool_end", id: item.id, output: item.aggregated_output, isError: false }];
+    }
+    return this.textDelta(item);
+  }
+  itemCompleted(item) {
+    if (item.type === "command_execution") {
+      return [{ type: "tool_end", id: item.id, output: item.aggregated_output, isError: item.status === "failed" || (item.exit_code ?? 0) !== 0 }];
+    }
+    if (item.type === "mcp_tool_call") {
+      return [
+        {
+          type: "tool_end",
+          id: item.id,
+          output: item.error?.message ?? JSON.stringify(item.result ?? {}),
+          isError: item.status === "failed"
+        }
+      ];
+    }
+    if (item.type === "file_change") {
+      return [{ type: "tool_end", id: item.id, output: JSON.stringify(item.changes), isError: item.status === "failed" }];
+    }
+    if (item.type === "web_search" || item.type === "todo_list") {
+      return [{ type: "tool_end", id: item.id, output: JSON.stringify(item), isError: false }];
+    }
+    if (item.type === "error") return [{ type: "error", message: item.message }];
+    return this.textDelta(item);
+  }
+  textDelta(item) {
+    if (item.type !== "agent_message") return [];
+    const previous = this.textByItem.get(item.id) ?? "";
+    const delta = item.text.startsWith(previous) ? item.text.slice(previous.length) : item.text;
+    this.textByItem.set(item.id, item.text);
+    return delta ? [{ type: "text", delta }] : [];
+  }
+};
+function usageEvent(usage) {
+  return {
+    type: "usage",
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    cachedInputTokens: usage.cached_input_tokens,
+    reasoningOutputTokens: usage.reasoning_output_tokens
+  };
+}
+
+// src/runner/sdk-runner.ts
+import { Codex } from "@openai/codex-sdk";
+import { access as access2 } from "fs/promises";
+import { join as join5 } from "path";
+var CodexSdkRunner = class {
+  active = /* @__PURE__ */ new Map();
+  async start(input2) {
+    return this.run(input2);
+  }
+  async resume(threadId, input2) {
+    return this.run({ ...input2, threadId });
+  }
+  async stop(runId) {
+    await this.active.get(runId)?.stop();
+  }
+  async listThreads(_input) {
+    return [];
+  }
+  async checkAvailability() {
+    try {
+      const pkg = await import("@openai/codex-sdk");
+      return { ok: Boolean(pkg.Codex), label: "Codex SDK" };
+    } catch (error) {
+      return { ok: false, label: "Codex SDK", detail: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  async run(input2) {
+    const abort = new AbortController();
+    let stopReason;
+    const timeout = input2.idleTimeoutMs && input2.idleTimeoutMs > 0 ? setTimeout(() => {
+      stopReason = "timeout";
+      abort.abort();
+    }, input2.idleTimeoutMs) : void 0;
+    const env = minimalCodexEnv(input2);
+    const codex = new Codex({
+      ...input2.codexPath ? { codexPathOverride: input2.codexPath } : {},
+      ...input2.apiKey ? { apiKey: input2.apiKey } : {},
+      ...input2.baseUrl ? { baseUrl: input2.baseUrl } : {},
+      env,
+      config: {
+        ...input2.config ?? {},
+        sandbox_workspace_write: { network_access: input2.networkAccess }
+      }
+    });
+    const options = {
+      workingDirectory: input2.cwdRealpath,
+      skipGitRepoCheck: true,
+      sandboxMode: input2.sandbox,
+      networkAccessEnabled: input2.networkAccess,
+      approvalPolicy: "never"
+    };
+    const thread = input2.threadId ? codex.resumeThread(input2.threadId, options) : codex.startThread(options);
+    const events = this.streamEvents(
+      input2,
+      thread.runStreamed(toSdkInput(input2), { signal: abort.signal }).then((turn) => turn.events),
+      () => stopReason,
+      () => {
+        if (timeout) clearTimeout(timeout);
+      }
+    );
+    const handle = {
+      runId: input2.runId,
+      threadId: input2.threadId,
+      events,
+      stop: async () => {
+        stopReason = "interrupted";
+        abort.abort();
+      }
+    };
+    this.active.set(input2.runId, handle);
+    return handle;
+  }
+  async *streamEvents(input2, sourcePromise, getStopReason, cleanup) {
+    const translator = new SdkEventTranslator();
+    let terminal = false;
+    try {
+      const source = await sourcePromise;
+      for await (const raw of source) {
+        for (const event of translator.translate(raw)) {
+          if (event.type === "done" || event.type === "error") terminal = true;
+          yield event;
+        }
+      }
+      const reason = getStopReason();
+      if (!terminal && reason) yield { type: "done", reason };
+    } catch (error) {
+      const reason = getStopReason();
+      if (reason) yield { type: "done", reason };
+      else yield { type: "error", message: error instanceof Error ? error.message : String(error) };
+    } finally {
+      cleanup();
+      this.active.delete(input2.runId);
+    }
+  }
+};
+function toSdkInput(input2) {
+  if (!input2.imagePaths?.length) return input2.prompt;
+  return [
+    { type: "text", text: input2.prompt },
+    ...input2.imagePaths.map((path) => ({ type: "local_image", path }))
+  ];
+}
+function minimalCodexEnv(input2) {
+  const keep = ["PATH", "HOME", "SHELL", "TMPDIR", "TEMP", "TMP", "LANG", "LC_ALL", "LC_CTYPE"];
+  const env = {};
+  for (const key of keep) {
+    const value = process.env[key];
+    if (value) env[key] = value;
+  }
+  if (input2.codexHome) env.CODEX_HOME = input2.codexHome;
+  return { ...env, ...input2.env ?? {} };
+}
+async function codexBinaryLooksAvailable(codexPath) {
+  const path = codexPath.includes("/") ? codexPath : join5(process.cwd(), codexPath);
+  return access2(path).then(() => true, () => false);
+}
+
+// src/runner/exec-json-runner.ts
+import { createInterface } from "readline";
+import { spawn as spawn2 } from "child_process";
+var ExecJsonRunner = class {
+  constructor(command, args = []) {
+    this.command = command;
+    this.args = args;
+  }
+  command;
+  args;
+  active = /* @__PURE__ */ new Map();
+  async start(input2) {
+    return this.spawn(input2);
+  }
+  async resume(threadId, input2) {
+    return this.spawn({ ...input2, threadId });
+  }
+  async stop(runId) {
+    const child = this.active.get(runId);
+    if (!child) return;
+    child.kill("SIGTERM");
+  }
+  async listThreads(_input) {
+    return [];
+  }
+  async checkAvailability() {
+    return { ok: true, label: "exec-json" };
+  }
+  async spawn(input2) {
+    const child = spawn2(this.command, this.args, {
+      cwd: input2.cwdRealpath,
+      env: { ...process.env, ...input2.env ?? {}, FEISHU_CODEX_PROMPT: input2.prompt },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.active.set(input2.runId, child);
+    child.stdin.end(JSON.stringify(input2), "utf8");
+    return {
+      runId: input2.runId,
+      threadId: input2.threadId,
+      events: streamJsonEvents(child, () => this.active.delete(input2.runId)),
+      stop: async () => {
+        child.kill("SIGTERM");
+      }
+    };
+  }
+};
+async function* streamJsonEvents(child, done) {
+  const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const parsed = JSON.parse(trimmed);
+      yield parsed;
+    }
+    const code = await waitExit(child);
+    if (code !== 0) {
+      yield { type: "error", message: `exec-json exited with code ${code}` };
+    }
+  } catch (error) {
+    yield { type: "error", message: error instanceof Error ? error.message : String(error) };
+  } finally {
+    rl.close();
+    done();
+  }
+}
+function waitExit(child) {
+  if (child.exitCode !== null) return Promise.resolve(child.exitCode);
+  return new Promise((resolve3) => child.once("exit", (code) => resolve3(code)));
+}
+
+// src/render/callback-auth.ts
+import { createHmac, randomBytes as randomBytes4, timingSafeEqual } from "crypto";
+var PREFIX = "feishu_codex_cb.v1";
+var CallbackAuth = class {
+  constructor(keys, nonceStore, opts = {}) {
+    this.nonceStore = nonceStore;
+    if (keys.length === 0) throw new Error("at least one callback key is required");
+    this.keys = [...keys].sort((a, b) => a.version - b.version);
+    this.now = opts.now ?? Date.now;
+    this.createNonce = opts.createNonce ?? (() => randomBytes4(16).toString("base64url"));
+  }
+  nonceStore;
+  keys;
+  now;
+  createNonce;
+  sign(input2) {
+    const key = this.signingKey();
+    const payload = {
+      r: input2.runId,
+      s: input2.scopeId,
+      c: input2.chatId,
+      o: input2.operatorOpenId,
+      a: input2.action,
+      exp: this.now() + input2.ttlMs,
+      fp: input2.policyFingerprint,
+      n: this.createNonce(),
+      kv: key.version
+    };
+    const encoded = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+    return `${PREFIX}.${encoded}.${mac(encoded, key.secret)}`;
+  }
+  verify(token, expected) {
+    const parts = token.split(".");
+    if (parts.length !== 4 || `${parts[0]}.${parts[1]}` !== PREFIX) return { ok: false, reason: "malformed" };
+    const payload = decode(parts[2]);
+    if (!payload) return { ok: false, reason: "malformed" };
+    const key = this.keys.find((entry) => entry.version === payload.kv);
+    if (!key) return { ok: false, reason: "unknown-key" };
+    if (!safeEqual(parts[3], mac(parts[2], key.secret))) return { ok: false, reason: "bad-signature" };
+    if (payload.exp <= this.now()) return { ok: false, reason: "expired" };
+    if (!matches(payload, expected)) return { ok: false, reason: "context-mismatch" };
+    const nonceState = this.nonceStore.state(payload.n);
+    if (nonceState === "revoked") return { ok: false, reason: "nonce-revoked" };
+    if (nonceState === "used") return { ok: false, reason: "nonce-replay" };
+    if (!this.nonceStore.consume(payload.n)) return { ok: false, reason: "nonce-replay" };
+    return { ok: true, payload };
+  }
+  signingKey() {
+    const key = this.keys.filter((entry) => !entry.retired).at(-1);
+    if (!key) throw new Error("no active callback key");
+    return key;
+  }
+};
+function decode(encoded) {
+  try {
+    const raw = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    if (typeof raw.r === "string" && typeof raw.s === "string" && typeof raw.c === "string" && typeof raw.o === "string" && typeof raw.a === "string" && typeof raw.exp === "number" && typeof raw.fp === "string" && typeof raw.n === "string" && typeof raw.kv === "number") {
+      return raw;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function mac(payload, secret) {
+  return createHmac("sha256", secret).update(payload).digest("base64url");
+}
+function safeEqual(actual, expected) {
+  const a = Buffer.from(actual);
+  const b = Buffer.from(expected);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function matches(payload, expected) {
+  return payload.r === expected.runId && payload.s === expected.scopeId && payload.c === expected.chatId && payload.o === expected.operatorOpenId && payload.a === expected.action && payload.fp === expected.policyFingerprint;
+}
+
+// src/render/callback-store.ts
+var MemoryCallbackNonceStore = class {
+  used = /* @__PURE__ */ new Set();
+  revoked = /* @__PURE__ */ new Set();
+  state(nonce) {
+    if (this.revoked.has(nonce)) return "revoked";
+    if (this.used.has(nonce)) return "used";
+    return "fresh";
+  }
+  consume(nonce) {
+    if (this.state(nonce) !== "fresh") return false;
+    this.used.add(nonce);
+    return true;
+  }
+  revoke(nonce) {
+    this.revoked.add(nonce);
+  }
+};
+
+// src/render/card.ts
+var MAX_TEXT_CHARS = 1e4;
+var MAX_TOOL_COUNT = 10;
+var MAX_TOOL_INPUT_CHARS = 1200;
+var MAX_TOOL_OUTPUT_CHARS = 2e3;
+function buildRunCard(state, context) {
+  const elements = [
+    markdown(
+      [
+        `**Workspace** ${context.workspaceLabel}`,
+        `**Sandbox** ${context.sandbox}`,
+        `**Auth** ${context.authMode}`,
+        `**Run** ${state.runId}`,
+        state.threadId ? `**Thread** ${state.threadId}` : void 0
+      ].filter(Boolean).join("\n")
+    )
+  ];
+  const text2 = state.text.trim();
+  if (text2) elements.push(markdown(`**Output**
+${truncateMiddle(text2, MAX_TEXT_CHARS)}`));
+  const omitted = Math.max(0, state.tools.length - MAX_TOOL_COUNT);
+  if (omitted > 0) elements.push(markdown(`**Tools** showing latest ${MAX_TOOL_COUNT}, ${omitted} earlier omitted.`));
+  for (const tool of state.tools.slice(-MAX_TOOL_COUNT)) {
+    elements.push(
+      markdown(
+        [
+          `**${toolStatusLabel(tool)}** ${tool.name}`,
+          `Input:
+\`\`\`json
+${truncateEnd(safeJson(tool.input), MAX_TOOL_INPUT_CHARS)}
+\`\`\``,
+          tool.output ? `Output:
+\`\`\`
+${truncateEnd(tool.output, MAX_TOOL_OUTPUT_CHARS)}
+\`\`\`` : void 0
+        ].filter(Boolean).join("\n")
+      )
+    );
+  }
+  if (state.usage) {
+    elements.push(
+      markdown(
+        [
+          `**Tokens** input ${state.usage.inputTokens ?? "-"} / output ${state.usage.outputTokens ?? "-"}`,
+          state.usage.cachedInputTokens !== void 0 ? `Cached input ${state.usage.cachedInputTokens}` : void 0,
+          state.usage.reasoningOutputTokens !== void 0 ? `Reasoning output ${state.usage.reasoningOutputTokens}` : void 0
+        ].filter(Boolean).join("\n")
+      )
+    );
+  }
+  if (state.error) elements.push(markdown(`**Error**
+${truncateEnd(state.error, 4e3)}`));
+  if (state.status !== "running") elements.push(markdown(`**State** ${titleFor(state.status)}`));
+  if (state.status === "running" && context.callbackAuth) {
+    elements.push({
+      tag: "action",
+      actions: [
+        {
+          tag: "button",
+          text: { tag: "plain_text", content: "Stop" },
+          type: "danger",
+          value: {
+            token: context.callbackAuth.sign({
+              runId: state.runId,
+              scopeId: context.scopeId,
+              chatId: context.chatId,
+              operatorOpenId: context.operatorOpenId,
+              action: "stop",
+              policyFingerprint: context.policyFingerprint,
+              ttlMs: 30 * 60 * 1e3
+            })
+          }
+        }
+      ]
+    });
+  }
+  return {
+    config: { wide_screen_mode: true, update_multi: true },
+    header: {
+      title: { tag: "plain_text", content: titleFor(state.status) },
+      template: templateFor(state.status)
+    },
+    elements
+  };
+}
+function renderMarkdownFallback(state) {
+  const status = titleFor(state.status);
+  const body = state.text.trim() || state.error || "(no output)";
+  return `**${status}**
+
+${body}`;
+}
+function markdown(content) {
+  return { tag: "div", text: { tag: "lark_md", content } };
+}
+function titleFor(status) {
+  if (status === "queued") return "Codex queued";
+  if (status === "running") return "Codex running";
+  if (status === "done") return "Codex done";
+  if (status === "interrupted") return "Codex stopped";
+  if (status === "timeout") return "Codex timed out";
+  return "Codex error";
+}
+function templateFor(status) {
+  if (status === "done") return "green";
+  if (status === "error" || status === "timeout") return "red";
+  if (status === "interrupted") return "orange";
+  return "blue";
+}
+function toolStatusLabel(tool) {
+  if (tool.status === "running") return "Running";
+  return tool.isError ? "Failed" : "Done";
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function truncateEnd(value, max) {
+  return value.length > max ? `${value.slice(0, max)}...` : value;
+}
+function truncateMiddle(value, max) {
+  if (value.length <= max) return value;
+  const head = Math.floor(max * 0.35);
+  const tail = max - head;
+  return `${value.slice(0, head)}
+
+...[truncated]...
+
+${value.slice(-tail)}`;
+}
+
+// src/render/redactor.ts
+var KEY_PATTERNS = [
+  /sk-[A-Za-z0-9_-]{20,}/g,
+  /OPENAI_API_KEY=([^\s]+)/g,
+  /app_secret["']?\s*[:=]\s*["']?([A-Za-z0-9_-]{12,})/gi
+];
+function redactSecrets(text2, explicitSecrets = []) {
+  let next = text2;
+  for (const secret of explicitSecrets.filter(Boolean)) {
+    next = next.split(secret).join("<redacted>");
+  }
+  for (const pattern of KEY_PATTERNS) {
+    next = next.replace(pattern, (match, group) => typeof group === "string" ? match.replace(group, "<redacted>") : "<redacted>");
+  }
+  return next;
+}
+
+// src/render/run-state.ts
+function createRunState(runId) {
+  return { runId, status: "queued", text: "", tools: [] };
+}
+function applyRunEvent(state, event, secrets = []) {
+  const next = { ...state, tools: state.tools.map((tool) => ({ ...tool })) };
+  if (event.type === "thread") next.threadId = event.threadId;
+  if (event.type === "text") {
+    next.status = "running";
+    next.text += redactSecrets(event.delta, secrets);
+  }
+  if (event.type === "tool_start") {
+    next.status = "running";
+    next.tools.push({ id: event.id, name: event.name, input: event.input, status: "running" });
+  }
+  if (event.type === "tool_end") {
+    const tool = next.tools.find((entry) => entry.id === event.id);
+    if (tool) {
+      tool.status = "done";
+      tool.output = redactSecrets(event.output, secrets);
+      tool.isError = event.isError;
+    }
+  }
+  if (event.type === "usage") next.usage = event;
+  if (event.type === "done") next.status = event.reason === "normal" ? "done" : event.reason;
+  if (event.type === "error") {
+    next.status = "error";
+    next.error = redactSecrets(event.message, secrets);
+  }
+  return next;
+}
+
+// src/gateway/comments.ts
+async function runDocumentComment(input2) {
+  const handle = await input2.runner.start({
+    runId: `comment_${Date.now()}`,
+    prompt: input2.prompt,
+    cwdRealpath: input2.cwdRealpath,
+    sandbox: input2.profile.permissions.defaultAccess === "read-only" ? "read-only" : "workspace-write",
+    networkAccess: input2.profile.permissions.networkAccess,
+    apiKey: input2.apiKey,
+    codexHome: input2.profile.codex.codexHome
+  });
+  let text2 = "";
+  for await (const event of handle.events) {
+    if (event.type === "text") text2 += event.delta;
+    if (event.type === "error") text2 += `
+${event.message}`;
+  }
+  const plain = stripMarkdown(text2.trim());
+  await input2.gateway.sendMessage({ commentScopeId: input2.commentScopeId }, { mode: "comment", content: plain });
+  return plain;
+}
+function stripMarkdown(value) {
+  return value.replace(/\*\*(.*?)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^#{1,6}\s+/gm, "").trim();
+}
+
+// src/media/cache.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile6, rm as rm3, stat as stat2, writeFile as writeFile4 } from "fs/promises";
+import { extname, join as join6 } from "path";
+var MediaCache = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  async putBytes(bytes, opts = {}) {
+    await ensureDir(this.root);
+    const hash = createHash2("sha256").update(bytes).digest("base64url");
+    const ext = extensionFor(opts.name, opts.mime);
+    const path = join6(this.root, `${hash}${ext}`);
+    await writeFile4(path, bytes, { mode: 384 });
+    return { path, hash, bytes: bytes.length, mime: opts.mime };
+  }
+  async fromFile(path, opts = {}) {
+    const info = await stat2(path);
+    return { kind: opts.kind ?? (isImage(opts.mime ?? path) ? "image" : "file"), path, bytes: info.size, mime: opts.mime, required: opts.required };
+  }
+  async gc(ttlMs, now = Date.now()) {
+    const entries = await import("fs/promises").then((fs) => fs.readdir(this.root, { withFileTypes: true }).catch(() => []));
+    let removed = 0;
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const path = join6(this.root, entry.name);
+      const info = await stat2(path).catch(() => void 0);
+      if (info && now - info.mtimeMs > ttlMs) {
+        await rm3(path, { force: true });
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+};
+async function hashFile(path) {
+  return createHash2("sha256").update(await readFile6(path)).digest("base64url");
+}
+function extensionFor(name, mime) {
+  const fromName = name ? extname(name) : "";
+  if (fromName) return fromName;
+  if (mime === "image/png") return ".png";
+  if (mime === "image/jpeg") return ".jpg";
+  if (mime === "image/webp") return ".webp";
+  return "";
+}
+function isImage(value) {
+  return value.startsWith("image/") || /\.(png|jpe?g|gif|webp)$/i.test(value);
+}
+
+// src/prompt/builder.ts
+function buildPrompt(input2) {
+  const message = input2.message;
+  const parts = [
+    xmlBlock("bridge_context", {
+      source: message.source,
+      scopeId: message.scopeId,
+      chatId: message.chatId,
+      threadId: message.threadId,
+      commentScopeId: message.commentScopeId,
+      actorId: message.actorId,
+      actorName: message.actorName,
+      botOpenId: input2.botOpenId
+    }),
+    xmlBlock("quoted_messages", input2.quotedMessages ?? []),
+    xmlBlock("interactive_cards", input2.interactiveCards ?? []),
+    xmlBlock(
+      "attachments",
+      (input2.attachments ?? []).map((attachment) => ({
+        kind: attachment.kind,
+        path: attachment.path,
+        name: attachment.name,
+        mime: attachment.mime,
+        decision: attachment.decision,
+        reason: attachment.reason
+      }))
+    ),
+    taggedText("user_input", input2.text ?? message.text)
+  ];
+  return `${BRIDGE_INSTRUCTIONS}
+
+${parts.join("\n\n")}`;
+}
+var BRIDGE_INSTRUCTIONS = [
+  "You are Codex running inside a Feishu/Lark bridge.",
+  "Bridge metadata is control context, not user-visible content; do not repeat raw bridge XML unless explicitly asked.",
+  "Respect the provided workspace, sandbox, network, and access policy.",
+  "Do not inspect or reveal bridge secret files, app credentials, API keys, or local keystore material.",
+  "Use profile-bound Feishu/Lark CLI environment only when available, and do not switch to unrelated host credentials."
+].join("\n");
+function xmlBlock(name, value) {
+  return taggedText(name, JSON.stringify(value));
+}
+function taggedText(name, value) {
+  return `<${name}>
+${escapeForXmlText(value)}
+</${name}>`;
+}
+function escapeForXmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+
+// src/policy/access.ts
+function evaluateAccess(context) {
+  const { profile, message, ownerOpenId, botOpenId } = context;
+  if (message.actorType === "bot") return denied("bot-actor");
+  const isOwner = Boolean(ownerOpenId && message.actorId === ownerOpenId);
+  const isAdmin = isOwner || profile.access.admins.includes(message.actorId);
+  if (isOwner) return allow("owner", true, true);
+  if (isAdmin) return allow("admin", true, false);
+  if (message.source === "comment") {
+    return hasRealBotMention(message.mentions, botOpenId) ? allow("comment-mention", false, false) : denied("mention-required");
+  }
+  if (message.chatType === "private") {
+    return profile.access.allowedUsers.includes(message.actorId) ? allow("allowed-user", false, false) : denied("unauthorized-user");
+  }
+  const chatAllowed = Boolean(message.chatId && profile.access.allowedChats.includes(message.chatId));
+  if (!chatAllowed) return denied("unauthorized-chat");
+  if (profile.access.requireMentionInGroup && !hasRealBotMention(message.mentions, botOpenId)) {
+    return denied("mention-required");
+  }
+  return allow("group-member", false, false);
+}
+function canRunAdminCommand(decision) {
+  return decision.ok && decision.isAdmin;
+}
+function allow(role, isAdmin, isOwner) {
+  return { ok: true, role, isAdmin, isOwner };
+}
+function denied(reason) {
+  return { ok: false, role: "denied", isAdmin: false, isOwner: false, reason };
+}
+
+// src/session/catalog.ts
+var SessionCatalog = class {
+  constructor(path, now = Date.now) {
+    this.path = path;
+    this.now = now;
+  }
+  path;
+  now;
+  async activeFor(input2) {
+    const file = await this.read();
+    return file.entries.find(
+      (entry) => entry.status === "active" && entry.scopeId === input2.scopeId && entry.cwdRealpath === input2.cwdRealpath && entry.policyFingerprint === input2.policyFingerprint
+    );
+  }
+  async upsertActive(input2) {
+    const file = await this.read();
+    const key = catalogKey(input2.scopeId, input2.cwdRealpath, input2.policyFingerprint);
+    for (const entry of file.entries) {
+      if (entry.scopeId === input2.scopeId && entry.cwdRealpath === input2.cwdRealpath && entry.policyFingerprint !== input2.policyFingerprint) {
+        entry.status = "archived";
+      }
+    }
+    const existing = file.entries.find((entry) => entry.key === key);
+    const next = {
+      ...input2,
+      key,
+      status: "active",
+      updatedAt: this.now()
+    };
+    if (existing) Object.assign(existing, next);
+    else file.entries.push(next);
+    await this.write(file);
+    return next;
+  }
+  async archiveScope(scopeId) {
+    const file = await this.read();
+    for (const entry of file.entries) {
+      if (entry.scopeId === scopeId && entry.status === "active") {
+        entry.status = "archived";
+        entry.updatedAt = this.now();
+      }
+    }
+    await this.write(file);
+  }
+  async recentCompatible(input2, limit = 5) {
+    const file = await this.read();
+    return file.entries.filter(
+      (entry) => entry.scopeId === input2.scopeId && entry.cwdRealpath === input2.cwdRealpath && entry.policyFingerprint === input2.policyFingerprint
+    ).sort((a, b) => b.updatedAt - a.updatedAt).slice(0, limit);
+  }
+  async recentForScopeWorkspace(scopeId, cwdRealpath, limit = 10) {
+    const file = await this.read();
+    return file.entries.filter((entry) => entry.scopeId === scopeId && entry.cwdRealpath === cwdRealpath).sort((a, b) => b.updatedAt - a.updatedAt).slice(0, limit);
+  }
+  async byKey(key) {
+    return (await this.read()).entries.find((entry) => entry.key === key);
+  }
+  async restoreActive(key) {
+    const file = await this.read();
+    const target = file.entries.find((entry) => entry.key === key);
+    if (!target) return void 0;
+    for (const entry of file.entries) {
+      if (entry.scopeId === target.scopeId && entry.cwdRealpath === target.cwdRealpath) entry.status = "archived";
+    }
+    target.status = "active";
+    target.updatedAt = this.now();
+    await this.write(file);
+    return target;
+  }
+  async read() {
+    const file = await readJsonFile(this.path, { schemaVersion: 1, entries: [] });
+    return {
+      schemaVersion: 1,
+      entries: Array.isArray(file.entries) ? file.entries : []
+    };
+  }
+  async write(file) {
+    await writeJsonAtomic(this.path, file);
+  }
+};
+function catalogKey(scopeId, cwdRealpath, policyFingerprint2) {
+  return `${scopeId}\0${cwdRealpath}\0${policyFingerprint2}`;
+}
+
+// src/session/store.ts
+var SessionStore = class {
+  constructor(path, now = Date.now) {
+    this.path = path;
+    this.now = now;
+  }
+  path;
+  now;
+  async get(scopeId) {
+    return (await this.read())[scopeId];
+  }
+  async set(scopeId, threadId, cwdRealpath) {
+    const store = await this.read();
+    store[scopeId] = { ...store[scopeId], threadId, cwdRealpath, updatedAt: this.now() };
+    await writeJsonAtomic(this.path, store);
+  }
+  async setTimeout(scopeId, minutes) {
+    const store = await this.read();
+    const current = store[scopeId] ?? { updatedAt: this.now() };
+    if (minutes === void 0) delete current.idleTimeoutMinutes;
+    else current.idleTimeoutMinutes = minutes;
+    current.updatedAt = this.now();
+    store[scopeId] = current;
+    await writeJsonAtomic(this.path, store);
+  }
+  async clear(scopeId) {
+    const store = await this.read();
+    delete store[scopeId];
+    await writeJsonAtomic(this.path, store);
+  }
+  read() {
+    return readJsonFile(this.path, {});
+  }
+};
+
+// src/workspace/store.ts
+var WorkspaceStore = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  async cwdFor(scopeId) {
+    const file = await this.read();
+    return file.currentByScope[scopeId];
+  }
+  async setCwd(scopeId, cwd) {
+    const file = await this.read();
+    file.currentByScope[scopeId] = cwd;
+    await this.write(file);
+  }
+  async clearCwd(scopeId) {
+    const file = await this.read();
+    delete file.currentByScope[scopeId];
+    await this.write(file);
+  }
+  async saveAlias(name, cwd) {
+    const file = await this.read();
+    file.aliases[name] = cwd;
+    await this.write(file);
+  }
+  async removeAlias(name) {
+    const file = await this.read();
+    delete file.aliases[name];
+    await this.write(file);
+  }
+  async alias(name) {
+    return (await this.read()).aliases[name];
+  }
+  async aliases() {
+    return { ...(await this.read()).aliases };
+  }
+  async read() {
+    const file = await readJsonFile(this.path, { schemaVersion: 1, currentByScope: {}, aliases: {} });
+    return {
+      schemaVersion: 1,
+      currentByScope: file.currentByScope ?? {},
+      aliases: file.aliases ?? {}
+    };
+  }
+  write(file) {
+    return writeJsonAtomic(this.path, file);
+  }
+};
+
+// src/runtime/process-pool.ts
+var ProcessPool = class {
+  constructor(maxConcurrency) {
+    this.maxConcurrency = maxConcurrency;
+    if (maxConcurrency <= 0) throw new Error("maxConcurrency must be positive");
+  }
+  maxConcurrency;
+  active = 0;
+  waiters = [];
+  snapshot() {
+    return { active: this.active, queued: this.waiters.length, maxConcurrency: this.maxConcurrency };
+  }
+  async acquire(opts = {}) {
+    if (this.active < this.maxConcurrency) {
+      this.active += 1;
+      return () => this.release();
+    }
+    if (opts.wait === false) throw new Error("pool full");
+    await new Promise((resolve3) => this.waiters.push(resolve3));
+    this.active += 1;
+    return () => this.release();
+  }
+  release() {
+    this.active = Math.max(0, this.active - 1);
+    const next = this.waiters.shift();
+    if (next) next();
+  }
+};
+
+// src/lark-cli/profile-projection.ts
+import { createHash as createHash3 } from "crypto";
+import { readdir as readdir2, readFile as readFile7, stat as stat3 } from "fs/promises";
+import { join as join7 } from "path";
+async function projectLarkCliIdentity(profile) {
+  const preset = profile.feishuCli.identityPreset;
+  if (!profile.feishuCli.enabled || preset === "disabled") {
+    return { preset: "disabled", env: {}, configDigest: "disabled", health: "disabled" };
+  }
+  await ensureDir(profile.feishuCli.configDir);
+  const digest = await digestDirectory(profile.feishuCli.configDir);
+  const env = {
+    LARKSUITE_CLI_CONFIG_DIR: profile.feishuCli.configDir,
+    FEISHU_CODEX_LARK_CLI_PRESET: preset
+  };
+  return {
+    preset,
+    env,
+    configDigest: digest,
+    health: preset === "user-default" && digest === emptyDigest() ? "missing-config" : preset === "user-default" ? "user-ready" : "app"
+  };
+}
+async function digestDirectory(dir) {
+  const hash = createHash3("sha256");
+  const files = await collectFiles(dir);
+  if (files.length === 0) return emptyDigest();
+  for (const file of files) {
+    hash.update(file.slice(dir.length));
+    hash.update(await readFile7(file));
+  }
+  return hash.digest("base64url");
+}
+function emptyDigest() {
+  return createHash3("sha256").update("").digest("base64url");
+}
+async function collectFiles(dir) {
+  const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
+  const files = [];
+  for (const entry of entries) {
+    const path = join7(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(path));
+    } else if (entry.isFile()) {
+      const info = await stat3(path);
+      if (info.size <= 1024 * 1024) files.push(path);
+    }
+  }
+  return files.sort();
+}
+
+// src/policy/fingerprint.ts
+import { createHash as createHash4 } from "crypto";
+function policyFingerprint(input2) {
+  return createHash4("sha256").update(stableJson(input2)).digest("base64url");
+}
+function accessPolicyDigest(profile) {
+  return createHash4("sha256").update(stableJson({ permissions: profile.permissions, access: profile.access })).digest("base64url");
+}
+function stableJson(value) {
+  return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, sortValue(entry)])
+    );
+  }
+  return value;
+}
+
+// src/policy/permissions.ts
+var ORDER = ["read-only", "workspace", "full"];
+function clampAccess(requested, max) {
+  return ORDER[Math.min(ORDER.indexOf(requested), ORDER.indexOf(max))] ?? "read-only";
+}
+function accessToSandbox(access3) {
+  if (access3 === "read-only") return "read-only";
+  if (access3 === "workspace") return "workspace-write";
+  return "danger-full-access";
+}
+function decideAccess(config, requested) {
+  return clampAccess(requested ?? config.defaultAccess, config.maxAccess);
+}
+
+// src/policy/run-policy.ts
+function evaluateRunPolicy(input2) {
+  if (!input2.access.ok) {
+    return reject("access-denied", "You are not allowed to use this bot in the current scope.");
+  }
+  if (input2.prompt.trim().length === 0 && input2.attachments.length === 0) {
+    return reject("prompt-empty", "Send a task or attachment for Codex to work on.");
+  }
+  const access3 = decideAccess(input2.profile.permissions, input2.requestedAccess);
+  if (input2.message.chatType !== "private" && input2.profile.feishuCli.identityPreset === "user-default" && !input2.profile.access.allowUserCliInGroups) {
+    return reject("user-cli-group-blocked", "Personal Feishu/Lark CLI identity is disabled in group scopes.");
+  }
+  const attachments = decideAttachments(input2.profile, input2.attachments);
+  const rejectedRequired = attachments.find((item) => item.required && item.decision === "rejected");
+  if (rejectedRequired) {
+    return reject("attachment-policy", `Attachment rejected: ${rejectedRequired.reason ?? "policy"}.`);
+  }
+  const sandbox = accessToSandbox(access3);
+  const fp = policyFingerprint({
+    scopeId: input2.scopeId,
+    cwdRealpath: input2.cwdRealpath,
+    sandbox,
+    networkAccess: input2.profile.permissions.networkAccess,
+    accessDigest: accessPolicyDigest(input2.profile),
+    resourceDigest: stableJson({}),
+    attachmentDigest: stableJson(attachments.map((item) => ({ kind: item.kind, path: item.path, decision: item.decision }))),
+    codexAuthMode: input2.profile.codex.auth.mode,
+    codexHome: input2.profile.codex.codexHome,
+    runtimeIdentity: input2.profile.codex.backend,
+    feishuCliIdentityPreset: input2.profile.feishuCli.identityPreset,
+    feishuCliConfigDigest: input2.feishuCliConfigDigest
+  });
+  return {
+    ok: true,
+    access: access3,
+    sandbox,
+    networkAccess: input2.profile.permissions.networkAccess,
+    policyFingerprint: fp,
+    attachments,
+    runScopedEnv: {}
+  };
+}
+function decideAttachments(profile, attachments) {
+  let total = 0;
+  return attachments.map((attachment, index) => {
+    if (attachment.decision === "rejected") return attachment;
+    const bytes = attachment.bytes ?? 0;
+    total += bytes;
+    if (index >= profile.attachments.maxCount) return rejectAttachment(attachment, "too many attachments");
+    if (total > profile.attachments.maxBytes) return rejectAttachment(attachment, "attachment total too large");
+    if (attachment.kind === "image" && bytes > profile.attachments.imageMaxBytes) {
+      return rejectAttachment(attachment, "image too large");
+    }
+    if (attachment.kind === "file" && bytes > profile.attachments.maxFileBytes) {
+      return rejectAttachment(attachment, "file too large");
+    }
+    return { ...attachment, decision: "accepted" };
+  });
+}
+function rejectAttachment(attachment, reason) {
+  return { ...attachment, decision: "rejected", reason };
+}
+function reject(code, userVisible) {
+  return { ok: false, rejectReason: { code, userVisible } };
+}
+
+// src/policy/workspace.ts
+import { homedir as homedir2, platform as platform2 } from "os";
+import { parse, resolve as resolve2, dirname as dirname4, basename as basename2 } from "path";
+import { realpath, stat as stat4 } from "fs/promises";
+async function resolveWorkspace(input2) {
+  if (!input2 || input2.trim().length === 0) {
+    return reject2("empty-cwd", "No workspace is configured. Use /cd <absolute-path> first.");
+  }
+  const expanded = expandTilde(input2.trim());
+  if (!isAbsolutePath(expanded)) {
+    return reject2("relative-cwd", "Workspace must be an absolute path.");
+  }
+  let resolved;
+  try {
+    resolved = await realpath(expanded);
+  } catch (error) {
+    const code = error.code;
+    return reject2(code === "ENOENT" ? "missing-cwd" : "inaccessible-cwd", "Workspace path is not accessible.");
+  }
+  const info = await stat4(resolved).catch(() => void 0);
+  if (!info) return reject2("missing-cwd", "Workspace path does not exist.");
+  if (!info.isDirectory()) return reject2("not-directory", "Workspace path is not a directory.");
+  if (isBroadWorkspace(resolved)) {
+    return reject2("broad-cwd", "Workspace is too broad. Pick a project directory instead.");
+  }
+  return { ok: true, cwdRealpath: resolved };
+}
+function isBroadWorkspace(path) {
+  const resolved = resolve2(path);
+  const root = parse(resolved).root;
+  const home = resolve2(homedir2());
+  const userRoot = dirname4(home);
+  const desktop = resolve2(home, "Desktop");
+  const downloads = resolve2(home, "Downloads");
+  const tmp = tempRoot();
+  if (resolved === root || resolved === home || resolved === userRoot || resolved === desktop || resolved === downloads || resolved === tmp) {
+    return true;
+  }
+  if (platform2() !== "win32") {
+    const systemRoots = ["/bin", "/sbin", "/usr", "/usr/bin", "/usr/local", "/etc", "/var", "/private", "/System", "/Library", "/Applications", "/Volumes"];
+    if (systemRoots.includes(resolved)) return true;
+    if (dirname4(resolved) === "/Volumes") return true;
+  } else {
+    const lower = resolved.toLowerCase();
+    const base = basename2(lower);
+    if (["windows", "program files", "program files (x86)", "programdata"].includes(base)) return true;
+  }
+  return false;
+}
+function isAbsolutePath(path) {
+  return resolve2(path) === path;
+}
+function reject2(reason, userVisible) {
+  return { ok: false, reason, userVisible };
+}
+
+// src/runtime/run-flow.ts
+async function startRun(input2) {
+  const requested = await input2.workspaces.cwdFor(input2.message.scopeId) ?? input2.profile.workspaces.default;
+  const workspace = await resolveWorkspace(requested);
+  if (!workspace.ok) {
+    return { ok: false, workspace, code: workspace.reason, userVisible: workspace.userVisible };
+  }
+  const cli = await projectLarkCliIdentity(input2.profile);
+  const policy = evaluateRunPolicy({
+    profile: input2.profile,
+    scopeId: input2.message.scopeId,
+    message: input2.message,
+    access: input2.access,
+    cwdRealpath: workspace.cwdRealpath,
+    prompt: input2.prompt,
+    attachments: input2.attachments,
+    feishuCliConfigDigest: cli.configDigest
+  });
+  if (!policy.ok) {
+    return { ok: false, policy, code: policy.rejectReason.code, userVisible: policy.rejectReason.userVisible };
+  }
+  const existing = await input2.sessionCatalog.activeFor({
+    scopeId: input2.message.scopeId,
+    cwdRealpath: workspace.cwdRealpath,
+    policyFingerprint: policy.policyFingerprint
+  });
+  const apiKey = input2.profile.codex.auth.mode === "api-key" && input2.profile.codex.auth.apiKey ? await input2.secretResolver.resolve(input2.profile.codex.auth.apiKey) : void 0;
+  const session = await input2.sessions.get(input2.message.scopeId);
+  const idleTimeoutMinutes = session?.idleTimeoutMinutes ?? input2.profile.preferences.idleTimeoutMinutes;
+  const runInput = {
+    runId: input2.runId,
+    prompt: input2.prompt,
+    cwdRealpath: workspace.cwdRealpath,
+    threadId: existing?.codexThreadId,
+    sandbox: policy.sandbox,
+    networkAccess: policy.networkAccess,
+    imagePaths: policy.attachments.filter((attachment) => attachment.kind === "image" && attachment.decision === "accepted" && attachment.path).map((attachment) => attachment.path),
+    env: cli.env,
+    apiKey,
+    baseUrl: input2.profile.codex.baseUrl,
+    codexHome: input2.profile.codex.inheritUserCodexHome ? void 0 : input2.profile.codex.codexHome,
+    codexPath: input2.profile.codex.codexPath,
+    config: input2.profile.codex.config,
+    idleTimeoutMs: idleTimeoutMinutes ? idleTimeoutMinutes * 60 * 1e3 : void 0
+  };
+  const handle = existing?.codexThreadId ? await input2.runner.resume(existing.codexThreadId, runInput) : await input2.runner.start(runInput);
+  void consumeEvents({
+    handle,
+    sessions: input2.sessions,
+    catalog: input2.sessionCatalog,
+    scopeId: input2.message.scopeId,
+    cwdRealpath: workspace.cwdRealpath,
+    policyFingerprint: policy.policyFingerprint,
+    onEvent: input2.onEvent
+  });
+  return {
+    ok: true,
+    handle,
+    cwdRealpath: workspace.cwdRealpath,
+    policy,
+    ...existing?.codexThreadId ? { resumeFrom: existing.codexThreadId } : {}
+  };
+}
+async function consumeEvents(input2) {
+  for await (const event of input2.handle.events) {
+    if (event.type === "thread") {
+      await input2.sessions.set(input2.scopeId, event.threadId, input2.cwdRealpath);
+      await input2.catalog.upsertActive({
+        scopeId: input2.scopeId,
+        cwdRealpath: input2.cwdRealpath,
+        policyFingerprint: input2.policyFingerprint,
+        codexThreadId: event.threadId
+      });
+    }
+    await input2.onEvent?.(event);
+  }
+}
+
+// src/runtime/orchestrator.ts
+import { randomUUID } from "crypto";
+var RunOrchestrator = class {
+  constructor(input2) {
+    this.input = input2;
+    this.pool = input2.pool ?? new ProcessPool(input2.profile.preferences.maxConcurrency);
+    this.runId = input2.runId ?? (() => `run_${randomUUID().slice(0, 8)}`);
+  }
+  input;
+  scopes = /* @__PURE__ */ new Map();
+  pool;
+  runId;
+  snapshot(scopeId) {
+    if (scopeId) {
+      const state = this.scopes.get(scopeId);
+      return { active: Boolean(state?.active), queued: state?.queued.length ?? 0, pool: this.pool.snapshot() };
+    }
+    return { scopes: this.scopes.size, pool: this.pool.snapshot() };
+  }
+  isActive(scopeId) {
+    return Boolean(this.scopes.get(scopeId)?.active);
+  }
+  async submit(input2) {
+    const state = this.state(input2.message.scopeId);
+    if (state.active) {
+      state.queued.push(input2);
+      return { ok: true, queued: true };
+    }
+    return this.startInScope(input2);
+  }
+  async stop(scopeId) {
+    const state = this.scopes.get(scopeId);
+    if (!state?.active) return false;
+    await state.active.stop();
+    return true;
+  }
+  async startInScope(input2) {
+    const state = this.state(input2.message.scopeId);
+    const release = await this.pool.acquire();
+    try {
+      const result = await startRun({
+        profile: this.input.profile,
+        runner: this.input.runner,
+        secretResolver: this.input.secretResolver,
+        sessions: this.input.sessions,
+        sessionCatalog: this.input.sessionCatalog,
+        workspaces: this.input.workspaces,
+        message: input2.message,
+        access: input2.access,
+        prompt: input2.prompt,
+        attachments: input2.attachments ?? [],
+        runId: this.runId(),
+        onEvent: async (event) => {
+          await this.input.onEvent?.(input2.message.scopeId, event);
+          if (event.type === "done" || event.type === "error") {
+            state.active = void 0;
+            release();
+            const queued = state.queued.splice(0);
+            if (queued.length) {
+              const next = combineQueued(queued);
+              void this.startInScope(next);
+            }
+          }
+        }
+      });
+      if (result.ok) {
+        state.active = result.handle;
+      } else {
+        release();
+      }
+      return result;
+    } catch (error) {
+      release();
+      throw error;
+    }
+  }
+  state(scopeId) {
+    const existing = this.scopes.get(scopeId);
+    if (existing) return existing;
+    const next = { queued: [] };
+    this.scopes.set(scopeId, next);
+    return next;
+  }
+};
+function combineQueued(items) {
+  const first = items[0];
+  return {
+    ...first,
+    prompt: items.map((item) => item.prompt).join("\n\n"),
+    attachments: items.flatMap((item) => item.attachments ?? [])
+  };
+}
+
+// src/render/command-cards.ts
+function buildHelpCard(profile, context) {
+  return card("feishu-codex help", "blue", [
+    markdown2(
+      [
+        `**Backend** ${profile.codex.backend}`,
+        "",
+        "`/new` clear current Codex thread",
+        "`/new group [name]` create a new group chat",
+        "`/resume` list recoverable sessions",
+        "`/cd <path>` switch workspace",
+        "`/ws list|save|add|use|remove` manage workspaces",
+        "`/status` show runtime state",
+        "`/stop` stop current run",
+        "`/timeout <minutes|off|default>` set scope timeout",
+        "`/config` configure connector behavior",
+        "`/invite`, `/remove` manage access",
+        "`/doctor` diagnostics"
+      ].join("\n")
+    ),
+    actions([
+      button("Status", "/status", context, "primary"),
+      button("Workspaces", "/ws list", context),
+      button("Config", "/config", context),
+      button("New session", "/new", context, "danger")
+    ])
+  ]);
+}
+function buildStatusCard(input2) {
+  return card("feishu-codex status", "green", [
+    markdown2(
+      [
+        `**Profile** ${input2.profile.name}`,
+        `**Tenant** ${input2.profile.tenant}`,
+        `**Scope** ${input2.scopeId}`,
+        `**Workspace** ${input2.workspace}`,
+        `**Codex** ${input2.profile.codex.backend} / ${input2.profile.codex.auth.mode}`,
+        `**lark-cli** ${input2.profile.feishuCli.identityPreset}`,
+        `**Access** ${input2.profile.permissions.defaultAccess}/${input2.profile.permissions.maxAccess}`,
+        `**Network** ${input2.profile.permissions.networkAccess ? "enabled" : "disabled"}`,
+        `**Thread** ${input2.threadId ?? "(none)"}`,
+        `**Queue** ${queueSummary(input2.queue)}`,
+        `**Actor** ${input2.actorRole}`
+      ].join("\n")
+    ),
+    actions([
+      button("Refresh", "/status", input2.context, "primary"),
+      button("Workspaces", "/ws list", input2.context),
+      button("New session", "/new", input2.context, "danger")
+    ])
+  ]);
+}
+function buildWorkspaceListCard(input2) {
+  const rows = [markdown2(`**Current** ${input2.current ?? "(not set)"}`)];
+  const entries = Object.entries(input2.aliases);
+  if (entries.length === 0) {
+    rows.push(markdown2("No saved workspaces."));
+  } else {
+    for (const [name, path] of entries) {
+      rows.push(markdown2(`**${escapeMarkdown(name)}**
+${escapeMarkdown(path)}`));
+      rows.push(actions([button("Use", `/ws use ${name}`, input2.context, "primary"), button("Remove", `/ws remove ${name}`, input2.context, "danger")]));
+    }
+  }
+  rows.push(actions([button("Refresh", "/ws list", input2.context)]));
+  return card("workspaces", "blue", rows);
+}
+function buildConfigCard(profile, context) {
+  const submitValue = commandValue("/config submit", context);
+  return card("feishu-codex config", "blue", [
+    markdown2("**Preferences**"),
+    {
+      tag: "form",
+      name: "config_form",
+      elements: [
+        select("replyMode", profile.preferences.replyMode, [
+          ["card", "Card"],
+          ["markdown", "Markdown"],
+          ["text", "Text"]
+        ]),
+        select("showToolCalls", profile.preferences.showToolCalls ? "true" : "false", [
+          ["true", "Show tools"],
+          ["false", "Hide tools"]
+        ]),
+        input("debounceMs", String(profile.preferences.debounceMs), "Debounce ms"),
+        input("maxConcurrency", String(profile.preferences.maxConcurrency), "Max concurrency"),
+        input("idleTimeoutMinutes", String(profile.preferences.idleTimeoutMinutes ?? ""), "Default timeout minutes"),
+        select("requireMentionInGroup", profile.access.requireMentionInGroup ? "true" : "false", [
+          ["true", "Require @ in groups"],
+          ["false", "No @ required"]
+        ]),
+        select("larkCliIdentity", profile.feishuCli.identityPreset, [
+          ["bot-only", "Bot only"],
+          ["user-default", "User default"],
+          ["disabled", "Disabled"]
+        ]),
+        select("defaultAccess", profile.permissions.defaultAccess, [
+          ["read-only", "Read only"],
+          ["workspace", "Workspace"],
+          ["full", "Full"]
+        ]),
+        select("maxAccess", profile.permissions.maxAccess, [
+          ["read-only", "Read only"],
+          ["workspace", "Workspace"],
+          ["full", "Full"]
+        ]),
+        select("networkAccess", profile.permissions.networkAccess ? "true" : "false", [
+          ["false", "Network off"],
+          ["true", "Network on"]
+        ]),
+        {
+          tag: "action",
+          actions: [
+            {
+              tag: "button",
+              text: { tag: "plain_text", content: "Save" },
+              type: "primary",
+              form_action_type: "submit",
+              value: submitValue
+            }
+          ]
+        }
+      ]
+    },
+    markdown2(
+      [
+        `**Allowed users** ${profile.access.allowedUsers.length}`,
+        `**Allowed chats** ${profile.access.allowedChats.length}`,
+        `**Admins** ${profile.access.admins.length}`
+      ].join("\n")
+    )
+  ]);
+}
+function card(title, template, elements) {
+  return {
+    config: { wide_screen_mode: true, update_multi: true },
+    header: { title: { tag: "plain_text", content: title }, template },
+    elements
+  };
+}
+function markdown2(content) {
+  return { tag: "div", text: { tag: "lark_md", content } };
+}
+function actions(items) {
+  return { tag: "action", actions: items };
+}
+function button(label, command, context, type) {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: label },
+    type: type ?? "default",
+    value: commandValue(command, context)
+  };
+}
+function commandValue(command, context) {
+  const token = context.callbackAuth && context.chatId && context.operatorOpenId ? context.callbackAuth.sign({
+    runId: "command",
+    scopeId: context.scopeId,
+    chatId: context.chatId,
+    operatorOpenId: context.operatorOpenId,
+    action: command,
+    policyFingerprint: "command",
+    ttlMs: 10 * 60 * 1e3
+  }) : void 0;
+  return {
+    kind: "feishu-codex.command",
+    command,
+    ...token ? { token } : {},
+    scopeId: context.scopeId,
+    chatId: context.chatId,
+    chatType: context.chatType
+  };
+}
+function select(name, initial, options) {
+  return {
+    tag: "select_static",
+    name,
+    initial_option: initial,
+    options: options.map(([value, label]) => ({ text: { tag: "plain_text", content: label }, value }))
+  };
+}
+function input(name, value, placeholder) {
+  return {
+    tag: "input",
+    name,
+    default_value: value,
+    placeholder: { tag: "plain_text", content: placeholder },
+    input_type: "text"
+  };
+}
+function escapeMarkdown(value) {
+  return value.replace(/([*_`])/g, "\\$1");
+}
+function queueSummary(value) {
+  const root = record(value);
+  const run = record(root.run);
+  const pending = record(root.pending);
+  const pool = record(run.pool);
+  const active = booleanText(run.active);
+  const runQueued = numberText(run.queued);
+  const poolActive = numberText(pool.active);
+  const poolQueued = numberText(pool.queued);
+  const poolMax = numberText(pool.maxConcurrency);
+  const pendingQueued = numberText(pending.queued);
+  const pendingBlocked = booleanText(pending.blocked);
+  return `run active ${active}, run queued ${runQueued}, pool ${poolActive}/${poolMax} active ${poolQueued} waiting, pending ${pendingQueued}, blocked ${pendingBlocked}`;
+}
+function record(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function numberText(value) {
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : "-";
+}
+function booleanText(value) {
+  return value === true ? "yes" : "no";
+}
+
+// src/commands/router.ts
+var ADMIN_COMMANDS = /* @__PURE__ */ new Set(["/cd", "/ws", "/config", "/invite", "/remove", "/doctor", "/ps", "/exit", "/reconnect"]);
+async function routeCommand(context) {
+  const parsed = parseCommand(context.message.text);
+  if (!parsed) return { handled: false };
+  if (ADMIN_COMMANDS.has(parsed.name) && !canRunAdminCommand(context.access)) {
+    return text("This command is limited to the owner or admins.");
+  }
+  switch (parsed.name) {
+    case "/help":
+      return card2(buildHelpCard(context.profile, commandCardContext(context)));
+    case "/status":
+      return statusCard(context);
+    case "/new":
+    case "/reset":
+      if (parsed.name === "/new" && parsed.args[0] === "group") return newGroupCommand(context, parsed.args.slice(1).join(" "));
+      await context.stopScope(context.message.scopeId);
+      await context.sessions.clear(context.message.scopeId);
+      await context.sessionCatalog.archiveScope(context.message.scopeId);
+      return text("Session reset for this scope.");
+    case "/cd":
+      return cdCommand(context, parsed.args.join(" "));
+    case "/ws":
+      return workspaceCommand(context, parsed.args);
+    case "/stop":
+      return text(await context.stopScope(context.message.scopeId) ? "Stopping the current run." : "No active run in this scope.");
+    case "/timeout":
+      return timeoutCommand(context, parsed.args[0]);
+    case "/config":
+      return configCommand(context, parsed.args);
+    case "/invite":
+      return inviteCommand(context, parsed.args);
+    case "/remove":
+      return removeCommand(context, parsed.args);
+    case "/doctor":
+      return markdown3(await doctorText(context, parsed.args[0] === "detail"), true);
+    case "/ps":
+      return markdown3(`Process registry:
+
+\`\`\`json
+${JSON.stringify(await context.processSnapshot?.() ?? [], null, 2)}
+\`\`\``);
+    case "/exit":
+      if (!context.lifecycle?.exit) return text("Lifecycle controls are not available in this runtime.");
+      await context.lifecycle?.exit?.(parsed.args[0]);
+      return text("Exit requested.");
+    case "/reconnect":
+      if (!context.lifecycle?.reconnect) return text("Reconnect is not available in this runtime.");
+      await context.lifecycle?.reconnect?.();
+      return text("Reconnect requested.");
+    case "/resume":
+      return resumeCommand(context, parsed.args);
+    default:
+      return text(`Unknown command: ${parsed.name}`);
+  }
+}
+function parseCommand(text2) {
+  const trimmed = text2.trim();
+  if (!trimmed.startsWith("/")) return void 0;
+  const [name, ...args] = trimmed.split(/\s+/);
+  return { name: name.toLowerCase(), args };
+}
+async function cdCommand(context, path) {
+  const resolved = await resolveWorkspace(path);
+  if (!resolved.ok) return text(resolved.userVisible);
+  await context.stopScope(context.message.scopeId);
+  await context.workspaces.setCwd(context.message.scopeId, resolved.cwdRealpath);
+  await context.sessions.clear(context.message.scopeId);
+  await context.sessionCatalog.archiveScope(context.message.scopeId);
+  return text(`Workspace switched to ${resolved.cwdRealpath}. Session reset.`);
+}
+async function workspaceCommand(context, args) {
+  const [sub, name] = args;
+  if (sub === "list") {
+    const aliases = await context.workspaces.aliases();
+    const current = await context.workspaces.cwdFor(context.message.scopeId);
+    return card2(buildWorkspaceListCard({ current, aliases, context: commandCardContext(context) }));
+  }
+  if (sub === "save" && name) {
+    const cwd = await context.workspaces.cwdFor(context.message.scopeId);
+    if (!cwd) return text("No current workspace to save.");
+    await context.workspaces.saveAlias(name, cwd);
+    return text(`Saved workspace ${name}.`);
+  }
+  if (sub === "add" && name && args[2]) {
+    const resolved = await resolveWorkspace(args.slice(2).join(" "));
+    if (!resolved.ok) return text(resolved.userVisible);
+    await context.workspaces.saveAlias(name, resolved.cwdRealpath);
+    return text(`Saved workspace ${name}: ${resolved.cwdRealpath}.`);
+  }
+  if (sub === "use" && name) {
+    const cwd = await context.workspaces.alias(name);
+    if (!cwd) return text(`Workspace alias not found: ${name}`);
+    const resolved = await resolveWorkspace(cwd);
+    if (!resolved.ok) return text(resolved.userVisible);
+    await context.workspaces.setCwd(context.message.scopeId, resolved.cwdRealpath);
+    await context.sessions.clear(context.message.scopeId);
+    await context.sessionCatalog.archiveScope(context.message.scopeId);
+    return text(`Workspace switched to ${name}. Session reset.`);
+  }
+  if (sub === "remove" && name) {
+    await context.workspaces.removeAlias(name);
+    return text(`Removed workspace ${name}.`);
+  }
+  return text("Usage: /ws list | /ws save <name> | /ws add <name> <path> | /ws use <name> | /ws remove <name>");
+}
+async function timeoutCommand(context, value) {
+  const current = await context.sessions.get(context.message.scopeId);
+  if (!value) {
+    return text(`Current timeout: ${current?.idleTimeoutMinutes ?? context.profile.preferences.idleTimeoutMinutes ?? "default"} minutes.`);
+  }
+  if (value === "off" || value === "default") await context.sessions.setTimeout(context.message.scopeId, void 0);
+  else {
+    const minutes = Number(value);
+    if (!Number.isFinite(minutes) || minutes < 1 || minutes > 24 * 60) return text("Timeout must be 1-1440 minutes, off, or default.");
+    await context.sessions.setTimeout(context.message.scopeId, Math.floor(minutes));
+  }
+  const next = await context.sessions.get(context.message.scopeId);
+  return text(`Timeout updated: ${next?.idleTimeoutMinutes ?? context.profile.preferences.idleTimeoutMinutes ?? "default"}.`);
+}
+async function inviteCommand(context, args) {
+  const [kind, second] = args;
+  if (kind === "all" && second === "group") {
+    if (!context.gateway?.listJoinedChats) return text("The current channel cannot list joined groups.");
+    const chats = await context.gateway.listJoinedChats();
+    for (const chat of chats) addUnique(context.profile.access.allowedChats, chat.chatId);
+    await context.saveProfile?.(context.profile);
+    return text(`Access list updated. Added ${chats.length} groups.`);
+  }
+  if (kind === "group") {
+    if (!context.message.chatId || context.message.chatType === "private") return text("/invite group must be used in a group or topic chat.");
+    addUnique(context.profile.access.allowedChats, context.message.chatId);
+  } else if (kind === "admin") {
+    const mentions = realUserMentions(context.message);
+    if (mentions.length === 0) return text("Mention at least one user: /invite admin @name");
+    for (const mention of mentions) addUnique(context.profile.access.admins, mention.id);
+  } else if (kind === "user") {
+    const mentions = realUserMentions(context.message);
+    if (mentions.length === 0) return text("Mention at least one user: /invite user @name");
+    for (const mention of mentions) addUnique(context.profile.access.allowedUsers, mention.id);
+  } else {
+    return text("Usage: /invite user @name | /invite admin @name | /invite group | /invite all group");
+  }
+  await context.saveProfile?.(context.profile);
+  return text("Access list updated.");
+}
+async function removeCommand(context, args) {
+  const [kind] = args;
+  if (kind === "group" && context.message.chatId) {
+    if (context.message.chatType === "private") return text("/remove group must be used in a group or topic chat.");
+    removeValue(context.profile.access.allowedChats, context.message.chatId);
+  } else if (kind === "admin") {
+    const mentions = realUserMentions(context.message);
+    if (mentions.length === 0) return text("Mention at least one user: /remove admin @name");
+    for (const mention of mentions) removeValue(context.profile.access.admins, mention.id);
+  } else if (kind === "user") {
+    const mentions = realUserMentions(context.message);
+    if (mentions.length === 0) return text("Mention at least one user: /remove user @name");
+    for (const mention of mentions) removeValue(context.profile.access.allowedUsers, mention.id);
+  } else {
+    return text("Usage: /remove user @name | /remove admin @name | /remove group");
+  }
+  await context.saveProfile?.(context.profile);
+  return text("Access list updated.");
+}
+async function statusCard(context) {
+  const cwd = await context.workspaces.cwdFor(context.message.scopeId) ?? context.profile.workspaces.default ?? "(not set)";
+  const session = await context.sessions.get(context.message.scopeId);
+  return card2(
+    buildStatusCard({
+      profile: context.profile,
+      scopeId: context.message.scopeId,
+      workspace: cwd,
+      threadId: session?.threadId,
+      queue: context.queueSnapshot(context.message.scopeId),
+      actorRole: context.access.role,
+      context: commandCardContext(context)
+    })
+  );
+}
+function commandCardContext(context) {
+  return {
+    scopeId: context.message.scopeId,
+    chatId: context.message.chatId,
+    chatType: context.message.chatType,
+    operatorOpenId: context.message.actorId,
+    callbackAuth: context.callbackAuth
+  };
+}
+async function doctorText(context, detail) {
+  const availability = await context.runner.checkAvailability();
+  const cwd = await context.workspaces.cwdFor(context.message.scopeId) ?? context.profile.workspaces.default;
+  const workspace = await resolveWorkspace(cwd);
+  const lines = [
+    "Doctor report",
+    `Profile: ${context.profile.name}`,
+    `Backend: ${availability.label} (${availability.ok ? "ok" : "failed"})`,
+    availability.detail ? `Backend detail: ${availability.detail}` : void 0,
+    `Workspace: ${workspace.ok ? workspace.cwdRealpath : workspace.userVisible}`,
+    `Sandbox: ${context.profile.permissions.defaultAccess}`,
+    `Access: ${context.access.role}`,
+    `Queue: ${JSON.stringify(context.queueSnapshot(context.message.scopeId))}`
+  ];
+  if (detail) {
+    lines.push(
+      `App suffix: ${context.profile.app.id.slice(-6)}`,
+      `Reply mode: ${context.profile.preferences.replyMode}`,
+      `Tool calls: ${context.profile.preferences.showToolCalls ? "show" : "hide"}`,
+      `Debounce: ${context.profile.preferences.debounceMs}ms`,
+      `Max concurrency: ${context.profile.preferences.maxConcurrency}`,
+      `Require mention in group: ${context.profile.access.requireMentionInGroup ? "yes" : "no"}`,
+      `Allowed users: ${context.profile.access.allowedUsers.length}`,
+      `Allowed chats: ${context.profile.access.allowedChats.length}`,
+      `Admins: ${context.profile.access.admins.length}`
+    );
+  }
+  return lines.filter(Boolean).join("\n");
+}
+function configText(profile) {
+  return JSON.stringify(
+    {
+      replyMode: profile.preferences.replyMode,
+      showToolCalls: profile.preferences.showToolCalls,
+      maxConcurrency: profile.preferences.maxConcurrency,
+      requireMentionInGroup: profile.access.requireMentionInGroup,
+      access: profile.permissions,
+      codexAuth: profile.codex.auth.mode,
+      feishuCli: profile.feishuCli.identityPreset
+    },
+    null,
+    2
+  );
+}
+async function configCommand(context, args) {
+  if (args[0] === "show") return markdown3(configText(context.profile));
+  if (args[0] === "submit") {
+    if (!context.formValues) return text("No config form values received.");
+    const result = applyConfigForm(context.profile, context.formValues);
+    if (!result.ok) return text(result.message);
+    await context.saveProfile?.(context.profile);
+    return text("Config updated.");
+  }
+  return card2(buildConfigCard(context.profile, commandCardContext(context)));
+}
+async function resumeCommand(context, args) {
+  if (!context.resumeNonces) return text("Resume controls are not available in this runtime.");
+  if (args[0] === "use") {
+    const nonce = args[1];
+    if (!nonce) return text("Usage: /resume use <nonce>");
+    const key = context.resumeNonces.consume(nonce);
+    if (!key) return text("Resume token expired or invalid.");
+    const entry = await context.sessionCatalog.restoreActive(key);
+    if (!entry || entry.scopeId !== context.message.scopeId) return text("Resume candidate is no longer available.");
+    await context.sessions.set(context.message.scopeId, entry.codexThreadId, entry.cwdRealpath);
+    return text(`Resumed thread ${entry.codexThreadId}.`);
+  }
+  const cwd = await context.workspaces.cwdFor(context.message.scopeId) ?? context.profile.workspaces.default;
+  const workspace = await resolveWorkspace(cwd);
+  if (!workspace.ok) return text(workspace.userVisible);
+  const candidates = await context.sessionCatalog.recentForScopeWorkspace(context.message.scopeId, workspace.cwdRealpath, 8);
+  if (candidates.length === 0) return text("No resumable sessions for this scope and workspace.");
+  const lines = ["Resumable sessions:"];
+  for (const entry of candidates) {
+    const nonce = context.resumeNonces.issue(entry.key);
+    lines.push(`- ${new Date(entry.updatedAt).toLocaleString()} ${entry.codexThreadId} -> /resume use ${nonce}`);
+  }
+  return markdown3(lines.join("\n"));
+}
+async function newGroupCommand(context, rawName) {
+  if (!canRunAdminCommand(context.access)) return text("Creating groups is limited to the owner or admins.");
+  const name = rawName.trim() || defaultGroupName(context.profile.name);
+  if (!context.gateway?.createGroupChat) return text("The current channel cannot create group chats.");
+  const created = await context.gateway.createGroupChat({ name, inviteOpenId: context.message.actorId });
+  const sourceCwd = await context.workspaces.cwdFor(context.message.scopeId) ?? context.profile.workspaces.default;
+  if (sourceCwd) await context.workspaces.setCwd(`chat:${created.chatId}`, sourceCwd);
+  const welcome = sourceCwd ? `Group created. Workspace inherited: ${sourceCwd}
+
+Mention me with a task to start.` : "Group created.\n\nMention me with a task to start.";
+  await context.gateway.sendMessage({ chatId: created.chatId }, { mode: "markdown", content: welcome }).catch(() => void 0);
+  return text(`Created group ${created.name}.`);
+}
+function applyConfigForm(profile, form) {
+  const replyMode = stringForm(form.replyMode);
+  if (replyMode && (replyMode === "card" || replyMode === "markdown" || replyMode === "text")) profile.preferences.replyMode = replyMode;
+  const showToolCalls = boolForm(form.showToolCalls);
+  if (showToolCalls !== void 0) profile.preferences.showToolCalls = showToolCalls;
+  const debounce = intForm(form.debounceMs);
+  if (debounce !== void 0) {
+    if (debounce < 0 || debounce > 6e4) return { ok: false, message: "debounceMs must be 0-60000." };
+    profile.preferences.debounceMs = debounce;
+  }
+  const maxConcurrency = intForm(form.maxConcurrency);
+  if (maxConcurrency !== void 0) {
+    if (maxConcurrency < 1 || maxConcurrency > 50) return { ok: false, message: "maxConcurrency must be 1-50." };
+    profile.preferences.maxConcurrency = maxConcurrency;
+  }
+  const idle = stringForm(form.idleTimeoutMinutes);
+  if (idle !== void 0) {
+    if (idle.trim() === "") delete profile.preferences.idleTimeoutMinutes;
+    else {
+      const minutes = Number(idle);
+      if (!Number.isInteger(minutes) || minutes < 1 || minutes > 1440) return { ok: false, message: "idleTimeoutMinutes must be blank or 1-1440." };
+      profile.preferences.idleTimeoutMinutes = minutes;
+    }
+  }
+  const requireMention = boolForm(form.requireMentionInGroup);
+  if (requireMention !== void 0) profile.access.requireMentionInGroup = requireMention;
+  const identity = stringForm(form.larkCliIdentity);
+  if (identity === "bot-only" || identity === "user-default" || identity === "disabled") {
+    profile.feishuCli.identityPreset = identity;
+    profile.feishuCli.enabled = identity !== "disabled";
+  }
+  const defaultAccess = stringForm(form.defaultAccess);
+  if (defaultAccess === "read-only" || defaultAccess === "workspace" || defaultAccess === "full") profile.permissions.defaultAccess = defaultAccess;
+  const maxAccess = stringForm(form.maxAccess);
+  if (maxAccess === "read-only" || maxAccess === "workspace" || maxAccess === "full") profile.permissions.maxAccess = maxAccess;
+  const network = boolForm(form.networkAccess);
+  if (network !== void 0) profile.permissions.networkAccess = network;
+  return { ok: true };
+}
+function stringForm(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    const raw = value;
+    if (typeof raw.value === "string") return raw.value;
+  }
+  return void 0;
+}
+function boolForm(value) {
+  const raw = stringForm(value);
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  return void 0;
+}
+function intForm(value) {
+  const raw = stringForm(value);
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const num = Number(raw);
+  return Number.isInteger(num) ? num : void 0;
+}
+function defaultGroupName(profileName) {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${profileName} ${now.getMonth() + 1}-${now.getDate()} ${pad(now.getHours())}:${pad(now.getMinutes())}`;
+}
+function realUserMentions(message) {
+  return message.mentions.filter((mention) => mention.id && !mention.isBot && !mention.isAll);
+}
+function text(content, sensitive = false) {
+  return { handled: true, sensitive, reply: { mode: "text", content } };
+}
+function markdown3(content, sensitive = false) {
+  return { handled: true, sensitive, reply: { mode: "markdown", content } };
+}
+function card2(content, sensitive = false) {
+  return { handled: true, sensitive, reply: { mode: "card", content } };
+}
+function addUnique(values, value) {
+  if (!values.includes(value)) values.push(value);
+}
+function removeValue(values, value) {
+  const index = values.indexOf(value);
+  if (index >= 0) values.splice(index, 1);
+}
+
+// src/media/resolve.ts
+async function resolveMessageAttachments(input2) {
+  const out = [];
+  for (const resource of input2.message.resources) {
+    const kind = attachmentKind(resource);
+    const required = resource.required !== false;
+    if (!kind) {
+      if (required) out.push({ kind: "file", required, decision: "rejected", reason: `unsupported attachment kind: ${resource.kind}` });
+      continue;
+    }
+    if (!input2.gateway.downloadResource) {
+      out.push({ kind, required, decision: "rejected", reason: "resource download unavailable" });
+      continue;
+    }
+    try {
+      const data = await input2.gateway.downloadResource(input2.message, resource);
+      const cached = await input2.cache.putBytes(data.bytes, { name: data.name ?? resource.name, mime: data.mime ?? resource.mime });
+      out.push({
+        kind,
+        path: cached.path,
+        name: data.name ?? resource.name,
+        bytes: cached.bytes,
+        mime: data.mime ?? resource.mime ?? cached.mime,
+        required
+      });
+    } catch (error) {
+      out.push({
+        kind,
+        required,
+        decision: "rejected",
+        reason: error instanceof Error ? error.message : "resource download failed"
+      });
+    }
+  }
+  return out;
+}
+function attachmentKind(resource) {
+  if (resource.kind === "image") return "image";
+  if (resource.kind === "file") return "file";
+  return void 0;
+}
+
+// src/session/resume-nonce.ts
+import { randomBytes as randomBytes5 } from "crypto";
+var ResumeNonceStore = class {
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  now;
+  entries = /* @__PURE__ */ new Map();
+  issue(key, ttlMs = 10 * 60 * 1e3) {
+    this.gc();
+    const nonce = randomBytes5(5).toString("base64url");
+    this.entries.set(nonce, { key, expiresAt: this.now() + ttlMs });
+    return nonce;
+  }
+  consume(nonce) {
+    this.gc();
+    const entry = this.entries.get(nonce);
+    if (!entry) return void 0;
+    this.entries.delete(nonce);
+    return entry.key;
+  }
+  gc() {
+    const now = this.now();
+    for (const [nonce, entry] of this.entries) {
+      if (entry.expiresAt <= now) this.entries.delete(nonce);
+    }
+  }
+};
+
+// src/runtime/pending-queue.ts
+var PendingMessageQueue = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  scopes = /* @__PURE__ */ new Map();
+  push(scopeId, item) {
+    const scope = this.scope(scopeId);
+    scope.items.push(item);
+    this.schedule(scopeId, scope);
+  }
+  block(scopeId) {
+    const scope = this.scope(scopeId);
+    scope.blocked = true;
+    this.clearTimer(scope);
+  }
+  unblock(scopeId) {
+    const scope = this.scopes.get(scopeId);
+    if (!scope) return;
+    scope.blocked = false;
+    this.schedule(scopeId, scope);
+  }
+  cancel(scopeId) {
+    const scope = this.scopes.get(scopeId);
+    if (!scope) return 0;
+    this.clearTimer(scope);
+    const count = scope.items.length;
+    this.scopes.delete(scopeId);
+    return count;
+  }
+  snapshot(scopeId) {
+    if (scopeId) {
+      const scope = this.scopes.get(scopeId);
+      return { queued: scope?.items.length ?? 0, blocked: Boolean(scope?.blocked) };
+    }
+    let queued = 0;
+    let blocked = 0;
+    for (const scope of this.scopes.values()) {
+      queued += scope.items.length;
+      if (scope.blocked) blocked += 1;
+    }
+    return { scopes: this.scopes.size, queued, blocked };
+  }
+  scope(scopeId) {
+    const existing = this.scopes.get(scopeId);
+    if (existing) return existing;
+    const next = { items: [], blocked: false };
+    this.scopes.set(scopeId, next);
+    return next;
+  }
+  schedule(scopeId, scope) {
+    this.clearTimer(scope);
+    if (scope.blocked || scope.items.length === 0) return;
+    scope.timer = setTimeout(() => {
+      void this.flushScope(scopeId);
+    }, Math.max(0, this.options.debounceMs));
+  }
+  async flushScope(scopeId) {
+    const scope = this.scopes.get(scopeId);
+    if (!scope || scope.blocked || scope.items.length === 0) return;
+    this.clearTimer(scope);
+    const items = scope.items.splice(0);
+    this.scopes.delete(scopeId);
+    await this.options.flush(scopeId, items);
+  }
+  clearTimer(scope) {
+    if (!scope.timer) return;
+    clearTimeout(scope.timer);
+    scope.timer = void 0;
+  }
+};
+
+// src/runtime/bridge-runtime.ts
+var CARD_RENDER_THROTTLE_MS = 400;
+function bindBridgeRuntime(input2) {
+  const sessions = new SessionStore(input2.paths.sessions);
+  const sessionCatalog = new SessionCatalog(input2.paths.sessionCatalog);
+  const workspaces = new WorkspaceStore(input2.paths.workspaces);
+  const mediaCache = new MediaCache(input2.paths.mediaDir);
+  void mediaCache.gc(input2.profile.attachments.cacheTtlMs).catch(() => void 0);
+  const callbackAuth = new CallbackAuth([{ version: 1, secret: input2.appSecret }], new MemoryCallbackNonceStore());
+  const resumeNonces = new ResumeNonceStore();
+  const states = /* @__PURE__ */ new Map();
+  let orchestrator;
+  const pending = new PendingMessageQueue({
+    debounceMs: input2.profile.preferences.debounceMs,
+    flush: async (_scopeId, items) => {
+      await submitPendingMessages(input2, orchestrator, pending, states, callbackAuth, mediaCache, items);
+    }
+  });
+  orchestrator = new RunOrchestrator({
+    profile: input2.profile,
+    runner: input2.runner,
+    secretResolver: input2.secretResolver,
+    sessions,
+    sessionCatalog,
+    workspaces,
+    onEvent: async (scopeId, event) => {
+      await renderEvent(input2.gateway, states, scopeId, event);
+      if (event.type === "done" || event.type === "error") {
+        pending.unblock(scopeId);
+      }
+    }
+  });
+  input2.gateway.onMessage?.(async (message) => {
+    await maybeBootstrapOwner(input2, message);
+    const access3 = evaluateAccess({ profile: input2.profile, message, ownerOpenId: input2.ownerOpenId, botOpenId: input2.botOpenId });
+    console.log(`[bridge:access] scope=${message.scopeId} actor=${message.actorId} ok=${access3.ok} role=${access3.role} reason=${access3.reason ?? ""}`);
+    if (!access3.ok) return;
+    const parsed = parseCommand(message.text);
+    const command = await routeCommand({
+      profile: input2.profile,
+      access: access3,
+      message,
+      sessions,
+      sessionCatalog,
+      workspaces,
+      runner: input2.runner,
+      stopScope: (scopeId) => orchestrator.stop(scopeId),
+      queueSnapshot: (scopeId) => ({ run: orchestrator.snapshot(scopeId), pending: pending.snapshot(scopeId) }),
+      processSnapshot: input2.processSnapshot,
+      saveProfile: input2.saveProfile,
+      callbackAuth,
+      resumeNonces,
+      gateway: input2.gateway,
+      lifecycle: input2.lifecycle
+    });
+    if (command.handled) {
+      if (parsed && cancelsPending(parsed.name, parsed.args)) pending.cancel(message.scopeId);
+      if (command.reply) await sendBridgeReply(input2.gateway, message, command.reply);
+      return;
+    }
+    if (orchestrator.isActive(message.scopeId)) pending.block(message.scopeId);
+    pending.push(message.scopeId, { message, payload: { access: access3 } });
+  });
+  input2.gateway.onAction?.(async (action) => {
+    const actionCommand = typeof action.value?.command === "string" ? action.value.command : void 0;
+    if (actionCommand) {
+      const token = typeof action.value?.token === "string" ? action.value.token : "";
+      const verified2 = callbackAuth.verify(token, {
+        runId: "command",
+        scopeId: typeof action.value?.scopeId === "string" ? action.value.scopeId : action.scopeId,
+        chatId: typeof action.value?.chatId === "string" ? action.value.chatId : action.chatId,
+        operatorOpenId: action.operatorOpenId,
+        action: actionCommand,
+        policyFingerprint: "command"
+      });
+      if (!verified2.ok) {
+        await input2.gateway.sendMessage({ chatId: action.chatId, messageId: action.messageId }, { mode: "text", content: `Action denied: ${verified2.reason}` });
+        return;
+      }
+      const message = messageFromAction(action, actionCommand, input2.botOpenId);
+      const access3 = evaluateAccess({ profile: input2.profile, message, ownerOpenId: input2.ownerOpenId, botOpenId: input2.botOpenId });
+      if (!access3.ok) {
+        await input2.gateway.sendMessage({ chatId: action.chatId, messageId: action.messageId }, { mode: "text", content: `Action denied: ${access3.reason ?? "unauthorized"}` });
+        return;
+      }
+      const parsed = parseCommand(message.text);
+      const command = await routeCommand({
+        profile: input2.profile,
+        access: access3,
+        message,
+        sessions,
+        sessionCatalog,
+        workspaces,
+        runner: input2.runner,
+        stopScope: (scopeId) => orchestrator.stop(scopeId),
+        queueSnapshot: (scopeId) => ({ run: orchestrator.snapshot(scopeId), pending: pending.snapshot(scopeId) }),
+        processSnapshot: input2.processSnapshot,
+        saveProfile: input2.saveProfile,
+        callbackAuth,
+        formValues: action.formValues,
+        resumeNonces,
+        gateway: input2.gateway,
+        lifecycle: input2.lifecycle
+      });
+      if (command.handled) {
+        if (parsed && cancelsPending(parsed.name, parsed.args)) pending.cancel(message.scopeId);
+        if (command.reply) await input2.gateway.sendMessage({ chatId: message.chatId, messageId: message.messageId }, command.reply);
+      }
+      return;
+    }
+    const entry = states.get(action.scopeId);
+    if (!entry || action.token.length === 0) return;
+    const verified = callbackAuth.verify(action.token, {
+      runId: entry.state.runId,
+      scopeId: action.scopeId,
+      chatId: action.chatId,
+      operatorOpenId: action.operatorOpenId,
+      action: "stop",
+      policyFingerprint: entry.context.policyFingerprint
+    });
+    if (!verified.ok) return;
+    await orchestrator.stop(action.scopeId);
+  });
+  return orchestrator;
+}
+async function maybeBootstrapOwner(input2, message) {
+  if (!input2.bootstrapOwner) return;
+  if (message.chatType !== "private" || message.actorType === "bot" || !message.actorId) return;
+  const access3 = input2.profile.access;
+  const hasConfiguredOperator = Boolean(input2.ownerOpenId) || access3.admins.length > 0 || access3.allowedUsers.length > 0 || access3.allowedChats.length > 0;
+  if (hasConfiguredOperator) return;
+  access3.admins.push(message.actorId);
+  access3.allowedUsers.push(message.actorId);
+  await input2.saveProfile?.(input2.profile);
+  console.log(`bootstrapped owner/admin open_id=${message.actorId}`);
+}
+async function submitPendingMessages(input2, orchestrator, pending, states, callbackAuth, mediaCache, items) {
+  const first = items[0];
+  if (!first) return;
+  const message = first.message;
+  const attachmentsByMessage = await Promise.all(
+    items.map((item) => resolveMessageAttachments({ gateway: input2.gateway, cache: mediaCache, message: item.message }))
+  );
+  const prompt = items.map((item, index) => buildPrompt({ message: item.message, botOpenId: input2.botOpenId, attachments: attachmentsByMessage[index] ?? [] })).join("\n\n");
+  const attachments = attachmentsByMessage.flat();
+  pending.block(message.scopeId);
+  const result = await orchestrator.submit({ message, access: first.payload.access, prompt, attachments });
+  if ("queued" in result) {
+    return;
+  }
+  if (!result.ok) {
+    pending.unblock(message.scopeId);
+    await sendBridgeReply(input2.gateway, message, { mode: "text", content: result.userVisible });
+    return;
+  }
+  const state = { ...createRunState(result.handle.runId), status: "running" };
+  const context = {
+    scopeId: message.scopeId,
+    chatId: message.chatId ?? "",
+    operatorOpenId: message.actorId,
+    policyFingerprint: result.policy.policyFingerprint,
+    workspaceLabel: result.cwdRealpath,
+    sandbox: result.policy.sandbox,
+    authMode: input2.profile.codex.auth.mode,
+    callbackAuth
+  };
+  if (message.commentTarget) {
+    states.set(message.scopeId, { state, context, commentTarget: message.commentTarget, commentScopeId: message.commentScopeId });
+    return;
+  }
+  states.set(message.scopeId, { state, context, initialSendPending: true });
+  const sent = await input2.gateway.sendMessage({ chatId: message.chatId, messageId: message.messageId }, { mode: "card", content: buildRunCard(state, context) });
+  const entry = states.get(message.scopeId);
+  if (entry) {
+    entry.initialSendPending = false;
+    if (sent?.messageId) entry.messageId = sent.messageId;
+    if (entry.renderPending) await flushRender(input2.gateway, entry);
+  }
+}
+function cancelsPending(name, args) {
+  if (name === "/new" || name === "/reset" || name === "/cd" || name === "/stop") return true;
+  return name === "/ws" && args[0] === "use";
+}
+function messageFromAction(action, command, botOpenId) {
+  const chatType = normalizeActionChatType(action.value?.chatType);
+  return {
+    source: "card",
+    scopeId: typeof action.value?.scopeId === "string" ? action.value.scopeId : action.scopeId,
+    chatId: typeof action.value?.chatId === "string" ? action.value.chatId : action.chatId,
+    messageId: action.messageId,
+    actorId: action.operatorOpenId,
+    actorType: "user",
+    chatType,
+    text: command,
+    mentions: botOpenId && chatType !== "private" ? [{ id: botOpenId, isBot: true }] : [],
+    resources: [],
+    raw: action.raw
+  };
+}
+function normalizeActionChatType(value) {
+  return value === "private" || value === "group" || value === "topic" ? value : "private";
+}
+async function sendBridgeReply(gateway, message, reply) {
+  if (message.commentTarget) {
+    await gateway.sendMessage(
+      { commentScopeId: message.commentScopeId, commentTarget: message.commentTarget },
+      { mode: "comment", content: plainCommentText(reply.content) }
+    );
+    return;
+  }
+  await gateway.sendMessage({ chatId: message.chatId, messageId: message.messageId }, reply);
+}
+function plainCommentText(content) {
+  if (typeof content === "string") return stripMarkdown(content);
+  return "This command is not available in document comments.";
+}
+async function renderEvent(gateway, states, scopeId, event) {
+  const entry = states.get(scopeId);
+  if (!entry) return;
+  entry.state = applyRunEvent(entry.state, event);
+  if (entry.commentTarget) {
+    if (isTerminalEvent(event)) {
+      const text2 = entry.state.text.trim() || entry.state.error || titleForComment(entry.state.status);
+      await gateway.sendMessage(
+        { commentScopeId: entry.commentScopeId, commentTarget: entry.commentTarget },
+        { mode: "comment", content: plainCommentText(text2) }
+      );
+    }
+    return;
+  }
+  entry.renderPending = true;
+  if (entry.initialSendPending) return;
+  if (isTerminalEvent(event)) {
+    if (entry.renderTimer) clearTimeout(entry.renderTimer);
+    entry.renderTimer = void 0;
+    await flushRender(gateway, entry);
+    return;
+  }
+  const now = Date.now();
+  const last = entry.lastRenderAt ?? 0;
+  if (now - last < CARD_RENDER_THROTTLE_MS) {
+    if (!entry.renderTimer) {
+      entry.renderTimer = setTimeout(() => {
+        entry.renderTimer = void 0;
+        void flushRender(gateway, entry);
+      }, CARD_RENDER_THROTTLE_MS - (now - last));
+    }
+    return;
+  }
+  await flushRender(gateway, entry);
+}
+async function flushRender(gateway, entry) {
+  if (!entry.renderPending) return;
+  entry.renderPending = false;
+  entry.lastRenderAt = Date.now();
+  const reply = entry.context.callbackAuth && entry.context.chatId ? { mode: "card", content: buildRunCard(entry.state, entry.context) } : { mode: "markdown", content: renderMarkdownFallback(entry.state) };
+  if (entry.messageId && gateway.updateMessage) {
+    await gateway.updateMessage(entry.messageId, reply).catch(() => void 0);
+  } else {
+    const sent = await gateway.sendMessage({ chatId: entry.context.chatId }, reply).catch(() => void 0);
+    if (sent?.messageId) entry.messageId = sent.messageId;
+  }
+}
+function isTerminalEvent(event) {
+  return event.type === "done" || event.type === "error";
+}
+function titleForComment(status) {
+  if (status === "interrupted") return "Stopped.";
+  if (status === "timeout") return "Timed out.";
+  if (status === "error") return "Codex failed.";
+  return "Done.";
+}
+
+// src/bootstrap/wizard.ts
+import { registerApp } from "@larksuiteoapi/node-sdk";
+import qrcode from "qrcode-terminal";
+import QRCode from "qrcode";
+import { mkdir as mkdir4, realpath as realpath2 } from "fs/promises";
+import { join as join8 } from "path";
+import { homedir as homedir3 } from "os";
+import * as p from "@clack/prompts";
+async function runRegistrationWizard(options = {}) {
+  const register = options.register ?? registerApp;
+  const log = options.log ?? console;
+  log.log("\n\u672A\u68C0\u6D4B\u5230 Feishu/Lark \u5E94\u7528\u914D\u7F6E\uFF0C\u8FDB\u5165\u626B\u7801\u521B\u5EFA\u5411\u5BFC\u3002\n");
+  const result = await register({
+    source: "feishu-codex-connector",
+    appPreset: {
+      name: "{user} PersonalAgent",
+      desc: "Personal Codex agent controlled from Feishu/Lark."
+    },
+    onQRCodeReady: (info) => {
+      log.log("\u8BF7\u7528\u98DE\u4E66 App \u626B\u63CF\u4EE5\u4E0B\u4E8C\u7EF4\u7801\uFF0C\u9009\u62E9\u6216\u521B\u5EFA PersonalAgent \u5E94\u7528\uFF1A\n");
+      if (options.renderQr) options.renderQr(info.url);
+      else qrcode.generate(info.url, { small: true });
+      if (options.qrImagePath) {
+        void QRCode.toFile(options.qrImagePath, info.url, { type: "png", width: 640, margin: 2 }).then(() => log.log(`
+\u4E8C\u7EF4\u7801\u56FE\u7247\u5DF2\u4FDD\u5B58\uFF1A${options.qrImagePath}`)).catch((error) => log.log(`
+\u4E8C\u7EF4\u7801\u56FE\u7247\u4FDD\u5B58\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`));
+      }
+      const minutes = Math.max(1, Math.round(info.expireIn / 60));
+      log.log(`
+\u4E8C\u7EF4\u7801\u6709\u6548\u671F\uFF1A\u7EA6 ${minutes} \u5206\u949F`);
+      log.log(`\u4E5F\u53EF\u4EE5\u76F4\u63A5\u5728\u6D4F\u89C8\u5668\u6253\u5F00\uFF1A${info.url}
+`);
+    },
+    onStatusChange: (info) => {
+      if (info.status === "domain_switched") log.log("\u8BC6\u522B\u5230 Lark \u56FD\u9645\u7248\u79DF\u6237\uFF0C\u5DF2\u5207\u6362\u5230 larksuite.com \u57DF\u540D\u3002");
+      if (info.status === "slow_down") log.log("\u8F6E\u8BE2\u901F\u5EA6\u8FC7\u5FEB\uFF0C\u5DF2\u81EA\u52A8\u964D\u901F\u3002");
+    }
+  });
+  const tenant = result.user_info?.tenant_brand ?? "feishu";
+  log.log("\n\u2713 \u5E94\u7528\u521B\u5EFA\u6210\u529F");
+  log.log(`  App ID:  ${result.client_id}`);
+  log.log(`  Tenant:  ${tenant}`);
+  if (result.user_info?.open_id) log.log(`  Creator: ${result.user_info.open_id}`);
+  log.log("\n\u521D\u59CB\u5316 agent: Codex\uFF08\u672C\u9879\u76EE\u4E3A Codex-only connector\uFF09\n");
+  return {
+    appId: result.client_id,
+    appSecret: result.client_secret,
+    tenant,
+    operatorOpenId: result.user_info?.open_id
+  };
+}
+async function ensureProfileForRun(options = {}) {
+  const store = new ProfileStore(options.home);
+  if (options.profile) {
+    try {
+      await store.read(options.profile);
+      return options.profile;
+    } catch (error) {
+      if (!isProfileMissingError(error)) throw error;
+      return bootstrapProfile(options);
+    }
+  }
+  const existing = await store.activeProfile();
+  if (existing) return existing;
+  const list = await store.list();
+  if (list.length > 0) {
+    const selected = options.profile ?? list[0]?.name;
+    if (selected) {
+      await store.use(selected);
+      return selected;
+    }
+  }
+  if (!isInteractiveTerminal() && !options.appId) {
+    throw new Error(
+      "\u5F53\u524D\u6CA1\u6709\u914D\u7F6E\uFF0C\u975E\u4EA4\u4E92\u6A21\u5F0F\u65E0\u6CD5\u5B8C\u6210\u626B\u7801\u521B\u5EFA\u5E94\u7528\u3002\u8BF7\u5148\u5728\u7EC8\u7AEF\u8FD0\u884C `feishu-codex run` \u5B8C\u6210\u9996\u6B21\u521D\u59CB\u5316\uFF0C\u6216\u4F20\u5165 --app-id \u548C --app-secret\u3002"
+    );
+  }
+  return bootstrapProfile(options);
+}
+function isProfileMissingError(error) {
+  return error instanceof Error && /profile not found|no active profile|ENOENT/i.test(error.message);
+}
+async function bootstrapProfile(options = {}) {
+  const store = new ProfileStore(options.home);
+  const profileName = options.profile ?? "default";
+  const app = options.appId ? await appFromExplicitOptions(options) : await runRegistrationWizard({ qrImagePath: join8(store.paths.home, "registration-qr.png") });
+  const workspace = await resolveBootstrapWorkspace(options.workspace, profileName, store.paths.home);
+  const auth = await resolveBootstrapCodexAuth(options);
+  await store.create({
+    name: profileName,
+    tenant: app.tenant,
+    appId: app.appId,
+    appSecret: app.appSecret,
+    codexAuthMode: auth.mode,
+    codexApiKey: auth.apiKey,
+    workspace,
+    codexPath: options.codexPath,
+    setActive: true
+  });
+  const profile = await store.read(profileName);
+  if (app.operatorOpenId) {
+    profile.access.admins = [app.operatorOpenId];
+    profile.access.allowedUsers = [app.operatorOpenId];
+    await store.write(profile);
+  }
+  console.log(`\u2713 \u914D\u7F6E\u5DF2\u5199\u5165 ${store.paths.configFile}`);
+  console.log(`\u2713 profile \u5DF2\u521D\u59CB\u5316: ${profileName}`);
+  return profileName;
+}
+async function appFromExplicitOptions(options) {
+  const appId = options.appId;
+  if (!appId) throw new Error("appId is required");
+  let appSecret = options.appSecret;
+  if (!appSecret) {
+    if (!isInteractiveTerminal()) throw new Error(`\u975E\u4EA4\u4E92\u6A21\u5F0F\u7F3A\u5C11 App Secret: ${appId}`);
+    const value = await p.password({ message: `\u8F93\u5165 ${appId} \u7684 App Secret` });
+    if (p.isCancel(value)) throw new Error("\u5DF2\u53D6\u6D88");
+    appSecret = String(value);
+  }
+  return {
+    appId,
+    appSecret,
+    tenant: options.tenant ?? "feishu"
+  };
+}
+async function resolveBootstrapWorkspace(workspace, profile, home) {
+  if (workspace) {
+    const resolved = await resolveWorkspace(workspace);
+    if (!resolved.ok) throw new Error(resolved.userVisible);
+    return resolved.cwdRealpath;
+  }
+  const managed = join8(home, "workspaces", profile, "default");
+  await mkdir4(managed, { recursive: true, mode: 448 });
+  return realpath2(managed);
+}
+async function resolveBootstrapCodexAuth(options) {
+  if (options.codexAuth === "api-key") {
+    const apiKey = options.codexApiKey ?? process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      if (!isInteractiveTerminal()) throw new Error("api-key \u6A21\u5F0F\u9700\u8981 --codex-api-key \u6216 OPENAI_API_KEY");
+      const value = await p.password({ message: "\u8F93\u5165 OpenAI API key" });
+      if (p.isCancel(value)) throw new Error("\u5DF2\u53D6\u6D88");
+      return { mode: "api-key", apiKey: String(value) };
+    }
+    return { mode: "api-key", apiKey };
+  }
+  if (options.codexAuth === "codex-home" || options.codexAuth === "inherit-user") {
+    return { mode: options.codexAuth };
+  }
+  if (process.env.OPENAI_API_KEY) return { mode: "api-key", apiKey: process.env.OPENAI_API_KEY };
+  if (await hasLocalCodexState()) return { mode: "inherit-user" };
+  if (!isInteractiveTerminal()) return { mode: "codex-home" };
+  const selected = await p.select({
+    message: "\u9009\u62E9 Codex \u8BA4\u8BC1\u65B9\u5F0F",
+    options: [
+      { value: "inherit-user", label: "inherit-user", hint: "\u590D\u7528\u672C\u673A Codex \u767B\u5F55\u72B6\u6001" },
+      { value: "api-key", label: "api-key", hint: "\u8F93\u5165 OpenAI API key\uFF0C\u9002\u5408\u540E\u53F0\u8FDC\u7A0B\u8FD0\u884C" },
+      { value: "codex-home", label: "codex-home", hint: "\u4F7F\u7528 profile-local Codex home" }
+    ]
+  });
+  if (p.isCancel(selected)) throw new Error("\u5DF2\u53D6\u6D88");
+  if (selected === "api-key") return resolveBootstrapCodexAuth({ ...options, codexAuth: "api-key" });
+  return { mode: selected };
+}
+async function hasLocalCodexState() {
+  try {
+    await realpath2(join8(homedir3(), ".codex"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isInteractiveTerminal() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+// src/runtime/app.ts
+import { once } from "events";
+
+// src/gateway/lark-channel.ts
+import { mkdtemp, readFile as readFile8, rm as rm4 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join9 } from "path";
+var LarkChannelGateway = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  channel;
+  messageHandler;
+  actionHandler;
+  pollTimer;
+  pollSeen = /* @__PURE__ */ new Set();
+  pollStartedAt = Math.floor(Date.now() / 1e3);
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onAction(handler) {
+    this.actionHandler = handler;
+  }
+  async connect() {
+    const sdk = await import("@larksuiteoapi/node-sdk");
+    const createLarkChannel = sdk.createLarkChannel;
+    if (!createLarkChannel) {
+      throw new Error("@larksuiteoapi/node-sdk does not expose createLarkChannel");
+    }
+    this.channel = createLarkChannel({
+      appId: this.options.appId,
+      appSecret: this.options.appSecret,
+      domain: this.options.tenant === "lark" ? sdk.Domain && sdk.Domain.Lark : sdk.Domain.Feishu,
+      source: "feishu-codex-connector",
+      loggerLevel: sdk.LoggerLevel?.info,
+      policy: {
+        dmMode: "open",
+        requireMention: false,
+        respondToMentionAll: false
+      },
+      safety: {
+        chatQueue: { enabled: false }
+      },
+      includeRawEvent: true,
+      outbound: {
+        streamThrottleMs: 400
+      },
+      wsConfig: {
+        pingTimeout: 3
+      },
+      handshakeTimeoutMs: 8e3
+    });
+    const channel = this.channel;
+    channel.on?.({
+      message: async (event) => {
+        console.log("[bridge:intake] message raw keys=" + Object.keys(record2(event)).join(","));
+        try {
+          const normalized = normalizeMessage(event);
+          console.log(
+            `[bridge:intake] message normalized chat=${normalized.chatId ?? ""} scope=${normalized.scopeId} actor=${normalized.actorId} text=${normalized.text.slice(0, 40)}`
+          );
+          await this.messageHandler?.(normalized);
+        } catch (error) {
+          console.error("[bridge:intake] message normalize/handler failed:", error instanceof Error ? error.stack ?? error.message : String(error));
+        }
+      },
+      cardAction: async (event) => {
+        console.log("[bridge:intake] cardAction raw keys=" + Object.keys(record2(event)).join(","));
+        try {
+          await this.actionHandler?.(normalizeAction(event));
+        } catch (error) {
+          console.error("[bridge:intake] cardAction normalize/handler failed:", error instanceof Error ? error.stack ?? error.message : String(error));
+        }
+      },
+      comment: async (event) => {
+        console.log("[bridge:intake] comment raw keys=" + Object.keys(record2(event)).join(","));
+        try {
+          const normalized = await this.normalizeComment(event);
+          if (normalized) await this.messageHandler?.(normalized);
+        } catch (error) {
+          console.error("[bridge:intake] comment normalize/handler failed:", error instanceof Error ? error.stack ?? error.message : String(error));
+        }
+      },
+      reject: (event) => {
+        console.warn("[bridge:intake] reject " + JSON.stringify(event));
+      },
+      reconnecting: () => {
+        console.warn("[bridge:ws] reconnecting");
+      },
+      reconnected: () => {
+        console.log("[bridge:ws] reconnected");
+      },
+      error: (error) => {
+        console.error("[bridge:ws] error:", error instanceof Error ? error.stack ?? error.message : String(error));
+      }
+    });
+    if (!channel.connect) {
+      throw new Error("Lark channel does not expose connect");
+    }
+    await channel.connect();
+    if (this.options.pollChats?.length) {
+      this.startPollingFallback();
+    }
+  }
+  async disconnect() {
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.pollTimer = void 0;
+    const maybe = this.channel;
+    await withTimeout(
+      maybe?.disconnect?.() ?? maybe?.close?.() ?? Promise.resolve(),
+      this.options.disconnectTimeoutMs ?? 5e3,
+      "Lark channel disconnect timed out"
+    );
+    this.channel = void 0;
+  }
+  async sendMessage(target, reply) {
+    const channel = this.channel;
+    if (!channel) throw new Error("Lark channel is not connected");
+    if (target.commentTarget) {
+      await this.postCommentReply(target.commentTarget, String(reply.content));
+      return;
+    }
+    if (target.chatId && channel.send) {
+      return channel.send(target.chatId, toChannelInput(reply), target.messageId ? { replyTo: target.messageId } : void 0);
+    }
+    if (target.messageId && channel.send) {
+      throw new Error("chatId is required when replying through Lark channel");
+    }
+    if (!channel.send) {
+      throw new Error("Lark channel does not expose a supported send method");
+    }
+  }
+  async updateMessage(messageId, reply) {
+    const channel = this.channel;
+    if (reply.mode === "card") {
+      if (!channel?.updateCard) throw new Error("Lark channel does not expose updateCard");
+      await channel.updateCard(messageId, reply.content);
+      return;
+    }
+    if (!channel?.editMessage) throw new Error("Lark channel does not expose editMessage");
+    await channel.editMessage(messageId, String(reply.content));
+  }
+  async downloadResource(message, resource) {
+    const channel = this.channel;
+    const get = channel?.rawClient?.im?.v1?.messageResource?.get;
+    if (!get) throw new Error("Lark channel does not expose messageResource.get");
+    const messageId = resource.messageId ?? message.messageId;
+    if (!messageId) throw new Error("resource message_id is missing");
+    if (!resource.fileKey) throw new Error("resource file_key is missing");
+    const result = await get({
+      params: { type: resource.kind },
+      path: { message_id: messageId, file_key: resource.fileKey }
+    });
+    return {
+      bytes: await resourceResultToBuffer(result),
+      name: resource.name,
+      mime: contentTypeFromResult(result) ?? resource.mime
+    };
+  }
+  async createGroupChat(input2) {
+    const create = this.channel?.rawClient?.im?.v1?.chat?.create;
+    if (!create) throw new Error("Lark channel does not expose im.v1.chat.create");
+    const result = await create({
+      data: {
+        name: input2.name,
+        description: input2.description,
+        chat_mode: "group",
+        chat_type: "private",
+        user_id_list: [input2.inviteOpenId]
+      },
+      params: { user_id_type: "open_id" }
+    });
+    const data = record2(record2(result).data);
+    const chatId = stringValue(data.chat_id) ?? stringValue(data.chatId);
+    if (!chatId) throw new Error("chat.create returned no chat_id");
+    return { chatId, name: input2.name };
+  }
+  async listJoinedChats() {
+    const list = this.channel?.rawClient?.im?.v1?.chat?.list;
+    if (!list) throw new Error("Lark channel does not expose im.v1.chat.list");
+    const out = [];
+    let pageToken;
+    do {
+      const result = await list({ params: { page_size: 100, ...pageToken ? { page_token: pageToken } : {} } });
+      const data = record2(record2(result).data);
+      const items = Array.isArray(data.items) ? data.items : [];
+      for (const item of items) {
+        const row = record2(item);
+        const chatId = stringValue(row.chat_id) ?? stringValue(row.chatId);
+        if (chatId) out.push({ chatId, name: stringValue(row.name) });
+      }
+      pageToken = stringValue(data.page_token) ?? stringValue(data.pageToken);
+    } while (pageToken);
+    return out;
+  }
+  async normalizeComment(event) {
+    const raw = record2(event);
+    const fileToken = stringValue(raw.fileToken) ?? stringValue(raw.file_token);
+    const fileType = stringValue(raw.fileType) ?? stringValue(raw.file_type);
+    const commentId = stringValue(raw.commentId) ?? stringValue(raw.comment_id);
+    if (!fileToken || !fileType || !commentId || !isSupportedCommentFileType(fileType)) return void 0;
+    const mentioned = Boolean(raw.mentionedBot ?? raw.mentioned_bot);
+    if (!mentioned) return void 0;
+    const replyId = stringValue(raw.replyId) ?? stringValue(raw.reply_id);
+    const operator = record2(raw.operator);
+    const actorId = stringValue(operator.openId) ?? stringValue(operator.open_id) ?? stringValue(raw.operatorOpenId) ?? stringValue(raw.operator_open_id) ?? "";
+    const context = await this.fetchCommentContext({ fileToken, fileType, commentId, replyId }).catch(() => ({
+      question: stringValue(raw.text) ?? stringValue(raw.commentText) ?? stringValue(raw.comment_text) ?? "",
+      quote: void 0,
+      isWhole: false
+    }));
+    const scopeId = scopeForChat({ fileToken, commentId });
+    return {
+      source: "comment",
+      scopeId,
+      commentScopeId: scopeId,
+      commentTarget: { fileToken, fileType, commentId, replyId, isWhole: context.isWhole },
+      messageId: `comment:${commentId}:${replyId ?? "root"}`,
+      actorId,
+      actorType: "user",
+      chatType: "private",
+      text: buildCommentPrompt({ fileToken, fileType, question: context.question, quote: context.quote, isWhole: context.isWhole }),
+      mentions: [{ id: "bot", isBot: true }],
+      resources: [],
+      raw: event
+    };
+  }
+  async fetchCommentContext(input2) {
+    const rawClient = this.channel?.rawClient;
+    const get = rawClient?.drive?.v1?.fileComment?.get;
+    if (!get) return { question: "", isWhole: false };
+    const result = await get({
+      params: { file_type: input2.fileType },
+      path: { file_token: input2.fileToken, comment_id: input2.commentId }
+    });
+    const data = record2(record2(result).data);
+    const replies = Array.isArray(record2(record2(data.reply_list).replies).items) ? record2(record2(data.reply_list).replies).items : Array.isArray(record2(data.reply_list).replies) ? record2(data.reply_list).replies : [];
+    return {
+      question: extractCommentQuestion(replies, input2.replyId),
+      quote: stringValue(data.quote),
+      isWhole: Boolean(data.is_whole)
+    };
+  }
+  async postCommentReply(target, text2) {
+    const rawClient = this.channel?.rawClient;
+    if (!rawClient) throw new Error("Lark channel does not expose rawClient");
+    if (!target.isWhole && rawClient.request) {
+      const url = `/open-apis/drive/v1/files/${encodeURIComponent(target.fileToken)}/comments/${encodeURIComponent(target.commentId)}/replies?file_type=${encodeURIComponent(target.fileType)}`;
+      try {
+        await rawClient.request({ method: "POST", url, data: commentContent(text2) });
+        return;
+      } catch (error) {
+        if (responseCode(error) !== 1069302) throw error;
+      }
+    }
+    const create = rawClient.drive?.v1?.fileComment?.create;
+    if (!create) throw new Error("Lark channel does not expose fileComment.create");
+    await create({
+      params: { file_type: target.fileType },
+      path: { file_token: target.fileToken },
+      data: {
+        reply_list: {
+          replies: [{ content: commentContent(text2).content }]
+        }
+      }
+    });
+  }
+  startPollingFallback() {
+    const tick = () => {
+      void this.pollOnce().catch((error) => {
+        console.error("[bridge:poll] failed:", error instanceof Error ? error.stack ?? error.message : String(error));
+      });
+    };
+    console.log("[bridge:poll] enabled chats=" + this.options.pollChats?.join(","));
+    tick();
+    this.pollTimer = setInterval(tick, this.options.pollIntervalMs ?? 3e3);
+  }
+  async pollOnce() {
+    const token = await this.tenantAccessToken();
+    const end = Math.floor(Date.now() / 1e3) + 60;
+    for (const chatId of this.options.pollChats ?? []) {
+      const url = new URL("https://open.feishu.cn/open-apis/im/v1/messages");
+      url.searchParams.set("container_id_type", "chat");
+      url.searchParams.set("container_id", chatId);
+      url.searchParams.set("start_time", String(this.pollStartedAt));
+      url.searchParams.set("end_time", String(end));
+      url.searchParams.set("page_size", "50");
+      const resp = await fetch(url, { headers: { authorization: `Bearer ${token}` } });
+      const json = await resp.json();
+      if (json.code !== 0) {
+        console.warn(`[bridge:poll] message list failed chat=${chatId} code=${json.code} msg=${json.msg ?? ""}`);
+        continue;
+      }
+      const items = [...json.data?.items ?? []].sort((a, b) => Number(record2(a).create_time ?? 0) - Number(record2(b).create_time ?? 0));
+      for (const item of items) {
+        const raw = record2(item);
+        const messageId = stringValue(raw.message_id);
+        if (!messageId || this.pollSeen.has(messageId)) continue;
+        this.pollSeen.add(messageId);
+        const sender = record2(raw.sender);
+        if (sender.sender_type === "app" || sender.id === this.options.appId) continue;
+        const normalized = normalizeMessageListItem(raw, chatId);
+        console.log(`[bridge:poll] message chat=${chatId} actor=${normalized.actorId} text=${normalized.text.slice(0, 40)}`);
+        await this.messageHandler?.(normalized);
+      }
+    }
+  }
+  async tenantAccessToken() {
+    const resp = await fetch("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ app_id: this.options.appId, app_secret: this.options.appSecret })
+    });
+    const json = await resp.json();
+    if (!json.tenant_access_token) throw new Error(`tenant token failed code=${json.code} msg=${json.msg ?? ""}`);
+    return json.tenant_access_token;
+  }
+};
+function toChannelInput(reply) {
+  if (reply.mode === "card") return { card: reply.content };
+  if (reply.mode === "markdown") return { markdown: String(reply.content) };
+  return { text: String(reply.content) };
+}
+function normalizeMessage(event) {
+  const raw = record2(event);
+  const chatId = stringValue(raw.chatId) ?? stringValue(raw.chat_id);
+  const threadId = stringValue(raw.threadId) ?? stringValue(raw.thread_id) ?? stringValue(raw.rootId) ?? stringValue(raw.root_id);
+  const chatType = raw.chatType === "group" || raw.chat_type === "group" ? "group" : threadId ? "topic" : raw.chatType === "topic" ? "topic" : "private";
+  const messageId = stringValue(raw.messageId) ?? stringValue(raw.message_id) ?? "";
+  return {
+    source: "im",
+    scopeId: scopeForChat({ chatId, threadId, chatType }),
+    chatId,
+    threadId,
+    messageId,
+    actorId: stringValue(raw.senderId) ?? stringValue(raw.sender_id) ?? stringValue(record2(raw.sender).openId) ?? stringValue(record2(raw.sender).open_id) ?? "",
+    actorName: stringValue(raw.senderName) ?? stringValue(record2(raw.sender).name),
+    actorType: raw.senderType === "bot" || raw.sender_type === "bot" ? "bot" : "user",
+    chatType,
+    text: stringValue(raw.text) ?? stringValue(raw.content) ?? "",
+    mentions: Array.isArray(raw.mentions) ? raw.mentions.map((mention) => {
+      const item = record2(mention);
+      return {
+        id: stringValue(item.id) ?? stringValue(item.openId) ?? stringValue(item.open_id) ?? "",
+        name: stringValue(item.name),
+        isBot: Boolean(item.isBot ?? item.is_bot),
+        isAll: Boolean(item.isAll ?? item.is_all)
+      };
+    }) : [],
+    resources: normalizeResources(raw, messageId),
+    raw: event
+  };
+}
+function normalizeAction(event) {
+  const raw = record2(event);
+  const value = record2(raw.value ?? record2(raw.action).value);
+  const chatId = stringValue(value.chatId) ?? stringValue(value.chat_id) ?? stringValue(raw.chatId) ?? stringValue(raw.chat_id) ?? "";
+  return {
+    source: "card",
+    token: stringValue(value.token) ?? stringValue(raw.token) ?? "",
+    value,
+    scopeId: stringValue(value.scopeId) ?? stringValue(value.scope_id) ?? stringValue(raw.scopeId) ?? stringValue(raw.scope_id) ?? (chatId ? scopeForChat({ chatId }) : ""),
+    chatId,
+    messageId: stringValue(raw.messageId) ?? stringValue(raw.message_id) ?? "",
+    operatorOpenId: stringValue(raw.operatorOpenId) ?? stringValue(raw.operator_open_id) ?? stringValue(record2(raw.operator).openId) ?? "",
+    raw: event,
+    formValues: record2(raw.formValues ?? raw.form_values)
+  };
+}
+function normalizeMessageListItem(raw, chatId) {
+  const sender = record2(raw.sender);
+  const body = record2(raw.body);
+  const content = parseContent(stringValue(body.content) ?? "");
+  const messageId = stringValue(raw.message_id) ?? "";
+  return {
+    source: "im",
+    scopeId: scopeForChat({ chatId }),
+    chatId,
+    messageId,
+    actorId: stringValue(sender.id) ?? "",
+    actorType: sender.sender_type === "app" ? "bot" : "user",
+    chatType: "private",
+    text: stringValue(content.text) ?? stringValue(body.content) ?? "",
+    mentions: [],
+    resources: normalizeResources({ ...raw, content, resources: raw.resources }, messageId),
+    raw
+  };
+}
+function normalizeResources(raw, messageId) {
+  const source = Array.isArray(raw.resources) ? raw.resources : Array.isArray(record2(raw.message).resources) ? record2(raw.message).resources : [];
+  const out = source.map((entry) => normalizeResource(record2(entry), messageId)).filter((entry) => Boolean(entry));
+  if (out.length) return out;
+  const content = record2(raw.content);
+  const messageType = stringValue(raw.messageType) ?? stringValue(raw.message_type) ?? stringValue(raw.type);
+  const kind = normalizeResourceKind(messageType);
+  const fileKey = stringValue(content.file_key) ?? stringValue(content.fileKey) ?? stringValue(content.image_key) ?? stringValue(content.imageKey) ?? stringValue(content.file_id);
+  if (!kind || !fileKey) return [];
+  return [
+    {
+      kind,
+      fileKey,
+      messageId,
+      name: stringValue(content.file_name) ?? stringValue(content.fileName),
+      mime: stringValue(content.mime) ?? stringValue(content.mime_type),
+      size: numberValue(content.size),
+      required: true
+    }
+  ];
+}
+function normalizeResource(value, messageId) {
+  const kind = normalizeResourceKind(stringValue(value.type) ?? stringValue(value.kind));
+  if (!kind) return void 0;
+  const fileKey = stringValue(value.fileKey) ?? stringValue(value.file_key) ?? stringValue(value.imageKey) ?? stringValue(value.image_key);
+  if (!fileKey) return void 0;
+  return {
+    kind,
+    fileKey,
+    messageId,
+    name: stringValue(value.fileName) ?? stringValue(value.file_name) ?? stringValue(value.name),
+    mime: stringValue(value.mime) ?? stringValue(value.mime_type),
+    size: numberValue(value.size),
+    required: true
+  };
+}
+function normalizeResourceKind(value) {
+  if (value === "image" || value === "file" || value === "audio" || value === "video" || value === "sticker") return value;
+  return void 0;
+}
+function isSupportedCommentFileType(value) {
+  return value === "doc" || value === "docx" || value === "sheet" || value === "file";
+}
+function buildCommentPrompt(input2) {
+  return [
+    "I was mentioned in a Feishu/Lark cloud document comment.",
+    `Document: https://feishu.cn/${input2.fileType}/${input2.fileToken}`,
+    `File token: ${input2.fileToken}`,
+    `File type: ${input2.fileType}`,
+    `Comment scope: ${input2.isWhole ? "whole document" : "inline comment"}`,
+    input2.quote ? `Quoted text:
+${input2.quote}` : void 0,
+    "",
+    `User question:
+${input2.question}`,
+    "",
+    "The bridge owns the comment reply API. Do not call document comment APIs. Return plain text only; avoid markdown, code fences, tool logs, and internal reasoning."
+  ].filter((line) => line !== void 0).join("\n");
+}
+function extractCommentQuestion(replies, replyId) {
+  const records = replies.map((reply) => record2(reply));
+  const target = (replyId ? records.find((reply) => stringValue(reply.reply_id) === replyId) : void 0) ?? records.at(-1);
+  if (!target) return "";
+  const elements = record2(record2(target.content).elements);
+  const array = Array.isArray(record2(target.content).elements) ? record2(target.content).elements : Array.isArray(elements.items) ? elements.items : [];
+  return array.map((entry) => {
+    const item = record2(entry);
+    if (item.type === "text_run") return stringValue(record2(item.text_run).text) ?? "";
+    if (item.type === "docs_link") return stringValue(record2(item.docs_link).url) ?? "";
+    return "";
+  }).join("").trim();
+}
+function commentContent(text2) {
+  return { content: { elements: [{ type: "text_run", text_run: { text: text2 } }] } };
+}
+function responseCode(error) {
+  return numberValue(record2(record2(record2(error).response).data).code);
+}
+function parseContent(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+}
+async function resourceResultToBuffer(result) {
+  if (Buffer.isBuffer(result)) return result;
+  if (result instanceof ArrayBuffer) return Buffer.from(result);
+  if (ArrayBuffer.isView(result)) return Buffer.from(result.buffer, result.byteOffset, result.byteLength);
+  const raw = record2(result);
+  if (typeof raw.writeFile === "function") {
+    const dir = await mkdtemp(join9(tmpdir2(), "feishu-codex-resource-"));
+    const path = join9(dir, "resource");
+    try {
+      await raw.writeFile(path);
+      return await readFile8(path);
+    } finally {
+      await rm4(dir, { recursive: true, force: true });
+    }
+  }
+  const data = raw.data;
+  if (Buffer.isBuffer(data)) return data;
+  if (data instanceof ArrayBuffer) return Buffer.from(data);
+  if (ArrayBuffer.isView(data)) return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  if (typeof data === "string") return Buffer.from(data);
+  const body = raw.body;
+  if (body && typeof body === "object" && Symbol.asyncIterator in body) {
+    const chunks = [];
+    for await (const chunk of body) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+  throw new Error("unsupported resource download result");
+}
+function contentTypeFromResult(result) {
+  const headers = record2(record2(result).headers);
+  const value = stringValue(headers["content-type"]) ?? stringValue(headers["Content-Type"]);
+  return value?.split(";")[0]?.trim().toLowerCase();
+}
+function record2(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function withTimeout(promise, timeoutMs, message) {
+  let timer;
+  const timeout = new Promise((_, reject3) => {
+    timer = setTimeout(() => reject3(new Error(message)), timeoutMs);
+  });
+  return Promise.race([promise, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
+// src/runtime/app.ts
+async function runBridge(options = {}) {
+  const store = new ProfileStore(options.home);
+  const profileName = await ensureProfileForRun({
+    profile: options.profile,
+    tenant: options.tenant,
+    appId: options.appId,
+    appSecret: options.appSecret,
+    workspace: options.workspace,
+    codexAuth: options.codexAuth,
+    codexApiKey: options.codexApiKey,
+    codexPath: options.codexPath,
+    home: options.home
+  });
+  const profile = await store.read(profileName);
+  if (options.workspace) {
+    profile.workspaces.default = options.workspace;
+    await store.write(profile);
+  }
+  const paths = store.profilePaths(profile.name);
+  const secrets = new SecretResolver({ keystore: store.keystore(profile.name) });
+  const appSecret = await secrets.resolve(profile.app.secret);
+  const runner = runnerForProfile(profile);
+  const availability = await runner.checkAvailability();
+  if (!availability.ok) throw new Error(`Codex runner unavailable: ${availability.detail ?? availability.label}`);
+  if (options.preflight) {
+    console.log(`profile=${profile.name} backend=${availability.label} workspace=${profile.workspaces.default ?? "(not set)"}`);
+    return;
+  }
+  const pLock = profileLock(profile.name, store.paths.home);
+  const aLock = appLock(profile.app.id, store.paths.home);
+  await pLock.acquire();
+  await aLock.acquire();
+  const registry = new RuntimeRegistry(store.paths.home);
+  const self = await registry.register({
+    profile: profile.name,
+    tenant: profile.tenant,
+    appId: profile.app.id,
+    logPath: profileLogPath(paths, "run")
+  });
+  const gateway = new LarkChannelGateway({
+    tenant: profile.tenant,
+    appId: profile.app.id,
+    appSecret,
+    pollChats: options.pollChat
+  });
+  bindBridgeRuntime({
+    profile,
+    paths,
+    gateway,
+    runner,
+    secretResolver: secrets,
+    appSecret,
+    ownerOpenId: process.env.FEISHU_CODEX_OWNER_OPEN_ID,
+    botOpenId: process.env.FEISHU_CODEX_BOT_OPEN_ID,
+    bootstrapOwner: options.bootstrapOwner,
+    saveProfile: (next) => store.write(next),
+    processSnapshot: () => registry.list(),
+    lifecycle: {
+      exit: async (target) => {
+        if (!target || target === self.id || target === String(self.pid)) {
+          setTimeout(() => process.kill(process.pid, "SIGTERM"), 50);
+          return;
+        }
+        const killed = await registry.kill(target);
+        if (!killed) throw new Error(`process not found: ${target}`);
+      },
+      reconnect: async () => {
+        await gateway.disconnect().catch(() => void 0);
+        await gateway.connect();
+      }
+    }
+  });
+  let keepalive;
+  try {
+    await gateway.connect();
+    console.log(`feishu-codex connector running for profile ${profile.name}`);
+    keepalive = setInterval(() => void 0, 6e4);
+    await Promise.race([once(process, "SIGINT"), once(process, "SIGTERM")]);
+  } finally {
+    if (keepalive) clearInterval(keepalive);
+    await gateway.disconnect().catch(() => void 0);
+    await registry.unregister(process.pid).catch(() => void 0);
+    await aLock.release().catch(() => void 0);
+    await pLock.release().catch(() => void 0);
+  }
+}
+function runnerForProfile(profile) {
+  if (profile.codex.backend === "exec-json") {
+    return new ExecJsonRunner(profile.codex.codexPath ?? "codex", ["exec", "--json"]);
+  }
+  return new CodexSdkRunner();
+}
+
+export {
+  DEFAULT_HOME_DIR,
+  expandTilde,
+  getBridgeHome,
+  bridgePaths,
+  profilePaths,
+  parentDir,
+  tempRoot,
+  LocalKeystore,
+  createDefaultProfileConfig,
+  normalizeProfileConfig,
+  isSecretRef,
+  redactProfileConfig,
+  ProfileStore,
+  profileExists,
+  profileNameFromPath,
+  profileLogPath,
+  SecretResolver,
+  scopeForChat,
+  messageRequiresMention,
+  hasRealBotMention,
+  hashId,
+  RuntimeLock,
+  profileLock,
+  appLock,
+  RuntimeRegistry,
+  isAlive,
+  SdkEventTranslator,
+  CodexSdkRunner,
+  codexBinaryLooksAvailable,
+  ExecJsonRunner,
+  CallbackAuth,
+  MemoryCallbackNonceStore,
+  buildRunCard,
+  renderMarkdownFallback,
+  redactSecrets,
+  createRunState,
+  applyRunEvent,
+  runDocumentComment,
+  stripMarkdown,
+  MediaCache,
+  hashFile,
+  buildPrompt,
+  BRIDGE_INSTRUCTIONS,
+  evaluateAccess,
+  canRunAdminCommand,
+  SessionCatalog,
+  catalogKey,
+  SessionStore,
+  WorkspaceStore,
+  ProcessPool,
+  projectLarkCliIdentity,
+  policyFingerprint,
+  accessPolicyDigest,
+  stableJson,
+  clampAccess,
+  accessToSandbox,
+  decideAccess,
+  evaluateRunPolicy,
+  resolveWorkspace,
+  isBroadWorkspace,
+  startRun,
+  RunOrchestrator,
+  routeCommand,
+  parseCommand,
+  bindBridgeRuntime,
+  runRegistrationWizard,
+  ensureProfileForRun,
+  bootstrapProfile,
+  runBridge,
+  runnerForProfile
+};