dsh-lark-bot 0.1.0

package/dist/cli.js

@@ -0,0 +1,1663 @@
+// src/cli.ts
+import { readFileSync } from "fs";
+import { Command } from "commander";
+
+// src/cli/commands/doctor.ts
+import { stat } from "fs/promises";
+
+// src/adapters/dsh/availability.ts
+import { spawn } from "cross-spawn";
+async function checkDshAvailability(options) {
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  return new Promise((resolve4) => {
+    const child = spawn(options.command, ["--version"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve4(result);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish({ ok: false, error: `timed out after ${timeoutMs}ms`, version: void 0 });
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      finish({ ok: false, error: error.message, version: void 0 });
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      const version = stdout.trim();
+      if (code !== 0 && !version) {
+        finish({ ok: false, error: stderr.trim() || `exited with code ${String(code)}`, version: void 0 });
+        return;
+      }
+      finish({ ok: true, error: void 0, version: version || void 0 });
+    });
+  });
+}
+
+// src/config/app-paths.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+function defaultHome() {
+  const override = process.env.DSH_LARK_HOME?.trim();
+  return override ? resolve(override) : join(homedir(), ".dsh-lark");
+}
+function resolveAppPaths(root = defaultHome()) {
+  const profileDir = (profile) => join(root, "profiles", profile);
+  const profilePath = (profile, ...parts) => join(profileDir(profile), ...parts);
+  return {
+    root,
+    configFile: join(root, "config.json"),
+    activeProfileFile: join(root, "active-profile"),
+    profileDir,
+    profilePath,
+    sessionsFile: (profile) => profilePath(profile, "sessions.json"),
+    sessionCatalogFile: (profile) => profilePath(profile, "sessions.json.catalog.json"),
+    workspacesFile: (profile) => profilePath(profile, "workspaces.json"),
+    mediaDir: (profile) => profilePath(profile, "media"),
+    logsDir: (profile) => profilePath(profile, "logs"),
+    registryFile: join(root, "registry", "processes.json"),
+    locksDir: join(root, "registry", "locks")
+  };
+}
+
+// src/config/env.ts
+import { join as join2, resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
+var DEFAULTS = {
+  tenant: "feishu",
+  dshCommand: "node",
+  dshArgs: ["lib/bin.js", "cordis.yml"],
+  provider: "deepseek-official",
+  model: "deepseek-v4-flash",
+  runTimeoutMs: 3e5,
+  stopGraceMs: 5e3
+};
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function parseTenant(value) {
+  const tenant = nonEmpty(value) ?? DEFAULTS.tenant;
+  if (tenant !== "feishu" && tenant !== "lark") {
+    throw new Error(`DSH_LARK_TENANT must be "feishu" or "lark", got "${tenant}"`);
+  }
+  return tenant;
+}
+function parseDshArgs(value) {
+  const raw = value?.trim();
+  if (!raw) return [...DEFAULTS.dshArgs];
+  return raw.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function parseTimeout(value) {
+  const raw = value?.trim();
+  if (!raw) return DEFAULTS.runTimeoutMs;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`DSH_LARK_RUN_TIMEOUT_MS must be a non-negative integer, got "${raw}"`);
+  }
+  return parsed;
+}
+function parseStopGrace(value) {
+  const raw = value?.trim();
+  if (!raw) return DEFAULTS.stopGraceMs;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`DSH_LARK_STOP_GRACE_MS must be a non-negative integer, got "${raw}"`);
+  }
+  return parsed;
+}
+function loadRuntimeEnv(source = process.env) {
+  const homeOverride = nonEmpty(source.DSH_LARK_HOME);
+  const workspace = nonEmpty(source.DSH_LARK_WORKSPACE);
+  return {
+    home: homeOverride ? resolve2(homeOverride) : join2(homedir2(), ".dsh-lark"),
+    tenant: parseTenant(source.DSH_LARK_TENANT),
+    appId: nonEmpty(source.DSH_LARK_APP_ID),
+    appSecret: nonEmpty(source.DSH_LARK_APP_SECRET),
+    workspace: workspace ? resolve2(workspace) : void 0,
+    dshCommand: nonEmpty(source.DSH_LARK_DSH_COMMAND) ?? DEFAULTS.dshCommand,
+    dshArgs: parseDshArgs(source.DSH_LARK_DSH_ARGS),
+    provider: nonEmpty(source.DSH_LARK_PROVIDER) ?? DEFAULTS.provider,
+    model: nonEmpty(source.DSH_LARK_MODEL) ?? DEFAULTS.model,
+    runTimeoutMs: parseTimeout(source.DSH_LARK_RUN_TIMEOUT_MS),
+    stopGraceMs: parseStopGrace(source.DSH_LARK_STOP_GRACE_MS)
+  };
+}
+
+// src/config/profile-store.ts
+import { readFile } from "fs/promises";
+import { mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+
+// src/platform/atomic-write.ts
+import { randomBytes } from "crypto";
+import { mkdir, rename, writeFile } from "fs/promises";
+import { dirname, join as join3 } from "path";
+async function writeFileAtomic(target, data, options = {}) {
+  const directory = dirname(target);
+  await mkdir(directory, { recursive: true });
+  const temporary = join3(directory, `.${randomBytes(8).toString("hex")}.tmp`);
+  try {
+    await writeFile(temporary, data, options.mode === void 0 ? void 0 : { mode: options.mode });
+    await rename(temporary, target);
+  } catch (error) {
+    await rmSilently(temporary);
+    throw error;
+  }
+}
+async function rmSilently(path) {
+  const { rm } = await import("fs/promises");
+  try {
+    await rm(path, { force: true });
+  } catch {
+  }
+}
+
+// src/config/profile-store.ts
+var ConfigStore = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  data;
+  async load() {
+    try {
+      const raw = await readFile(this.path, "utf8");
+      const parsed = JSON.parse(raw);
+      this.data = {
+        schemaVersion: 1,
+        activeProfile: parsed.activeProfile ?? "default",
+        profiles: parsed.profiles ?? {}
+      };
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      this.data = {
+        schemaVersion: 1,
+        activeProfile: "default",
+        profiles: {}
+      };
+    }
+    return this.data;
+  }
+  getActiveProfile() {
+    const data = this.getData();
+    return data.profiles[data.activeProfile];
+  }
+  getProfile(name) {
+    const data = this.getData();
+    return data.profiles[name];
+  }
+  async saveProfile(name, input) {
+    const data = this.getData();
+    const existing = data.profiles[name];
+    const profile = {
+      schemaVersion: 1,
+      agentKind: "dsh",
+      tenant: input.tenant,
+      accounts: {
+        appId: input.appId,
+        appSecret: input.appSecret
+      },
+      workspaces: {
+        default: input.workspace ?? existing?.workspaces.default ?? void 0
+      },
+      preferences: {
+        model: input.model ?? existing?.preferences.model ?? void 0,
+        stopGraceMs: input.stopGraceMs ?? existing?.preferences.stopGraceMs ?? void 0,
+        runTimeoutMs: input.runTimeoutMs ?? existing?.preferences.runTimeoutMs ?? void 0
+      }
+    };
+    data.profiles[name] = profile;
+    data.activeProfile = name;
+    await this.persist();
+  }
+  getData() {
+    if (!this.data) {
+      throw new Error("ConfigStore must be loaded before use");
+    }
+    return this.data;
+  }
+  async persist() {
+    const data = this.getData();
+    await mkdir2(dirname2(this.path), { recursive: true });
+    await writeFileAtomic(this.path, `${JSON.stringify(data, null, 2)}
+`, {
+      mode: 384
+    });
+  }
+};
+
+// src/cli/commands/doctor.ts
+async function runDoctor(options) {
+  const env = loadRuntimeEnv({
+    ...process.env,
+    ...options.workspace ? { DSH_LARK_WORKSPACE: options.workspace } : {},
+    ...options.tenant ? { DSH_LARK_TENANT: options.tenant } : {},
+    ...options.appId ? { DSH_LARK_APP_ID: options.appId } : {},
+    ...options.appSecret ? { DSH_LARK_APP_SECRET: options.appSecret } : {}
+  });
+  const paths = resolveAppPaths(env.home);
+  const profileName = options.profile ?? "default";
+  const store = new ConfigStore(paths.configFile);
+  await store.load();
+  const profile = store.getProfile(profileName);
+  const lines = [
+    "dsh-lark-bot doctor",
+    `version: ${options.version ?? "unknown"}`,
+    `node: ${process.version}`,
+    `profile: ${profileName}`,
+    `home: ${paths.root}`
+  ];
+  let critical = false;
+  if (!profile) {
+    lines.push("config: missing");
+    critical = true;
+  } else {
+    lines.push(
+      [
+        "config: ok",
+        `tenant=${profile.tenant}`,
+        `app_id=${profile.accounts.appId}`,
+        `app_secret=${profile.accounts.appSecret ? "present" : "missing"}`
+      ].join(" ")
+    );
+    if (!profile.accounts.appId || !profile.accounts.appSecret) critical = true;
+  }
+  const workspace = options.workspace ?? profile?.workspaces.default ?? env.workspace ?? paths.profilePath(profileName, "workspace");
+  try {
+    const info = await stat(workspace);
+    lines.push(`workspace: ${workspace} (${info.isDirectory() ? "directory" : "not-directory"})`);
+  } catch {
+    lines.push(`workspace: ${workspace} (missing)`);
+  }
+  const availability = await checkDshAvailability({ command: env.dshCommand });
+  if (availability.ok) {
+    lines.push(`dsh: ok${availability.version ? ` (${availability.version})` : ""}`);
+  } else {
+    lines.push(`dsh: unavailable (${availability.error ?? "unknown"})`);
+    critical = true;
+  }
+  const output = options.output ?? ((text) => process.stdout.write(text));
+  output(`${lines.join("\n")}
+`);
+  if (critical) process.exitCode = 1;
+}
+
+// src/cli/commands/start.ts
+import { mkdir as mkdir4 } from "fs/promises";
+
+// src/adapters/dsh/adapter.ts
+import { spawn as spawn2 } from "cross-spawn";
+import { createInterface } from "readline";
+
+// src/adapters/dsh/translate.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function translateDshLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!isRecord(parsed) || typeof parsed.type !== "string") return [];
+    switch (parsed.type) {
+      case "system":
+        return [
+          {
+            type: "system",
+            sessionId: stringValue(parsed.sessionId),
+            cwd: stringValue(parsed.cwd),
+            model: stringValue(parsed.model)
+          }
+        ];
+      case "text":
+        return [{ type: "text", delta: stringValue(parsed.delta) ?? "" }];
+      case "final_text":
+        return [{ type: "final_text", content: stringValue(parsed.content) ?? "" }];
+      case "thinking":
+        return [{ type: "thinking", delta: stringValue(parsed.delta) ?? "" }];
+      case "tool_use":
+        return [
+          {
+            type: "tool_use",
+            id: stringValue(parsed.id) ?? "unknown",
+            name: stringValue(parsed.name) ?? "tool",
+            input: parsed.input
+          }
+        ];
+      case "tool_result":
+        return [
+          {
+            type: "tool_result",
+            id: stringValue(parsed.id) ?? "unknown",
+            output: stringValue(parsed.output) ?? "",
+            isError: parsed.isError === true
+          }
+        ];
+      case "done":
+        return [
+          {
+            type: "done",
+            sessionId: stringValue(parsed.sessionId),
+            terminationReason: "normal"
+          }
+        ];
+      case "error":
+        return [
+          {
+            type: "error",
+            message: stringValue(parsed.message) ?? "dsh failed",
+            terminationReason: "failed"
+          }
+        ];
+      default:
+        return [];
+    }
+  } catch {
+    return [];
+  }
+}
+function plainOutputEvent(output) {
+  const trimmed = output.trim();
+  return trimmed ? [{ type: "final_text", content: trimmed }] : [];
+}
+
+// src/adapters/dsh/adapter.ts
+var DshAdapter = class {
+  id = "dsh";
+  displayName = "DeepSeek Harness";
+  command;
+  args;
+  stopGraceMs;
+  constructor(options = {}) {
+    this.command = options.command ?? "dsh";
+    this.args = options.args ?? ["--profile", "headless"];
+    this.stopGraceMs = options.stopGraceMs ?? 5e3;
+  }
+  async isAvailable() {
+    return (await this.checkAvailability()).ok;
+  }
+  checkAvailability() {
+    return checkDshAvailability({ command: this.command });
+  }
+  run(options) {
+    const child = spawn2(
+      this.command,
+      [...this.args, options.prompt],
+      {
+        cwd: options.cwd,
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    child.stdin?.end();
+    const stderrChunks = [];
+    let runtimeError = null;
+    child.stderr?.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    child.on("error", (error) => {
+      runtimeError = error;
+    });
+    return {
+      runId: options.runId,
+      events: createEventStream(child, stderrChunks, () => runtimeError, {
+        sessionId: options.sessionId,
+        cwd: options.cwd,
+        model: options.model
+      }),
+      stop: () => stopChild(child, this.stopGraceMs),
+      waitForExit: (timeoutMs) => waitForChildExit(child, timeoutMs)
+    };
+  }
+};
+async function* createEventStream(child, stderrChunks, getError, system) {
+  if (!child.pid) {
+    const error = getError();
+    yield {
+      type: "error",
+      message: error ? `failed to spawn dsh: ${error.message}` : "spawn returned no pid",
+      terminationReason: "failed"
+    };
+    return;
+  }
+  yield {
+    type: "system",
+    sessionId: system.sessionId,
+    cwd: system.cwd,
+    model: system.model
+  };
+  if (!child.stdout) {
+    yield {
+      type: "error",
+      message: "dsh stdout stream is unavailable",
+      terminationReason: "failed"
+    };
+    return;
+  }
+  const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+  const plainLines = [];
+  let emittedProtocol = false;
+  let terminalEmitted = false;
+  for await (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const events = translateDshLine(trimmed);
+    if (events.length > 0) {
+      emittedProtocol = true;
+      for (const event of events) {
+        if (event.type === "done" || event.type === "error") terminalEmitted = true;
+        yield event;
+      }
+    } else {
+      plainLines.push(trimmed);
+    }
+  }
+  const exitCode = await waitForExitResult(child, 0).then((value) => value.code);
+  const runtimeError = getError();
+  if (!terminalEmitted) {
+    if (exitCode !== null && exitCode !== 0) {
+      const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+      const detail = stderr ? `: ${stderr.slice(0, 500)}` : "";
+      yield {
+        type: "error",
+        message: `dsh exited with code ${exitCode}${detail}`,
+        terminationReason: "failed"
+      };
+      return;
+    }
+    if (runtimeError) {
+      yield {
+        type: "error",
+        message: `dsh runtime error: ${runtimeError.message}`,
+        terminationReason: "failed"
+      };
+      return;
+    }
+    if (emittedProtocol) {
+      yield { type: "done", sessionId: system.sessionId, terminationReason: "normal" };
+    } else {
+      yield* plainOutputEvent(plainLines.join("\n"));
+      yield { type: "done", sessionId: system.sessionId, terminationReason: "normal" };
+    }
+  }
+}
+async function waitForExitResult(child, timeoutMs) {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return { code: child.exitCode, timedOut: false };
+  }
+  return new Promise((resolve4) => {
+    const onExit = (code) => {
+      if (timer !== void 0) clearTimeout(timer);
+      resolve4({ code, timedOut: false });
+    };
+    const timer = timeoutMs > 0 ? setTimeout(() => {
+      child.removeListener("exit", onExit);
+      resolve4({ code: child.exitCode, timedOut: true });
+    }, timeoutMs) : void 0;
+    child.once("exit", onExit);
+  });
+}
+async function stopChild(child, graceMs) {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  child.kill("SIGTERM");
+  const stopped = await waitForExitResult(child, graceMs);
+  if (!stopped.timedOut) return;
+  child.kill("SIGKILL");
+}
+async function waitForChildExit(child, timeoutMs) {
+  const result = await waitForExitResult(child, timeoutMs);
+  return !result.timedOut && result.code !== null;
+}
+
+// src/bot/active-runs.ts
+var ActiveRuns = class {
+  runs = /* @__PURE__ */ new Map();
+  set(scope, handle) {
+    this.runs.set(scope, handle);
+  }
+  get(scope) {
+    return this.runs.get(scope);
+  }
+  delete(scope) {
+    return this.runs.delete(scope);
+  }
+  async interrupt(scope) {
+    const handle = this.runs.get(scope);
+    if (!handle) return false;
+    this.runs.delete(scope);
+    await handle.stop();
+    return true;
+  }
+};
+
+// src/bot/pending-queue.ts
+var PendingQueue = class {
+  constructor(quietMs, onFlush) {
+    this.quietMs = quietMs;
+    this.onFlush = onFlush;
+  }
+  quietMs;
+  onFlush;
+  pending = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  blocked = /* @__PURE__ */ new Set();
+  flushing = /* @__PURE__ */ new Set();
+  push(scope, item) {
+    const batch = this.pending.get(scope) ?? [];
+    batch.push(item);
+    this.pending.set(scope, batch);
+    this.schedule(scope);
+  }
+  block(scope) {
+    this.blocked.add(scope);
+    this.clearTimer(scope);
+  }
+  unblock(scope) {
+    this.blocked.delete(scope);
+    this.schedule(scope);
+  }
+  async flushNow(scope) {
+    this.clearTimer(scope);
+    if (this.flushing.has(scope)) return;
+    const batch = this.pending.get(scope) ?? [];
+    this.pending.delete(scope);
+    if (batch.length === 0) return;
+    this.flushing.add(scope);
+    try {
+      await this.onFlush(scope, batch);
+    } finally {
+      this.flushing.delete(scope);
+    }
+  }
+  hasPending(scope) {
+    return (this.pending.get(scope)?.length ?? 0) > 0;
+  }
+  isBlocked(scope) {
+    return this.blocked.has(scope);
+  }
+  schedule(scope) {
+    if (this.blocked.has(scope) || this.flushing.has(scope)) return;
+    if (this.timers.has(scope)) return;
+    if (!this.hasPending(scope)) return;
+    this.timers.set(
+      scope,
+      setTimeout(() => {
+        this.timers.delete(scope);
+        void this.flushNow(scope);
+      }, this.quietMs)
+    );
+  }
+  clearTimer(scope) {
+    const timer = this.timers.get(scope);
+    if (timer === void 0) return;
+    clearTimeout(timer);
+    this.timers.delete(scope);
+  }
+};
+
+// src/bot/run-policy.ts
+var RunPolicyStore = class {
+  timeouts = /* @__PURE__ */ new Map();
+  get(scope) {
+    return this.timeouts.get(scope);
+  }
+  set(scope, runTimeoutMs) {
+    this.timeouts.set(scope, runTimeoutMs);
+  }
+  clear(scope) {
+    return this.timeouts.delete(scope);
+  }
+};
+
+// src/bridge/channel.ts
+import { createLarkChannel } from "@larksuite/channel";
+
+// src/commands/index.ts
+import { resolve as resolve3 } from "path";
+var HELP = [
+  "**dsh-lark-bot \u547D\u4EE4**",
+  "",
+  "- `/new` `/reset` \u2014 \u5F00\u59CB\u65B0\u4F1A\u8BDD",
+  "- `/cd <path>` \u2014 \u5207\u6362\u5DE5\u4F5C\u76EE\u5F55\u5E76\u91CD\u7F6E\u4F1A\u8BDD",
+  "- `/ws list|save <name>|use <name>|remove <name>` \u2014 \u7BA1\u7406\u5DE5\u4F5C\u7A7A\u95F4",
+  "- `/status` \u2014 \u67E5\u770B\u5F53\u524D\u72B6\u6001",
+  "- `/stop` \u2014 \u7EC8\u6B62\u5F53\u524D\u4EFB\u52A1",
+  "- `/timeout [N|off|default]` \u2014 \u67E5\u770B\u6216\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6",
+  "- `/help` \u2014 \u663E\u793A\u672C\u5E2E\u52A9"
+].join("\n");
+async function reply(ctx, markdown2) {
+  await ctx.channel.sendMarkdown(ctx.chatId, markdown2, {
+    replyTo: ctx.messageId
+  });
+}
+async function handleNew(_args, ctx) {
+  const wasRunning = await ctx.activeRuns.interrupt(ctx.scope);
+  ctx.sessions.clear(ctx.scope);
+  await reply(ctx, wasRunning ? "\u5DF2\u4E2D\u65AD\u5F53\u524D\u4EFB\u52A1\u5E76\u5F00\u59CB\u65B0\u4F1A\u8BDD\u3002" : "\u5DF2\u5F00\u59CB\u65B0\u4F1A\u8BDD\u3002");
+}
+async function handleCd(args, ctx) {
+  const path = args.trim();
+  if (!path) {
+    await reply(ctx, "\u7528\u6CD5\uFF1A`/cd <path>`");
+    return;
+  }
+  const cwd = resolve3(path);
+  await ctx.activeRuns.interrupt(ctx.scope);
+  ctx.workspaces.setCwd(ctx.scope, cwd);
+  ctx.sessions.clear(ctx.scope);
+  await reply(ctx, `\u5DF2\u5207\u6362\u5DE5\u4F5C\u76EE\u5F55\uFF1A\`${cwd}\`\uFF0C\u4F1A\u8BDD\u5DF2\u91CD\u7F6E\u3002`);
+}
+async function handleWs(args, ctx) {
+  const [sub, ...rest] = args.trim().split(/\s+/);
+  const name = rest.join(" ").trim();
+  if (!sub || sub === "list") {
+    const current = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
+    const named = ctx.workspaces.listNamed();
+    const lines = Object.entries(named).map(
+      ([key, value]) => `- **${key}** \u2192 \`${value}\`${value === current ? " \u2190 \u5F53\u524D" : ""}`
+    );
+    await reply(
+      ctx,
+      [
+        `\u5F53\u524D cwd\uFF1A\`${current}\``,
+        "",
+        ...lines.length > 0 ? lines : ["\u6682\u65E0\u547D\u540D\u5DE5\u4F5C\u7A7A\u95F4\u3002"]
+      ].join("\n")
+    );
+    return;
+  }
+  if (sub === "save") {
+    if (!name) {
+      await reply(ctx, "\u7528\u6CD5\uFF1A`/ws save <name>`");
+      return;
+    }
+    const current = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
+    ctx.workspaces.saveNamed(name, current);
+    await reply(ctx, `\u5DF2\u4FDD\u5B58\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}** \u2192 \`${current}\``);
+    return;
+  }
+  if (sub === "use") {
+    if (!name) {
+      await reply(ctx, "\u7528\u6CD5\uFF1A`/ws use <name>`");
+      return;
+    }
+    const cwd = ctx.workspaces.getNamed(name);
+    if (!cwd) {
+      await reply(ctx, `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**`);
+      return;
+    }
+    await ctx.activeRuns.interrupt(ctx.scope);
+    ctx.workspaces.setCwd(ctx.scope, cwd);
+    ctx.sessions.clear(ctx.scope);
+    await reply(ctx, `\u5DF2\u5207\u6362\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}** \u2192 \`${cwd}\``);
+    return;
+  }
+  if (sub === "remove") {
+    if (!name) {
+      await reply(ctx, "\u7528\u6CD5\uFF1A`/ws remove <name>`");
+      return;
+    }
+    const removed = ctx.workspaces.removeNamed(name);
+    await reply(ctx, removed ? `\u5DF2\u5220\u9664\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**` : `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**`);
+    return;
+  }
+  await reply(ctx, "\u672A\u77E5 `/ws` \u5B50\u547D\u4EE4\uFF0C\u8BF7\u4F7F\u7528 list / save / use / remove\u3002");
+}
+async function handleStatus(_args, ctx) {
+  const cwd = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
+  const session = ctx.sessions.getRaw(ctx.scope)?.sessionId ?? "(\u65E0)";
+  const running = Boolean(ctx.activeRuns.get(ctx.scope));
+  const scopeLabel = ctx.chatMode === "topic" ? `${ctx.scope}\uFF08\u8BDD\u9898\u72EC\u7ACB session\uFF09` : ctx.scope;
+  await reply(
+    ctx,
+    [
+      `\u{1F9ED} **scope**: \`${scopeLabel}\``,
+      `\u{1F4C1} **cwd**: \`${cwd}\``,
+      `\u{1F517} **session**: \`${session}\``,
+      `\u{1F3C3} **active run**: ${running ? "yes" : "no"}`
+    ].join("\n")
+  );
+}
+async function handleStop(_args, ctx) {
+  const stopped = await ctx.activeRuns.interrupt(ctx.scope);
+  await reply(ctx, stopped ? "\u5DF2\u8BF7\u6C42\u7EC8\u6B62\u5F53\u524D\u4EFB\u52A1\u3002" : "\u5F53\u524D\u6CA1\u6709\u8FD0\u884C\u4E2D\u7684\u4EFB\u52A1\u3002");
+}
+async function handleTimeout(args, ctx) {
+  const input = args.trim();
+  const effectiveMs = ctx.runPolicies.get(ctx.scope) ?? ctx.defaultRunTimeoutMs;
+  if (!input) {
+    const minutes2 = effectiveMs > 0 ? Math.round(effectiveMs / 6e4) : 0;
+    await reply(
+      ctx,
+      minutes2 > 0 ? `\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A${minutes2} \u5206\u949F\u3002\u53EF\u7528 \`/timeout <N|off|default>\` \u8C03\u6574\u3002` : "\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A\u5173\u95ED\u3002"
+    );
+    return;
+  }
+  if (input === "off") {
+    ctx.runPolicies.set(ctx.scope, 0);
+    await reply(ctx, "\u5DF2\u5173\u95ED\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\u3002");
+    return;
+  }
+  if (input === "default") {
+    ctx.runPolicies.clear(ctx.scope);
+    await reply(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u8FD0\u884C\u8D85\u65F6\u3002");
+    return;
+  }
+  const minutes = Number(input);
+  if (!Number.isInteger(minutes) || minutes <= 0) {
+    await reply(ctx, "\u7528\u6CD5\uFF1A`/timeout <N|off|default>`\uFF0CN \u4E3A\u5927\u4E8E 0 \u7684\u5206\u949F\u6570\u3002");
+    return;
+  }
+  ctx.runPolicies.set(ctx.scope, minutes * 6e4);
+  await reply(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A${minutes} \u5206\u949F\u3002`);
+}
+async function handleHelp(_args, ctx) {
+  await reply(ctx, HELP);
+}
+var handlers = {
+  "/new": handleNew,
+  "/reset": handleNew,
+  "/cd": handleCd,
+  "/ws": handleWs,
+  "/status": handleStatus,
+  "/stop": handleStop,
+  "/timeout": handleTimeout,
+  "/help": handleHelp
+};
+async function tryHandleCommand(text, ctx) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/")) return false;
+  const [command, ...rest] = trimmed.split(/\s+/);
+  const handler = handlers[command ?? ""];
+  if (!handler) return false;
+  await handler(rest.join(" "), ctx);
+  return true;
+}
+
+// src/core/logger.ts
+var REDACTED = "[redacted]";
+var SENSITIVE_KEY = /(secret|token|password|api[_-]?key)/i;
+function redactValue(value, key, depth) {
+  if (SENSITIVE_KEY.test(key)) return REDACTED;
+  if (depth === 0) return value;
+  if (Array.isArray(value)) {
+    return value.map((item, index) => redactValue(item, `${key}.${index}`, depth - 1));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [childKey, childValue] of Object.entries(value)) {
+      out[childKey] = redactValue(childValue, childKey, depth - 1);
+    }
+    return out;
+  }
+  return value;
+}
+function redactFields(fields, depth = 4) {
+  return redactValue(fields, "", depth);
+}
+function serializeMessage(level, category, event, fields) {
+  const entry = {
+    time: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    category,
+    event,
+    fields: redactFields(fields)
+  };
+  return JSON.stringify(entry);
+}
+function createLogger(output = process.stderr) {
+  const write = (level, category, event, fields) => {
+    output.write(`${serializeMessage(level, category, event, fields)}
+`);
+  };
+  return {
+    info: (category, event, fields = {}) => write("info", category, event, fields),
+    warn: (category, event, fields = {}) => write("warn", category, event, fields),
+    error: (category, event, fields = {}) => write("error", category, event, fields),
+    fail(category, error, fields = {}) {
+      const message = error instanceof Error ? error.message : String(error);
+      write("error", category, "fail", { message, ...fields });
+    }
+  };
+}
+var log = createLogger();
+
+// src/bridge/lark-channel.ts
+function adaptLarkChannel(channel) {
+  const base = {
+    async sendMarkdown(chatId, markdown2, options) {
+      const sendOptions = {};
+      if (options?.replyTo) sendOptions.replyTo = options.replyTo;
+      await channel.send(chatId, { markdown: markdown2 }, sendOptions);
+    }
+  };
+  return {
+    ...base,
+    async streamCard(chatId, initial, producer, options) {
+      const sendOptions = {};
+      if (options?.replyTo) sendOptions.replyTo = options.replyTo;
+      await channel.stream(
+        chatId,
+        {
+          card: {
+            initial,
+            producer: async (controller) => {
+              await producer(controller);
+            }
+          }
+        },
+        sendOptions
+      );
+    }
+  };
+}
+
+// src/bridge/channel.ts
+async function startChannel(deps) {
+  const channel = (deps.createChannel ?? createLarkChannel)({
+    appId: deps.appId,
+    appSecret: deps.appSecret,
+    domain: deps.tenant === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn",
+    source: "dsh-lark-bot",
+    policy: {
+      dmMode: "open",
+      requireMention: true,
+      respondToMentionAll: false
+    },
+    safety: {
+      chatQueue: { enabled: false }
+    },
+    outbound: {
+      streamThrottleMs: 400
+    },
+    includeRawEvent: true,
+    handshakeTimeoutMs: 8e3,
+    httpTimeoutMs: 3e4,
+    respectProxyEnv: true
+  });
+  const streaming = adaptLarkChannel(channel);
+  const commandChannel = streaming;
+  channel.on({
+    message: async (msg) => {
+      const scope = scopeForMessage(msg);
+      const context = {
+        scope,
+        chatId: msg.chatId,
+        messageId: msg.messageId,
+        threadId: msg.threadId,
+        chatMode: msg.chatMode ?? msg.chatType,
+        sessions: deps.sessions,
+        workspaces: deps.workspaces,
+        activeRuns: deps.activeRuns,
+        runPolicies: deps.runPolicies,
+        defaultRunTimeoutMs: deps.defaultRunTimeoutMs,
+        channel: commandChannel,
+        defaultWorkspace: deps.defaultWorkspace
+      };
+      const handled = await tryHandleCommand(msg.content, context).catch((error) => {
+        log.fail("channel-command", error, { scope });
+        return false;
+      });
+      if (!handled) deps.pending.push(scope, msg);
+    },
+    cardAction: async (event) => {
+      const value = event.action.value && typeof event.action.value === "object" ? event.action.value : void 0;
+      if (value?.cmd === "stop") {
+        const scope = event.raw ? await resolveCardScope(event.chatId, event.raw) : event.chatId;
+        await deps.activeRuns.interrupt(scope);
+      }
+    },
+    reconnecting: () => {
+      log.warn("channel", "reconnecting", {});
+    },
+    reconnected: () => {
+      log.info("channel", "reconnected", {});
+    },
+    error: (error) => {
+      log.fail("channel", error);
+    }
+  });
+  await channel.connect();
+  return {
+    channel,
+    disconnect: () => channel.disconnect()
+  };
+}
+function scopeForMessage(msg) {
+  if (msg.chatMode === "topic" && msg.threadId) return `${msg.chatId}:${msg.threadId}`;
+  return msg.chatId;
+}
+async function resolveCardScope(chatId, raw) {
+  return raw.message?.thread_id ? `${chatId}:${raw.message.thread_id}` : chatId;
+}
+
+// src/bridge/run-flow.ts
+import { randomUUID } from "crypto";
+
+// src/card/run-state.ts
+var initialState = {
+  blocks: [],
+  reasoning: { content: "", active: false },
+  footer: "thinking",
+  terminal: "running",
+  errorMsg: void 0,
+  idleTimeoutMinutes: void 0
+};
+function closeStreamingText(blocks) {
+  return blocks.map(
+    (block) => block.kind === "text" && block.streaming ? { ...block, streaming: false } : block
+  );
+}
+function reduce(state, event) {
+  switch (event.type) {
+    case "text": {
+      const last = state.blocks[state.blocks.length - 1];
+      if (last?.kind === "text" && last.streaming) {
+        return {
+          ...state,
+          blocks: [
+            ...state.blocks.slice(0, -1),
+            { ...last, content: last.content + event.delta }
+          ],
+          reasoning: { ...state.reasoning, active: false },
+          footer: "streaming"
+        };
+      }
+      return {
+        ...state,
+        blocks: [...state.blocks, { kind: "text", content: event.delta, streaming: true }],
+        reasoning: { ...state.reasoning, active: false },
+        footer: "streaming"
+      };
+    }
+    case "thinking":
+      return {
+        ...state,
+        reasoning: {
+          content: state.reasoning.content + event.delta,
+          active: true
+        },
+        footer: "thinking"
+      };
+    case "tool_use":
+      return {
+        ...state,
+        blocks: [
+          ...closeStreamingText(state.blocks),
+          {
+            kind: "tool",
+            tool: {
+              id: event.id,
+              name: event.name,
+              input: event.input,
+              status: "running"
+            }
+          }
+        ],
+        reasoning: { ...state.reasoning, active: false },
+        footer: "tool_running"
+      };
+    case "tool_result":
+      return {
+        ...state,
+        blocks: state.blocks.map((block) => {
+          if (block.kind !== "tool" || block.tool.id !== event.id) return block;
+          return {
+            ...block,
+            tool: {
+              ...block.tool,
+              status: event.isError ? "error" : "done",
+              output: event.output
+            }
+          };
+        })
+      };
+    case "error":
+      return {
+        ...state,
+        terminal: event.terminationReason === "interrupted" ? "interrupted" : event.terminationReason === "timeout" ? "idle_timeout" : "error",
+        errorMsg: event.terminationReason === "failed" ? event.message : void 0,
+        idleTimeoutMinutes: void 0,
+        footer: null
+      };
+    case "done":
+      return {
+        ...state,
+        blocks: closeStreamingText(state.blocks),
+        reasoning: { ...state.reasoning, active: false },
+        terminal: event.terminationReason === "interrupted" ? "interrupted" : event.terminationReason === "timeout" ? "idle_timeout" : "done",
+        footer: null
+      };
+    default:
+      return state;
+  }
+}
+function markInterrupted(state) {
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoning: { ...state.reasoning, active: false },
+    terminal: "interrupted",
+    footer: null
+  };
+}
+function markIdleTimeout(state, minutes) {
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoning: { ...state.reasoning, active: false },
+    terminal: "idle_timeout",
+    footer: null,
+    idleTimeoutMinutes: minutes
+  };
+}
+function finalizeIfRunning(state) {
+  if (state.terminal !== "running") return state;
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoning: { ...state.reasoning, active: false },
+    terminal: "done",
+    footer: null
+  };
+}
+
+// src/card/run-renderer.ts
+function markdown(content) {
+  return { tag: "markdown", content };
+}
+function noteMd(content) {
+  return { tag: "markdown", content, text_size: "notation" };
+}
+function footerStatus(status) {
+  const text = status === "thinking" ? "\u{1F9E0} \u6B63\u5728\u601D\u8003" : status === "tool_running" ? "\u{1F9F0} \u6B63\u5728\u8C03\u7528\u5DE5\u5177" : "\u270D\uFE0F \u6B63\u5728\u8F93\u51FA";
+  return noteMd(text);
+}
+function summaryText(state) {
+  if (state.terminal === "interrupted") return "\u5DF2\u4E2D\u65AD";
+  if (state.terminal === "idle_timeout") return "\u5DF2\u8D85\u65F6";
+  if (state.terminal === "error") return "\u51FA\u9519";
+  if (state.terminal === "done") return "\u5DF2\u5B8C\u6210";
+  if (state.footer === "tool_running") return "\u6B63\u5728\u8C03\u7528\u5DE5\u5177";
+  if (state.footer === "streaming") return "\u6B63\u5728\u8F93\u51FA";
+  return "\u601D\u8003\u4E2D";
+}
+function stopButton() {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: "\u23F9 \u7EC8\u6B62" },
+    type: "danger",
+    value: { cmd: "stop" }
+  };
+}
+function textBlock(block) {
+  return markdown(block.content);
+}
+function toolBlock(tool) {
+  const icon = tool.status === "error" ? "\u26A0\uFE0F" : tool.status === "done" ? "\u2705" : "\u23F3";
+  return markdown(`${icon} **${tool.name}**`);
+}
+function renderCard(state) {
+  const elements = [];
+  if (state.reasoning.content) {
+    elements.push(
+      noteMd(
+        state.reasoning.active ? "\u{1F9E0} \u6B63\u5728\u601D\u8003\u2026" : `\u{1F9E0} \u601D\u8003\u5B8C\u6210\uFF1A${state.reasoning.content.slice(0, 300)}`
+      )
+    );
+  }
+  for (const block of state.blocks) {
+    elements.push(block.kind === "text" ? textBlock(block) : toolBlock(block.tool));
+  }
+  if (state.terminal === "interrupted") {
+    elements.push(noteMd("_\u23F9 \u5DF2\u88AB\u4E2D\u65AD_"));
+  } else if (state.terminal === "idle_timeout") {
+    elements.push(noteMd(`_\u23F1 ${state.idleTimeoutMinutes ?? 0} \u5206\u949F\u65E0\u54CD\u5E94\uFF0C\u5DF2\u81EA\u52A8\u7EC8\u6B62_`));
+  } else if (state.terminal === "error" && state.errorMsg) {
+    elements.push(noteMd(`\u26A0\uFE0F agent \u5931\u8D25\uFF1A${state.errorMsg}`));
+  } else if (state.terminal === "done" && elements.length === 0) {
+    elements.push(noteMd("_\uFF08\u672A\u8FD4\u56DE\u5185\u5BB9\uFF09_"));
+  }
+  if (state.terminal === "running") {
+    if (state.footer) elements.push(footerStatus(state.footer));
+    elements.push(stopButton());
+  }
+  return {
+    schema: "2.0",
+    config: {
+      streaming_mode: state.terminal === "running",
+      summary: { content: summaryText(state) }
+    },
+    body: { elements }
+  };
+}
+
+// src/bridge/run-flow.ts
+async function runAgentBatch(input) {
+  const replyOptions = input.replyTo ? { replyTo: input.replyTo } : {};
+  if (input.activeRuns.get(input.scope)) {
+    await input.channel.sendMarkdown(input.chatId, "\u5F53\u524D\u4F1A\u8BDD\u5DF2\u6709\u4EFB\u52A1\u6B63\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148 `/stop` \u6216\u7B49\u5F85\u5B8C\u6210\u3002", {
+      ...replyOptions
+    });
+    return;
+  }
+  const requestedCwd = input.workspaces.cwdFor(input.scope) ?? input.defaultWorkspace;
+  const workspace = input.workspaceManager ? await input.workspaceManager.ensure(input.scope, requestedCwd) : { cwd: requestedCwd };
+  const cwd = workspace.cwd;
+  const sessionId = input.sessions.resumeFor(input.scope, cwd);
+  const prompt = input.messages.join("\n\n");
+  const runId = randomUUID();
+  const run = input.adapter.run({
+    runId,
+    prompt,
+    cwd,
+    sessionId,
+    model: input.model,
+    images: void 0,
+    stopGraceMs: input.stopGraceMs
+  });
+  input.activeRuns.set(input.scope, { runId, stop: run.stop });
+  let state = initialState;
+  const stopRequested = { value: false };
+  const timeoutMs = input.runPolicies?.get(input.scope) ?? input.runTimeoutMs ?? 0;
+  let timedOut = false;
+  try {
+    await input.channel.streamCard(
+      input.chatId,
+      renderCard(state),
+      async (controller) => {
+        const consume = async () => {
+          for await (const event of run.events) {
+            if (timedOut) return;
+            state = applyEvent(state, event, stopRequested);
+            if (event.type === "system" && event.sessionId) {
+              input.sessions.set(input.scope, event.sessionId, event.cwd ?? cwd);
+            }
+            await controller.update(renderCard(state));
+          }
+        };
+        let timeoutTimer;
+        const timeoutPromise = timeoutMs > 0 ? new Promise((resolve4) => {
+          timeoutTimer = setTimeout(() => {
+            timedOut = true;
+            void run.stop();
+            resolve4();
+          }, timeoutMs);
+        }) : void 0;
+        try {
+          if (timeoutPromise) {
+            await Promise.race([consume(), timeoutPromise]);
+          } else {
+            await consume();
+          }
+          state = timedOut ? markIdleTimeout(state, timeoutMs / 6e4) : finalizeIfRunning(state);
+          await controller.update(renderCard(state));
+        } finally {
+          if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
+        }
+      },
+      replyOptions
+    );
+  } catch (error) {
+    log.fail("run-flow", error, { scope: input.scope, runId });
+    state = markInterrupted(state);
+    try {
+      await input.channel.sendMarkdown(input.chatId, `\u26A0\uFE0F agent \u8FD0\u884C\u5931\u8D25\uFF1A${errorMessage(error)}`, {
+        ...replyOptions
+      });
+    } catch {
+    }
+  } finally {
+    input.activeRuns.delete(input.scope);
+  }
+}
+function applyEvent(state, event, stopRequested) {
+  if (event.type === "done" && event.terminationReason === "interrupted") {
+    stopRequested.value = true;
+    return markInterrupted(state);
+  }
+  if (event.type === "error" && event.terminationReason === "timeout") {
+    return markIdleTimeout(state, 0);
+  }
+  return reduce(state, event);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/onboard/registration.ts
+import { registerApp } from "@larksuite/channel";
+import qrcode from "qrcode-terminal";
+var DEFAULT_SOURCE = "dsh-lark-bot";
+async function onboardPersonalAgent(deps = {}) {
+  const register = deps.register ?? registerApp;
+  const renderQr = deps.renderQr ?? ((value) => qrcode.generate(value, { small: true }));
+  const print = deps.print ?? ((line) => process.stdout.write(`${line}
+`));
+  print("");
+  print("\u672A\u68C0\u6D4B\u5230\u98DE\u4E66 / Lark \u5E94\u7528\u51ED\u636E\uFF0C\u8FDB\u5165\u626B\u7801\u521B\u5EFA\u5411\u5BFC\u3002");
+  print("");
+  const result = await register({
+    source: deps.source ?? DEFAULT_SOURCE,
+    ...deps.signal ? { signal: deps.signal } : {},
+    onQRCodeReady: (info) => {
+      print("\u8BF7\u4F7F\u7528\u98DE\u4E66 / Lark App \u626B\u63CF\u4EE5\u4E0B\u4E8C\u7EF4\u7801\uFF0C\u521B\u5EFA\u6216\u9009\u62E9 PersonalAgent \u5E94\u7528\uFF1A");
+      print("");
+      renderQr(info.url);
+      print("");
+      const minutes = Math.max(1, Math.round(info.expireIn / 60));
+      print(`\u4E8C\u7EF4\u7801\u6709\u6548\u671F\u7EA6 ${minutes} \u5206\u949F\u3002`);
+      print(`\u4E5F\u53EF\u4EE5\u76F4\u63A5\u5728\u6D4F\u89C8\u5668\u6253\u5F00\uFF1A${info.url}`);
+      print("");
+    },
+    onStatusChange: (info) => {
+      if (info.status === "domain_switched") {
+        print("\u5DF2\u8BC6\u522B\u5230\u56FD\u9645\u7248\u79DF\u6237\uFF0C\u81EA\u52A8\u5207\u6362\u5230 larksuite.com \u57DF\u540D\u3002");
+      } else if (info.status === "slow_down") {
+        print("\u8F6E\u8BE2\u901F\u5EA6\u8FC7\u5FEB\uFF0C\u5DF2\u81EA\u52A8\u964D\u901F\u3002");
+      }
+    }
+  });
+  const tenant = result.user_info?.tenant_brand === "lark" ? "lark" : "feishu";
+  print("\u2713 PersonalAgent \u5E94\u7528\u521B\u5EFA / \u7ED1\u5B9A\u6210\u529F\u3002");
+  print(`  App ID:  ${result.client_id}`);
+  print(`  Tenant:  ${tenant}`);
+  print("");
+  return {
+    appId: result.client_id,
+    appSecret: result.client_secret,
+    tenant
+  };
+}
+
+// src/session/store.ts
+import { readFile as readFile2 } from "fs/promises";
+var SessionStore = class {
+  data = { chats: {} };
+  saving = Promise.resolve();
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  async load() {
+    try {
+      const raw = await readFile2(this.path, "utf8");
+      const parsed = JSON.parse(raw);
+      this.data = {
+        chats: parsed.chats ?? {}
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+  }
+  getRaw(scopeId) {
+    return this.data.chats[scopeId];
+  }
+  set(scopeId, sessionId, cwd) {
+    this.data.chats[scopeId] = { sessionId, cwd };
+    this.schedulePersist();
+  }
+  clear(scopeId) {
+    if (!(scopeId in this.data.chats)) return false;
+    delete this.data.chats[scopeId];
+    this.schedulePersist();
+    return true;
+  }
+  resumeFor(scopeId, cwd) {
+    const record = this.data.chats[scopeId];
+    return record && record.cwd === cwd ? record.sessionId : void 0;
+  }
+  async flush() {
+    await this.saving;
+  }
+  schedulePersist() {
+    const snapshot = this.snapshot();
+    this.saving = this.saving.then(async () => {
+      await writeFileAtomic(this.path, `${JSON.stringify(snapshot, null, 2)}
+`, {
+        mode: 384
+      });
+    }).catch((error) => {
+      log.fail("session", error, { step: "persist" });
+    });
+  }
+  snapshot() {
+    return {
+      chats: { ...this.data.chats }
+    };
+  }
+};
+
+// src/workspace/git-worktree.ts
+import { execFile } from "child_process";
+import { randomBytes as randomBytes2 } from "crypto";
+import { access, copyFile, mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function defaultRunGit(args, cwd) {
+  const result = await execFileAsync("git", args, {
+    cwd,
+    encoding: "utf8"
+  });
+  return result.stdout;
+}
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function defaultCopyRulesFile(source, target) {
+  await mkdir3(dirname3(target), { recursive: true });
+  await copyFile(source, target);
+}
+function slugify(scope) {
+  const slug = scope.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  return slug || "session";
+}
+var GitWorktreeManager = class {
+  constructor(options) {
+    this.options = options;
+    this.runGit = options.runGit ?? defaultRunGit;
+    this.copyRulesFile = options.copyRulesFile ?? defaultCopyRulesFile;
+  }
+  options;
+  runGit;
+  copyRulesFile;
+  async ensure(scope, base) {
+    const isGit = await this.isGitRepository(base);
+    if (!isGit) return { cwd: base, created: false };
+    const slug = slugify(scope);
+    const target = join4(this.options.worktreesRoot, slug);
+    if (await exists(target)) {
+      await this.ensureProjectRules(base, target);
+      return { cwd: target, created: false };
+    }
+    const branch = `dsh-lark/${slug}-${Date.now().toString(36)}-${randomBytes2(3).toString("hex")}`;
+    await mkdir3(this.options.worktreesRoot, { recursive: true });
+    await this.runGit(["worktree", "add", "-b", branch, target, "HEAD"], base);
+    await this.ensureProjectRules(base, target);
+    return { cwd: target, created: true, branch };
+  }
+  async isGitRepository(cwd) {
+    try {
+      const result = await this.runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+      return result.trim() === "true";
+    } catch {
+      return false;
+    }
+  }
+  async ensureProjectRules(base, target) {
+    const destination = join4(target, "AGENTS.md");
+    if (await exists(destination)) return;
+    const sourceCandidates = [join4(base, ".dsh-lark", "AGENTS.md"), join4(base, "AGENTS.md")];
+    for (const source of sourceCandidates) {
+      if (await exists(source)) {
+        await this.copyRulesFile(source, destination);
+        return;
+      }
+    }
+  }
+};
+
+// src/workspace/store.ts
+import { readFile as readFile3 } from "fs/promises";
+var WorkspaceStore = class {
+  data = { chats: {}, named: {} };
+  saving = Promise.resolve();
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  async load() {
+    try {
+      const raw = await readFile3(this.path, "utf8");
+      const parsed = JSON.parse(raw);
+      this.data = {
+        chats: parsed.chats ?? {},
+        named: parsed.named ?? {}
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+  }
+  cwdFor(scopeId) {
+    return this.data.chats[scopeId]?.cwd;
+  }
+  setCwd(scopeId, cwd) {
+    this.data.chats[scopeId] = { cwd };
+    this.schedulePersist();
+  }
+  removeCwd(scopeId) {
+    if (!(scopeId in this.data.chats)) return false;
+    delete this.data.chats[scopeId];
+    this.schedulePersist();
+    return true;
+  }
+  listNamed() {
+    return { ...this.data.named };
+  }
+  getNamed(name) {
+    return this.data.named[name];
+  }
+  saveNamed(name, cwd) {
+    this.data.named[name] = cwd;
+    this.schedulePersist();
+  }
+  removeNamed(name) {
+    if (!(name in this.data.named)) return false;
+    delete this.data.named[name];
+    this.schedulePersist();
+    return true;
+  }
+  async flush() {
+    await this.saving;
+  }
+  schedulePersist() {
+    const snapshot = {
+      chats: { ...this.data.chats },
+      named: { ...this.data.named }
+    };
+    this.saving = this.saving.then(async () => {
+      await writeFileAtomic(this.path, `${JSON.stringify(snapshot, null, 2)}
+`, {
+        mode: 384
+      });
+    }).catch((error) => {
+      log.fail("workspace", error, { step: "persist" });
+    });
+  }
+};
+
+// src/cli/commands/start.ts
+var DEBOUNCE_MS = 600;
+async function runStart(options) {
+  const env = loadRuntimeEnv({
+    ...process.env,
+    ...options.workspace ? { DSH_LARK_WORKSPACE: options.workspace } : {},
+    ...options.tenant ? { DSH_LARK_TENANT: options.tenant } : {},
+    ...options.appId ? { DSH_LARK_APP_ID: options.appId } : {},
+    ...options.appSecret ? { DSH_LARK_APP_SECRET: options.appSecret } : {}
+  });
+  const paths = resolveAppPaths(env.home);
+  const profileName = options.profile ?? "default";
+  const configStore = new ConfigStore(paths.configFile);
+  await configStore.load();
+  if (env.appId && env.appSecret) {
+    const profileInput = {
+      tenant: env.tenant,
+      appId: env.appId,
+      appSecret: env.appSecret,
+      model: env.model,
+      stopGraceMs: env.stopGraceMs,
+      runTimeoutMs: env.runTimeoutMs
+    };
+    if (env.workspace !== void 0) profileInput.workspace = env.workspace;
+    await configStore.saveProfile(profileName, profileInput);
+  }
+  const profile = configStore.getProfile(profileName);
+  if (!profile) {
+    try {
+      const created = await onboardPersonalAgent();
+      const onboardingProfile = {
+        tenant: created.tenant,
+        appId: created.appId,
+        appSecret: created.appSecret,
+        model: env.model,
+        stopGraceMs: env.stopGraceMs,
+        runTimeoutMs: env.runTimeoutMs
+      };
+      if (env.workspace !== void 0) onboardingProfile.workspace = env.workspace;
+      await configStore.saveProfile(profileName, onboardingProfile);
+    } catch (error) {
+      log.fail("onboarding", error);
+      process.stderr.write("\u626B\u7801\u521B\u5EFA\u5E94\u7528\u5931\u8D25\uFF0C\u672A\u5199\u5165\u672C\u5730\u914D\u7F6E\u3002\n");
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const activeProfile = configStore.getProfile(profileName);
+  if (!activeProfile) {
+    process.stderr.write("\u672C\u5730\u914D\u7F6E\u8BFB\u53D6\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u540E\u91CD\u8BD5\u3002\n");
+    process.exitCode = 1;
+    return;
+  }
+  const defaultWorkspace = options.workspace ?? activeProfile.workspaces.default ?? env.workspace ?? paths.profilePath(profileName, "workspace");
+  await mkdir4(defaultWorkspace, { recursive: true });
+  const sessions = new SessionStore(paths.sessionsFile(profileName));
+  const workspaces = new WorkspaceStore(paths.workspacesFile(profileName));
+  const worktreeManager = new GitWorktreeManager({
+    worktreesRoot: paths.profilePath(profileName, "worktrees")
+  });
+  await Promise.all([sessions.load(), workspaces.load()]);
+  const adapterOptions = {
+    command: env.dshCommand,
+    args: env.dshArgs,
+    stopGraceMs: env.stopGraceMs
+  };
+  if (activeProfile.preferences.stopGraceMs !== void 0) {
+    Object.assign(adapterOptions, { stopGraceMs: activeProfile.preferences.stopGraceMs });
+  }
+  const adapter = new DshAdapter(adapterOptions);
+  const activeRuns = new ActiveRuns();
+  const runPolicies = new RunPolicyStore();
+  let streaming;
+  const pending = new PendingQueue(DEBOUNCE_MS, async (scope, batch) => {
+    if (!streaming) return;
+    const first = batch[0];
+    if (!first) return;
+    pending.block(scope);
+    try {
+      const runInput = {
+        scope,
+        chatId: first.chatId,
+        messages: batch.map((message) => message.content),
+        adapter,
+        sessions,
+        workspaces,
+        workspaceManager: worktreeManager,
+        activeRuns,
+        runPolicies,
+        channel: streaming,
+        defaultWorkspace,
+        replyTo: first.messageId,
+        runTimeoutMs: activeProfile.preferences.runTimeoutMs ?? env.runTimeoutMs
+      };
+      if (activeProfile.preferences.model !== void 0) runInput.model = activeProfile.preferences.model;
+      if (activeProfile.preferences.stopGraceMs !== void 0) {
+        runInput.stopGraceMs = activeProfile.preferences.stopGraceMs;
+      }
+      await runAgentBatch(runInput);
+    } finally {
+      pending.unblock(scope);
+    }
+  });
+  const channelInput = {
+    appId: activeProfile.accounts.appId,
+    appSecret: activeProfile.accounts.appSecret,
+    tenant: activeProfile.tenant,
+    adapter,
+    sessions,
+    workspaces,
+    activeRuns,
+    runPolicies,
+    defaultRunTimeoutMs: activeProfile.preferences.runTimeoutMs ?? env.runTimeoutMs,
+    pending,
+    defaultWorkspace
+  };
+  if (activeProfile.preferences.model !== void 0) channelInput.model = activeProfile.preferences.model;
+  if (activeProfile.preferences.stopGraceMs !== void 0) {
+    channelInput.stopGraceMs = activeProfile.preferences.stopGraceMs;
+  }
+  const bridge = await startChannel(channelInput);
+  streaming = adaptLarkChannel(bridge.channel);
+  log.info("cli", "started", {
+    profile: profileName,
+    home: paths.root,
+    tenant: activeProfile.tenant,
+    workspace: defaultWorkspace
+  });
+  process.stdout.write(`dsh-lark-bot \u5DF2\u542F\u52A8\uFF0Cprofile=${profileName}
+`);
+  await waitForShutdown();
+  await bridge.disconnect();
+  await Promise.all([sessions.flush(), workspaces.flush()]);
+}
+function waitForShutdown() {
+  return new Promise((resolve4) => {
+    const shutdown = () => {
+      process.off("SIGINT", shutdown);
+      process.off("SIGTERM", shutdown);
+      resolve4();
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+
+// src/cli.ts
+function packageVersion() {
+  const raw = readFileSync(new URL("../package.json", import.meta.url), "utf8");
+  const pkg = JSON.parse(raw);
+  return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("dsh-lark-bot").description("Bridge DeepSeek Harness into Feishu / Lark").version(packageVersion(), "-v, --version");
+  program.command("start").description("Start the bridge in the foreground").option("--profile <name>", "profile name").option("--workspace <path>", "initial working directory").option("--app-id <id>", "existing Lark/Feishu app id").option("--app-secret <secret>", "existing Lark/Feishu app secret").option("--tenant <tenant>", "feishu or lark").action(async (opts) => {
+    await runStart(opts);
+  });
+  program.command("doctor").description("Run local diagnostics").option("--profile <name>", "profile name").option("--workspace <path>", "initial working directory").option("--app-id <id>", "existing Lark/Feishu app id").option("--app-secret <secret>", "existing Lark/Feishu app secret").option("--tenant <tenant>", "feishu or lark").action(async (opts) => {
+    await runDoctor({ ...opts, version: packageVersion() });
+  });
+  return program;
+}
+async function main(argv = process.argv) {
+  await buildProgram().parseAsync([...argv]);
+}
+export {
+  buildProgram,
+  main
+};
+//# sourceMappingURL=cli.js.map