@opentag/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,2320 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config.ts
+import { randomUUID } from "crypto";
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { formatConfigError as formatDaemonConfigError, parseDaemonConfig } from "@opentag/local-runtime";
+import { z } from "zod";
+var ExecutorSchema = z.enum(["echo", "codex", "claude-code"]);
+var KeepWorktreeSchema = z.enum(["always", "on_failure", "never"]);
+var PositiveIntegerSchema = z.number().int().positive();
+var CliLanguageSchema = z.enum(["en", "zh-CN"]);
+var PlatformSchema = z.enum(["lark", "slack", "github", "telegram"]);
+var LarkSetupMethodSchema = z.enum(["saved", "scan", "manual"]);
+var SlackModeSchema = z.enum(["socket_mode", "events_api"]);
+var BindingMethodSchema = z.enum(["default_project", "bind_later"]);
+var OptionalPortSchema = z.number().int().min(1).max(65535).optional();
+var RepositoryBindingSchema = z.object({
+  provider: z.string().min(1),
+  owner: z.string().min(1),
+  repo: z.string().min(1),
+  checkoutPath: z.string().min(1),
+  defaultExecutor: ExecutorSchema,
+  baseBranch: z.string().min(1),
+  pushRemote: z.string().min(1),
+  worktreeRoot: z.string().min(1),
+  keepWorktree: KeepWorktreeSchema
+}).strict();
+var ChannelBindingSchema = z.object({
+  provider: z.string().min(1),
+  accountId: z.string().min(1),
+  conversationId: z.string().min(1),
+  repoProvider: z.string().min(1),
+  owner: z.string().min(1),
+  repo: z.string().min(1),
+  metadata: z.record(z.string(), z.unknown()).optional()
+}).strict();
+var ClaudeCodeSchema = z.object({
+  command: z.string().min(1).optional(),
+  model: z.string().min(1).optional(),
+  permissionMode: z.enum(["acceptEdits", "auto", "bypassPermissions", "default", "plan"]).optional(),
+  dangerouslySkipPermissions: z.boolean().optional()
+}).strict();
+var SecuritySchema = z.object({
+  mode: z.enum(["enforce", "audit", "off"]).optional(),
+  allowedWorkspaceRoot: z.string().min(1).optional(),
+  allowUnsafePrompts: z.boolean().optional(),
+  extraSafeEnv: z.array(z.string().min(1)).optional()
+}).strict();
+var DaemonConfigSchema = z.object({
+  runnerId: z.string().min(1),
+  dispatcherUrl: z.string().url(),
+  repositories: z.array(RepositoryBindingSchema).min(1),
+  channelBindings: z.array(ChannelBindingSchema).optional(),
+  claudeCode: ClaudeCodeSchema.optional(),
+  security: SecuritySchema.optional(),
+  githubToken: z.string().min(1).optional(),
+  preparePullRequestBranch: z.boolean().optional(),
+  allowAutoCreatePullRequest: z.boolean().optional(),
+  pairingToken: z.string().min(1),
+  pollIntervalMs: PositiveIntegerSchema,
+  heartbeatIntervalMs: PositiveIntegerSchema
+}).strict();
+var LarkPlatformSchema = z.object({
+  appId: z.string().min(1),
+  appSecret: z.string().min(1),
+  domain: z.enum(["lark", "feishu"]),
+  botOpenId: z.string().min(1).optional(),
+  defaultProjectBinding: z.boolean().optional()
+}).strict();
+var SlackPlatformSchema = z.object({
+  mode: SlackModeSchema.optional(),
+  appToken: z.string().min(1).optional(),
+  signingSecret: z.string().min(1).optional(),
+  botToken: z.string().min(1),
+  teamId: z.string().min(1),
+  channelId: z.string().min(1),
+  appId: z.string().min(1).optional(),
+  defaultProjectBinding: z.boolean().optional(),
+  port: OptionalPortSchema
+}).strict().superRefine((value, context) => {
+  const mode = value.mode ?? "events_api";
+  if (mode === "socket_mode" && !value.appToken) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["appToken"],
+      message: "Slack Socket Mode requires appToken."
+    });
+  }
+  if (mode === "events_api" && !value.signingSecret) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["signingSecret"],
+      message: "Slack Events API requires signingSecret."
+    });
+  }
+});
+var GitHubPlatformSchema = z.object({
+  webhookSecret: z.string().min(1),
+  owner: z.string().min(1),
+  repo: z.string().min(1),
+  webhookPath: z.string().min(1).optional(),
+  port: OptionalPortSchema
+}).strict();
+var PreferencesSchema = z.object({
+  language: CliLanguageSchema.optional(),
+  lastSetup: z.object({
+    platforms: z.array(PlatformSchema).optional(),
+    executor: ExecutorSchema.optional(),
+    projectPath: z.string().min(1).optional(),
+    larkSetupMethod: LarkSetupMethodSchema.optional(),
+    larkDomain: z.enum(["lark", "feishu"]).optional(),
+    bindingMethod: BindingMethodSchema.optional(),
+    slackMode: SlackModeSchema.optional(),
+    slackTeamId: z.string().min(1).optional(),
+    slackChannelId: z.string().min(1).optional(),
+    slackPort: OptionalPortSchema,
+    githubOwner: z.string().min(1).optional(),
+    githubRepo: z.string().min(1).optional(),
+    githubPort: OptionalPortSchema,
+    githubAutoCreatePullRequest: z.boolean().optional()
+  }).strict().optional()
+}).strict();
+var OpenTagCliConfigSchema = z.object({
+  schemaVersion: z.literal(1),
+  state: z.object({
+    directory: z.string().min(1),
+    databasePath: z.string().min(1),
+    worktreeRoot: z.string().min(1)
+  }).strict(),
+  preferences: PreferencesSchema.optional(),
+  daemon: DaemonConfigSchema,
+  platforms: z.object({
+    lark: LarkPlatformSchema.optional(),
+    slack: SlackPlatformSchema.optional(),
+    github: GitHubPlatformSchema.optional()
+  }).strict()
+}).strict();
+function configHome(env, home = homedir()) {
+  if (env.OPENTAG_CONFIG_HOME) return resolve(env.OPENTAG_CONFIG_HOME);
+  if (env.XDG_CONFIG_HOME) return resolve(env.XDG_CONFIG_HOME, "opentag");
+  return join(home, ".config", "opentag");
+}
+function defaultConfigPath(env = process.env, home = homedir()) {
+  if (env.OPENTAG_CONFIG_PATH) return resolve(env.OPENTAG_CONFIG_PATH);
+  return join(configHome(env, home), "config.json");
+}
+function defaultStateDirectory(env = process.env, home = homedir()) {
+  if (env.OPENTAG_STATE_DIR) return resolve(env.OPENTAG_STATE_DIR);
+  if (env.XDG_STATE_HOME) return resolve(env.XDG_STATE_HOME, "opentag");
+  return join(home, ".local", "state", "opentag");
+}
+function formatPath(path) {
+  return path.length ? path.join(".") : "config";
+}
+function formatCliConfigError(error) {
+  if (error instanceof z.ZodError) {
+    return error.issues.map((issue) => `${formatPath(issue.path)}: ${issue.message}`).join("\n");
+  }
+  return formatDaemonConfigError(error);
+}
+function parseCliConfig(value) {
+  const parsed = OpenTagCliConfigSchema.parse(value);
+  return {
+    ...parsed,
+    daemon: parseDaemonConfig(parsed.daemon)
+  };
+}
+function readCliConfig(path = defaultConfigPath()) {
+  assertPrivateConfigFile(path);
+  return parseCliConfig(JSON.parse(readFileSync(path, "utf8")));
+}
+function ensurePrivateDirectory(path) {
+  const createdPath = mkdirSync(path, { recursive: true, mode: 448 });
+  if (createdPath) {
+    chmodSync(path, 448);
+  }
+}
+function writeCliConfigAtomic(path, config) {
+  ensurePrivateDirectory(dirname(path));
+  const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tempPath, `${JSON.stringify(config, null, 2)}
+`, { mode: 384, flag: "wx" });
+    chmodSync(tempPath, 384);
+    renameSync(tempPath, path);
+    chmodSync(path, 384);
+  } catch (error) {
+    rmSync(tempPath, { force: true });
+    throw error;
+  }
+}
+function assertPrivateConfigFile(path) {
+  if (process.platform === "win32") return;
+  const mode = statSync(path).mode & 511;
+  if ((mode & 63) !== 0) {
+    throw new Error(`OpenTag config contains secrets and must not be readable by group or others: ${path}
+Fix it with: chmod 600 ${path}`);
+  }
+}
+function redactValue(key, value) {
+  if (["appSecret", "appToken", "botToken", "githubToken", "pairingToken", "signingSecret", "webhookSecret"].includes(key)) {
+    return "[REDACTED]";
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactValue("", entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, redactValue(entryKey, entryValue)]));
+  }
+  return value;
+}
+function redactedCliConfig(config) {
+  return redactValue("", config);
+}
+
+// src/catalogs/executors.ts
+import { existsSync } from "fs";
+import { delimiter, extname, join as join2 } from "path";
+var EXECUTOR_CATALOG = [
+  {
+    id: "codex",
+    label: "Codex",
+    command: "codex"
+  },
+  {
+    id: "claude-code",
+    label: "Claude Code",
+    command: "claude"
+  },
+  {
+    id: "echo",
+    label: "Echo",
+    alwaysAvailable: true,
+    devOnly: true
+  }
+];
+function pathExistsOnPath(command, env = process.env) {
+  const paths = env.PATH?.split(delimiter).filter(Boolean) ?? [];
+  const candidates = process.platform === "win32" && !extname(command) ? [command, ...(env.PATHEXT?.split(delimiter).filter(Boolean) ?? [".COM", ".EXE", ".BAT", ".CMD"]).map((extension) => `${command}${extension.toLowerCase()}`)] : [command];
+  return paths.some((directory) => candidates.some((candidate) => existsSync(join2(directory, candidate))));
+}
+function parseExecutorId(value) {
+  if (value === "echo" || value === "codex" || value === "claude-code") {
+    return value;
+  }
+  throw new Error("Executor must be echo, codex, or claude-code.");
+}
+function detectExecutors(env = process.env) {
+  return EXECUTOR_CATALOG.map((executor) => {
+    if (executor.alwaysAvailable) {
+      return {
+        id: executor.id,
+        available: true,
+        reason: executor.devOnly ? "Dev/test only; does not run a real coding agent" : "Built in"
+      };
+    }
+    const available = executor.command ? pathExistsOnPath(executor.command, env) : false;
+    return {
+      id: executor.id,
+      available,
+      reason: available ? `Found ${executor.command} on PATH` : `Could not find ${executor.command} on PATH`
+    };
+  });
+}
+function defaultExecutorId(input = {}) {
+  if (input.previous) {
+    return input.previous;
+  }
+  const detections = input.detections ?? detectExecutors();
+  if (detections.find((executor) => executor.id === "codex")?.available) {
+    return "codex";
+  }
+  if (detections.find((executor) => executor.id === "claude-code")?.available) {
+    return "claude-code";
+  }
+  return "echo";
+}
+function executorLabel(id) {
+  return EXECUTOR_CATALOG.find((executor) => executor.id === id)?.label ?? id;
+}
+function formatExecutorStatus(executor, available) {
+  if (executor.devOnly) {
+    return "dev/test only";
+  }
+  return available ? "available" : "not found";
+}
+function formatExecutors(env = process.env) {
+  const detections = detectExecutors(env);
+  return [
+    "Coding agents:",
+    ...EXECUTOR_CATALOG.map((executor) => {
+      const detection = detections.find((entry) => entry.id === executor.id);
+      const status = formatExecutorStatus(executor, detection?.available ?? false);
+      return `  ${executor.label}: ${status}${detection ? ` (${detection.reason})` : ""}`;
+    })
+  ].join("\n");
+}
+
+// src/commands/executors.ts
+function runExecutorsCommand(options = {}) {
+  console.log(formatExecutors(options.env ?? process.env));
+}
+
+// src/catalogs/platforms.ts
+var SETUP_GUIDE_BASE_URL = "https://github.com/amplifthq/opentag/blob/main/docs/platforms";
+var PLATFORM_SETUP_GUIDE_FILES = {
+  lark: {
+    en: "lark.en.md",
+    "zh-CN": "lark.zh-CN.md"
+  },
+  slack: {
+    en: "slack.en.md",
+    "zh-CN": "slack.zh-CN.md"
+  },
+  github: {
+    en: "github.en.md",
+    "zh-CN": "github.zh-CN.md"
+  }
+};
+var PLATFORM_CATALOG = [
+  {
+    id: "lark",
+    label: "Lark / Feishu",
+    status: "setup_ready",
+    startable: true
+  },
+  {
+    id: "slack",
+    label: "Slack",
+    status: "setup_ready",
+    startable: true
+  },
+  {
+    id: "github",
+    label: "GitHub",
+    status: "setup_ready",
+    startable: true
+  },
+  {
+    id: "telegram",
+    label: "Telegram",
+    status: "experimental_setup_pending",
+    startable: false
+  }
+];
+function parsePlatformId(value) {
+  if (value === "lark" || value === "slack" || value === "github" || value === "telegram") {
+    return value;
+  }
+  throw new Error("Platform must be lark, slack, github, or telegram.");
+}
+function platformById(id) {
+  const descriptor = PLATFORM_CATALOG.find((platform) => platform.id === id);
+  if (!descriptor) {
+    throw new Error(`Unknown platform: ${id}`);
+  }
+  return descriptor;
+}
+function platformSetupGuideUrl(id, language) {
+  const file = PLATFORM_SETUP_GUIDE_FILES[id]?.[language];
+  return file ? `${SETUP_GUIDE_BASE_URL}/${file}` : void 0;
+}
+function formatPlatformStatus(status) {
+  switch (status) {
+    case "setup_ready":
+      return "Setup wizard ready";
+    case "setup_pending":
+      return "Adapter exists; CLI setup pending";
+    case "experimental_setup_pending":
+      return "Experimental adapter; CLI setup pending";
+  }
+}
+function formatPlatforms() {
+  return [
+    "CLI setup support:",
+    ...PLATFORM_CATALOG.map((platform) => {
+      return `  ${platform.label}: ${formatPlatformStatus(platform.status)}`;
+    })
+  ].join("\n");
+}
+
+// src/commands/platforms.ts
+function runPlatformsCommand() {
+  console.log(formatPlatforms());
+}
+
+// src/doctor.ts
+import { doctorHasFailures, executorsFromConfig, formatDoctorChecks, runDoctor } from "@opentag/local-runtime";
+async function runDoctorCommand(options) {
+  const config = readCliConfig(options.config ?? defaultConfigPath());
+  const checks = await runDoctor({
+    config: config.daemon,
+    executors: executorsFromConfig(config.daemon)
+  });
+  console.log(formatDoctorChecks(checks));
+  if (doctorHasFailures(checks)) {
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/setup.ts
+import { existsSync as existsSync5 } from "fs";
+
+// src/setup/builders.ts
+import { randomBytes } from "crypto";
+import { realpathSync } from "fs";
+import { join as join3 } from "path";
+import { projectTargetRefFromLocalPath } from "@opentag/core";
+function pairingToken() {
+  return randomBytes(32).toString("hex");
+}
+function createSetupConfig(input, env = process.env) {
+  const checkoutPath = realpathSync.native(input.projectPath);
+  const target = projectTargetRefFromLocalPath(checkoutPath);
+  const stateDirectory = input.stateDirectory ?? defaultStateDirectory(env);
+  const worktreeRoot = join3(stateDirectory, "worktrees");
+  const databasePath = join3(stateDirectory, "opentag.db");
+  const repositoryBindings = [
+    {
+      provider: target.provider,
+      owner: target.owner,
+      repo: target.repo,
+      checkoutPath,
+      defaultExecutor: input.executor,
+      baseBranch: "main",
+      pushRemote: "origin",
+      worktreeRoot,
+      keepWorktree: "on_failure"
+    },
+    ...input.github ? [
+      {
+        provider: "github",
+        owner: input.github.owner,
+        repo: input.github.repo,
+        checkoutPath,
+        defaultExecutor: input.executor,
+        baseBranch: "main",
+        pushRemote: "origin",
+        worktreeRoot,
+        keepWorktree: "on_failure"
+      }
+    ] : []
+  ].filter((binding, index, bindings) => {
+    return bindings.findIndex((candidate) => candidate.provider === binding.provider && candidate.owner === binding.owner && candidate.repo === binding.repo) === index;
+  });
+  const channelBindings = [
+    ...input.slack && input.slack.bindingMethod === "default_project" ? [
+      {
+        provider: "slack",
+        accountId: input.slack.teamId,
+        conversationId: input.slack.channelId,
+        repoProvider: target.provider,
+        owner: target.owner,
+        repo: target.repo
+      }
+    ] : []
+  ];
+  return {
+    schemaVersion: 1,
+    preferences: {
+      language: input.language,
+      lastSetup: {
+        platforms: [input.platform],
+        executor: input.executor,
+        projectPath: checkoutPath,
+        ...input.lark ? {
+          larkSetupMethod: input.lark.setupMethod,
+          larkDomain: input.lark.domain,
+          bindingMethod: input.lark.bindingMethod
+        } : {},
+        ...input.slack ? {
+          bindingMethod: input.slack.bindingMethod,
+          slackMode: input.slack.mode,
+          slackTeamId: input.slack.teamId,
+          slackChannelId: input.slack.channelId,
+          ...input.slack.port ? { slackPort: input.slack.port } : {}
+        } : {},
+        ...input.github ? {
+          githubOwner: input.github.owner,
+          githubRepo: input.github.repo,
+          githubPort: input.github.port,
+          githubAutoCreatePullRequest: input.github.autoCreatePullRequest
+        } : {}
+      }
+    },
+    state: {
+      directory: stateDirectory,
+      databasePath,
+      worktreeRoot
+    },
+    daemon: {
+      runnerId: "runner_local",
+      dispatcherUrl: "http://localhost:3030",
+      pairingToken: pairingToken(),
+      repositories: repositoryBindings,
+      ...channelBindings.length > 0 ? { channelBindings } : {},
+      ...input.github ? { githubToken: input.github.token } : {},
+      ...input.github ? { preparePullRequestBranch: true } : {},
+      ...input.github ? { allowAutoCreatePullRequest: input.github.autoCreatePullRequest } : {},
+      pollIntervalMs: 5e3,
+      heartbeatIntervalMs: 15e3
+    },
+    platforms: {
+      ...input.lark ? {
+        lark: {
+          appId: input.lark.appId,
+          appSecret: input.lark.appSecret,
+          domain: input.lark.domain,
+          defaultProjectBinding: input.lark.bindingMethod === "default_project",
+          ...input.lark.botOpenId ? { botOpenId: input.lark.botOpenId } : {}
+        }
+      } : {},
+      ...input.slack ? {
+        slack: {
+          mode: input.slack.mode,
+          ...input.slack.appToken ? { appToken: input.slack.appToken } : {},
+          ...input.slack.signingSecret ? { signingSecret: input.slack.signingSecret } : {},
+          botToken: input.slack.botToken,
+          teamId: input.slack.teamId,
+          channelId: input.slack.channelId,
+          defaultProjectBinding: input.slack.bindingMethod === "default_project",
+          ...input.slack.appId ? { appId: input.slack.appId } : {},
+          ...input.slack.port ? { port: input.slack.port } : {}
+        }
+      } : {},
+      ...input.github ? {
+        github: {
+          webhookSecret: input.github.webhookSecret,
+          owner: input.github.owner,
+          repo: input.github.repo,
+          webhookPath: input.github.webhookPath,
+          port: input.github.port
+        }
+      } : {}
+    }
+  };
+}
+
+// src/setup/flow.ts
+import { execFileSync } from "child_process";
+import { randomBytes as randomBytes2 } from "crypto";
+import { existsSync as existsSync4 } from "fs";
+
+// src/catalogs/languages.ts
+var LANGUAGE_OPTIONS = [
+  { id: "en", label: "English", hint: "Default" },
+  { id: "zh-CN", label: "\u7B80\u4F53\u4E2D\u6587", hint: "Chinese" }
+];
+function parseCliLanguage(value) {
+  if (value === "en" || value === "zh-CN") {
+    return value;
+  }
+  throw new Error("Language must be en or zh-CN.");
+}
+
+// src/platforms/lark/display.ts
+function shortId(value) {
+  if (value.length <= 16) return value;
+  return `${value.slice(0, 6)}...${value.slice(-6)}`;
+}
+function domainLabel(domain) {
+  return domain === "feishu" ? "Feishu" : "Lark";
+}
+function sourceLabel(source, language) {
+  if (language === "zh-CN") {
+    return source === "opentag_config" ? "OpenTag \u914D\u7F6E" : "\u65E7 start-lark \u914D\u7F6E";
+  }
+  return source === "opentag_config" ? "OpenTag config" : "legacy start-lark config";
+}
+function formatLarkPersonalAgentSummary(input, language) {
+  const parts = [
+    domainLabel(input.domain),
+    `App ID ${shortId(input.appId)}`,
+    input.botOpenId ? `Bot Open ID ${shortId(input.botOpenId)}` : void 0,
+    input.source ? language === "zh-CN" ? `\u6765\u6E90: ${sourceLabel(input.source, language)}` : `from ${sourceLabel(input.source, language)}` : void 0
+  ];
+  return parts.filter((part) => Boolean(part)).join(" | ");
+}
+function formatSavedLarkCredentialsHint(credentials, language) {
+  return formatLarkPersonalAgentSummary(credentials, language);
+}
+
+// src/platforms/lark/saved-config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { z as z2 } from "zod";
+var SavedLarkCredentialsSchema = z2.object({
+  appId: z2.string().min(1),
+  appSecret: z2.string().min(1),
+  domain: z2.enum(["lark", "feishu"]),
+  botOpenId: z2.string().min(1).optional()
+}).passthrough();
+function savedLarkCredentialsFromCliConfig(config) {
+  const lark = config.platforms.lark;
+  if (!lark) return void 0;
+  return {
+    appId: lark.appId,
+    appSecret: lark.appSecret,
+    domain: lark.domain,
+    ...lark.botOpenId ? { botOpenId: lark.botOpenId } : {},
+    source: "opentag_config"
+  };
+}
+function legacyLarkConfigPath(projectPath) {
+  return join4(projectPath, ".opentag", "lark", "lark.local.json");
+}
+function parseJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    throw new Error(`Saved Lark config at ${path} is invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function readLegacyLarkCredentials(projectPath) {
+  const path = legacyLarkConfigPath(projectPath);
+  if (!existsSync2(path)) return void 0;
+  assertPrivateConfigFile(path);
+  const parsed = SavedLarkCredentialsSchema.safeParse(parseJsonFile(path));
+  if (!parsed.success) {
+    throw new Error(`Saved Lark config at ${path} is invalid: ${parsed.error.message}`);
+  }
+  return {
+    appId: parsed.data.appId,
+    appSecret: parsed.data.appSecret,
+    domain: parsed.data.domain,
+    ...parsed.data.botOpenId ? { botOpenId: parsed.data.botOpenId } : {},
+    source: "legacy_start_lark",
+    path
+  };
+}
+
+// src/platforms/ports.ts
+var DEFAULT_SLACK_EVENTS_PORT = 3040;
+var DEFAULT_GITHUB_WEBHOOK_PORT = 3050;
+function parseLocalPort(value, label) {
+  const port = typeof value === "number" ? value : Number(value.trim());
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`${label} must be an integer from 1 to 65535.`);
+  }
+  return port;
+}
+
+// src/ui/messages.ts
+var MESSAGES = {
+  en: {
+    intro: "OpenTag setup",
+    language: "Language / \u8BED\u8A00",
+    platform: "Where should OpenTag listen?",
+    executor: "Which coding agent should OpenTag use?",
+    projectPath: "Which project should OpenTag use?",
+    larkSetup: "How should OpenTag connect to Lark / Feishu?",
+    larkDomain: "Which Lark domain should OpenTag use?",
+    larkAppId: "Lark App ID",
+    larkAppSecret: "Lark App Secret",
+    larkBotOpenId: "Lark Bot Open ID (optional)",
+    slackMode: "How should OpenTag connect to Slack?",
+    slackAppToken: "Slack App-Level Token",
+    slackSigningSecret: "Slack Signing Secret",
+    slackBotToken: "Slack Bot User OAuth Token",
+    slackAppId: "Slack App ID (optional)",
+    slackTeamId: "Slack Team ID",
+    slackChannelId: "Slack Channel ID",
+    slackPort: "Local Slack Events API port",
+    githubRepository: "GitHub repository (owner/repo)",
+    githubToken: "GitHub token for comments and `apply 1` pull requests",
+    githubWebhookSecret: "GitHub webhook secret",
+    githubPort: "Local GitHub webhook port",
+    githubAutoCreatePr: "Create pull requests immediately after runs? (advanced)",
+    bindingMethod: "How should Lark chats bind to this project?",
+    confirmSetup: "Write this OpenTag config?",
+    cancelled: "OpenTag setup cancelled.",
+    complete: "OpenTag setup complete."
+  },
+  "zh-CN": {
+    intro: "OpenTag \u8BBE\u7F6E",
+    language: "Language / \u8BED\u8A00",
+    platform: "OpenTag \u8981\u76D1\u542C\u54EA\u4E2A\u5E73\u53F0\uFF1F",
+    executor: "OpenTag \u8981\u4F7F\u7528\u54EA\u4E2A coding agent\uFF1F",
+    projectPath: "OpenTag \u8981\u4F7F\u7528\u54EA\u4E2A\u9879\u76EE\uFF1F",
+    larkSetup: "OpenTag \u8981\u5982\u4F55\u8FDE\u63A5 Lark / \u98DE\u4E66\uFF1F",
+    larkDomain: "OpenTag \u8981\u4F7F\u7528\u54EA\u4E2A Lark \u57DF\u540D\uFF1F",
+    larkAppId: "Lark App ID",
+    larkAppSecret: "Lark App Secret",
+    larkBotOpenId: "Lark Bot Open ID\uFF08\u53EF\u9009\uFF09",
+    slackMode: "OpenTag \u8981\u5982\u4F55\u8FDE\u63A5 Slack\uFF1F",
+    slackAppToken: "Slack App-Level Token",
+    slackSigningSecret: "Slack Signing Secret",
+    slackBotToken: "Slack Bot User OAuth Token",
+    slackAppId: "Slack App ID\uFF08\u53EF\u9009\uFF09",
+    slackTeamId: "Slack Team ID",
+    slackChannelId: "Slack Channel ID",
+    slackPort: "\u672C\u5730 Slack Events API \u7AEF\u53E3",
+    githubRepository: "GitHub \u4ED3\u5E93\uFF08owner/repo\uFF09",
+    githubToken: "GitHub token\uFF08\u7528\u4E8E\u56DE\u5199\u8BC4\u8BBA\u548C apply 1 \u521B\u5EFA PR\uFF09",
+    githubWebhookSecret: "GitHub webhook secret",
+    githubPort: "\u672C\u5730 GitHub webhook \u7AEF\u53E3",
+    githubAutoCreatePr: "run \u7ED3\u675F\u540E\u7ACB\u523B\u81EA\u52A8\u521B\u5EFA pull request \u5417\uFF1F\uFF08\u9AD8\u7EA7\u9009\u9879\uFF09",
+    bindingMethod: "Lark \u7FA4\u804A\u8981\u5982\u4F55\u7ED1\u5B9A\u5230\u8FD9\u4E2A\u9879\u76EE\uFF1F",
+    confirmSetup: "\u5199\u5165\u8FD9\u4EFD OpenTag \u914D\u7F6E\uFF1F",
+    cancelled: "OpenTag \u8BBE\u7F6E\u5DF2\u53D6\u6D88\u3002",
+    complete: "OpenTag \u8BBE\u7F6E\u5B8C\u6210\u3002"
+  }
+};
+function t(language, key) {
+  return MESSAGES[language][key];
+}
+function larkSetupLabel(language, method) {
+  if (language === "zh-CN") {
+    if (method === "saved") return "\u4F7F\u7528\u5DF2\u4FDD\u5B58\u7684 Personal Agent";
+    return method === "scan" ? "\u521B\u5EFA\u65B0\u7684 Personal Agent" : "\u624B\u52A8\u586B\u5199 App ID / Secret";
+  }
+  if (method === "saved") return "Use saved Personal Agent";
+  return method === "scan" ? "Create a new Personal Agent" : "Manual credentials";
+}
+function larkSetupHint(language, method) {
+  if (language === "zh-CN") {
+    if (method === "saved") return "\u63A8\u8350\uFF0C\u4E0D\u9700\u8981\u91CD\u65B0\u626B\u7801";
+    return method === "scan" ? "\u6CA1\u6709\u5DF2\u4FDD\u5B58\u914D\u7F6E\u65F6\u4F7F\u7528" : "\u5DF2\u6709\u81EA\u5EFA\u5E94\u7528\u65F6\u4F7F\u7528";
+  }
+  if (method === "saved") return "Recommended; no new scan";
+  return method === "scan" ? "Use when no saved app exists" : "Use an existing app";
+}
+function slackModeLabel(language, mode) {
+  if (language === "zh-CN") {
+    return mode === "socket_mode" ? "\u672C\u5730 Socket Mode\uFF08\u63A8\u8350\uFF09" : "\u516C\u7F51 Events API";
+  }
+  return mode === "socket_mode" ? "Local Socket Mode (Recommended)" : "Public Events API";
+}
+function slackModeHint(language, mode) {
+  if (language === "zh-CN") {
+    return mode === "socket_mode" ? "\u9002\u5408\u672C\u673A\u8FD0\u884C\uFF0C\u4E0D\u9700\u8981\u516C\u7F51 URL" : "\u9002\u5408\u4E91\u7AEF\u90E8\u7F72\u6216 tunnel \u6D4B\u8BD5";
+  }
+  return mode === "socket_mode" ? "Best for this computer; no public URL" : "Best for hosted OpenTag or tunnel testing";
+}
+function bindingMethodLabel(language, method, platform = "lark") {
+  if (language === "zh-CN") {
+    if (method === "default_project") return "\u9ED8\u8BA4\u4F7F\u7528\u8FD9\u4E2A\u9879\u76EE";
+    return platform === "slack" ? "\u7A0D\u540E\u5728 OpenTag \u914D\u7F6E\u91CC\u7ED1\u5B9A" : "\u7A0D\u540E\u5728 Lark \u91CC\u7528 /bind \u7ED1\u5B9A";
+  }
+  if (method === "default_project") return "Use this project by default";
+  return platform === "slack" ? "Bind later from OpenTag config" : "Bind later from Lark with /bind";
+}
+function bindingMethodHint(language, method, platform = "lark") {
+  if (language === "zh-CN") {
+    if (method === "default_project") return "\u63A8\u8350\uFF0C\u6700\u5FEB\u8DD1\u901A";
+    return platform === "slack" ? "\u9002\u5408\u5148\u53EA\u4FDD\u5B58 Slack \u8FDE\u63A5" : "\u9002\u5408\u591A\u4E2A\u9879\u76EE";
+  }
+  if (method === "default_project") return "Recommended";
+  return platform === "slack" ? "Use when you only want to save the Slack connection first" : "Best for multiple projects";
+}
+
+// src/setup/defaults.ts
+import { existsSync as existsSync3 } from "fs";
+function defaultBindingMethod(config) {
+  const lastSetup = config.preferences?.lastSetup;
+  if (lastSetup?.bindingMethod) return lastSetup.bindingMethod;
+  if (config.platforms.lark?.defaultProjectBinding === false) return "bind_later";
+  if (config.platforms.lark) return "default_project";
+  if (config.platforms.slack?.defaultProjectBinding === false) return "bind_later";
+  if (config.platforms.slack) return "default_project";
+  return void 0;
+}
+function setupDefaultsFromConfig(config) {
+  const repository = config.daemon.repositories[0];
+  const lark = config.platforms.lark;
+  const slack = config.platforms.slack;
+  const github = config.platforms.github;
+  const lastSetup = config.preferences?.lastSetup;
+  const savedLarkCredentials = savedLarkCredentialsFromCliConfig(config);
+  const bindingMethod = defaultBindingMethod(config);
+  return {
+    ...config.preferences?.language ? { language: config.preferences.language } : {},
+    ...lastSetup?.platforms?.[0] ? { platform: lastSetup.platforms[0] } : lark ? { platform: "lark" } : slack ? { platform: "slack" } : github ? { platform: "github" } : {},
+    ...repository?.checkoutPath ? { projectPath: repository.checkoutPath } : {},
+    ...repository?.defaultExecutor ? { executor: repository.defaultExecutor } : {},
+    ...lastSetup?.larkSetupMethod ? { larkSetupMethod: lastSetup.larkSetupMethod } : {},
+    ...lastSetup?.larkDomain ? { larkDomain: lastSetup.larkDomain } : lark?.domain ? { larkDomain: lark.domain } : {},
+    ...bindingMethod ? { bindingMethod } : {},
+    ...lastSetup?.slackMode ? { slackMode: lastSetup.slackMode } : slack ? { slackMode: slack.mode ?? "events_api" } : {},
+    ...lastSetup?.slackTeamId ? { slackTeamId: lastSetup.slackTeamId } : slack?.teamId ? { slackTeamId: slack.teamId } : {},
+    ...lastSetup?.slackChannelId ? { slackChannelId: lastSetup.slackChannelId } : slack?.channelId ? { slackChannelId: slack.channelId } : {},
+    ...lastSetup?.slackPort ? { slackPort: lastSetup.slackPort } : slack?.port ? { slackPort: slack.port } : {},
+    ...lastSetup?.githubOwner ? { githubOwner: lastSetup.githubOwner } : github?.owner ? { githubOwner: github.owner } : {},
+    ...lastSetup?.githubRepo ? { githubRepo: lastSetup.githubRepo } : github?.repo ? { githubRepo: github.repo } : {},
+    ...lastSetup?.githubPort ? { githubPort: lastSetup.githubPort } : github?.port ? { githubPort: github.port } : {},
+    ...github?.webhookSecret ? { githubWebhookSecret: github.webhookSecret } : {},
+    ...github?.webhookPath ? { githubWebhookPath: github.webhookPath } : {},
+    ...lastSetup?.githubAutoCreatePullRequest !== void 0 ? { githubAutoCreatePullRequest: lastSetup.githubAutoCreatePullRequest } : config.daemon.allowAutoCreatePullRequest !== void 0 ? { githubAutoCreatePullRequest: config.daemon.allowAutoCreatePullRequest } : {},
+    ...savedLarkCredentials ? { savedLarkCredentials } : {}
+  };
+}
+function loadSetupDefaults(path = defaultConfigPath()) {
+  if (!existsSync3(path)) {
+    return {};
+  }
+  return setupDefaultsFromConfig(readCliConfig(path));
+}
+
+// src/setup/guides.ts
+var OFFICIAL_SETUP_LINKS = {
+  githubTokenPage: "https://github.com/settings/personal-access-tokens/new",
+  githubTokenDocs: "https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens",
+  githubWebhookDocs: "https://docs.github.com/en/webhooks/using-webhooks/creating-webhooks",
+  slackApps: "https://api.slack.com/apps",
+  slackSocketModeDocs: "https://docs.slack.dev/apis/events-api/using-socket-mode/",
+  slackQuickstartDocs: "https://docs.slack.dev/quickstart/",
+  slackSigningSecretDocs: "https://docs.slack.dev/authentication/verifying-requests-from-slack/",
+  larkConsole: "https://open.larksuite.com/app",
+  feishuConsole: "https://open.feishu.cn/app",
+  larkAppIdDocs: "https://open.larksuite.com/document/uAjLw4CM/ugTN1YjL4UTN24CO1UjN/trouble-shooting/how-to-obtain-app-id",
+  larkWebSocketDocs: "https://open.larksuite.com/document/ukTMukTMukTM/uYDNxYjL2QTM24iN0EjN/event-subscription-configure-/use-websocket",
+  feishuWebSocketDocs: "https://open.feishu.cn/document/server-docs/event-subscription-guide/event-subscription-configure-/use-websocket?lang=zh-CN"
+};
+function setupNeeds(platform, language) {
+  if (language === "zh-CN") {
+    switch (platform) {
+      case "lark":
+        return ["\u63A8\u8350\u76F4\u63A5\u626B\u7801\u521B\u5EFA Personal Agent", "\u624B\u52A8\u914D\u7F6E\u65F6\u9700\u8981 Lark App ID \u548C App Secret"];
+      case "slack":
+        return ["\u63A8\u8350\u672C\u5730\u4F7F\u7528 Socket Mode", "Socket Mode \u9700\u8981 Slack App-Level Token \u548C Bot User OAuth Token", "Events API \u9700\u8981 Slack Signing Secret \u548C\u516C\u7F51 Request URL", "Slack bot scopes \u9700\u8981 app_mentions:read\u3001chat:write\u3001channels:history", "\u8BA2\u9605 bot events: app_mention\u3001message.channels", "Slack Team ID", "Slack Channel ID", "\u6D4B\u8BD5\u524D\u9700\u8981\u628A Slack app \u9080\u8BF7\u8FDB\u76EE\u6807 channel"];
+      case "github":
+        return ["GitHub \u4ED3\u5E93 owner/repo", "GitHub token\uFF08\u7528\u4E8E\u56DE\u5199\u8BC4\u8BBA\uFF1B\u4F60\u56DE\u590D apply 1 \u540E\u4E5F\u7528\u4E8E\u521B\u5EFA PR\uFF09", "OpenTag \u4F1A\u81EA\u52A8\u751F\u6210 webhook secret", "\u672C\u5730 webhook \u7AEF\u53E3\uFF0C\u9ED8\u8BA4 3050", "\u9700\u8981\u4E00\u4E2A\u516C\u7F51 tunnel \u8F6C\u53D1 GitHub webhook"];
+      case "telegram":
+        return [];
+    }
+  }
+  switch (platform) {
+    case "lark":
+      return ["QR scan is the recommended path", "manual setup needs a Lark App ID and App Secret"];
+    case "slack":
+      return ["Socket Mode is recommended for local OpenTag", "Socket Mode needs a Slack App-Level Token and Bot User OAuth Token", "Events API needs a Slack Signing Secret and public Request URL", "Slack bot scopes need app_mentions:read, chat:write, channels:history", "Subscribe to bot events: app_mention, message.channels", "Slack Team ID", "Slack Channel ID", "Invite the Slack app to the target channel before testing"];
+    case "github":
+      return ["GitHub repository owner/repo", "GitHub token for comments and PR creation after you reply `apply 1`", "OpenTag generates the webhook secret", "Local webhook port, default 3050", "A public tunnel is required for GitHub webhook delivery"];
+    case "telegram":
+      return [];
+  }
+}
+function officialSetupLinks(platform, language) {
+  if (language === "zh-CN") {
+    switch (platform) {
+      case "lark":
+        return [
+          `Lark \u5F00\u53D1\u8005\u540E\u53F0: ${OFFICIAL_SETUP_LINKS.larkConsole}`,
+          `\u98DE\u4E66\u5F00\u53D1\u8005\u540E\u53F0: ${OFFICIAL_SETUP_LINKS.feishuConsole}`
+        ];
+      case "slack":
+        return [
+          `Slack App \u7BA1\u7406\u9875: ${OFFICIAL_SETUP_LINKS.slackApps}`,
+          `Socket Mode \u5B98\u65B9\u6587\u6863: ${OFFICIAL_SETUP_LINKS.slackSocketModeDocs}`
+        ];
+      case "github":
+        return [
+          `GitHub token \u521B\u5EFA\u9875: ${OFFICIAL_SETUP_LINKS.githubTokenPage}`,
+          `Repository webhook \u5B98\u65B9\u6587\u6863: ${OFFICIAL_SETUP_LINKS.githubWebhookDocs}`
+        ];
+      case "telegram":
+        return [];
+    }
+  }
+  switch (platform) {
+    case "lark":
+      return [
+        `Lark Developer Console: ${OFFICIAL_SETUP_LINKS.larkConsole}`,
+        `Feishu Developer Console: ${OFFICIAL_SETUP_LINKS.feishuConsole}`
+      ];
+    case "slack":
+      return [
+        `Slack app settings: ${OFFICIAL_SETUP_LINKS.slackApps}`,
+        `Socket Mode docs: ${OFFICIAL_SETUP_LINKS.slackSocketModeDocs}`
+      ];
+    case "github":
+      return [
+        `GitHub token page: ${OFFICIAL_SETUP_LINKS.githubTokenPage}`,
+        `Repository webhook docs: ${OFFICIAL_SETUP_LINKS.githubWebhookDocs}`
+      ];
+    case "telegram":
+      return [];
+  }
+}
+function formatPlatformSetupGuide(platform, language) {
+  const url = platformSetupGuideUrl(platform, language);
+  if (!url) return void 0;
+  const descriptor = platformById(platform);
+  const needs = setupNeeds(platform, language);
+  const officialLinks = officialSetupLinks(platform, language);
+  if (language === "zh-CN") {
+    return [
+      `${descriptor.label} \u914D\u7F6E\u6559\u7A0B:`,
+      url,
+      "",
+      "\u5B98\u65B9\u5165\u53E3:",
+      ...officialLinks.map((item) => `- ${item}`),
+      "",
+      "\u7EE7\u7EED\u586B\u5199\u524D\uFF0C\u5148\u6253\u5F00\u6559\u7A0B\u786E\u8BA4\u8FD9\u4E9B\u503C\u5728\u54EA\u91CC\u62FF\uFF1A",
+      ...needs.map((item) => `- ${item}`)
+    ].join("\n");
+  }
+  return [
+    `${descriptor.label} setup guide:`,
+    url,
+    "",
+    "Official setup pages:",
+    ...officialLinks.map((item) => `- ${item}`),
+    "",
+    "Open the guide before filling in these values:",
+    ...needs.map((item) => `- ${item}`)
+  ].join("\n");
+}
+function formatLarkManualCredentialHelp(language, domain) {
+  const consoleUrl = domain === "feishu" ? OFFICIAL_SETUP_LINKS.feishuConsole : OFFICIAL_SETUP_LINKS.larkConsole;
+  const websocketDocs = domain === "feishu" ? OFFICIAL_SETUP_LINKS.feishuWebSocketDocs : OFFICIAL_SETUP_LINKS.larkWebSocketDocs;
+  if (language === "zh-CN") {
+    return [
+      "\u624B\u52A8 Lark / \u98DE\u4E66\u51ED\u636E\u5728\u54EA\u91CC\u62FF:",
+      `- \u5F00\u53D1\u8005\u540E\u53F0: ${consoleUrl}`,
+      "- App ID / App Secret: \u6253\u5F00\u4F60\u7684\u5E94\u7528\uFF0C\u8FDB\u5165 Credentials & Basic Info / \u51ED\u8BC1\u4E0E\u57FA\u7840\u4FE1\u606F",
+      "- \u4E8B\u4EF6\u63A5\u6536\u65B9\u5F0F: \u4F7F\u7528\u957F\u8FDE\u63A5 / WebSocket",
+      `- \u957F\u8FDE\u63A5\u5B98\u65B9\u6587\u6863: ${websocketDocs}`,
+      "",
+      "\u5982\u679C\u4F60\u6CA1\u6709\u81EA\u5EFA\u5E94\u7528\uFF0C\u5EFA\u8BAE\u8FD4\u56DE\u9009\u62E9\u626B\u7801\u521B\u5EFA Personal Agent\u3002"
+    ].join("\n");
+  }
+  return [
+    "Where to find manual Lark / Feishu credentials:",
+    `- Developer console: ${consoleUrl}`,
+    "- App ID / App Secret: open your app, then go to Credentials & Basic Info",
+    "- Event delivery mode: use long connection / WebSocket",
+    `- WebSocket docs: ${websocketDocs}`,
+    "",
+    "If you do not already manage a self-built app, use QR scan instead."
+  ].join("\n");
+}
+function formatSlackCredentialHelp(language, mode) {
+  if (language === "zh-CN") {
+    const modeSpecific2 = mode === "socket_mode" ? [
+      `- Socket Mode \u5B98\u65B9\u6587\u6863: ${OFFICIAL_SETUP_LINKS.slackSocketModeDocs}`,
+      "- Slack App-Level Token: Basic Information -> App-Level Tokens -> Generate Token and Scopes\uFF0Cscope \u9009 connections:write",
+      "- Socket Mode \u4E0D\u9700\u8981 Request URL"
+    ] : [
+      `- Signing Secret \u5B98\u65B9\u6587\u6863: ${OFFICIAL_SETUP_LINKS.slackSigningSecretDocs}`,
+      "- Slack Signing Secret: Basic Information -> App Credentials",
+      "- Request URL: \u586B\u4F60\u7684\u516C\u7F51 tunnel\uFF0C\u4F8B\u5982 https://<your-tunnel>/slack/events"
+    ];
+    return [
+      "Slack \u8FD9\u4E9B\u503C\u5728\u54EA\u91CC\u62FF:",
+      `- Slack App \u7BA1\u7406\u9875: ${OFFICIAL_SETUP_LINKS.slackApps}`,
+      ...modeSpecific2,
+      "- Slack Bot User OAuth Token: OAuth & Permissions -> Bot User OAuth Token",
+      "- Bot Token Scopes: app_mentions:read, chat:write, channels:history",
+      "- Bot Events: app_mention, message.channels",
+      "- Team ID / Channel ID: \u7528\u6D4F\u89C8\u5668\u6253\u5F00 Slack channel\uFF0C\u4ECE\u5730\u5740\u91CC\u590D\u5236 T... \u548C C...",
+      "- \u6D4B\u8BD5\u524D\u5728\u76EE\u6807 channel \u91CC\u8FD0\u884C /invite @\u4F60\u7684 App \u540D\u79F0\uFF0C\u628A app \u9080\u8BF7\u8FDB channel"
+    ].join("\n");
+  }
+  const modeSpecific = mode === "socket_mode" ? [
+    `- Socket Mode docs: ${OFFICIAL_SETUP_LINKS.slackSocketModeDocs}`,
+    "- Slack App-Level Token: Basic Information -> App-Level Tokens -> Generate Token and Scopes, then add connections:write",
+    "- Socket Mode does not need a Request URL"
+  ] : [
+    `- Signing Secret docs: ${OFFICIAL_SETUP_LINKS.slackSigningSecretDocs}`,
+    "- Slack Signing Secret: Basic Information -> App Credentials",
+    "- Request URL: use your public tunnel, for example https://<your-tunnel>/slack/events"
+  ];
+  return [
+    "Where to find these Slack values:",
+    `- Slack app settings: ${OFFICIAL_SETUP_LINKS.slackApps}`,
+    ...modeSpecific,
+    "- Slack Bot User OAuth Token: OAuth & Permissions -> Bot User OAuth Token",
+    "- Bot Token Scopes: app_mentions:read, chat:write, channels:history",
+    "- Bot Events: app_mention, message.channels",
+    "- Team ID / Channel ID: open the Slack channel in a browser and copy the T... and C... values from the URL",
+    "- Before testing, run /invite @your app name in the target channel so Slack sends mentions to the app"
+  ].join("\n");
+}
+function formatGitHubTokenHelp(language, input) {
+  if (language === "zh-CN") {
+    const permissions2 = input.autoCreatePullRequest ? ["- Issues: Read and write", "- Pull requests: Read and write", "- Contents: Read and write"] : ["- Issues: Read and write", "- Pull requests: Read and write", "- Contents: \u9ED8\u8BA4 apply 1 \u6D41\u7A0B\u4E0D\u9700\u8981\uFF1Brun branch \u4F1A\u4F7F\u7528\u672C\u673A git remote \u51ED\u636E\u63A8\u9001"];
+    return [
+      "GitHub token \u5728\u54EA\u91CC\u521B\u5EFA:",
+      `- \u76F4\u63A5\u6253\u5F00: ${OFFICIAL_SETUP_LINKS.githubTokenPage}`,
+      `- \u5B98\u65B9\u6559\u7A0B: ${OFFICIAL_SETUP_LINKS.githubTokenDocs}`,
+      "",
+      "\u63A8\u8350\u521B\u5EFA fine-grained personal access token\uFF0C\u53EA\u6388\u6743\u5F53\u524D\u4ED3\u5E93\u3002\u9700\u8981\u6743\u9650:",
+      ...permissions2,
+      "",
+      "GitHub \u53EA\u4F1A\u5C55\u793A token \u4E00\u6B21\uFF0C\u521B\u5EFA\u540E\u9A6C\u4E0A\u590D\u5236\u5E76\u7C98\u8D34\u5230\u4E0B\u4E00\u6B65\u3002"
+    ].join("\n");
+  }
+  const permissions = input.autoCreatePullRequest ? ["- Issues: Read and write", "- Pull requests: Read and write", "- Contents: Read and write"] : ["- Issues: Read and write", "- Pull requests: Read and write", "- Contents: not needed for the default apply-1 flow; branch push uses your local git remote credentials"];
+  return [
+    "Where to create the GitHub token:",
+    `- Direct token page: ${OFFICIAL_SETUP_LINKS.githubTokenPage}`,
+    `- Official guide: ${OFFICIAL_SETUP_LINKS.githubTokenDocs}`,
+    "",
+    "Create a fine-grained personal access token and limit it to this repository. Required permissions:",
+    ...permissions,
+    "",
+    "GitHub only shows the token once. Copy it immediately, then paste it into the next prompt."
+  ].join("\n");
+}
+
+// src/platforms/github/display.ts
+function githubLocalWebhookUrl(input) {
+  return `http://127.0.0.1:${input.port ?? DEFAULT_GITHUB_WEBHOOK_PORT}${input.webhookPath ?? "/github/webhooks"}`;
+}
+function githubPublicWebhookUrlPlaceholder(webhookPath = "/github/webhooks") {
+  return `https://<your-tunnel-host>${webhookPath}`;
+}
+function githubWebhooksSettingsUrl(input) {
+  return `https://github.com/${input.owner}/${input.repo}/settings/hooks`;
+}
+
+// src/setup/summary.ts
+function yesNo(value, language) {
+  return language === "zh-CN" ? value ? "\u662F" : "\u5426" : value ? "yes" : "no";
+}
+function larkSetupDescription(method, language) {
+  if (language === "zh-CN") {
+    if (method === "saved") return "\u4F7F\u7528\u5DF2\u4FDD\u5B58\u7684 Personal Agent";
+    return method === "scan" ? "\u521B\u5EFA\u65B0\u7684 Personal Agent" : "\u624B\u52A8\u586B\u5199";
+  }
+  if (method === "saved") return "Saved Personal Agent";
+  return method === "scan" ? "Create new Personal Agent" : "Manual credentials";
+}
+function formatSetupReview(input, configPath) {
+  const platform = platformById(input.platform);
+  const commonLines = input.language === "zh-CN" ? [
+    "\u8BF7\u786E\u8BA4 OpenTag \u914D\u7F6E\uFF1A",
+    `\u914D\u7F6E\u6587\u4EF6: ${configPath}`,
+    `\u5E73\u53F0: ${platform.label}`,
+    `Coding agent: ${executorLabel(input.executor)}`,
+    `\u9879\u76EE\u8DEF\u5F84: ${input.projectPath}`
+  ] : [
+    "Review your OpenTag setup:",
+    `Config: ${configPath}`,
+    `Platform: ${platform.label}`,
+    `Coding agent: ${executorLabel(input.executor)}`,
+    `Project path: ${input.projectPath}`
+  ];
+  const platformLines = [];
+  if (input.lark) {
+    const larkPersonalAgent = formatLarkPersonalAgentSummary(
+      {
+        ...input.lark,
+        ...input.lark.savedCredentialsSource ? { source: input.lark.savedCredentialsSource } : {}
+      },
+      input.language
+    );
+    platformLines.push(
+      ...input.language === "zh-CN" ? [
+        `Lark \u8FDE\u63A5\u65B9\u5F0F: ${larkSetupDescription(input.lark.setupMethod, input.language)}`,
+        `Personal Agent: ${larkPersonalAgent}`,
+        `Lark \u57DF\u540D: ${input.lark.domain}`,
+        `\u9ED8\u8BA4\u7ED1\u5B9A\u5F53\u524D\u9879\u76EE: ${yesNo(input.lark.bindingMethod === "default_project", input.language)}`
+      ] : [
+        `Lark setup: ${larkSetupDescription(input.lark.setupMethod, input.language)}`,
+        `Personal Agent: ${larkPersonalAgent}`,
+        `Lark domain: ${input.lark.domain}`,
+        `Default project binding: ${yesNo(input.lark.bindingMethod === "default_project", input.language)}`
+      ]
+    );
+  }
+  if (input.slack) {
+    const slackConnectionLines = input.slack.mode === "socket_mode" ? input.language === "zh-CN" ? ["Slack \u8FDE\u63A5\u65B9\u5F0F: \u672C\u5730 Socket Mode", "Slack \u5165\u7AD9: \u901A\u8FC7 Slack WebSocket\uFF0C\u4E0D\u9700\u8981\u516C\u7F51 URL"] : ["Slack connection: Local Socket Mode", "Slack ingress: Slack WebSocket; no public URL required"] : input.language === "zh-CN" ? ["Slack \u8FDE\u63A5\u65B9\u5F0F: \u516C\u7F51 Events API", `Slack Events URL: http://localhost:${input.slack.port ?? DEFAULT_SLACK_EVENTS_PORT}/slack/events`] : ["Slack connection: Public Events API", `Slack Events URL: http://localhost:${input.slack.port ?? DEFAULT_SLACK_EVENTS_PORT}/slack/events`];
+    platformLines.push(
+      ...input.language === "zh-CN" ? [
+        ...slackConnectionLines,
+        `Slack Team ID: ${input.slack.teamId}`,
+        `Slack Channel ID: ${input.slack.channelId}`,
+        `\u9ED8\u8BA4\u7ED1\u5B9A\u5F53\u524D\u9879\u76EE: ${yesNo(input.slack.bindingMethod === "default_project", input.language)}`
+      ] : [
+        ...slackConnectionLines,
+        `Slack Team ID: ${input.slack.teamId}`,
+        `Slack Channel ID: ${input.slack.channelId}`,
+        `Default project binding: ${yesNo(input.slack.bindingMethod === "default_project", input.language)}`
+      ]
+    );
+  }
+  if (input.github) {
+    const webhookPath = input.github.webhookPath;
+    platformLines.push(
+      ...input.language === "zh-CN" ? [
+        `GitHub \u4ED3\u5E93: ${input.github.owner}/${input.github.repo}`,
+        `GitHub \u672C\u5730 webhook: ${githubLocalWebhookUrl({ port: input.github.port, webhookPath })}`,
+        `GitHub Payload URL: ${githubPublicWebhookUrlPlaceholder(webhookPath)}`,
+        "Webhook secret: OpenTag \u4F1A\u81EA\u52A8\u751F\u6210",
+        "\u9ED8\u8BA4 PR \u6D41\u7A0B: \u56DE\u590D apply 1 \u540E\u521B\u5EFA",
+        `run \u540E\u7ACB\u523B\u81EA\u52A8\u521B\u5EFA PR: ${yesNo(input.github.autoCreatePullRequest, input.language)}`
+      ] : [
+        `GitHub repository: ${input.github.owner}/${input.github.repo}`,
+        `GitHub local webhook: ${githubLocalWebhookUrl({ port: input.github.port, webhookPath })}`,
+        `GitHub Payload URL: ${githubPublicWebhookUrlPlaceholder(webhookPath)}`,
+        "Webhook secret: generated by OpenTag",
+        "Default PR flow: create after replying `apply 1`",
+        `Immediate PR after run: ${yesNo(input.github.autoCreatePullRequest, input.language)}`
+      ]
+    );
+  }
+  const lines = [...commonLines, ...platformLines];
+  return lines.join("\n");
+}
+function formatSetupComplete(config, configPath) {
+  const repository = config.daemon.repositories[0];
+  const language = config.preferences?.language ?? "en";
+  const github = config.platforms.github;
+  const slack = config.platforms.slack;
+  const githubPort = github?.port ?? DEFAULT_GITHUB_WEBHOOK_PORT;
+  if (language === "zh-CN") {
+    return [
+      "OpenTag \u914D\u7F6E\u5DF2\u4FDD\u5B58\u3002",
+      `\u914D\u7F6E\u6587\u4EF6: ${configPath}`,
+      repository ? `\u9879\u76EE\u8DEF\u5F84: ${repository.checkoutPath}` : void 0,
+      slack ? "" : void 0,
+      slack ? "Slack \u4E0B\u4E00\u6B65\uFF1A" : void 0,
+      slack ? `\u7ED1\u5B9A channel: ${slack.teamId}/${slack.channelId}` : void 0,
+      slack ? "\u6D4B\u8BD5\u524D\u5148\u5728 Slack channel \u91CC\u8FD0\u884C /invite @\u4F60\u7684 App \u540D\u79F0\u3002" : void 0,
+      slack?.mode === "socket_mode" ? "Socket Mode \u4E0D\u9700\u8981\u516C\u7F51 URL\uFF1B\u76F4\u63A5\u4FDD\u6301 opentag start \u8FD0\u884C\u5373\u53EF\u3002" : void 0,
+      slack?.mode !== "socket_mode" && slack ? `Events API \u672C\u5730\u76D1\u542C: http://localhost:${slack.port ?? DEFAULT_SLACK_EVENTS_PORT}/slack/events` : void 0,
+      github ? "" : void 0,
+      github ? "GitHub webhook \u4E0B\u4E00\u6B65\uFF1A" : void 0,
+      github ? `GitHub \u8BBE\u7F6E\u9875: ${githubWebhooksSettingsUrl(github)}` : void 0,
+      github ? `Payload URL: ${githubPublicWebhookUrlPlaceholder(github.webhookPath ?? "/github/webhooks")}` : void 0,
+      github ? `Secret: ${github.webhookSecret}` : void 0,
+      github ? "Content type: application/json" : void 0,
+      github ? "Events: Issue comments, Pull request review comments" : void 0,
+      github ? `\u672C\u5730\u76D1\u542C: ${githubLocalWebhookUrl({ port: github.port, webhookPath: github.webhookPath })}` : void 0,
+      github ? `\u516C\u7F51 URL \u9700\u8981\u7531 tunnel \u6307\u5411\u672C\u5730\u76D1\u542C\u5730\u5740\uFF0C\u4F8B\u5982 ngrok http ${githubPort}\u3002` : void 0,
+      github ? "\u5F53 OpenTag \u7ED9\u51FA create_pull_request \u5EFA\u8BAE\u52A8\u4F5C\u540E\uFF0C\u5728 thread \u91CC\u56DE\u590D apply 1 \u521B\u5EFA PR\u3002" : void 0
+    ].filter((line) => Boolean(line)).join("\n");
+  }
+  return [
+    "OpenTag config saved.",
+    `Config: ${configPath}`,
+    repository ? `Project path: ${repository.checkoutPath}` : void 0,
+    slack ? "" : void 0,
+    slack ? "Slack next steps:" : void 0,
+    slack ? `Bound channel: ${slack.teamId}/${slack.channelId}` : void 0,
+    slack ? "Before testing, run /invite @your app name in that Slack channel." : void 0,
+    slack?.mode === "socket_mode" ? "Socket Mode does not need a public URL; keep opentag start running." : void 0,
+    slack?.mode !== "socket_mode" && slack ? `Events API local listener: http://localhost:${slack.port ?? DEFAULT_SLACK_EVENTS_PORT}/slack/events` : void 0,
+    github ? "" : void 0,
+    github ? "GitHub webhook next steps:" : void 0,
+    github ? `GitHub settings: ${githubWebhooksSettingsUrl(github)}` : void 0,
+    github ? `Payload URL: ${githubPublicWebhookUrlPlaceholder(github.webhookPath ?? "/github/webhooks")}` : void 0,
+    github ? `Secret: ${github.webhookSecret}` : void 0,
+    github ? "Content type: application/json" : void 0,
+    github ? "Events: Issue comments, Pull request review comments" : void 0,
+    github ? `Local listener: ${githubLocalWebhookUrl({ port: github.port, webhookPath: github.webhookPath })}` : void 0,
+    github ? `Point a public tunnel at the local listener, for example: ngrok http ${githubPort}.` : void 0,
+    github ? "When OpenTag shows a create_pull_request action, reply `apply 1` in the thread to create the PR." : void 0
+  ].filter((line) => Boolean(line)).join("\n");
+}
+
+// src/setup/flow.ts
+function parseLarkSetupMethod(value) {
+  if (value === "saved" || value === "scan" || value === "manual") return value;
+  throw new Error("Lark setup method must be saved, scan, or manual.");
+}
+function parseLarkDomain(value) {
+  if (value === "lark" || value === "feishu") return value;
+  throw new Error("Lark domain must be lark or feishu.");
+}
+function parseSlackSetupMode(value) {
+  const normalized = value.trim().toLowerCase().replace(/-/g, "_");
+  if (normalized === "socket_mode" || normalized === "events_api") return normalized;
+  throw new Error("Slack mode must be socket_mode or events_api.");
+}
+function parseBindingMethod(value) {
+  if (value === "default_project" || value === "bind_later") return value;
+  throw new Error("Binding method must be default_project or bind_later.");
+}
+function parseGitHubRepository(value) {
+  const trimmed = value.trim().replace(/^github:/, "");
+  const match = trimmed.match(/^([^/\s]+)\/([^/\s]+)$/);
+  if (!match) {
+    throw new Error("GitHub repository must use owner/repo.");
+  }
+  return {
+    owner: match[1],
+    repo: match[2].replace(/\.git$/, "")
+  };
+}
+function parsePortInput(value, label) {
+  return value === void 0 ? void 0 : parseLocalPort(value, label);
+}
+function githubRepositoryFromRemote(projectPath) {
+  let remote;
+  try {
+    remote = execFileSync("git", ["-C", projectPath, "remote", "get-url", "origin"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return void 0;
+  }
+  const patterns = [
+    /^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?$/,
+    /^https:\/\/github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?$/,
+    /^ssh:\/\/git@github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?$/
+  ];
+  for (const pattern of patterns) {
+    const match = remote.match(pattern);
+    if (match) {
+      return `${match[1]}/${match[2]}`;
+    }
+  }
+  return void 0;
+}
+function nonEmpty(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`${label} is required.`);
+  }
+  return trimmed;
+}
+function assertExistingPath(path) {
+  if (!existsSync4(path)) {
+    throw new Error(`Path does not exist: ${path}`);
+  }
+  return path;
+}
+function optionalTrimmed(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function generateGitHubWebhookSecret() {
+  return randomBytes2(32).toString("hex");
+}
+function parseGitHubWebhookPath(value) {
+  const trimmed = nonEmpty(value, "GitHub webhook path");
+  if (!trimmed.startsWith("/")) {
+    throw new Error("GitHub webhook path must start with /.");
+  }
+  return trimmed;
+}
+function hasManualLarkCredentials(options) {
+  return Boolean(options.larkAppId || options.larkAppSecret || options.larkBotOpenId);
+}
+function hasCompleteManualLarkCredentials(options) {
+  return Boolean(options.larkAppId && options.larkAppSecret);
+}
+function assertCompleteManualLarkCredentials(options) {
+  if (options.larkAppId && !options.larkAppSecret) {
+    throw new Error("--lark-app-secret is required when --lark-app-id is provided.");
+  }
+  if (options.larkAppSecret && !options.larkAppId) {
+    throw new Error("--lark-app-id is required when --lark-app-secret is provided.");
+  }
+}
+function assertNoManualLarkCredentialFlags(options) {
+  if (hasManualLarkCredentials(options)) {
+    throw new Error("--lark-app-id, --lark-app-secret, and --lark-bot-open-id can only be used with --lark-setup manual.");
+  }
+}
+function findSavedLarkCredentials(defaults, projectPath) {
+  return defaults.savedLarkCredentials ?? readLegacyLarkCredentials(projectPath);
+}
+function shouldReadSavedLarkCredentials(options) {
+  return !options.larkSetup || parseLarkSetupMethod(options.larkSetup) === "saved";
+}
+function loadDefaultsForSetup(options, configPath) {
+  try {
+    return loadSetupDefaults(configPath);
+  } catch (error) {
+    if (options.force) {
+      return {};
+    }
+    throw error;
+  }
+}
+function defaultLanguage(options, defaults) {
+  return options.language ? parseCliLanguage(options.language) : defaults.language ?? "en";
+}
+function formatPlatformStatusForSetup(language, status) {
+  if (language === "zh-CN") {
+    switch (status) {
+      case "setup_ready":
+        return "\u8FD9\u4E2A setup \u5411\u5BFC\u73B0\u5728\u53EF\u914D\u7F6E";
+      case "setup_pending":
+        return "\u9002\u914D\u5668\u5DF2\u6709\uFF0Csetup \u5411\u5BFC\u5F85\u63A5\u5165";
+      case "experimental_setup_pending":
+        return "\u5B9E\u9A8C\u9002\u914D\u5668\uFF0Csetup \u5411\u5BFC\u5F85\u63A5\u5165";
+    }
+  }
+  return formatPlatformStatus(status);
+}
+function formatPlatformsForSetup(language) {
+  const lines = PLATFORM_CATALOG.map((platform) => `- ${platform.label}: ${formatPlatformStatusForSetup(language, platform.status)}`);
+  if (language === "zh-CN") {
+    return ["\u8FD9\u4E2A setup \u5411\u5BFC\u5F53\u524D\u53EF\u914D\u7F6E\u7684\u5E73\u53F0\uFF1A", ...lines].join("\n");
+  }
+  return ["This setup wizard can configure:", ...lines].join("\n");
+}
+function formatExecutorHint(input) {
+  if (input.executor.devOnly) {
+    const echoHint = input.language === "zh-CN" ? "\u5F00\u53D1\u6D4B\u8BD5\u7528\uFF0C\u4E0D\u4F1A\u8C03\u7528\u771F\u5B9E coding agent" : "dev/test only; no real coding agent";
+    return input.current ? `${input.language === "zh-CN" ? "\u5F53\u524D\u9009\u62E9\uFF0C" : "current, "}${echoHint}` : echoHint;
+  }
+  const availability = input.language === "zh-CN" ? input.available ? "\u5DF2\u68C0\u6D4B\u5230" : "\u672A\u68C0\u6D4B\u5230" : input.available ? "available" : "not found";
+  const current = input.current ? input.language === "zh-CN" ? "\u5F53\u524D\u9009\u62E9\uFF0C" : "current, " : "";
+  const recommended = input.selectedByDefault ? input.language === "zh-CN" ? "\u63A8\u8350\uFF0C" : "recommended, " : "";
+  return `${current || recommended}${availability}`;
+}
+async function collectLanguage(options, defaults, prompts) {
+  if (options.language) {
+    return parseCliLanguage(options.language);
+  }
+  return prompts.select({
+    message: t("en", "language"),
+    initialValue: defaultLanguage(options, defaults),
+    options: LANGUAGE_OPTIONS.map((language) => ({
+      value: language.id,
+      label: language.label,
+      hint: language.hint
+    }))
+  });
+}
+async function collectPlatform(options, defaults, prompts, language) {
+  prompts.note(formatPlatformsForSetup(language));
+  const selected = options.platform ? parsePlatformId(options.platform) : await prompts.select({
+    message: t(language, "platform"),
+    initialValue: defaults.platform ?? "lark",
+    options: PLATFORM_CATALOG.filter((platform) => platform.startable).map((platform) => ({
+      value: platform.id,
+      label: platform.label,
+      hint: formatPlatformStatusForSetup(language, platform.status)
+    }))
+  });
+  const descriptor = platformById(selected);
+  if (!descriptor.startable) {
+    throw new Error(`${descriptor.label} setup is not available in the OpenTag CLI yet.`);
+  }
+  const guide = formatPlatformSetupGuide(selected, language);
+  if (guide) {
+    prompts.note(guide);
+  }
+  return selected;
+}
+async function collectExecutor(options, defaults, prompts, language, env) {
+  if (options.executor) {
+    return parseExecutorId(options.executor);
+  }
+  const detections = detectExecutors(env);
+  const previous = defaults.executor;
+  const initialValue = defaultExecutorId({
+    ...previous ? { previous } : {},
+    detections
+  });
+  return prompts.select({
+    message: t(language, "executor"),
+    initialValue,
+    options: EXECUTOR_CATALOG.map((executor) => {
+      const detection = detections.find((entry) => entry.id === executor.id);
+      return {
+        value: executor.id,
+        label: executor.label,
+        hint: formatExecutorHint({
+          language,
+          executor,
+          available: detection?.available ?? false,
+          current: executor.id === previous,
+          selectedByDefault: executor.id === initialValue
+        })
+      };
+    })
+  });
+}
+async function collectProjectPath(options, defaults, prompts, language, cwd) {
+  if (options.project) {
+    return assertExistingPath(options.project);
+  }
+  const initialValue = defaults.projectPath ?? cwd;
+  return prompts.text({
+    message: t(language, "projectPath"),
+    initialValue,
+    placeholder: initialValue,
+    validate(value) {
+      const candidate = value.trim() || initialValue;
+      if (!existsSync4(candidate)) {
+        return `Path does not exist: ${candidate}`;
+      }
+      return void 0;
+    }
+  });
+}
+async function collectLarkSetupMethod(options, defaults, prompts, language, savedLarkCredentials) {
+  if (options.larkSetup) {
+    const setupMethod = parseLarkSetupMethod(options.larkSetup);
+    if (setupMethod === "saved" && !savedLarkCredentials) {
+      throw new Error("No saved Lark Personal Agent config was found. Use --lark-setup scan or --lark-setup manual.");
+    }
+    return setupMethod;
+  }
+  if (hasManualLarkCredentials(options)) {
+    return "manual";
+  }
+  const methods = savedLarkCredentials ? ["saved", "scan", "manual"] : ["scan", "manual"];
+  const previous = defaults.larkSetupMethod && methods.includes(defaults.larkSetupMethod) ? defaults.larkSetupMethod : void 0;
+  return prompts.select({
+    message: t(language, "larkSetup"),
+    initialValue: savedLarkCredentials ? "saved" : previous ?? "scan",
+    options: methods.map((method) => ({
+      value: method,
+      label: larkSetupLabel(language, method),
+      hint: method === "saved" && savedLarkCredentials ? formatSavedLarkCredentialsHint(savedLarkCredentials, language) : larkSetupHint(language, method)
+    }))
+  });
+}
+async function collectLarkDomain(options, defaults, prompts, language, setupMethod, savedLarkCredentials) {
+  if (setupMethod === "saved") {
+    if (!savedLarkCredentials) {
+      throw new Error("No saved Lark Personal Agent config was found.");
+    }
+    return savedLarkCredentials.domain;
+  }
+  if (options.larkDomain) {
+    return parseLarkDomain(options.larkDomain);
+  }
+  return prompts.select({
+    message: t(language, "larkDomain"),
+    initialValue: defaults.larkDomain ?? "lark",
+    options: [
+      { value: "lark", label: "Lark", hint: "larksuite.com" },
+      { value: "feishu", label: "Feishu", hint: "feishu.cn" }
+    ]
+  });
+}
+async function collectLarkCredentials(input) {
+  if (input.setupMethod === "saved") {
+    if (!input.savedLarkCredentials) {
+      throw new Error("No saved Lark Personal Agent config was found.");
+    }
+    return {
+      appId: input.savedLarkCredentials.appId,
+      appSecret: input.savedLarkCredentials.appSecret,
+      ...input.savedLarkCredentials.botOpenId ? { botOpenId: input.savedLarkCredentials.botOpenId } : {}
+    };
+  }
+  if (input.setupMethod === "scan") {
+    assertNoManualLarkCredentialFlags(input.options);
+    const registered = await input.scanLarkPersonalAgent({ domain: input.domain });
+    return {
+      appId: registered.appId,
+      appSecret: registered.appSecret,
+      ...registered.botOpenId ? { botOpenId: registered.botOpenId } : {}
+    };
+  }
+  assertCompleteManualLarkCredentials(input.options);
+  if (!hasCompleteManualLarkCredentials(input.options)) {
+    input.prompts.note(formatLarkManualCredentialHelp(input.language, input.domain));
+  }
+  const appId = nonEmpty(input.options.larkAppId ?? await input.prompts.text({ message: t(input.language, "larkAppId") }), "Lark App ID");
+  const appSecret = nonEmpty(
+    input.options.larkAppSecret ?? await input.prompts.password({
+      message: t(input.language, "larkAppSecret"),
+      validate(value) {
+        if (!value.trim()) return "Lark App Secret is required.";
+        return void 0;
+      }
+    }),
+    "Lark App Secret"
+  );
+  const botOpenIdInput = input.options.larkBotOpenId ?? (hasCompleteManualLarkCredentials(input.options) ? void 0 : await input.prompts.text({
+    message: t(input.language, "larkBotOpenId"),
+    placeholder: "ou_..."
+  }));
+  const botOpenId = optionalTrimmed(botOpenIdInput);
+  return {
+    appId,
+    appSecret,
+    ...botOpenId ? { botOpenId } : {}
+  };
+}
+async function collectSlackSetup(options, defaults, prompts, language) {
+  const derivedMode = options.slackMode ? parseSlackSetupMode(options.slackMode) : options.slackAppToken && !options.slackSigningSecret ? "socket_mode" : options.slackSigningSecret && !options.slackAppToken ? "events_api" : void 0;
+  const selectedMode = derivedMode ? derivedMode : await prompts.select({
+    message: t(language, "slackMode"),
+    initialValue: defaults.slackMode ?? "socket_mode",
+    options: ["socket_mode", "events_api"].map((candidate) => ({
+      value: candidate,
+      label: slackModeLabel(language, candidate),
+      hint: slackModeHint(language, candidate)
+    }))
+  });
+  if (selectedMode === "socket_mode" && options.slackPort) {
+    throw new Error("--slack-port can only be used with --slack-mode events_api.");
+  }
+  if (selectedMode === "socket_mode" && (!options.slackAppToken || !options.slackBotToken) || selectedMode === "events_api" && (!options.slackSigningSecret || !options.slackBotToken)) {
+    prompts.note(formatSlackCredentialHelp(language, selectedMode));
+  }
+  const appToken = selectedMode === "socket_mode" ? nonEmpty(
+    options.slackAppToken ?? await prompts.password({ message: t(language, "slackAppToken") }),
+    "Slack App-Level Token"
+  ) : void 0;
+  const signingSecret = selectedMode === "events_api" ? nonEmpty(
+    options.slackSigningSecret ?? await prompts.password({ message: t(language, "slackSigningSecret") }),
+    "Slack Signing Secret"
+  ) : void 0;
+  const botToken = nonEmpty(
+    options.slackBotToken ?? await prompts.password({ message: t(language, "slackBotToken") }),
+    "Slack Bot User OAuth Token"
+  );
+  const appId = optionalTrimmed(
+    options.slackAppId ?? await prompts.text({
+      message: t(language, "slackAppId"),
+      placeholder: "A..."
+    })
+  );
+  const teamId = nonEmpty(
+    options.slackTeamId ?? await prompts.text({
+      message: t(language, "slackTeamId"),
+      placeholder: "T...",
+      ...defaults.slackTeamId ? { initialValue: defaults.slackTeamId } : {}
+    }),
+    "Slack Team ID"
+  );
+  const channelId = nonEmpty(
+    options.slackChannelId ?? await prompts.text({
+      message: t(language, "slackChannelId"),
+      placeholder: "C...",
+      ...defaults.slackChannelId ? { initialValue: defaults.slackChannelId } : {}
+    }),
+    "Slack Channel ID"
+  );
+  const port = selectedMode === "events_api" ? parsePortInput(options.slackPort, "Slack Events API port") ?? (options.yes ? defaults.slackPort ?? DEFAULT_SLACK_EVENTS_PORT : parseLocalPort(
+    await prompts.text({
+      message: t(language, "slackPort"),
+      initialValue: String(defaults.slackPort ?? DEFAULT_SLACK_EVENTS_PORT),
+      placeholder: String(DEFAULT_SLACK_EVENTS_PORT)
+    }),
+    "Slack Events API port"
+  )) : void 0;
+  const bindingMethod = await collectBindingMethod(options, defaults, prompts, language, "slack");
+  return {
+    mode: selectedMode,
+    ...appToken ? { appToken } : {},
+    ...signingSecret ? { signingSecret } : {},
+    botToken,
+    teamId,
+    channelId,
+    bindingMethod,
+    ...appId ? { appId } : {},
+    ...port ? { port } : {}
+  };
+}
+async function collectGitHubSetup(options, defaults, prompts, language, projectPath) {
+  const repositoryDefault = options.githubRepository ?? (defaults.githubOwner && defaults.githubRepo ? `${defaults.githubOwner}/${defaults.githubRepo}` : void 0) ?? githubRepositoryFromRemote(projectPath);
+  const repositoryInput = nonEmpty(
+    options.githubRepository ?? await prompts.text({
+      message: t(language, "githubRepository"),
+      ...repositoryDefault ? { initialValue: repositoryDefault, placeholder: repositoryDefault } : { placeholder: "owner/repo" },
+      validate(value) {
+        try {
+          parseGitHubRepository(value);
+          return void 0;
+        } catch (error) {
+          return error instanceof Error ? error.message : String(error);
+        }
+      }
+    }),
+    "GitHub repository"
+  );
+  const repository = parseGitHubRepository(repositoryInput);
+  const autoCreatePullRequest = options.githubAutoCreatePr ?? (options.yes ? defaults.githubAutoCreatePullRequest ?? false : await prompts.confirm({
+    message: t(language, "githubAutoCreatePr"),
+    initialValue: defaults.githubAutoCreatePullRequest ?? false
+  }));
+  if (!options.githubToken) {
+    prompts.note(formatGitHubTokenHelp(language, { autoCreatePullRequest }));
+  }
+  const token = nonEmpty(options.githubToken ?? await prompts.password({ message: t(language, "githubToken") }), "GitHub token");
+  const webhookSecret = options.githubWebhookSecret ? nonEmpty(options.githubWebhookSecret, "GitHub webhook secret") : defaults.githubWebhookSecret ?? generateGitHubWebhookSecret();
+  const port = parsePortInput(options.githubPort, "GitHub webhook port") ?? (options.yes ? defaults.githubPort ?? DEFAULT_GITHUB_WEBHOOK_PORT : parseLocalPort(
+    await prompts.text({
+      message: t(language, "githubPort"),
+      initialValue: String(defaults.githubPort ?? DEFAULT_GITHUB_WEBHOOK_PORT),
+      placeholder: String(DEFAULT_GITHUB_WEBHOOK_PORT)
+    }),
+    "GitHub webhook port"
+  ));
+  return {
+    token,
+    webhookSecret,
+    owner: repository.owner,
+    repo: repository.repo,
+    webhookPath: parseGitHubWebhookPath(options.githubWebhookPath ?? defaults.githubWebhookPath ?? "/github/webhooks"),
+    autoCreatePullRequest,
+    port
+  };
+}
+async function collectBindingMethod(options, defaults, prompts, language, platform) {
+  if (options.binding) {
+    const binding = parseBindingMethod(options.binding);
+    if (platform === "slack" && binding === "bind_later") {
+      throw new Error("Slack setup requires a channel binding. Use --binding default_project.");
+    }
+    return binding;
+  }
+  if (platform === "slack") {
+    return "default_project";
+  }
+  const message = t(language, "bindingMethod");
+  return prompts.select({
+    message,
+    initialValue: defaults.bindingMethod ?? "default_project",
+    options: ["default_project", "bind_later"].map((method) => ({
+      value: method,
+      label: bindingMethodLabel(language, method, platform),
+      hint: bindingMethodHint(language, method, platform)
+    }))
+  });
+}
+async function collectSetupInput(options, configPath, dependencies) {
+  const defaults = dependencies.defaults ?? loadDefaultsForSetup(options, configPath);
+  const prompts = dependencies.prompts;
+  const cwd = dependencies.cwd ?? process.cwd();
+  prompts.intro(t(defaultLanguage(options, defaults), "intro"));
+  const language = await collectLanguage(options, defaults, prompts);
+  const platform = await collectPlatform(options, defaults, prompts, language);
+  const executor = await collectExecutor(options, defaults, prompts, language, dependencies.env);
+  const projectPath = await collectProjectPath(options, defaults, prompts, language, cwd);
+  const resolvedProjectPath = projectPath.trim() || cwd;
+  const savedLarkCredentials = platform === "lark" && shouldReadSavedLarkCredentials(options) ? findSavedLarkCredentials(defaults, resolvedProjectPath) : void 0;
+  const larkSetupMethod = platform === "lark" ? await collectLarkSetupMethod(options, defaults, prompts, language, savedLarkCredentials) : void 0;
+  const larkDomain = platform === "lark" && larkSetupMethod ? await collectLarkDomain(options, defaults, prompts, language, larkSetupMethod, savedLarkCredentials) : void 0;
+  const larkCredentials = platform === "lark" && larkSetupMethod && larkDomain ? await collectLarkCredentials({
+    options,
+    prompts,
+    language,
+    setupMethod: larkSetupMethod,
+    domain: larkDomain,
+    ...savedLarkCredentials ? { savedLarkCredentials } : {},
+    scanLarkPersonalAgent: dependencies.scanLarkPersonalAgent
+  }) : void 0;
+  const larkBindingMethod = platform === "lark" ? await collectBindingMethod(options, defaults, prompts, language, "lark") : void 0;
+  const slackSetup = platform === "slack" ? await collectSlackSetup(options, defaults, prompts, language) : void 0;
+  const githubSetup = platform === "github" ? await collectGitHubSetup(options, defaults, prompts, language, resolvedProjectPath) : void 0;
+  const setupInput = {
+    language,
+    platform,
+    projectPath: resolvedProjectPath,
+    executor,
+    ...larkCredentials && larkDomain && larkSetupMethod && larkBindingMethod ? {
+      lark: {
+        ...larkCredentials,
+        domain: larkDomain,
+        setupMethod: larkSetupMethod,
+        bindingMethod: larkBindingMethod,
+        ...larkSetupMethod === "saved" && savedLarkCredentials ? { savedCredentialsSource: savedLarkCredentials.source } : {}
+      }
+    } : {},
+    ...slackSetup ? { slack: slackSetup } : {},
+    ...githubSetup ? { github: githubSetup } : {}
+  };
+  prompts.note(formatSetupReview(setupInput, configPath));
+  if (!options.yes) {
+    const confirmed = await prompts.confirm({
+      message: t(language, "confirmSetup"),
+      initialValue: true
+    });
+    if (!confirmed) {
+      throw new Error(t(language, "cancelled"));
+    }
+  }
+  return setupInput;
+}
+
+// src/ui/clack.ts
+import * as p from "@clack/prompts";
+function cancelled() {
+  p.cancel("OpenTag setup cancelled.");
+  process.exit(0);
+}
+function unwrapPromptResult(value) {
+  if (p.isCancel(value)) {
+    cancelled();
+  }
+  return value;
+}
+function clackOptions(options) {
+  return options.map((option) => {
+    const clackOption = {
+      value: option.value,
+      label: option.label
+    };
+    return option.hint ? { ...clackOption, hint: option.hint } : clackOption;
+  });
+}
+function createClackPromptAdapter() {
+  return {
+    intro(message) {
+      p.intro(message);
+    },
+    outro(message) {
+      p.outro(message);
+    },
+    note(message) {
+      p.log.message(message);
+    },
+    async select(input) {
+      const selected = unwrapPromptResult(
+        await p.select({
+          message: input.message,
+          options: clackOptions(input.options),
+          ...input.initialValue ? { initialValue: input.initialValue } : {}
+        })
+      );
+      return selected;
+    },
+    async text(input) {
+      return unwrapPromptResult(await p.text(input));
+    },
+    async password(input) {
+      return unwrapPromptResult(await p.password({ ...input, mask: "*" }));
+    },
+    async confirm(input) {
+      return unwrapPromptResult(await p.confirm(input));
+    }
+  };
+}
+
+// src/platforms/lark/registration-ui.ts
+import qrcode from "qrcode-terminal";
+import { registerLarkPersonalAgent } from "@opentag/lark";
+async function scanLarkPersonalAgent(input, dependencies = {}) {
+  const output = dependencies.output ?? process.stdout;
+  const register = dependencies.register ?? registerLarkPersonalAgent;
+  const showQrCode = dependencies.showQrCode ?? process.env.OPENTAG_SHOW_QR === "1";
+  const registered = await register({
+    domain: input.domain,
+    onQrCode(info) {
+      output.write("\nOpen this URL to create the Lark / Feishu Personal Agent app:\n");
+      output.write(`URL: ${info.url}
+`);
+      output.write(`This QR code expires in about ${Math.ceil(info.expireIn / 60)} minute(s).
+`);
+      if (showQrCode) {
+        output.write("\nTerminal QR code:\n");
+        qrcode.generate(info.url, { small: true }, (qr) => {
+          output.write(`${qr}
+`);
+        });
+      } else {
+        output.write("Terminal QR codes are hidden by default because Lark setup links are large.\n");
+        output.write("Set OPENTAG_SHOW_QR=1 if you prefer scanning a terminal QR code.\n");
+      }
+      output.write("Keep this terminal open. OpenTag will continue automatically after the app is created.\n\n");
+    },
+    onStatus(info) {
+      if (info.status === "slow_down") {
+        output.write(`Lark asked OpenTag to poll more slowly. Next check in ${info.interval ?? "a few"} seconds.
+`);
+      } else if (info.status === "domain_switched") {
+        output.write("Detected a Lark tenant. Continuing registration on larksuite.com.\n");
+      }
+    },
+    onWarning(message) {
+      output.write(`${message}
+`);
+    }
+  });
+  output.write("Lark Personal Agent connected.\n");
+  output.write(`App ID: ${registered.appId}
+`);
+  output.write(`Domain: ${registered.domain}
+`);
+  if (registered.operatorOpenId) {
+    output.write(`Setup user: ${registered.operatorOpenId}
+`);
+  }
+  if (registered.botOpenId) {
+    output.write(`Bot: ${registered.botName ?? "OpenTag"} (${registered.botOpenId})
+`);
+  }
+  output.write("\n");
+  return registered;
+}
+
+// src/start.ts
+import { createServer } from "net";
+import { createDispatcherAdminClient } from "@opentag/client";
+import { startGitHubIngress } from "@opentag/github";
+import { DEFAULT_AGENT_ID, startLarkIngress } from "@opentag/lark";
+import {
+  createDaemonRuntimeInput,
+  normalizeChannelBindings,
+  serveDaemon,
+  startDispatcher
+} from "@opentag/local-runtime";
+import {
+  startSlackIngress,
+  startSlackSocketModeIngress
+} from "@opentag/slack";
+
+// src/health.ts
+async function fetchWithTimeout(input) {
+  const fetchImpl = input.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
+  try {
+    return await fetchImpl(input.url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function probeDispatcherHealth(input) {
+  const healthUrl = `${input.dispatcherUrl.replace(/\/$/, "")}/healthz`;
+  try {
+    const response = await fetchWithTimeout({
+      url: healthUrl,
+      ...input.fetchImpl ? { fetchImpl: input.fetchImpl } : {},
+      timeoutMs: input.timeoutMs
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/start.ts
+function dispatcherPortFromUrl(dispatcherUrl) {
+  const url = new URL(dispatcherUrl);
+  if (url.protocol !== "http:" || url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
+    throw new Error("opentag start currently supports only local http dispatcher URLs.");
+  }
+  if (url.pathname !== "/" || url.search || url.hash) {
+    throw new Error("Dispatcher URL must not include a path, query, or hash.");
+  }
+  const port = url.port ? Number(url.port) : 80;
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new Error(`Dispatcher URL has an invalid port: ${dispatcherUrl}`);
+  }
+  return port;
+}
+function requireLarkConfig(config) {
+  const lark = config.platforms.lark;
+  if (!lark) {
+    throw new Error("This config has no Lark platform config.");
+  }
+  return lark;
+}
+function requireSlackConfig(config) {
+  const slack = config.platforms.slack;
+  if (!slack) {
+    throw new Error("This config has no Slack platform config.");
+  }
+  return slack;
+}
+function requireGitHubConfig(config) {
+  const github = config.platforms.github;
+  if (!github) {
+    throw new Error("This config has no GitHub platform config.");
+  }
+  return github;
+}
+function hasStartablePlatform(config) {
+  return Boolean(config.platforms.lark || config.platforms.slack || config.platforms.github);
+}
+function localStartPortChecks(config) {
+  const checks = [
+    {
+      label: "dispatcher",
+      port: dispatcherPortFromUrl(config.daemon.dispatcherUrl),
+      fix: "Change daemon.dispatcherUrl in the OpenTag config."
+    }
+  ];
+  const slack = config.platforms.slack;
+  if (slack && slackModeFromCliConfig(config) === "events_api") {
+    checks.push({
+      label: "Slack Events API",
+      port: slack.port ?? DEFAULT_SLACK_EVENTS_PORT,
+      fix: "Run `opentag setup --platform slack --slack-mode events_api --slack-port <port> --force`, or edit platforms.slack.port in the OpenTag config."
+    });
+  }
+  const github = config.platforms.github;
+  if (github) {
+    checks.push({
+      label: "GitHub local webhook",
+      port: github.port ?? DEFAULT_GITHUB_WEBHOOK_PORT,
+      fix: "Run `opentag setup --platform github --github-port <port> --force`, or edit platforms.github.port in the OpenTag config."
+    });
+  }
+  return checks;
+}
+async function assertPortAvailable(check) {
+  const server = createServer();
+  await new Promise((resolve2, reject) => {
+    server.once("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        reject(
+          new Error(
+            [
+              `OpenTag cannot start ${check.label} because port ${check.port} is already in use.`,
+              check.fix,
+              `To inspect the current process: lsof -nP -iTCP:${check.port} -sTCP:LISTEN`
+            ].join("\n")
+          )
+        );
+        return;
+      }
+      reject(
+        new Error(
+          [`OpenTag cannot start ${check.label} on port ${check.port}: ${error.message}`, check.fix].join("\n")
+        )
+      );
+    });
+    server.listen(check.port, "127.0.0.1", () => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve2();
+      });
+    });
+  });
+}
+async function assertStartPortsAvailable(config) {
+  const checks = localStartPortChecks(config);
+  const seen = /* @__PURE__ */ new Map();
+  for (const check of checks) {
+    const existing = seen.get(check.port);
+    if (existing) {
+      throw new Error(
+        [
+          `OpenTag cannot start because ${existing.label} and ${check.label} both use port ${check.port}.`,
+          `${existing.label}: ${existing.fix}`,
+          `${check.label}: ${check.fix}`
+        ].join("\n")
+      );
+    }
+    seen.set(check.port, check);
+  }
+  for (const check of checks) {
+    await assertPortAvailable(check);
+  }
+}
+function dispatcherRuntimeInputFromCliConfig(config) {
+  if (!hasStartablePlatform(config)) {
+    throw new Error("This config has no startable platform. Run `opentag setup` and choose Lark, Slack, or GitHub.");
+  }
+  const lark = config.platforms.lark;
+  const slack = config.platforms.slack;
+  const github = config.platforms.github;
+  if (github && !config.daemon.githubToken) {
+    throw new Error("GitHub platform requires daemon.githubToken for callbacks.");
+  }
+  if (github && !config.daemon.preparePullRequestBranch && !config.daemon.allowAutoCreatePullRequest) {
+    throw new Error(
+      "GitHub platform requires daemon.preparePullRequestBranch=true unless legacy daemon.allowAutoCreatePullRequest is enabled. Run `opentag setup` and choose GitHub to update this config."
+    );
+  }
+  return {
+    port: dispatcherPortFromUrl(config.daemon.dispatcherUrl),
+    databasePath: config.state.databasePath,
+    ...config.daemon.pairingToken ? { pairingToken: config.daemon.pairingToken } : {},
+    ...config.daemon.githubToken ? { githubToken: config.daemon.githubToken } : {},
+    ...lark ? {
+      lark: {
+        appId: lark.appId,
+        appSecret: lark.appSecret,
+        domain: lark.domain
+      }
+    } : {},
+    ...slack ? { slackBotToken: slack.botToken } : {}
+  };
+}
+function defaultRepoBindingFromConfig(config) {
+  if (config.platforms.lark?.defaultProjectBinding === false) return void 0;
+  if (config.daemon.repositories.length !== 1) return void 0;
+  const repository = config.daemon.repositories[0];
+  if (!repository) return void 0;
+  return {
+    repoProvider: repository.provider,
+    owner: repository.owner,
+    repo: repository.repo
+  };
+}
+function larkIngressConfigFromCliConfig(config) {
+  const lark = requireLarkConfig(config);
+  const defaultRepoBinding = defaultRepoBindingFromConfig(config);
+  return {
+    appId: lark.appId,
+    appSecret: lark.appSecret,
+    dispatcherUrl: config.daemon.dispatcherUrl,
+    domain: lark.domain,
+    agentId: DEFAULT_AGENT_ID,
+    ...config.daemon.pairingToken ? { dispatcherToken: config.daemon.pairingToken } : {},
+    ...lark.botOpenId ? { botOpenId: lark.botOpenId } : {},
+    ...defaultRepoBinding ? { defaultRepoBinding } : {}
+  };
+}
+function slackModeFromCliConfig(config) {
+  const slack = requireSlackConfig(config);
+  return slack.mode ?? "events_api";
+}
+function slackIngressConfigFromCliConfig(config) {
+  const slack = requireSlackConfig(config);
+  if (!slack.signingSecret) {
+    throw new Error("Slack Events API mode requires platforms.slack.signingSecret.");
+  }
+  return {
+    signingSecret: slack.signingSecret,
+    dispatcherUrl: config.daemon.dispatcherUrl,
+    ...config.daemon.pairingToken ? { dispatcherToken: config.daemon.pairingToken } : {},
+    ...slack.appId ? { appId: slack.appId } : {},
+    ...slack.port ? { port: slack.port } : {}
+  };
+}
+function slackSocketModeIngressConfigFromCliConfig(config) {
+  const slack = requireSlackConfig(config);
+  if (!slack.appToken) {
+    throw new Error("Slack Socket Mode requires platforms.slack.appToken.");
+  }
+  return {
+    appToken: slack.appToken,
+    dispatcherUrl: config.daemon.dispatcherUrl,
+    ...config.daemon.pairingToken ? { dispatcherToken: config.daemon.pairingToken } : {},
+    ...slack.appId ? { appId: slack.appId } : {}
+  };
+}
+function githubIngressConfigFromCliConfig(config) {
+  const github = requireGitHubConfig(config);
+  return {
+    webhookSecret: github.webhookSecret,
+    dispatcherUrl: config.daemon.dispatcherUrl,
+    ...config.daemon.pairingToken ? { dispatcherToken: config.daemon.pairingToken } : {},
+    port: github.port ?? DEFAULT_GITHUB_WEBHOOK_PORT,
+    ...github.webhookPath ? { webhookPath: github.webhookPath } : {}
+  };
+}
+async function bootstrapLocalDispatcher(config, client) {
+  const admin = client ?? createDispatcherAdminClient({
+    dispatcherUrl: config.daemon.dispatcherUrl,
+    runnerId: config.daemon.runnerId,
+    ...config.daemon.pairingToken ? { pairingToken: config.daemon.pairingToken } : {}
+  });
+  await admin.registerRunner(config.daemon.runnerId);
+  for (const repository of config.daemon.repositories) {
+    await admin.bindRepository({
+      provider: repository.provider,
+      owner: repository.owner,
+      repo: repository.repo,
+      checkoutPath: repository.checkoutPath,
+      ...repository.defaultExecutor ? { defaultExecutor: repository.defaultExecutor } : {},
+      ...repository.baseBranch ? { baseBranch: repository.baseBranch } : {},
+      ...repository.pushRemote ? { pushRemote: repository.pushRemote } : {},
+      ...repository.worktreeRoot ? { worktreeRoot: repository.worktreeRoot } : {},
+      ...repository.keepWorktree ? { keepWorktree: repository.keepWorktree } : {}
+    });
+  }
+  for (const binding of normalizeChannelBindings(config.daemon)) {
+    await admin.bindChannel({
+      provider: binding.provider,
+      accountId: binding.accountId,
+      conversationId: binding.conversationId,
+      repoProvider: binding.repoProvider,
+      owner: binding.owner,
+      repo: binding.repo,
+      ...binding.metadata ? { metadata: binding.metadata } : {}
+    });
+  }
+}
+async function waitForDispatcher(input) {
+  const attempts = input.attempts ?? 60;
+  const delayMs = input.delayMs ?? 500;
+  const timeoutMs = input.timeoutMs ?? 1e3;
+  const healthUrl = `${input.dispatcherUrl.replace(/\/$/, "")}/healthz`;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const healthy = await probeDispatcherHealth({
+      dispatcherUrl: input.dispatcherUrl,
+      ...input.fetchImpl ? { fetchImpl: input.fetchImpl } : {},
+      timeoutMs
+    });
+    if (healthy) return;
+    await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+  }
+  throw new Error(`Dispatcher did not become healthy at ${healthUrl}.`);
+}
+function waitForAbort(signal) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve2) => {
+    signal.addEventListener("abort", () => resolve2(), { once: true });
+  });
+}
+function shouldRethrowAbortReason(input) {
+  return !input.shutdownRequested && input.reason instanceof Error;
+}
+async function runStartCommand(options) {
+  const configPath = options.config ?? defaultConfigPath();
+  const config = readCliConfig(configPath);
+  ensurePrivateDirectory(config.state.directory);
+  ensurePrivateDirectory(config.state.worktreeRoot);
+  await assertStartPortsAvailable(config);
+  const abortController = new AbortController();
+  const dispatcher = startDispatcher(dispatcherRuntimeInputFromCliConfig(config));
+  const ingresses = [];
+  let shutdownRequested = false;
+  const onSignal = () => {
+    shutdownRequested = true;
+    abortController.abort();
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  try {
+    await waitForDispatcher({ dispatcherUrl: config.daemon.dispatcherUrl });
+    await bootstrapLocalDispatcher(config);
+    const daemonPromise = serveDaemon({
+      ...createDaemonRuntimeInput(config.daemon),
+      signal: abortController.signal
+    });
+    if (config.platforms.lark) {
+      const handle = startLarkIngress(larkIngressConfigFromCliConfig(config));
+      ingresses.push({ platform: "lark", handle });
+      handle.startPromise.catch((error) => {
+        if (!abortController.signal.aborted) {
+          abortController.abort(error);
+        }
+      });
+    }
+    if (config.platforms.slack) {
+      if (slackModeFromCliConfig(config) === "socket_mode") {
+        const handle = startSlackSocketModeIngress(slackSocketModeIngressConfigFromCliConfig(config));
+        ingresses.push({ platform: "slack", mode: "socket_mode", handle });
+        handle.startPromise.catch((error) => {
+          if (!abortController.signal.aborted) {
+            abortController.abort(error);
+          }
+        });
+      } else {
+        const handle = startSlackIngress(slackIngressConfigFromCliConfig(config));
+        ingresses.push({ platform: "slack", mode: "events_api", url: handle.url, handle });
+      }
+    }
+    if (config.platforms.github) {
+      const handle = startGitHubIngress(githubIngressConfigFromCliConfig(config));
+      ingresses.push({ platform: "github", url: handle.url, webhookPath: handle.webhookPath, handle });
+    }
+    daemonPromise.catch((error) => {
+      if (!abortController.signal.aborted) {
+        abortController.abort(error);
+      }
+    });
+    console.log("OpenTag is running.");
+    console.log(`Config: ${configPath}`);
+    console.log(`Dispatcher: ${config.daemon.dispatcherUrl}`);
+    for (const ingress of ingresses) {
+      if (ingress.platform === "slack") {
+        const slack = config.platforms.slack;
+        if (ingress.mode === "socket_mode") {
+          console.log("Slack: using Socket Mode");
+          console.log(`Slack channel binding: ${slack.teamId}/${slack.channelId}`);
+          console.log("Before testing, invite the Slack app to that channel with /invite @your app name.");
+        } else {
+          console.log(`Slack Events: ${ingress.url}/slack/events`);
+          console.log(`Slack channel binding: ${slack.teamId}/${slack.channelId}`);
+          console.log("Before testing, invite the Slack app to that channel with /invite @your app name.");
+        }
+      } else if (ingress.platform === "github") {
+        const github = config.platforms.github;
+        console.log(`GitHub local webhook: ${githubLocalWebhookUrl({ port: github.port, webhookPath: ingress.webhookPath })}`);
+        console.log(`GitHub Payload URL: ${githubPublicWebhookUrlPlaceholder(ingress.webhookPath)}`);
+        console.log(`GitHub settings: ${githubWebhooksSettingsUrl(github)}`);
+        console.log(`Tunnel example: ngrok http ${github.port ?? DEFAULT_GITHUB_WEBHOOK_PORT}`);
+      } else {
+        console.log("Lark / Feishu: connected through Personal Agent long connection");
+      }
+    }
+    console.log("Press Ctrl-C to stop.");
+    await waitForAbort(abortController.signal);
+    const reason = abortController.signal.reason;
+    if (shouldRethrowAbortReason({ shutdownRequested, reason })) {
+      throw reason;
+    }
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    abortController.abort();
+    await Promise.allSettled([...ingresses].reverse().map((ingress) => ingress.handle.close()));
+    await dispatcher.close();
+  }
+}
+
+// src/commands/setup.ts
+function startPromptMessage(language) {
+  return language === "zh-CN" ? "\u73B0\u5728\u542F\u52A8 OpenTag\uFF1F" : "Start OpenTag now?";
+}
+function setupCompleteMessage(language) {
+  return language === "zh-CN" ? "OpenTag \u8BBE\u7F6E\u5B8C\u6210\u3002" : "OpenTag setup complete.";
+}
+function startingMessage(language) {
+  return language === "zh-CN" ? "\u6B63\u5728\u542F\u52A8 OpenTag..." : "Starting OpenTag...";
+}
+async function runSetupCommand(options, dependencies = {}) {
+  const env = dependencies.env ?? process.env;
+  const configPath = options.config ?? defaultConfigPath(env);
+  if (options.yes && existsSync5(configPath) && !options.force) {
+    throw new Error(`OpenTag config already exists at ${configPath}. Use --force with --yes to overwrite it.`);
+  }
+  const prompts = dependencies.prompts ?? createClackPromptAdapter();
+  const setupInput = await collectSetupInput(options, configPath, {
+    prompts,
+    scanLarkPersonalAgent: dependencies.scanLarkPersonalAgent ?? scanLarkPersonalAgent,
+    ...dependencies.cwd ? { cwd: dependencies.cwd } : {},
+    ...dependencies.env ? { env: dependencies.env } : {},
+    ...dependencies.defaults ? { defaults: dependencies.defaults } : {}
+  });
+  const config = createSetupConfig(setupInput, env);
+  ensurePrivateDirectory(config.state.directory);
+  ensurePrivateDirectory(config.state.worktreeRoot);
+  writeCliConfigAtomic(configPath, config);
+  prompts.note(formatSetupComplete(config, configPath));
+  const shouldStart = options.start ?? (!options.yes ? await prompts.confirm({
+    message: startPromptMessage(config.preferences?.language),
+    initialValue: true
+  }) : false);
+  if (shouldStart) {
+    prompts.outro(startingMessage(config.preferences?.language));
+    await (dependencies.startOpenTag ?? runStartCommand)({ config: configPath });
+  } else {
+    prompts.outro(setupCompleteMessage(config.preferences?.language));
+  }
+}
+
+// src/status.ts
+async function getStatusSummary(input = {}) {
+  const configPath = input.configPath ?? defaultConfigPath();
+  const config = readCliConfig(configPath);
+  return statusFromConfig({ config, configPath, ...input.fetchImpl ? { fetchImpl: input.fetchImpl } : {} });
+}
+async function statusFromConfig(input) {
+  const dispatcher = await probeDispatcherHealth({
+    dispatcherUrl: input.config.daemon.dispatcherUrl,
+    ...input.fetchImpl ? { fetchImpl: input.fetchImpl } : {},
+    timeoutMs: input.healthTimeoutMs ?? 1e3
+  }) ? "online" : "offline";
+  return {
+    configPath: input.configPath,
+    dispatcher,
+    dispatcherUrl: input.config.daemon.dispatcherUrl,
+    runnerId: input.config.daemon.runnerId,
+    repositories: input.config.daemon.repositories.map((repository) => {
+      return `${repository.provider}:${repository.owner}/${repository.repo} -> ${repository.checkoutPath}`;
+    }),
+    platforms: Object.entries(input.config.platforms).filter(([, value]) => value !== void 0).map(([key]) => key)
+  };
+}
+function formatStatus(summary) {
+  return [
+    `Config: ${summary.configPath}`,
+    `Dispatcher: ${summary.dispatcher} (${summary.dispatcherUrl})`,
+    `Runner: ${summary.runnerId}`,
+    `Platforms: ${summary.platforms.length ? summary.platforms.join(", ") : "none"}`,
+    "Project Targets:",
+    ...summary.repositories.length ? summary.repositories.map((repository) => `  ${repository}`) : ["  none"]
+  ].join("\n");
+}
+async function runStatusCommand(options) {
+  console.log(formatStatus(await getStatusSummary({ ...options.config ? { configPath: options.config } : {} })));
+}
+
+// src/index.ts
+var program = new Command();
+function handleError(error) {
+  console.error(formatCliConfigError(error));
+  process.exit(1);
+}
+program.name(process.env.OPENTAG_CLI_NAME?.trim() || "opentag").description("OpenTag CLI");
+program.command("setup").description("Create a local OpenTag config").option("--platform <platform>", "Platform to configure").option("--config <path>", "Config file path").option("--project <path>", "Project checkout path").option("--language <language>", "Setup language: en or zh-CN").option("--executor <executor>", "Default executor: echo, codex, or claude-code").option("--lark-setup <method>", "Lark setup method: saved, scan, or manual").option("--lark-app-id <id>", "Lark app id").option("--lark-app-secret <secret>", "Lark app secret").option("--lark-domain <domain>", "Lark domain: lark or feishu").option("--lark-bot-open-id <openId>", "Lark bot open id for group mentions").option("--slack-mode <mode>", "Slack connection mode: socket_mode or events_api").option("--slack-app-token <token>", "Slack app-level token for Socket Mode").option("--slack-signing-secret <secret>", "Slack signing secret").option("--slack-bot-token <token>", "Slack bot user OAuth token").option("--slack-app-id <id>", "Slack app id").option("--slack-team-id <id>", "Slack team id").option("--slack-channel-id <id>", "Slack channel id").option("--slack-port <port>", "Local Slack Events API port").option("--github-token <token>", "GitHub token for comments and apply-1 pull requests").option("--github-webhook-secret <secret>", "GitHub webhook secret; generated when omitted").option("--github-repository <ownerRepo>", "GitHub repository as owner/repo").option("--github-webhook-path <path>", "GitHub webhook path").option("--github-port <port>", "Local GitHub webhook port").option("--github-auto-create-pr", "Create pull requests immediately after runs").option("--no-github-auto-create-pr", "Use the default apply-1 pull request flow").option("--binding <method>", "Binding method: default_project or bind_later").option("--force", "Overwrite an existing config").option("--start", "Start OpenTag immediately after setup").option("--no-start", "Do not ask to start OpenTag after setup").option("-y, --yes", "Skip setup confirmation").action(async (options) => {
+  try {
+    await runSetupCommand(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("start").description("Start the local OpenTag stack").option("--config <path>", "Config file path").action(async (options) => {
+  try {
+    await runStartCommand(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("status").description("Show the local OpenTag status").option("--config <path>", "Config file path").action(async (options) => {
+  try {
+    await runStatusCommand(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("doctor").description("Check dispatcher, bindings, checkouts, and executors").option("--config <path>", "Config file path").action(async (options) => {
+  try {
+    await runDoctorCommand(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("platforms").description("List OpenTag platform setup support").action(() => {
+  runPlatformsCommand();
+});
+program.command("executors").description("List available coding agents").action(() => {
+  runExecutorsCommand();
+});
+var configCommand = program.command("config").description("Inspect OpenTag config");
+configCommand.command("path").description("Print the OpenTag config path").action(() => {
+  console.log(defaultConfigPath());
+});
+configCommand.command("show").description("Print the OpenTag config with secrets redacted").option("--config <path>", "Config file path").action((options) => {
+  try {
+    console.log(JSON.stringify(redactedCliConfig(readCliConfig(options.config ?? defaultConfigPath())), null, 2));
+  } catch (error) {
+    handleError(error);
+  }
+});
+await program.parseAsync(process.argv);
+//# sourceMappingURL=index.js.map