@yoooclaw/cli 0.0.1 → 0.0.2

package/dist/bin.cjs

@@ -59,13 +59,34 @@ module.exports = __toCommonJS(exports_src);
 var import_commander = require("commander");
 
 // src/command-tree.ts
+var NOTIFICATION_QUERY_OPTIONS = [
+  { flags: "--from <iso8601>", summary: "开始时间，如 2026-03-01T09:00:00+08:00" },
+  { flags: "--to <iso8601>", summary: "结束时间" },
+  { flags: "--app <name>", summary: "按应用过滤（支持中英文别名）" },
+  { flags: "--sender <name>", summary: "按发送人/标题过滤" },
+  { flags: "--conversation-type <type>", summary: "会话类型 group|private" },
+  { flags: "--keyword <text>", summary: "在标题/内容/发送人/会话名中搜索" },
+  { flags: "--limit <n>", summary: "最大返回条数", default: "100" }
+];
 var COMMAND_TREE = [
   {
     name: "config",
     summary: "配置管理 \uD83D\uDFE2",
     subcommands: [
-      { name: "init", summary: "交互式首次向导，生成 config + gateway token" },
-      { name: "show", summary: "显示当前 profile 配置（敏感字段遮罩）" },
+      {
+        name: "init",
+        summary: "交互式首次向导，生成 config + gateway token",
+        options: [
+          { flags: "--non-interactive", summary: "跳过向导（配合 --from-file）" },
+          { flags: "--from-file <path>", summary: "从 JSON 文件导入配置（- 为 stdin）" },
+          { flags: "--force", summary: "已存在 config 时覆盖" }
+        ]
+      },
+      {
+        name: "show",
+        summary: "显示当前 profile 配置（敏感字段遮罩）",
+        options: [{ flags: "--show-secrets", summary: "输出敏感字段明文（需 TTY）" }]
+      },
       { name: "set <key> <value>", summary: "设置单个配置项（点号路径）" },
       { name: "unset <key>", summary: "删除单个配置项" }
     ]
@@ -77,15 +98,27 @@ var COMMAND_TREE = [
       { name: "list", summary: "列出所有 profile，标注 active" },
       { name: "use <name>", summary: "切换 active profile" },
       { name: "create <name>", summary: "新建 profile（走 config init 向导）" },
-      { name: "delete <name>", summary: "删除 profile（非 active，需 --yes）" }
+      {
+        name: "delete <name>",
+        summary: "删除 profile（非 active，需 --yes）",
+        options: [{ flags: "--yes", summary: "跳过确认" }]
+      }
     ]
   },
   {
     name: "auth",
     summary: "凭据与鉴权 \uD83D\uDFE2/\uD83D\uDFE1",
     subcommands: [
-      { name: "set-api-key <key>", summary: "写入 account 级 api-key 到共享凭据文件 \uD83D\uDFE2" },
-      { name: "token rotate", summary: "生成新 gateway token 并热重载 \uD83D\uDFE1" },
+      {
+        name: "set-api-key <key>",
+        summary: "写入 account 级 api-key 到共享凭据文件（- 从 stdin 读）\uD83D\uDFE2",
+        options: [{ flags: "--keychain", summary: "写入 OS keychain 而非文件" }]
+      },
+      {
+        name: "token-rotate",
+        summary: "生成新 gateway token 并热重载 \uD83D\uDFE1",
+        options: [{ flags: "--length <n>", summary: "token 字节长度", default: "32" }]
+      },
       { name: "status", summary: "显示鉴权状态（本地检查，不调 daemon）\uD83D\uDFE2" },
       { name: "check", summary: "端到端鉴权体检（调 daemon /daemon/status）\uD83D\uDFE1" }
     ]
@@ -94,20 +127,63 @@ var COMMAND_TREE = [
     name: "daemon",
     summary: "守护进程管理 \uD83D\uDD35",
     subcommands: [
-      { name: "start", summary: "启动 daemon（默认后台 detach）" },
+      {
+        name: "start",
+        summary: "启动 daemon（默认后台 detach）",
+        options: [
+          { flags: "--bind <host>", summary: "监听地址（默认 config.daemon.bind）" },
+          { flags: "--port <n>", summary: "监听端口（默认 config.daemon.port）" },
+          { flags: "--no-detach", summary: "前台运行（systemd/launchd 用）" },
+          { flags: "--log-level <level>", summary: "error|warn|info|debug|trace" }
+        ]
+      },
       { name: "stop", summary: "停止 daemon（SIGTERM → 10s → SIGKILL）" },
       { name: "restart", summary: "stop + start，保留原启动参数" },
       { name: "status", summary: "打印 daemon 状态（PID/端口/relay/规则数...）" },
-      { name: "logs", summary: "跟踪 daemon 日志" }
+      {
+        name: "logs",
+        summary: "跟踪 daemon 日志",
+        options: [
+          { flags: "-f, --follow", summary: "持续 tail" },
+          { flags: "--lines <n>", summary: "初始展示行数", default: "100" },
+          { flags: "--level <level>", summary: "过滤日志级别" }
+        ]
+      },
+      {
+        name: "run-foreground",
+        summary: "（内部）前台运行 daemon 主循环，供 detach 子进程调用",
+        options: [
+          { flags: "--bind <host>", summary: "监听地址" },
+          { flags: "--port <n>", summary: "监听端口" },
+          { flags: "--log-level <level>", summary: "日志级别" }
+        ]
+      }
     ]
   },
   {
     name: "notification",
     summary: "通知查询 \uD83D\uDFE2",
     subcommands: [
-      { name: "search", summary: "按筛选条件查询通知，时间倒序" },
-      { name: "summary", summary: "聚合统计 + 样例摘要，供 Agent 总结" },
-      { name: "stats", summary: "按维度聚合统计" },
+      { name: "search", summary: "按筛选条件查询通知，时间倒序", options: NOTIFICATION_QUERY_OPTIONS },
+      {
+        name: "summary",
+        summary: "聚合统计 + 样例摘要，供 Agent 总结",
+        options: [
+          ...NOTIFICATION_QUERY_OPTIONS,
+          { flags: "--sample <n>", summary: "返回最近样例条数", default: "30" },
+          { flags: "--top <n>", summary: "聚合榜单条数", default: "10" }
+        ]
+      },
+      {
+        name: "stats",
+        summary: "按维度聚合统计",
+        options: [
+          { flags: "--from <date>", summary: "YYYY-MM-DD，默认 7 天前" },
+          { flags: "--to <date>", summary: "YYYY-MM-DD，默认今天" },
+          { flags: "--app <name>", summary: "仅统计指定应用" },
+          { flags: "--dim <dim>", summary: "date|app|sender|hour|all", default: "all" }
+        ]
+      },
       { name: "storage-path", summary: "打印 notifications 目录绝对路径" }
     ],
     shortcuts: [
@@ -121,18 +197,44 @@ var COMMAND_TREE = [
     summary: "通知同步给记忆系统 \uD83D\uDFE2",
     subcommands: [
       { name: "scan", summary: "扫描未处理通知，返回各日期待同步摘要" },
-      { name: "fetch", summary: "获取指定日期未处理通知详情" },
-      { name: "commit", summary: "标记指定日期当前批次处理完成" }
+      {
+        name: "fetch",
+        summary: "获取指定日期未处理通知详情",
+        options: [
+          { flags: "--date <YYYY-MM-DD>", summary: "目标日期（必填）" },
+          { flags: "--max-end-index <index>", summary: "本次快照允许读取的最大 endIndex" }
+        ]
+      },
+      {
+        name: "commit",
+        summary: "标记指定日期当前批次处理完成",
+        options: [
+          { flags: "--date <YYYY-MM-DD>", summary: "目标日期（必填）" },
+          { flags: "--end-index <index>", summary: "本批次 fetch 返回的 endIndex" }
+        ]
+      }
     ]
   },
   {
     name: "recording",
     summary: "录音管理 \uD83D\uDFE2/\uD83D\uDFE1",
     subcommands: [
-      { name: "list", summary: "列出所有录音 \uD83D\uDFE2" },
+      {
+        name: "list",
+        summary: "列出所有录音 \uD83D\uDFE2",
+        options: [{ flags: "--status <status>", summary: "按传输状态过滤" }]
+      },
       { name: "status <id>", summary: "查看单条录音详情 \uD83D\uDFE2" },
       { name: "storage-path", summary: "打印录音存储目录绝对路径 \uD83D\uDFE2" },
-      { name: "setup-asr", summary: "交互式配置 ASR 转写参数 \uD83D\uDFE2" }
+      {
+        name: "setup-asr",
+        summary: "交互式配置 ASR 转写参数 \uD83D\uDFE2",
+        options: [
+          { flags: "--provider <name>", summary: "volcengine | whisper-local | ..." },
+          { flags: "--api-key <key>", summary: "非交互模式直接传入" },
+          { flags: "--non-interactive", summary: "跳过向导，从参数构造配置" }
+        ]
+      }
     ],
     shortcuts: [{ name: "+latest", summary: "展示最新一条录音详情" }]
   },
@@ -140,9 +242,23 @@ var COMMAND_TREE = [
     name: "image",
     summary: "图片管理 \uD83D\uDFE2",
     subcommands: [
-      { name: "list", summary: "列出所有图片" },
+      {
+        name: "list",
+        summary: "列出所有图片",
+        options: [
+          { flags: "--status <status>", summary: "syncing|synced|sync_failed" },
+          { flags: "--app <name>", summary: "按来源应用过滤" },
+          { flags: "--from <iso8601>", summary: "created_at 起" },
+          { flags: "--to <iso8601>", summary: "created_at 止" },
+          { flags: "--limit <n>", summary: "最大返回条数", default: "100" }
+        ]
+      },
       { name: "status <id>", summary: "查看单张图片详情" },
-      { name: "path <id>", summary: "打印图片本地文件绝对路径" },
+      {
+        name: "path <id>",
+        summary: "打印图片本地文件绝对路径",
+        options: [{ flags: "--thumbnail", summary: "返回缩略图路径（若有）" }]
+      },
       { name: "storage-path", summary: "打印图片存储目录绝对路径" }
     ],
     shortcuts: [{ name: "+latest", summary: "展示最新一张图片详情" }]
@@ -151,7 +267,16 @@ var COMMAND_TREE = [
     name: "light",
     summary: "灯效硬件控制 \uD83D\uDFE1",
     subcommands: [
-      { name: "send", summary: "发送灯效指令到硬件（--segments / --preset）" }
+      {
+        name: "send",
+        summary: "发送灯效指令到硬件（--segments / --preset）",
+        options: [
+          { flags: "--segments <json>", summary: "灯效参数 JSON" },
+          { flags: "--preset <name>", summary: "预设名，如 red-blink" },
+          { flags: "--repeat", summary: "无限循环播放" },
+          { flags: "--repeat-times <n>", summary: "整条组合重复次数（0=无限）" }
+        ]
+      }
     ],
     shortcuts: [{ name: "+blink", summary: "灯效连通性测试" }]
   },
@@ -161,9 +286,33 @@ var COMMAND_TREE = [
     subcommands: [
       { name: "list", summary: "列出所有规则及状态" },
       { name: "show <id>", summary: "查看单条规则详情" },
-      { name: "create", summary: "创建规则（--from-file / --intent ...）" },
-      { name: "update <id>", summary: "更新现有规则" },
-      { name: "delete <id>", summary: "删除规则（--yes）" },
+      {
+        name: "create",
+        summary: "创建规则（--from-file / --intent ...）",
+        options: [
+          { flags: "--from-file <path>", summary: "从 JSON/YAML 读规则（- 为 stdin）" },
+          { flags: "--name <text>", summary: "规则名" },
+          { flags: "--intent <text>", summary: "自然语言意图描述" },
+          { flags: "--light-action <json>", summary: "命中后的 light 动作 JSON" },
+          { flags: "--match-rules <json>", summary: "前置硬过滤规则 JSON" }
+        ]
+      },
+      {
+        name: "update <id>",
+        summary: "更新现有规则",
+        options: [
+          { flags: "--from-file <path>", summary: "从 JSON/YAML 读规则（- 为 stdin）" },
+          { flags: "--name <text>", summary: "规则名" },
+          { flags: "--intent <text>", summary: "自然语言意图描述" },
+          { flags: "--light-action <json>", summary: "命中后的 light 动作 JSON" },
+          { flags: "--match-rules <json>", summary: "前置硬过滤规则 JSON" }
+        ]
+      },
+      {
+        name: "delete <id>",
+        summary: "删除规则（--yes）",
+        options: [{ flags: "--yes", summary: "跳过确认" }]
+      },
       { name: "enable <id>", summary: "启用单条规则" },
       { name: "disable <id>", summary: "停用单条规则" }
     ],
@@ -178,8 +327,20 @@ var COMMAND_TREE = [
     subcommands: [
       { name: "list", summary: "列出所有监控任务" },
       { name: "show <name>", summary: "查看监控任务详情" },
-      { name: "create <name>", summary: "创建监控任务（cron 驱动）" },
-      { name: "delete <name>", summary: "删除监控任务（--yes）" },
+      {
+        name: "create <name>",
+        summary: "创建监控任务（cron 驱动）",
+        options: [
+          { flags: "--description <text>", summary: "任务描述（必填）" },
+          { flags: "--match-rules <json>", summary: "匹配规则 JSON（必填）" },
+          { flags: "--schedule <cron>", summary: "cron 表达式（必填）" }
+        ]
+      },
+      {
+        name: "delete <name>",
+        summary: "删除监控任务（--yes）",
+        options: [{ flags: "--yes", summary: "跳过确认" }]
+      },
       { name: "enable <name>", summary: "启用监控任务" },
       { name: "disable <name>", summary: "暂停监控任务" }
     ]
@@ -197,53 +358,92 @@ var COMMAND_TREE = [
     name: "log",
     summary: "日志检索 \uD83D\uDFE2",
     args: "[keyword]",
+    options: [
+      { flags: "--from <date>", summary: "YYYY-MM-DD，默认 7 天前" },
+      { flags: "--to <date>", summary: "YYYY-MM-DD，默认今天" },
+      { flags: "--limit <n>", summary: "最大返回条数", default: "50" },
+      { flags: "--level <level>", summary: "过滤日志级别" }
+    ],
     shortcuts: [{ name: "+errors", summary: "昨天起的 error 级日志" }]
   },
   {
     name: "gateway",
     summary: "协议自检 \uD83D\uDFE2/\uD83D\uDFE1",
     subcommands: [
-      { name: "test", summary: "模拟手机端调 daemon /notifications，验证连通/鉴权/relay \uD83D\uDFE1" }
+      {
+        name: "test",
+        summary: "模拟手机端调 daemon /notifications，验证连通/鉴权/relay \uD83D\uDFE1",
+        options: [
+          { flags: "--from-phone-ip <ip>", summary: "模拟来源 IP" },
+          { flags: "--via-relay", summary: "强制走 Relay 隧道" }
+        ]
+      }
     ]
   },
   {
     name: "api",
     summary: "Raw HTTP escape hatch \uD83D\uDFE1",
-    args: "<method> <path>"
+    args: "<method> <path>",
+    options: [
+      { flags: "--data <json>", summary: "请求体（@file 读文件、- 读 stdin）" },
+      { flags: "--header <key:value>", summary: "追加 header（可重复）" }
+    ]
   },
   {
     name: "migrate",
     summary: "从 openclaw 插件迁移数据 \uD83D\uDFE2",
     subcommands: [
-      { name: "from-openclaw", summary: "迁移 notifications/recordings/规则/api-key 到 ~/.yoooclaw" }
+      {
+        name: "from-openclaw",
+        summary: "迁移 notifications/recordings/规则/api-key 到 ~/.yoooclaw",
+        options: [
+          { flags: "--dry-run", summary: "只打印迁移计划，不写入" },
+          { flags: "--source <path>", summary: "自定义源目录，默认 ~/.openclaw" }
+        ]
+      }
     ]
   },
   {
     name: "update",
     summary: "版本检查 \uD83D\uDFE2",
     subcommands: [
-      { name: "self", summary: "检查 npm 最新版本并提示（不自动更新）" }
+      {
+        name: "self",
+        summary: "检查 npm 最新版本并提示（不自动更新）",
+        options: [
+          { flags: "--beta", summary: "检查 beta channel" },
+          { flags: "--json", summary: "只输出版本信息 JSON" }
+        ]
+      }
     ]
   },
   {
     name: "doctor",
-    summary: "环境自检：Node/目录/keychain/daemon/relay \uD83D\uDFE2/\uD83D\uDFE1"
+    summary: "环境自检：Node/目录/keychain/daemon/relay \uD83D\uDFE2/\uD83D\uDFE1",
+    options: [
+      { flags: "--json", summary: "JSON 输出（给脚本用）" },
+      { flags: "--fix", summary: "自动修复可修复的问题" }
+    ]
   }
 ];
 
 // src/context.ts
-var import_node_fs = require("node:fs");
+var import_node_fs2 = require("node:fs");
 
 // src/paths.ts
 var exports_paths = {};
 __export(exports_paths, {
   sharedCredentialsPath: () => sharedCredentialsPath,
   rootDir: () => rootDir,
+  readActiveProfile: () => readActiveProfile,
+  profilesRoot: () => profilesRoot,
   profilePaths: () => profilePaths,
   profileDir: () => profileDir,
+  listProfileNames: () => listProfileNames,
   activeProfilePath: () => activeProfilePath,
   DEFAULT_PROFILE: () => DEFAULT_PROFILE
 });
+var import_node_fs = require("node:fs");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 var DEFAULT_PROFILE = "default";
@@ -259,6 +459,22 @@ function activeProfilePath() {
 function profileDir(profile) {
   return import_node_path.join(rootDir(), "profiles", profile);
 }
+function profilesRoot() {
+  return import_node_path.join(rootDir(), "profiles");
+}
+function listProfileNames() {
+  const root = profilesRoot();
+  if (!import_node_fs.existsSync(root))
+    return [];
+  return import_node_fs.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort((a, b) => a.localeCompare(b));
+}
+function readActiveProfile() {
+  const file = activeProfilePath();
+  if (!import_node_fs.existsSync(file))
+    return;
+  const name = import_node_fs.readFileSync(file, "utf-8").trim();
+  return name || undefined;
+}
 function profilePaths(profile) {
   const dir = profileDir(profile);
   return {
@@ -287,7 +503,14 @@ var ErrorCode = {
   CONFIG_INVALID: "YOOOCLAW_CONFIG_INVALID",
   PROFILE_NOT_FOUND: "YOOOCLAW_PROFILE_NOT_FOUND",
   IMAGE_NOT_READY: "YOOOCLAW_IMAGE_NOT_READY",
-  NOT_FOUND: "YOOOCLAW_NOT_FOUND"
+  NOT_FOUND: "YOOOCLAW_NOT_FOUND",
+  ALREADY_EXISTS: "YOOOCLAW_ALREADY_EXISTS",
+  STORAGE_UNAVAILABLE: "YOOOCLAW_STORAGE_UNAVAILABLE",
+  CREDENTIAL_MISSING: "YOOOCLAW_CREDENTIAL_MISSING",
+  KEYCHAIN_UNAVAILABLE: "YOOOCLAW_KEYCHAIN_UNAVAILABLE",
+  NETWORK_ERROR: "YOOOCLAW_NETWORK_ERROR",
+  CONFIRMATION_REQUIRED: "YOOOCLAW_CONFIRMATION_REQUIRED",
+  NOT_INTERACTIVE: "YOOOCLAW_NOT_INTERACTIVE"
 };
 
 class YoooclawError extends Error {
@@ -393,8 +616,8 @@ function resolveActiveProfile(flagProfile) {
   if (envProfile)
     return envProfile;
   const file = activeProfilePath();
-  if (import_node_fs.existsSync(file)) {
-    const name = import_node_fs.readFileSync(file, "utf-8").trim();
+  if (import_node_fs2.existsSync(file)) {
+    const name = import_node_fs2.readFileSync(file, "utf-8").trim();
     if (name)
       return name;
   }
@@ -412,16 +635,16 @@ function buildContext(flags) {
 }
 
 // src/version.ts
-var import_node_fs2 = require("node:fs");
+var import_node_fs3 = require("node:fs");
 function readBuildInjectedVersion() {
   if (false) {}
-  const version = "0.0.1".trim();
+  const version = "0.0.2".trim();
   return version || undefined;
 }
 function readVersionFromPackageJson() {
   try {
     const packageJsonUrl = new URL("../package.json", "file:///Users/cobb/github/openclaw-plugin/packages/cli/src/version.ts");
-    const packageJson = JSON.parse(import_node_fs2.readFileSync(packageJsonUrl, "utf-8"));
+    const packageJson = JSON.parse(import_node_fs3.readFileSync(packageJsonUrl, "utf-8"));
     const version = packageJson.version?.trim();
     return version || undefined;
   } catch {
@@ -430,47 +653,4137 @@ function readVersionFromPackageJson() {
 }
 var CLI_VERSION = readBuildInjectedVersion() ?? readVersionFromPackageJson() ?? "unknown";
 
-// src/program.ts
-function wrapAction(handler) {
-  return async (...rawArgs) => {
-    const command = rawArgs.at(-1);
-    const opts = rawArgs.at(-2);
-    const positionals = rawArgs.slice(0, -2);
-    const globals = command.optsWithGlobals();
-    let ctx;
+// src/fs-utils.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path2 = require("node:path");
+var DIR_MODE = 448;
+var SECRET_FILE_MODE = 384;
+var CONFIG_FILE_MODE = 420;
+function ensureDir(dir, mode = DIR_MODE) {
+  import_node_fs4.mkdirSync(dir, { recursive: true, mode });
+  try {
+    import_node_fs4.chmodSync(dir, mode);
+  } catch {}
+}
+function writeFileAtomic(filePath, contents, mode = CONFIG_FILE_MODE) {
+  ensureDir(import_node_path2.dirname(filePath));
+  const tmp = import_node_path2.join(import_node_path2.dirname(filePath), `.${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+  import_node_fs4.writeFileSync(tmp, contents, { mode });
+  import_node_fs4.renameSync(tmp, filePath);
+  try {
+    import_node_fs4.chmodSync(filePath, mode);
+  } catch {}
+}
+function writeJsonFile(filePath, data, mode = CONFIG_FILE_MODE) {
+  writeFileAtomic(filePath, JSON.stringify(data, null, 2) + `
+`, mode);
+}
+function readJsonFile(filePath) {
+  if (!import_node_fs4.existsSync(filePath))
+    return;
+  let raw;
+  try {
+    raw = import_node_fs4.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    throw new YoooclawError("YOOOCLAW_CONFIG_INVALID", `读取文件失败：${filePath}`, { cause: err instanceof Error ? err.message : String(err) });
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new YoooclawError("YOOOCLAW_CONFIG_INVALID", `文件不是合法 JSON：${filePath}`, { hint: "可手动修复或删除后重新生成" });
+  }
+}
+
+// src/prompt.ts
+var import_promises = require("node:readline/promises");
+var import_node_process = require("node:process");
+function isInteractive() {
+  return Boolean(import_node_process.stdin.isTTY && import_node_process.stdout.isTTY);
+}
+function ensureInteractive() {
+  if (!isInteractive()) {
+    throw new YoooclawError("YOOOCLAW_NOT_INTERACTIVE", "当前为非交互环境，无法进行交互式输入", { hint: "改用 --non-interactive --from-file，或在 TTY 中运行" });
+  }
+}
+async function ask(question, defaultValue) {
+  ensureInteractive();
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  const rl = import_promises.createInterface({ input: import_node_process.stdin, output: import_node_process.stdout });
+  try {
+    const answer = (await rl.question(`${question}${suffix}: `)).trim();
+    return answer || defaultValue || "";
+  } finally {
+    rl.close();
+  }
+}
+async function confirm(question, defaultYes = false) {
+  const hint = defaultYes ? "Y/n" : "y/N";
+  const answer = (await ask(`${question} (${hint})`)).toLowerCase();
+  if (!answer)
+    return defaultYes;
+  return answer === "y" || answer === "yes";
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of import_node_process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+// src/config/store.ts
+var import_node_fs5 = require("node:fs");
+
+// src/config/schema.ts
+var CONFIG_VERSION = 1;
+var DEFAULT_RELAY_URL = "wss://relay.yoooclaw.com/tunnel";
+var DEFAULT_PORT = 18789;
+var DEFAULT_BIND = "127.0.0.1";
+var DEFAULT_IMAGE_MAX_BYTES = 20 * 1024 * 1024;
+function defaultConfig(credentialsPath) {
+  return {
+    version: CONFIG_VERSION,
+    daemon: {
+      bind: DEFAULT_BIND,
+      port: DEFAULT_PORT,
+      logLevel: "info",
+      detach: true
+    },
+    auth: {
+      mode: "token",
+      tokenRef: `file:${credentialsPath}#gatewayToken`
+    },
+    relay: {
+      url: DEFAULT_RELAY_URL,
+      heartbeatSec: 10,
+      reconnectBackoffMs: 2000,
+      enabled: true
+    },
+    notification: {
+      retentionDays: null,
+      ignoredApps: []
+    },
+    lightRules: {
+      enabled: true
+    },
+    autoUpdate: {
+      enabled: true,
+      channel: "stable"
+    },
+    output: {
+      defaultFormat: "auto"
+    },
+    image: {
+      maxBytes: DEFAULT_IMAGE_MAX_BYTES
+    }
+  };
+}
+function defaultEvaluator(credentialsPath) {
+  return {
+    mode: "webhook",
+    webhookUrl: "",
+    webhookSecretRef: `file:${credentialsPath}#evaluatorSecret`,
+    timeoutMs: 5000,
+    retries: 1
+  };
+}
+var SECRET_REF_PATHS = [
+  "auth.tokenRef",
+  "lightRules.evaluator.webhookSecretRef"
+];
+
+// src/config/store.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(target, source) {
+  if (!isPlainObject(source))
+    return target;
+  const out = isPlainObject(target) ? { ...target } : {};
+  for (const [key, value] of Object.entries(source)) {
+    const prev = out[key];
+    out[key] = isPlainObject(value) && isPlainObject(prev) ? deepMerge(prev, value) : value;
+  }
+  return out;
+}
+function configExists(paths) {
+  return import_node_fs5.existsSync(paths.config);
+}
+function loadConfig(paths) {
+  const base = defaultConfig(paths.credentials);
+  const stored = readJsonFile(paths.config);
+  if (!stored)
+    return base;
+  return deepMerge(base, stored);
+}
+function requireConfig(paths) {
+  if (!configExists(paths)) {
+    throw new YoooclawError("YOOOCLAW_CONFIG_INVALID", `profile \`${paths.profile}\` 尚未初始化`, { hint: "先运行 yoooclaw config init", checkedPaths: [paths.config] });
+  }
+  return loadConfig(paths);
+}
+function saveConfig(paths, config) {
+  writeJsonFile(paths.config, config, CONFIG_FILE_MODE);
+}
+function getByPath(obj, path) {
+  const segments = path.split(".");
+  let cursor = obj;
+  for (const seg of segments) {
+    if (!isPlainObject(cursor))
+      return;
+    cursor = cursor[seg];
+  }
+  return cursor;
+}
+function setByPath(obj, path, value) {
+  const segments = path.split(".");
+  let cursor = obj;
+  for (let i = 0;i < segments.length - 1; i += 1) {
+    const seg = segments[i];
+    if (!isPlainObject(cursor[seg]))
+      cursor[seg] = {};
+    cursor = cursor[seg];
+  }
+  cursor[segments.at(-1)] = value;
+}
+function unsetByPath(obj, path) {
+  const segments = path.split(".");
+  let cursor = obj;
+  for (let i = 0;i < segments.length - 1; i += 1) {
+    const seg = segments[i];
+    if (!isPlainObject(cursor[seg]))
+      return false;
+    cursor = cursor[seg];
+  }
+  const last = segments.at(-1);
+  if (!(last in cursor))
+    return false;
+  delete cursor[last];
+  return true;
+}
+var NUMBER_PATHS = new Set([
+  "daemon.port",
+  "relay.heartbeatSec",
+  "relay.reconnectBackoffMs",
+  "notification.retentionDays",
+  "lightRules.evaluator.timeoutMs",
+  "lightRules.evaluator.retries",
+  "image.maxBytes"
+]);
+var BOOLEAN_PATHS = new Set([
+  "daemon.detach",
+  "relay.enabled",
+  "lightRules.enabled",
+  "autoUpdate.enabled"
+]);
+var ARRAY_PATHS = new Set(["notification.ignoredApps"]);
+function coerceConfigValue(path, raw) {
+  if (NUMBER_PATHS.has(path)) {
+    if (path === "notification.retentionDays" && (raw === "null" || raw === "")) {
+      return null;
+    }
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+      throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", `${path} 需要数字，收到：${raw}`);
+    }
+    return n;
+  }
+  if (BOOLEAN_PATHS.has(path)) {
+    if (raw === "true")
+      return true;
+    if (raw === "false")
+      return false;
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", `${path} 需要 true/false，收到：${raw}`);
+  }
+  if (ARRAY_PATHS.has(path)) {
+    return raw.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  return raw;
+}
+function maskConfig(config) {
+  const clone = structuredClone(config);
+  for (const path of SECRET_REF_PATHS) {
+    const value = getByPath(clone, path);
+    if (typeof value === "string" && value.startsWith("inline:")) {
+      setByPath(clone, path, "inline:****");
+    }
+  }
+  return clone;
+}
+
+// src/credentials/store.ts
+var import_node_crypto = require("node:crypto");
+
+// src/credentials/keychain.ts
+var import_node_child_process = require("node:child_process");
+var import_node_os2 = require("node:os");
+function hasCommand(cmd) {
+  const probe = import_node_child_process.spawnSync(process.platform === "win32" ? "where" : "which", [cmd], {
+    encoding: "utf-8"
+  });
+  return probe.status === 0;
+}
+function keychainAvailable() {
+  switch (import_node_os2.platform()) {
+    case "darwin":
+      return hasCommand("security");
+    case "linux":
+      return hasCommand("secret-tool");
+    default:
+      return false;
+  }
+}
+function keychainGet(service, account) {
+  switch (import_node_os2.platform()) {
+    case "darwin": {
+      if (!hasCommand("security"))
+        return { available: false };
+      const r = import_node_child_process.spawnSync("security", ["find-generic-password", "-s", service, "-a", account, "-w"], { encoding: "utf-8" });
+      if (r.status !== 0)
+        return { available: true, value: undefined };
+      return { available: true, value: r.stdout.replace(/\n$/, "") };
+    }
+    case "linux": {
+      if (!hasCommand("secret-tool"))
+        return { available: false };
+      const r = import_node_child_process.spawnSync("secret-tool", ["lookup", "service", service, "account", account], { encoding: "utf-8" });
+      if (r.status !== 0)
+        return { available: true, value: undefined };
+      return { available: true, value: r.stdout.replace(/\n$/, "") };
+    }
+    default:
+      return { available: false };
+  }
+}
+function keychainSet(service, account, value) {
+  switch (import_node_os2.platform()) {
+    case "darwin": {
+      if (!hasCommand("security"))
+        return false;
+      const r = import_node_child_process.spawnSync("security", ["add-generic-password", "-U", "-s", service, "-a", account, "-w", value], { encoding: "utf-8" });
+      return r.status === 0;
+    }
+    case "linux": {
+      if (!hasCommand("secret-tool"))
+        return false;
+      const r = import_node_child_process.spawnSync("secret-tool", ["store", "--label", `${service}:${account}`, "service", service, "account", account], { encoding: "utf-8", input: value });
+      return r.status === 0;
+    }
+    default:
+      return false;
+  }
+}
+
+// src/credentials/refs.ts
+var import_node_os3 = require("node:os");
+var import_node_path3 = require("node:path");
+function expandHome(path) {
+  if (path === "~")
+    return import_node_os3.homedir();
+  if (path.startsWith("~/"))
+    return import_node_path3.join(import_node_os3.homedir(), path.slice(2));
+  return path;
+}
+function parseFileRef(rest) {
+  const hashIdx = rest.lastIndexOf("#");
+  if (hashIdx < 0) {
+    throw new YoooclawError("YOOOCLAW_CONFIG_INVALID", `file: 引用缺少 #字段：${rest}`, { hint: "格式应为 file:<path>#<jsonField>" });
+  }
+  return {
+    path: expandHome(rest.slice(0, hashIdx)),
+    field: rest.slice(hashIdx + 1)
+  };
+}
+function parseKeychainRef(rest) {
+  const slashIdx = rest.indexOf("/");
+  if (slashIdx < 0) {
+    throw new YoooclawError("YOOOCLAW_CONFIG_INVALID", `keychain: 引用缺少 /account：${rest}`, { hint: "格式应为 keychain:<service>/<account>" });
+  }
+  return {
+    service: rest.slice(0, slashIdx),
+    account: rest.slice(slashIdx + 1)
+  };
+}
+function resolveRef(ref) {
+  const colonIdx = ref.indexOf(":");
+  if (colonIdx < 0) {
+    throw new YoooclawError("YOOOCLAW_CONFIG_INVALID", `非法凭据引用：${ref}`, { hint: "支持 env: / file: / keychain: / inline:" });
+  }
+  const scheme = ref.slice(0, colonIdx);
+  const rest = ref.slice(colonIdx + 1);
+  switch (scheme) {
+    case "env": {
+      const value = process.env[rest]?.trim();
+      return { source: "env", value: value || undefined, location: rest };
+    }
+    case "file": {
+      const { path, field } = parseFileRef(rest);
+      const data = readJsonFile(path);
+      const value = data?.[field];
+      return {
+        source: "file",
+        value: typeof value === "string" && value ? value : undefined,
+        location: path
+      };
+    }
+    case "keychain": {
+      const { service, account } = parseKeychainRef(rest);
+      const r = keychainGet(service, account);
+      return { source: "keychain", value: r.value, location: `${service}/${account}` };
+    }
+    case "inline": {
+      const decoded = Buffer.from(rest, "base64").toString("utf-8");
+      return { source: "inline", value: decoded || undefined };
+    }
+    default:
+      throw new YoooclawError("YOOOCLAW_CONFIG_INVALID", `不支持的凭据引用 scheme：${scheme}`, { hint: "支持 env: / file: / keychain: / inline:" });
+  }
+}
+function writeRef(ref, value) {
+  const colonIdx = ref.indexOf(":");
+  const scheme = ref.slice(0, colonIdx);
+  const rest = ref.slice(colonIdx + 1);
+  switch (scheme) {
+    case "file": {
+      const { path, field } = parseFileRef(rest);
+      const data = readJsonFile(path) ?? {};
+      data[field] = value;
+      writeJsonFile(path, data, SECRET_FILE_MODE);
+      return { source: "file", value, location: path };
+    }
+    case "keychain": {
+      const { service, account } = parseKeychainRef(rest);
+      if (!keychainSet(service, account, value)) {
+        throw new YoooclawError("YOOOCLAW_KEYCHAIN_UNAVAILABLE", `keychain 写入失败：${service}/${account}`, { hint: "当前平台可能没有可用的 keychain 工具，请改用 file: 引用" });
+      }
+      return { source: "keychain", value, location: `${service}/${account}` };
+    }
+    case "env":
+      throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "env: 引用无法持久化写入；请改用 file: 或 keychain:");
+    case "inline":
+      throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "inline: 引用需直接写进 config，不通过 writeRef");
+    default:
+      throw new YoooclawError("YOOOCLAW_CONFIG_INVALID", `不支持的凭据引用 scheme：${scheme}`);
+  }
+}
+
+// src/credentials/store.ts
+var API_KEY_ENV = "YOOOCLAW_API_KEY";
+var KEYCHAIN_SERVICE = "yoooclaw";
+var KEYCHAIN_API_KEY_ACCOUNT = "api-key";
+var API_KEY_FIELD = "apiKey";
+function resolveApiKey() {
+  const env = process.env[API_KEY_ENV]?.trim();
+  if (env)
+    return { value: env, source: "env", location: API_KEY_ENV };
+  if (keychainAvailable()) {
+    const r = keychainGet(KEYCHAIN_SERVICE, KEYCHAIN_API_KEY_ACCOUNT);
+    if (r.value) {
+      return { value: r.value, source: "keychain", location: `${KEYCHAIN_SERVICE}/${KEYCHAIN_API_KEY_ACCOUNT}` };
+    }
+  }
+  const file = sharedCredentialsPath();
+  const data = readJsonFile(file);
+  const value = data?.[API_KEY_FIELD];
+  if (typeof value === "string" && value) {
+    return { value, source: "file", location: file };
+  }
+  return { source: "none" };
+}
+function setApiKey(key, useKeychain) {
+  if (useKeychain) {
+    if (!keychainSet(KEYCHAIN_SERVICE, KEYCHAIN_API_KEY_ACCOUNT, key)) {
+      throw new YoooclawError("YOOOCLAW_KEYCHAIN_UNAVAILABLE", "当前平台无法写入 keychain，请去掉 --keychain 改写共享文件");
+    }
+    return { value: key, source: "keychain", location: `${KEYCHAIN_SERVICE}/${KEYCHAIN_API_KEY_ACCOUNT}` };
+  }
+  const file = sharedCredentialsPath();
+  const data = readJsonFile(file) ?? {};
+  data[API_KEY_FIELD] = key;
+  writeJsonFile(file, data, SECRET_FILE_MODE);
+  return { value: key, source: "file", location: file };
+}
+function resolveGatewayToken(config) {
+  return resolveRef(config.auth.tokenRef);
+}
+function writeGatewayToken(config, value) {
+  return writeRef(config.auth.tokenRef, value);
+}
+function generateToken(bytes = 32) {
+  return import_node_crypto.randomBytes(bytes).toString("hex");
+}
+
+// src/commands/config.ts
+function phoneSummary(ctx, config, token) {
+  return {
+    ok: true,
+    profile: ctx.profile,
+    daemon: {
+      bind: config.daemon.bind,
+      port: config.daemon.port,
+      localUrl: `http://${config.daemon.bind}:${config.daemon.port}`
+    },
+    relay: { url: config.relay.url, enabled: config.relay.enabled },
+    gatewayToken: token,
+    configPath: ctx.paths.config,
+    hint: "在手机 App 中填入上面的地址与 token；公网部署请用 cloudflared / tailscale serve 反代到 localUrl"
+  };
+}
+async function configInit(ctx, _args, opts) {
+  if (configExists(ctx.paths) && !opts.force) {
+    throw new YoooclawError("YOOOCLAW_ALREADY_EXISTS", `profile \`${ctx.profile}\` 已初始化`, { hint: "加 --force 覆盖，或换一个 --profile", checkedPaths: [ctx.paths.config] });
+  }
+  ensureDir(ctx.paths.dir);
+  let config = defaultConfig(ctx.paths.credentials);
+  if (opts.nonInteractive || !isInteractive()) {
+    if (!opts.fromFile) {
+      throw new YoooclawError("YOOOCLAW_NOT_INTERACTIVE", "非交互模式必须提供 --from-file <config.json>（- 为 stdin）");
+    }
+    const raw = opts.fromFile === "-" ? await readStdin() : undefined;
+    const imported = raw ? JSON.parse(raw) : readJsonFile(opts.fromFile);
+    if (!imported) {
+      throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", `无法读取配置文件：${opts.fromFile}`);
+    }
+    config = deepMerge(config, imported);
+    config.version = defaultConfig(ctx.paths.credentials).version;
+  } else {
+    config.daemon.bind = await ask("daemon 监听地址", config.daemon.bind);
+    config.daemon.port = Number(await ask("daemon 监听端口", String(config.daemon.port)));
+    config.relay.url = await ask("Relay 地址", config.relay.url);
+    config.relay.enabled = await confirm("启用 Relay 隧道？", config.relay.enabled);
+    const enableEval = await confirm("启用灯效 webhook 评估器？", false);
+    if (enableEval) {
+      const evaluator = defaultEvaluator(ctx.paths.credentials);
+      evaluator.webhookUrl = await ask("评估器 webhook URL");
+      config.lightRules.evaluator = evaluator;
+    }
+  }
+  const token = generateToken();
+  saveConfig(ctx.paths, config);
+  writeGatewayToken(config, token);
+  return phoneSummary(ctx, config, token);
+}
+async function configShow(ctx, _args, opts) {
+  if (!configExists(ctx.paths)) {
+    throw new YoooclawError("YOOOCLAW_CONFIG_INVALID", `profile \`${ctx.profile}\` 尚未初始化`, { hint: "先运行 yoooclaw config init", checkedPaths: [ctx.paths.config] });
+  }
+  const config = loadConfig(ctx.paths);
+  if (opts.showSecrets) {
+    if (!isInteractive()) {
+      throw new YoooclawError("YOOOCLAW_NOT_INTERACTIVE", "--show-secrets 需要在 TTY 中运行");
+    }
+    if (!await confirm("确认明文输出敏感字段？", false)) {
+      throw new YoooclawError("YOOOCLAW_CONFIRMATION_REQUIRED", "已取消");
+    }
+    return config;
+  }
+  return maskConfig(config);
+}
+function configSet(ctx, args, _opts) {
+  const [key, value] = args;
+  if (key === "version") {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "version 字段不可修改");
+  }
+  const config = loadConfig(ctx.paths);
+  setByPath(config, key, coerceConfigValue(key, value));
+  saveConfig(ctx.paths, config);
+  return { ok: true, key, value: getByPath(config, key) };
+}
+function configUnset(ctx, args, _opts) {
+  const [key] = args;
+  const config = loadConfig(ctx.paths);
+  const removed = unsetByPath(config, key);
+  if (removed)
+    saveConfig(ctx.paths, config);
+  return { ok: true, key, removed };
+}
+
+// src/commands/profile.ts
+var import_node_fs6 = require("node:fs");
+function profileList(ctx) {
+  const active = readActiveProfile() ?? DEFAULT_PROFILE;
+  const names = listProfileNames();
+  for (const implied of [active, DEFAULT_PROFILE]) {
+    if (!names.includes(implied))
+      names.push(implied);
+  }
+  return names.sort((a, b) => a.localeCompare(b)).map((name) => ({
+    name,
+    active: name === active,
+    initialized: configExists(profilePaths(name))
+  }));
+}
+function profileUse(_ctx, args) {
+  const [name] = args;
+  const paths = profilePaths(name);
+  if (!import_node_fs6.existsSync(paths.dir)) {
+    throw new YoooclawError("YOOOCLAW_PROFILE_NOT_FOUND", `profile \`${name}\` 不存在`, { hint: "用 yoooclaw profile create 新建", checkedPaths: [paths.dir] });
+  }
+  writeFileAtomic(activeProfilePath(), `${name}
+`);
+  return { ok: true, active: name };
+}
+async function profileCreate(ctx, args, opts) {
+  const [name] = args;
+  const paths = profilePaths(name);
+  if (configExists(paths)) {
+    throw new YoooclawError("YOOOCLAW_ALREADY_EXISTS", `profile \`${name}\` 已存在`);
+  }
+  const subCtx = { ...ctx, profile: name, paths };
+  return configInit(subCtx, [], opts);
+}
+async function profileDelete(ctx, args, opts) {
+  const [name] = args;
+  const active = readActiveProfile() ?? DEFAULT_PROFILE;
+  if (name === active) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", `不能删除当前 active profile \`${name}\``, { hint: "先 yoooclaw profile use <其他 profile> 再删除" });
+  }
+  const paths = profilePaths(name);
+  if (!import_node_fs6.existsSync(paths.dir)) {
+    throw new YoooclawError("YOOOCLAW_PROFILE_NOT_FOUND", `profile \`${name}\` 不存在`);
+  }
+  if (!opts.yes && !await confirm(`确认删除 profile \`${name}\` 及其全部数据？`, false)) {
+    throw new YoooclawError("YOOOCLAW_CONFIRMATION_REQUIRED", "已取消");
+  }
+  import_node_fs6.rmSync(paths.dir, { recursive: true, force: true });
+  return { ok: true, deleted: name };
+}
+
+// src/daemon/lock.ts
+var import_node_fs7 = require("node:fs");
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function readLock(paths) {
+  if (!import_node_fs7.existsSync(paths.daemonLock))
+    return;
+  return readJsonFile(paths.daemonLock);
+}
+function daemonState(paths) {
+  const lock = readLock(paths);
+  if (!lock)
+    return { running: false, stale: false };
+  const alive = isProcessAlive(lock.pid);
+  return { running: alive, lock, stale: !alive };
+}
+function writeLock(paths, lock) {
+  writeJsonFile(paths.daemonLock, lock);
+}
+function removeLock(paths) {
+  import_node_fs7.rmSync(paths.daemonLock, { force: true });
+}
+
+// src/daemon/client.ts
+class DaemonClient {
+  paths;
+  baseUrl;
+  token;
+  timeoutMs;
+  constructor(paths, opts = {}) {
+    this.paths = paths;
+    const config = loadConfig(paths);
+    const state = daemonState(paths);
+    const bind = state.lock?.bind ?? config.daemon.bind;
+    const host = bind === "0.0.0.0" ? "127.0.0.1" : bind;
+    const port = state.lock?.port ?? config.daemon.port;
+    this.baseUrl = opts.baseUrl ?? `http://${host}:${port}`;
+    this.token = resolveGatewayToken(config).value;
+    this.timeoutMs = opts.timeoutMs ?? 1e4;
+  }
+  async request(method, path, body, extraHeaders) {
+    const headers = { ...extraHeaders };
+    if (this.token)
+      headers["Authorization"] = `Bearer ${this.token}`;
+    let payload;
+    if (body !== undefined) {
+      headers["Content-Type"] ??= "application/json";
+      payload = typeof body === "string" ? body : JSON.stringify(body);
+    }
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let res;
     try {
-      ctx = buildContext(globals);
-      const result = await handler(ctx, positionals, opts);
-      renderResult(result, { format: ctx.format });
+      res = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers,
+        body: payload,
+        signal: controller.signal
+      });
     } catch (err) {
-      const format = ctx?.format ?? "json";
-      renderError(err, { format });
-      process.exitCode = err instanceof YoooclawError ? err.exitCode : 1;
+      const code = err.code;
+      if (code === "ECONNREFUSED" || err.name === "AbortError") {
+        throw new YoooclawError("YOOOCLAW_DAEMON_NOT_RUNNING", "daemon 未启动或无响应", { hint: "先执行 yoooclaw daemon start", baseUrl: this.baseUrl });
+      }
+      throw new YoooclawError("YOOOCLAW_NETWORK_ERROR", `调用 daemon 失败：${err.message}`);
+    } finally {
+      clearTimeout(timer);
     }
-  };
+    const text = await res.text();
+    let parsed = text;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {}
+    }
+    if (res.status === 401 || res.status === 403) {
+      throw new YoooclawError("YOOOCLAW_UNAUTHORIZED", "daemon 拒绝鉴权（token 不一致）", {
+        status: res.status
+      });
+    }
+    return { status: res.status, body: parsed };
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
 }
-function stubHandler(commandPath) {
-  return () => {
-    throw notImplemented(commandPath);
+function assertDaemonRunning(paths) {
+  const state = daemonState(paths);
+  if (!state.running) {
+    throw new YoooclawError("YOOOCLAW_DAEMON_NOT_RUNNING", "daemon 未运行", { hint: "先执行 yoooclaw daemon start", stale: state.stale });
+  }
+}
+
+// src/commands/auth.ts
+function mask(value) {
+  if (!value)
+    return;
+  if (value.length <= 8)
+    return "***";
+  return `${value.slice(0, 4)}***${value.slice(-4)}`;
+}
+async function authSetApiKey(ctx, args, opts) {
+  let [key] = args;
+  if (key === "-") {
+    key = (await readStdin()).trim();
+  }
+  if (!key) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "api-key 不能为空");
+  }
+  const result = setApiKey(key, Boolean(opts.keychain));
+  return {
+    ok: true,
+    source: result.source,
+    location: result.location,
+    masked: mask(result.value),
+    hint: "插件 / CLI / daemon 共用同一份；daemon 在跑时会经文件 watch 热生效"
   };
 }
-function attachService(program, spec) {
-  const service = program.command(spec.name).description(spec.summary);
-  if (!spec.subcommands || spec.subcommands.length === 0) {
-    if (spec.args) {
-      service.arguments(spec.args);
+function authStatus(ctx) {
+  const apiKey = resolveApiKey();
+  const config = configExists(ctx.paths) ? loadConfig(ctx.paths) : undefined;
+  const token = config ? resolveGatewayToken(config) : undefined;
+  const state = daemonState(ctx.paths);
+  return {
+    ok: true,
+    profile: ctx.profile,
+    apiKey: {
+      present: Boolean(apiKey.value),
+      source: apiKey.source,
+      location: apiKey.location,
+      masked: mask(apiKey.value)
+    },
+    gatewayToken: {
+      present: Boolean(token?.value),
+      source: token?.source,
+      location: token?.location,
+      masked: mask(token?.value)
+    },
+    daemon: {
+      running: state.running,
+      pid: state.lock?.pid,
+      stale: state.stale
     }
-    service.action(wrapAction(stubHandler(spec.name)));
+  };
+}
+function authTokenRotate(ctx, _args, opts) {
+  if (!configExists(ctx.paths)) {
+    throw new YoooclawError("YOOOCLAW_CONFIG_INVALID", `profile \`${ctx.profile}\` 尚未初始化`, {
+      hint: "先运行 yoooclaw config init"
+    });
+  }
+  const config = loadConfig(ctx.paths);
+  const bytes = opts.length ? Number(opts.length) : 32;
+  if (!Number.isInteger(bytes) || bytes < 16) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "--length 至少 16 字节");
+  }
+  const token = generateToken(bytes);
+  const written = writeGatewayToken(config, token);
+  const state = daemonState(ctx.paths);
+  let hotReload;
+  if (state.running) {
+    hotReload = "daemon 在运行：请执行 yoooclaw daemon restart 使新 token 生效";
   } else {
-    for (const sub of spec.subcommands) {
-      const path = `${spec.name} ${sub.name}`;
-      service.command(sub.name).description(sub.summary).action(wrapAction(stubHandler(path)));
+    hotReload = "daemon 未运行：下次启动即用新 token";
+  }
+  return {
+    ok: true,
+    token,
+    source: written.source,
+    location: written.location,
+    hint: hotReload
+  };
+}
+async function authCheck(ctx) {
+  assertDaemonRunning(ctx.paths);
+  const client = new DaemonClient(ctx.paths);
+  const res = await client.get("/daemon/status");
+  return {
+    ok: res.status >= 200 && res.status < 300,
+    profile: ctx.profile,
+    daemonReachable: true,
+    status: res.status,
+    daemon: res.body
+  };
+}
+
+// src/notification/query.ts
+var import_node_fs11 = require("node:fs");
+
+// ../phone-notifications/src/cli/helpers.ts
+var import_node_fs8 = require("node:fs");
+var import_promises2 = require("node:fs/promises");
+var import_node_path4 = require("node:path");
+function today() {
+  return formatDate(new Date);
+}
+function formatDate(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function daysAgo(n) {
+  const d = new Date;
+  d.setDate(d.getDate() - n);
+  return formatDate(d);
+}
+function sortNotificationsByTimestampDesc(items) {
+  return items.sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
+}
+var APP_ALIAS_GROUPS = [
+  ["微信", "wechat", "weixin", "com.tencent.mm", "com.tencent.xin"],
+  ["企业微信", "wecom", "wxwork", "com.tencent.wework"],
+  ["飞书", "feishu", "lark", "com.ss.android.lark", "com.bytedance.ee.lark", "com.larksuite.suite"],
+  ["钉钉", "dingtalk", "com.alibaba.android.rimet"],
+  ["qq", "腾讯qq", "com.tencent.mobileqq"]
+];
+function normalizeLookupText(value) {
+  return value.trim().toLowerCase();
+}
+function appAliasGroup(value) {
+  const normalized = normalizeLookupText(value);
+  if (!normalized)
+    return null;
+  return APP_ALIAS_GROUPS.find((group) => group.some((candidate) => normalizeLookupText(candidate) === normalized)) ?? null;
+}
+function matchesNotificationAppFilter(item, app) {
+  const filter = normalizeLookupText(app);
+  if (!filter)
+    return true;
+  const candidates = [item.appName, item.appDisplayName].filter((value) => typeof value === "string" && value.length > 0);
+  if (candidates.some((candidate) => normalizeLookupText(candidate) === filter)) {
+    return true;
+  }
+  const filterGroup = appAliasGroup(app);
+  if (!filterGroup)
+    return false;
+  return candidates.some((candidate) => appAliasGroup(candidate) === filterGroup);
+}
+async function listDateKeysAsync(dir) {
+  const pattern = /^(\d{4}-\d{2}-\d{2})\.json$/;
+  const keys = [];
+  const entries = await import_promises2.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile())
+      continue;
+    const m = pattern.exec(entry.name);
+    if (m)
+      keys.push(m[1]);
+  }
+  return keys.sort().reverse();
+}
+async function readDateFileAsync(dir, dateKey) {
+  const filePath = import_node_path4.join(dir, `${dateKey}.json`);
+  if (!import_node_fs8.existsSync(filePath))
+    return [];
+  try {
+    const content = await import_promises2.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+function readRecordingIndex(dir) {
+  const indexPath = import_node_path4.join(dir, "index.json");
+  if (!import_node_fs8.existsSync(indexPath))
+    return [];
+  try {
+    const raw = JSON.parse(import_node_fs8.readFileSync(indexPath, "utf-8"));
+    return Array.isArray(raw?.recordings) ? raw.recordings : [];
+  } catch {
+    return [];
+  }
+}
+
+// ../phone-notifications/src/cli/ntf-query.ts
+function matchesNotificationQuery(item, opts) {
+  if (opts.app && !matchesNotificationAppFilter(item, opts.app))
+    return false;
+  if (opts.conversationType && item.conversationType !== opts.conversationType) {
+    return false;
+  }
+  const senderHaystack = [item.senderName, item.title].filter((value) => typeof value === "string" && value.length > 0).join(`
+`);
+  if (opts.sender && !senderHaystack.includes(opts.sender))
+    return false;
+  const keywordHaystack = [
+    item.title,
+    item.content,
+    item.senderName,
+    item.conversationName
+  ].filter((value) => typeof value === "string" && value.length > 0).join(`
+`);
+  if (opts.keyword && !keywordHaystack.includes(opts.keyword))
+    return false;
+  const itemTs = Date.parse(item.timestamp);
+  if (Number.isNaN(itemTs))
+    return false;
+  if (opts.fromTs !== null && itemTs < opts.fromTs)
+    return false;
+  if (opts.toTs !== null && itemTs > opts.toTs)
+    return false;
+  return true;
+}
+async function collectMatchingNotifications(dir, opts) {
+  const keys = await listDateKeysAsync(dir);
+  const results = [];
+  const canStopAfterLimit = opts.fromTs === null && opts.toTs === null;
+  for (const dateKey of keys) {
+    if (opts.fromDateKey && dateKey < opts.fromDateKey)
+      continue;
+    if (opts.toDateKey && dateKey > opts.toDateKey)
+      continue;
+    const items = sortNotificationsByTimestampDesc([
+      ...await readDateFileAsync(dir, dateKey)
+    ]);
+    for (const item of items) {
+      if (!matchesNotificationQuery(item, opts))
+        continue;
+      results.push(item);
+      if (canStopAfterLimit && results.length >= opts.limit) {
+        return results;
+      }
     }
   }
-  for (const shortcut of spec.shortcuts ?? []) {
-    const path = `${spec.name} ${shortcut.name}`;
-    service.command(shortcut.name).description(shortcut.summary).action(wrapAction(stubHandler(path)));
+  return sortNotificationsByTimestampDesc(results).slice(0, opts.limit);
+}
+// ../phone-notifications/src/notification/storage.ts
+var import_node_fs9 = require("node:fs");
+var import_node_crypto2 = require("node:crypto");
+var import_node_path5 = require("node:path");
+
+// ../phone-notifications/src/notification/feishu-normalize.ts
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+function isFeishuApp(appName) {
+  const normalized = appName.trim().toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+  return normalized === "飞书" || normalized === "feishu" || normalized === "lark" || normalized === "com.ss.android.lark" || normalized === "com.bytedance.ee.lark" || normalized === "com.larksuite.suite" || normalized.includes("feishu") || normalized.includes("lark") || normalized.includes("飞书");
+}
+function isFeishuAppLabel(text) {
+  const t = text.trim().toLowerCase();
+  return t === "飞书" || t === "lark" || t === "feishu";
+}
+function extractColonSender(body) {
+  if (!body)
+    return;
+  const candidates = [body.indexOf(":"), body.indexOf("：")].filter((i) => i > 0);
+  if (candidates.length === 0)
+    return;
+  const idx = Math.min(...candidates);
+  const senderName = body.slice(0, idx).trim();
+  return senderName || undefined;
+}
+function findMetadataTextByKey(value, targetKey, depth = 0) {
+  if (!value || typeof value !== "object" || depth > 4) {
+    return { found: false };
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const match = findMetadataTextByKey(item, targetKey, depth + 1);
+      if (match.found) {
+        return match;
+      }
+    }
+    return { found: false };
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (key.trim().toLowerCase() === targetKey) {
+      return { found: true, value: normalizeOptionalText(child) };
+    }
+  }
+  for (const child of Object.values(value)) {
+    const match = findMetadataTextByKey(child, targetKey, depth + 1);
+    if (match.found) {
+      return match;
+    }
+  }
+  return { found: false };
+}
+function deriveStructured(n) {
+  const subtitle = findMetadataTextByKey(n.metadata, "subtitle");
+  if (subtitle.found) {
+    const senderName = normalizeOptionalText(n.title);
+    const structured = {
+      conversationType: subtitle.value ? "group" : "private"
+    };
+    if (senderName) {
+      structured.senderName = senderName;
+    }
+    if (subtitle.value) {
+      structured.conversationName = subtitle.value;
+    }
+    return structured;
+  }
+  const rawTitle = typeof n.title === "string" ? n.title : "";
+  if (isFeishuAppLabel(rawTitle)) {
+    const senderName = extractColonSender(n.body ?? "");
+    if (senderName) {
+      return {
+        senderName,
+        conversationType: "private"
+      };
+    }
   }
+  return {};
+}
+function buildTitle(n, structured) {
+  if (structured.conversationType === "group" && structured.conversationName) {
+    return structured.conversationName;
+  }
+  if (structured.conversationType === "private" && structured.senderName) {
+    return structured.senderName;
+  }
+  return typeof n.title === "string" ? n.title : "";
+}
+function buildContent(n, structured) {
+  const body = n.body?.trim();
+  if (structured.conversationType === "group" && structured.senderName && body) {
+    const half = `${structured.senderName}:`;
+    const full = `${structured.senderName}：`;
+    return body.startsWith(half) || body.startsWith(full) ? body : `${structured.senderName}: ${body}`;
+  }
+  if (structured.conversationType === "private" && structured.senderName && body) {
+    const half = `${structured.senderName}:`;
+    const full = `${structured.senderName}：`;
+    if (body.startsWith(half))
+      return body.slice(half.length).trimStart();
+    if (body.startsWith(full))
+      return body.slice(full.length).trimStart();
+    return body;
+  }
+  return body ?? "";
+}
+function normalizeFeishuFields(n) {
+  const appName = typeof n.app === "string" ? n.app : "";
+  if (!isFeishuApp(appName)) {
+    return;
+  }
+  const structured = deriveStructured(n);
+  if (structured.senderName === undefined && structured.conversationType === undefined && structured.conversationName === undefined) {
+    return;
+  }
+  return {
+    title: buildTitle(n, structured),
+    content: buildContent(n, structured),
+    structured
+  };
+}
+
+// ../phone-notifications/src/notification/storage.ts
+var ID_INDEX_DIR_NAME = ".ids";
+var CONTENT_KEY_INDEX_DIR_NAME = ".keys";
+function computeLagMs(timestamp) {
+  if (!timestamp)
+    return null;
+  const t = new Date(timestamp).getTime();
+  if (Number.isNaN(t))
+    return null;
+  return Date.now() - t;
+}
+function buildFallbackContent(n) {
+  const body = n.body?.trim();
+  if (body) {
+    return body;
+  }
+  const fallback = [];
+  if (n.category) {
+    fallback.push(`category:${n.category}`);
+  }
+  if (n.metadata && Object.keys(n.metadata).length > 0) {
+    fallback.push(`metadata:${JSON.stringify(n.metadata)}`);
+  }
+  return fallback.join(" ; ") || "-";
+}
+class NotificationStorage {
+  config;
+  logger;
+  dir;
+  idIndexDir;
+  contentKeyIndexDir;
+  idCache = new Map;
+  contentKeyCache = new Map;
+  dateWriteChains = new Map;
+  resolveDisplayName;
+  constructor(dir, config, logger, resolveDisplayName) {
+    this.config = config;
+    this.logger = logger;
+    this.dir = dir;
+    this.idIndexDir = import_node_path5.join(dir, ID_INDEX_DIR_NAME);
+    this.contentKeyIndexDir = import_node_path5.join(dir, CONTENT_KEY_INDEX_DIR_NAME);
+    this.resolveDisplayName = resolveDisplayName;
+  }
+  async init() {
+    import_node_fs9.mkdirSync(this.dir, { recursive: true });
+    import_node_fs9.mkdirSync(this.idIndexDir, { recursive: true });
+    import_node_fs9.rmSync(this.contentKeyIndexDir, { recursive: true, force: true });
+    import_node_fs9.mkdirSync(this.contentKeyIndexDir, { recursive: true });
+  }
+  async ingest(items, ingestId) {
+    const result = {
+      received: items.length,
+      ingested: 0,
+      dedupedById: 0,
+      dedupedByContent: 0,
+      invalid: 0,
+      inserted: []
+    };
+    const traceTag = ingestId ? `[${ingestId}]` : "";
+    for (const n of items) {
+      const outcome = await this.writeNotification(n);
+      const lagMs = computeLagMs(n.timestamp);
+      const lagPart = lagMs === null ? "lag=?" : `lag=${lagMs}ms`;
+      this.logger.info(`ingest${traceTag}: app=${n.app ?? "Unknown"} id=${n.id ?? "-"} ts=${n.timestamp} ${lagPart} outcome=${outcome.kind}`);
+      switch (outcome.kind) {
+        case "ingested":
+          result.ingested += 1;
+          result.inserted.push(outcome.entry);
+          break;
+        case "dedupedById":
+          result.dedupedById += 1;
+          break;
+        case "dedupedByContent":
+          result.dedupedByContent += 1;
+          break;
+        case "invalid":
+          result.invalid += 1;
+          break;
+      }
+    }
+    this.prune();
+    return result;
+  }
+  async writeNotification(n) {
+    const ts = new Date(n.timestamp);
+    if (Number.isNaN(ts.getTime())) {
+      this.logger.warn(`忽略非法 timestamp 的通知: ${n.id}`);
+      return { kind: "invalid" };
+    }
+    const dateKey = this.formatDate(ts);
+    const filePath = import_node_path5.join(this.dir, `${dateKey}.json`);
+    const normalizedId = typeof n.id === "string" ? n.id.trim() : "";
+    const entry = this.buildStoredNotification(n);
+    return this.withDateWriteLock(dateKey, async () => {
+      if (normalizedId && this.hasNotificationId(dateKey, normalizedId)) {
+        return { kind: "dedupedById" };
+      }
+      if (this.hasNotificationContentKey(dateKey, filePath, entry)) {
+        return { kind: "dedupedByContent" };
+      }
+      const appDisplayName = this.resolveDisplayName ? await this.resolveDisplayName(entry.appName) : entry.appName;
+      const storedEntry = {
+        ...entry,
+        appDisplayName
+      };
+      const arr = this.readStoredNotifications(filePath);
+      arr.push(storedEntry);
+      import_node_fs9.writeFileSync(filePath, JSON.stringify(arr, null, 2), "utf-8");
+      if (normalizedId) {
+        this.recordNotificationId(dateKey, normalizedId);
+      }
+      this.recordNotificationContentKey(dateKey, filePath, storedEntry);
+      return { kind: "ingested", entry: storedEntry };
+    });
+  }
+  buildStoredNotification(n) {
+    const appName = typeof n.app === "string" && n.app ? n.app : "Unknown";
+    const feishu = normalizeFeishuFields(n);
+    if (feishu) {
+      return {
+        appName,
+        title: feishu.title,
+        content: feishu.content || buildFallbackContent(n),
+        timestamp: n.timestamp,
+        ...feishu.structured
+      };
+    }
+    return {
+      appName,
+      title: typeof n.title === "string" ? n.title : "",
+      content: buildFallbackContent(n),
+      timestamp: n.timestamp
+    };
+  }
+  formatDate(d) {
+    const year = d.getFullYear();
+    const month = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+  }
+  getIdIndexPath(dateKey) {
+    return import_node_path5.join(this.idIndexDir, `${dateKey}.ids`);
+  }
+  getIdSet(dateKey) {
+    const cached = this.idCache.get(dateKey);
+    if (cached) {
+      return cached;
+    }
+    const idPath = this.getIdIndexPath(dateKey);
+    const ids = new Set;
+    if (import_node_fs9.existsSync(idPath)) {
+      const lines = import_node_fs9.readFileSync(idPath, "utf-8").split(/\r?\n/);
+      for (const line of lines) {
+        const id = line.trim();
+        if (id) {
+          ids.add(id);
+        }
+      }
+    }
+    this.idCache.set(dateKey, ids);
+    return ids;
+  }
+  hasNotificationId(dateKey, id) {
+    return this.getIdSet(dateKey).has(id);
+  }
+  getContentKeyIndexPath(dateKey) {
+    return import_node_path5.join(this.contentKeyIndexDir, `${dateKey}.keys`);
+  }
+  getContentKeySet(dateKey, filePath) {
+    const cached = this.contentKeyCache.get(dateKey);
+    if (cached) {
+      return cached;
+    }
+    const keyPath = this.getContentKeyIndexPath(dateKey);
+    const keys = new Set;
+    if (import_node_fs9.existsSync(filePath)) {
+      for (const item of this.readStoredNotifications(filePath)) {
+        keys.add(this.buildNotificationContentKey(item));
+      }
+    }
+    if (keys.size > 0) {
+      import_node_fs9.writeFileSync(keyPath, `${Array.from(keys).join(`
+`)}
+`, "utf-8");
+    } else if (import_node_fs9.existsSync(keyPath)) {
+      import_node_fs9.rmSync(keyPath, { force: true });
+    }
+    this.contentKeyCache.set(dateKey, keys);
+    return keys;
+  }
+  hasNotificationContentKey(dateKey, filePath, entry) {
+    return this.getContentKeySet(dateKey, filePath).has(this.buildNotificationContentKey(entry));
+  }
+  recordNotificationId(dateKey, id) {
+    const ids = this.getIdSet(dateKey);
+    if (ids.has(id)) {
+      return;
+    }
+    import_node_fs9.appendFileSync(this.getIdIndexPath(dateKey), `${id}
+`, "utf-8");
+    ids.add(id);
+  }
+  recordNotificationContentKey(dateKey, filePath, entry) {
+    const keys = this.getContentKeySet(dateKey, filePath);
+    const key = this.buildNotificationContentKey(entry);
+    if (keys.has(key)) {
+      return;
+    }
+    import_node_fs9.appendFileSync(this.getContentKeyIndexPath(dateKey), `${key}
+`, "utf-8");
+    keys.add(key);
+  }
+  buildNotificationContentKey(entry) {
+    return import_node_crypto2.createHash("sha256").update(entry.appName).update("\x1F").update(entry.title).update("\x1F").update(entry.content).update("\x1F").update(entry.timestamp).digest("hex");
+  }
+  readStoredNotifications(filePath) {
+    if (!import_node_fs9.existsSync(filePath)) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(import_node_fs9.readFileSync(filePath, "utf-8"));
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async withDateWriteLock(dateKey, task) {
+    const previous = this.dateWriteChains.get(dateKey) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    const chain = previous.then(() => current);
+    this.dateWriteChains.set(dateKey, chain);
+    await previous;
+    try {
+      return await task();
+    } finally {
+      release();
+      if (this.dateWriteChains.get(dateKey) === chain) {
+        this.dateWriteChains.delete(dateKey);
+      }
+    }
+  }
+  prune() {
+    const retentionDays = this.config.retentionDays;
+    if (retentionDays === undefined) {
+      return;
+    }
+    const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+    const cutoffDate = this.formatDate(new Date(cutoffMs));
+    this.pruneDataFiles(cutoffDate);
+    this.pruneIdIndex(cutoffDate);
+    this.pruneContentKeyIndex(cutoffDate);
+  }
+  pruneDataFiles(cutoffDate) {
+    const dateFilePattern = /^(\d{4}-\d{2}-\d{2})\.(json|md)$/;
+    const dateDirPattern = /^\d{4}-\d{2}-\d{2}$/;
+    try {
+      for (const entry of import_node_fs9.readdirSync(this.dir, { withFileTypes: true })) {
+        if (entry.isFile()) {
+          const match = dateFilePattern.exec(entry.name);
+          if (match && match[1] < cutoffDate) {
+            import_node_fs9.rmSync(import_node_path5.join(this.dir, entry.name), { force: true });
+          }
+        } else if (entry.isDirectory() && dateDirPattern.test(entry.name) && entry.name < cutoffDate) {
+          import_node_fs9.rmSync(import_node_path5.join(this.dir, entry.name), { recursive: true, force: true });
+        }
+      }
+    } catch {}
+  }
+  pruneIdIndex(cutoffDate) {
+    try {
+      for (const entry of import_node_fs9.readdirSync(this.idIndexDir, { withFileTypes: true })) {
+        if (!entry.isFile())
+          continue;
+        const match = /^(\d{4}-\d{2}-\d{2})\.ids$/.exec(entry.name);
+        if (match && match[1] < cutoffDate) {
+          import_node_fs9.rmSync(import_node_path5.join(this.idIndexDir, entry.name), { force: true });
+          this.idCache.delete(match[1]);
+        }
+      }
+    } catch {}
+  }
+  pruneContentKeyIndex(cutoffDate) {
+    try {
+      for (const entry of import_node_fs9.readdirSync(this.contentKeyIndexDir, { withFileTypes: true })) {
+        if (!entry.isFile())
+          continue;
+        const match = /^(\d{4}-\d{2}-\d{2})\.keys$/.exec(entry.name);
+        if (match && match[1] < cutoffDate) {
+          import_node_fs9.rmSync(import_node_path5.join(this.contentKeyIndexDir, entry.name), { force: true });
+          this.contentKeyCache.delete(match[1]);
+        }
+      }
+    } catch {}
+  }
+  async close() {
+    this.idCache.clear();
+    this.contentKeyCache.clear();
+    this.dateWriteChains.clear();
+  }
+}
+// ../phone-notifications/src/plugin/notifications.ts
+var import_node_crypto3 = require("node:crypto");
+
+// ../phone-notifications/src/tunnel/http-proxy.ts
+var RELAY_INTERNAL_HTTP_HEADER = "x-openclaw-relay-internal";
+
+// ../phone-notifications/src/plugin/shared.ts
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+
+// ../phone-notifications/src/plugin/notifications.ts
+function newIngestId() {
+  return `ing_${import_node_crypto3.randomBytes(4).toString("hex")}`;
+}
+function summarizeIncomingBatch(items) {
+  const total = items.length;
+  if (total === 0)
+    return "items=0";
+  const now = Date.now();
+  let earliest = Number.POSITIVE_INFINITY;
+  let latest = Number.NEGATIVE_INFINITY;
+  for (const n of items) {
+    const t = new Date(n.timestamp).getTime();
+    if (Number.isNaN(t))
+      continue;
+    if (t < earliest)
+      earliest = t;
+    if (t > latest)
+      latest = t;
+  }
+  if (!Number.isFinite(earliest)) {
+    return `items=${total} (all ts invalid)`;
+  }
+  const maxLag = now - earliest;
+  const minLag = now - latest;
+  return `items=${total} earliestTs=${new Date(earliest).toISOString()} lag=${minLag}..${maxLag}ms`;
+}
+function createEmptyIngestResult() {
+  return {
+    received: 0,
+    ingested: 0,
+    dedupedById: 0,
+    dedupedByContent: 0,
+    invalid: 0,
+    inserted: []
+  };
+}
+function isRelayInternalHttpRequest(req) {
+  const header = req.headers?.[RELAY_INTERNAL_HTTP_HEADER];
+  if (Array.isArray(header)) {
+    return header.includes("1");
+  }
+  return header === "1";
+}
+function toIngestResponse(result) {
+  const { inserted: _inserted, ...rest } = result;
+  return rest;
+}
+function registerNotificationInterfaces(deps) {
+  const {
+    api,
+    logger,
+    getStorage,
+    filterNotifications,
+    registerGatewayMethod,
+    tunnelService,
+    onAfterIngest
+  } = deps;
+  function triggerAfterIngest(inserted, ingestId) {
+    if (inserted.length === 0 || !onAfterIngest)
+      return;
+    logger.info(`notifications[${ingestId}]: enqueue ${inserted.length} for light-rule evaluation`);
+    Promise.resolve().then(() => onAfterIngest(inserted, ingestId)).catch((err) => logger.warn(`notifications[${ingestId}]: onAfterIngest failed: ${err?.message ?? err}`));
+  }
+  registerGatewayMethod("notifications.push", async ({ params, respond }) => {
+    const storage = getStorage();
+    if (!storage) {
+      respond(false, null, {
+        code: "NOT_READY",
+        message: "Storage service not ready"
+      });
+      return;
+    }
+    const { items } = params;
+    if (!Array.isArray(items)) {
+      respond(false, null, {
+        code: "INVALID_PARAMS",
+        message: "items must be an array"
+      });
+      return;
+    }
+    const ingestId = newIngestId();
+    const startMs = Date.now();
+    logger.info(`notifications[${ingestId}]: gateway notifications.push received ${summarizeIncomingBatch(items)}`);
+    const filtered = filterNotifications(items);
+    if (filtered.length !== items.length) {
+      logger.info(`notifications[${ingestId}]: filtered ${items.length - filtered.length} ignored-app item(s), kept=${filtered.length}`);
+    }
+    const result = filtered.length ? await storage.ingest(filtered, ingestId) : createEmptyIngestResult();
+    logger.info(`notifications[${ingestId}]: ingest done in ${Date.now() - startMs}ms ` + `(received=${result.received} ingested=${result.ingested} ` + `dedupedById=${result.dedupedById} dedupedByContent=${result.dedupedByContent} invalid=${result.invalid})`);
+    respond(true, toIngestResponse(result));
+    triggerAfterIngest(result.inserted, ingestId);
+  });
+  api.registerHttpRoute({
+    path: "/notifications",
+    auth: "gateway",
+    async handler(req, res) {
+      if (req.method !== "POST") {
+        res.writeHead(405, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Method Not Allowed" }));
+        return;
+      }
+      if (!isRelayInternalHttpRequest(req)) {
+        await tunnelService?.deactivateForExternalTunnel("POST /notifications");
+      }
+      const storage = getStorage();
+      if (!storage) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Service Not Ready" }));
+        return;
+      }
+      let body;
+      try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Invalid JSON" }));
+        return;
+      }
+      if (!Array.isArray(body.notifications)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          ok: false,
+          error: "notifications must be an array"
+        }));
+        return;
+      }
+      const ingestId = newIngestId();
+      const startMs = Date.now();
+      logger.info(`notifications[${ingestId}]: HTTP POST /notifications received ${summarizeIncomingBatch(body.notifications)}`);
+      const filtered = filterNotifications(body.notifications);
+      if (filtered.length !== body.notifications.length) {
+        logger.info(`notifications[${ingestId}]: filtered ${body.notifications.length - filtered.length} ignored-app item(s), kept=${filtered.length}`);
+      }
+      const result = filtered.length ? await storage.ingest(filtered, ingestId) : createEmptyIngestResult();
+      logger.info(`notifications[${ingestId}]: ingest done in ${Date.now() - startMs}ms ` + `(received=${result.received} ingested=${result.ingested} ` + `dedupedById=${result.dedupedById} dedupedByContent=${result.dedupedByContent} invalid=${result.invalid})`);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, ...toIngestResponse(result) }));
+      triggerAfterIngest(result.inserted, ingestId);
+    }
+  });
+  logger.info("Gateway 通知方法已注册: notifications.push");
+  logger.info("HTTP 通知端点已注册: POST /notifications");
+}
+// ../phone-notifications/src/light-rules/storage.ts
+var import_node_fs10 = require("node:fs");
+var import_node_path6 = require("node:path");
+
+// ../phone-notifications/src/light/repeat.ts
+function normalizeRepeatTimes(input) {
+  if (typeof input === "boolean") {
+    return input ? 0 : 1;
+  }
+  if (typeof input === "number") {
+    return validateRepeatTimes(input);
+  }
+  if (!input) {
+    return 1;
+  }
+  if (input.repeat_times !== undefined) {
+    return validateRepeatTimes(input.repeat_times);
+  }
+  if (input.repeat !== undefined) {
+    return input.repeat ? 0 : 1;
+  }
+  return 1;
+}
+function assertAncsRepeatTimes(repeatTimes) {
+  if (repeatTimes !== 0 && repeatTimes !== 1) {
+    throw new Error("当前 ANCS 路径仅支持 repeat_times=0（无限循环）或 1（播放一轮）；N>=2 需非 ANCS 路径");
+  }
+}
+function validateRepeatTimes(value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error("repeat_times 必须是 >=0 的整数");
+  }
+  return value;
+}
+
+// ../phone-notifications/src/light-rules/storage.ts
+function resolveBaseDir(ctx) {
+  if (ctx.workspaceDir)
+    return ctx.workspaceDir;
+  if (ctx.stateDir) {
+    const inferredWorkspaceDir = import_node_path6.join(ctx.stateDir, "workspace");
+    if (import_node_fs10.existsSync(inferredWorkspaceDir))
+      return inferredWorkspaceDir;
+    return ctx.stateDir;
+  }
+  throw new Error("workspaceDir and stateDir both unavailable");
+}
+function tasksDir(ctx) {
+  return import_node_path6.join(resolveBaseDir(ctx), "tasks");
+}
+function normalizeLightRuleLookupName(name) {
+  return name.trim().replace(/\.json$/i, "");
+}
+function resolveLightRuleTask(ctx, name) {
+  const dir = tasksDir(ctx);
+  const normalizedName = normalizeLightRuleLookupName(name);
+  if (!normalizedName)
+    return null;
+  const directTaskDir = import_node_path6.join(dir, normalizedName);
+  const directMeta = readMeta(directTaskDir);
+  if (directMeta) {
+    return {
+      taskDir: directTaskDir,
+      meta: directMeta
+    };
+  }
+  if (!import_node_fs10.existsSync(dir))
+    return null;
+  for (const entry of import_node_fs10.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const taskDir = import_node_path6.join(dir, entry.name);
+    const meta = readMeta(taskDir);
+    if (meta?.name === normalizedName) {
+      return {
+        taskDir,
+        meta
+      };
+    }
+  }
+  return null;
+}
+function readOptionalString(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+function readMeta(taskDir) {
+  const metaPath = import_node_path6.join(taskDir, "meta.json");
+  if (!import_node_fs10.existsSync(metaPath))
+    return null;
+  try {
+    const raw = JSON.parse(import_node_fs10.readFileSync(metaPath, "utf-8"));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+      return null;
+    if (raw.type !== "light-rule")
+      return null;
+    if (!Array.isArray(raw.segments))
+      return null;
+    const name = readOptionalString(raw.name) ?? import_node_path6.basename(taskDir);
+    const title = readOptionalString(raw.title) ?? name;
+    const description = readOptionalString(raw.description) ?? name;
+    const createdAt = readOptionalString(raw.createdAt) ?? import_node_fs10.statSync(metaPath).birthtime.toISOString();
+    const enabled = typeof raw.enabled === "boolean" ? raw.enabled : true;
+    const repeatTimes = normalizeRepeatTimes({
+      repeat: raw.repeat,
+      repeat_times: raw.repeat_times
+    });
+    assertAncsRepeatTimes(repeatTimes);
+    return {
+      ...raw,
+      name,
+      title,
+      type: "light-rule",
+      description,
+      segments: raw.segments,
+      repeat_times: repeatTimes,
+      enabled,
+      createdAt
+    };
+  } catch {
+    return null;
+  }
+}
+function writeMeta(taskDir, meta) {
+  import_node_fs10.writeFileSync(import_node_path6.join(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+}
+function listLightRules(ctx) {
+  const dir = tasksDir(ctx);
+  if (!import_node_fs10.existsSync(dir))
+    return [];
+  const rules = [];
+  for (const entry of import_node_fs10.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const meta = readMeta(import_node_path6.join(dir, entry.name));
+    if (meta)
+      rules.push(meta);
+  }
+  return rules;
+}
+function createLightRule(ctx, params) {
+  const dir = tasksDir(ctx);
+  const taskDir = import_node_path6.join(dir, params.name);
+  if (import_node_fs10.existsSync(taskDir)) {
+    throw new LightRuleError("ALREADY_EXISTS", `灯效规则 '${params.name}' 已存在`);
+  }
+  import_node_fs10.mkdirSync(taskDir, { recursive: true });
+  const repeatTimes = normalizeRepeatTimes({
+    repeat: params.repeat,
+    repeat_times: params.repeat_times
+  });
+  assertAncsRepeatTimes(repeatTimes);
+  const meta = {
+    name: params.name,
+    title: params.title,
+    type: "light-rule",
+    description: params.description,
+    segments: params.segments,
+    repeat_times: repeatTimes,
+    enabled: true,
+    createdAt: new Date().toISOString()
+  };
+  writeMeta(taskDir, meta);
+  return { meta };
+}
+function updateLightRule(ctx, params) {
+  const resolved = resolveLightRuleTask(ctx, params.name);
+  const taskDir = resolved?.taskDir;
+  const meta = resolved?.meta;
+  if (!taskDir || !meta) {
+    throw new LightRuleError("NOT_FOUND", `灯效规则 '${params.name}' 不存在`);
+  }
+  if (params.description !== undefined) {
+    meta.description = params.description;
+  }
+  if (params.title !== undefined) {
+    meta.title = params.title;
+  }
+  if (params.segments !== undefined) {
+    meta.segments = params.segments;
+  }
+  if (params.repeat !== undefined || params.repeat_times !== undefined) {
+    meta.repeat_times = normalizeRepeatTimes({
+      repeat: params.repeat,
+      repeat_times: params.repeat_times
+    });
+    assertAncsRepeatTimes(meta.repeat_times);
+  }
+  if (params.enabled !== undefined) {
+    meta.enabled = params.enabled;
+  }
+  meta.updatedAt = new Date().toISOString();
+  writeMeta(taskDir, meta);
+  return { meta };
+}
+function deleteLightRule(ctx, name) {
+  const resolved = resolveLightRuleTask(ctx, name);
+  const taskDir = resolved?.taskDir;
+  const meta = resolved?.meta;
+  if (!taskDir || !meta) {
+    throw new LightRuleError("NOT_FOUND", `灯效规则 '${name}' 不存在`);
+  }
+  import_node_fs10.rmSync(taskDir, { recursive: true, force: true });
+  return { name: meta.name };
+}
+
+class LightRuleError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "LightRuleError";
+  }
+}
+
+// ../phone-notifications/src/light-rules/registry.ts
+class LightRuleRegistry {
+  ctx;
+  index = new Map;
+  writeChain = Promise.resolve();
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.reload();
+  }
+  reload() {
+    this.index.clear();
+    for (const meta of listLightRules(this.ctx)) {
+      this.index.set(meta.name, meta);
+    }
+  }
+  list() {
+    return Array.from(this.index.values());
+  }
+  getEnabled() {
+    return this.list().filter((rule) => rule.enabled);
+  }
+  get(name) {
+    return this.index.get(name) ?? null;
+  }
+  async create(params) {
+    return this.runExclusive(() => {
+      const result = createLightRule(this.ctx, params);
+      this.index.set(result.meta.name, result.meta);
+      return result;
+    });
+  }
+  async update(params) {
+    return this.runExclusive(() => {
+      const result = updateLightRule(this.ctx, params);
+      this.index.set(result.meta.name, result.meta);
+      return result;
+    });
+  }
+  async delete(name) {
+    return this.runExclusive(() => {
+      const result = deleteLightRule(this.ctx, name);
+      this.index.delete(result.name);
+      return result;
+    });
+  }
+  buildSystemPrompt() {
+    const enabled = this.getEnabled();
+    if (enabled.length === 0) {
+      return "当前没有启用任何灯效规则。";
+    }
+    const lines = [
+      '你是一个判断"通知 → 灯效规则"是否命中的助手。',
+      "",
+      "下面是用户当前启用的全部灯效规则（按创建时间倒序）：",
+      ""
+    ];
+    const sorted = [...enabled].sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
+    sorted.forEach((rule, idx) => {
+      lines.push(`[${idx + 1}] title: ${rule.title}`, `    name: ${rule.name}`, `    description: ${rule.description}`, "");
+    });
+    lines.push('任务：根据用户接下来发给你的"通知"内容，判断哪些规则被命中。', "- 命中 0 条：不调用任何工具，直接结束。", "- 命中 1 条或多条：对每一条命中的规则调用一次 trigger_light(rule_name)。", "- 不要回复任何自由文本；判定结果**只**通过 tool calling 表达。", '- 拿不准的时候倾向于"不触发"，避免骚扰用户。');
+    return lines.join(`
+`);
+  }
+  runExclusive(fn) {
+    const next = this.writeChain.then(() => fn(), () => fn());
+    this.writeChain = next.catch(() => {
+      return;
+    });
+    return next;
+  }
+}
+// ../phone-notifications/src/light/validators.ts
+var VALID_MODES = [
+  "wave",
+  "breath",
+  "strobe",
+  "steady",
+  "color_flow",
+  "pixel_frame"
+];
+var MAX_SEGMENTS = 12;
+function validateSegments(segments) {
+  if (!Array.isArray(segments)) {
+    return { valid: false, errors: [{ field: "segments", message: "必须是数组" }] };
+  }
+  if (segments.length === 0) {
+    return { valid: false, errors: [{ field: "segments", message: "不能为空" }] };
+  }
+  if (segments.length > MAX_SEGMENTS) {
+    return {
+      valid: false,
+      errors: [{ field: "segments", message: `最多 ${MAX_SEGMENTS} 段` }]
+    };
+  }
+  const errors = [];
+  const warnings = [];
+  for (let i = 0;i < segments.length; i++) {
+    validateSegment(segments[i], `segments[${i}]`, errors, warnings);
+  }
+  if (errors.length > 0)
+    return { valid: false, errors };
+  return { valid: true, segments, warnings };
+}
+function validateSegment(seg, prefix, errors, warnings) {
+  if (!isRecord(seg)) {
+    errors.push({ field: prefix, message: "必须是对象" });
+    return;
+  }
+  const mode = seg.mode;
+  if (!VALID_MODES.includes(mode)) {
+    errors.push({
+      field: `${prefix}.mode`,
+      message: `不支持的模式 '${String(mode)}'，可选：${VALID_MODES.join("/")}`
+    });
+  }
+  validateNonNegativeNumber(seg.duration_s, `${prefix}.duration_s`, errors, "必须是 ≥0 的数字（0 表示无限时长）");
+  switch (mode) {
+    case "wave":
+      validateForegroundSegment(seg, prefix, errors);
+      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
+      validateOptionalDirection(seg.direction, `${prefix}.direction`, errors);
+      validateOptionalWindow(seg.window, `${prefix}.window`, errors);
+      validateOptionalBackground(seg.background, `${prefix}.background`, errors);
+      break;
+    case "color_flow":
+      validateForegroundSegment(seg, prefix, errors);
+      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
+      validateOptionalDirection(seg.direction, `${prefix}.direction`, errors);
+      validateOptionalWindow(seg.window, `${prefix}.window`, errors);
+      validateOptionalBackground(seg.background, `${prefix}.background`, errors);
+      if (!hasNonZeroRgb(seg.color) && !hasNonZeroRgb(seg.background)) {
+        errors.push({
+          field: prefix,
+          message: "color_flow 至少需要一组非零颜色锚点（color 或 background）"
+        });
+      }
+      detectColorFlowSingleAnchorMisuse(seg, prefix, warnings);
+      break;
+    case "breath":
+      validateForegroundSegment(seg, prefix, errors);
+      validateOptionalBreathTiming(seg.breath_timing, `${prefix}.breath_timing`, errors);
+      break;
+    case "strobe":
+      validateForegroundSegment(seg, prefix, errors);
+      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
+      break;
+    case "steady":
+      validateForegroundSegment(seg, prefix, errors);
+      break;
+    case "pixel_frame":
+      validatePixelFrame(seg.pixels, `${prefix}.pixels`, errors);
+      break;
+    default:
+      validateOptionalNonNegativeNumber(seg.brightness, `${prefix}.brightness`, errors);
+      validateOptionalColor(seg.color, `${prefix}.color`, errors);
+      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
+      validateOptionalDirection(seg.direction, `${prefix}.direction`, errors);
+      validateOptionalWindow(seg.window, `${prefix}.window`, errors);
+      validateOptionalBreathTiming(seg.breath_timing, `${prefix}.breath_timing`, errors);
+      validateOptionalBackground(seg.background, `${prefix}.background`, errors);
+  }
+}
+function validateForegroundSegment(seg, prefix, errors) {
+  validateNumberInRange(seg.brightness, `${prefix}.brightness`, errors, 0, 255, "必须是 0–255 的数字");
+  validateColor(seg.color, `${prefix}.color`, errors);
+  if (seg.mode !== "steady" && seg.brightness === 0) {
+    errors.push({
+      field: `${prefix}.brightness`,
+      message: "brightness=0 仅 steady 模式允许；其它模式会在固件侧被过滤"
+    });
+  }
+}
+function validatePixelFrame(value, field, errors) {
+  if (!Array.isArray(value)) {
+    errors.push({ field, message: "pixel_frame 必须提供 pixels 数组（1–7 项）" });
+    return;
+  }
+  if (value.length < 1 || value.length > 7) {
+    errors.push({ field, message: "pixels 必须为 1–7 项" });
+  }
+  const seen = new Set;
+  for (let i = 0;i < value.length; i++) {
+    const pixel = value[i];
+    const prefix = `${field}[${i}]`;
+    if (!isRecord(pixel)) {
+      errors.push({ field: prefix, message: "必须是对象" });
+      continue;
+    }
+    const idx = pixel.index;
+    if (!Number.isInteger(idx) || idx < 0 || idx > 6) {
+      errors.push({ field: `${prefix}.index`, message: "index 必须是 0–6 的整数" });
+    } else if (seen.has(idx)) {
+      errors.push({ field: `${prefix}.index`, message: `index=${idx} 重复` });
+    } else {
+      seen.add(idx);
+    }
+    validateNumberInRange(pixel.brightness, `${prefix}.brightness`, errors, 0, 255, "必须是 0–255 的数字");
+    validateColor(pixel.color, `${prefix}.color`, errors);
+  }
+}
+function validateOptionalBreathTiming(value, field, errors) {
+  if (value === undefined)
+    return;
+  if (!isRecord(value)) {
+    errors.push({ field, message: "必须是对象" });
+    return;
+  }
+  validatePositiveNumber(value.rise_ms, `${field}.rise_ms`, errors, "rise_ms 必须是 >0 的数字（不支持 0ms）");
+  validateNonNegativeNumber(value.hold_ms, `${field}.hold_ms`, errors, "hold_ms 必须是 ≥0 的数字");
+  validatePositiveNumber(value.fall_ms, `${field}.fall_ms`, errors, "fall_ms 必须是 >0 的数字（不支持 0ms）");
+  validateNonNegativeNumber(value.off_ms, `${field}.off_ms`, errors, "off_ms 必须是 ≥0 的数字");
+}
+function validateOptionalBackground(value, field, errors) {
+  if (value === undefined)
+    return;
+  if (!isRecord(value)) {
+    errors.push({ field, message: "必须包含 r/g/b/brightness 数值" });
+    return;
+  }
+  validateColor(value, field, errors);
+  validateNumberInRange(value.brightness, `${field}.brightness`, errors, 0, 255, "必须是 0–255 的数字");
+}
+function validateOptionalColor(value, field, errors) {
+  if (value === undefined)
+    return;
+  validateColor(value, field, errors);
+}
+function validateColor(value, field, errors) {
+  if (!isRecord(value)) {
+    errors.push({ field, message: "必须包含 r/g/b 数值" });
+    return;
+  }
+  validateNumberInRange(value.r, `${field}.r`, errors, 0, 255, "必须是 0–255 的数字");
+  validateNumberInRange(value.g, `${field}.g`, errors, 0, 255, "必须是 0–255 的数字");
+  validateNumberInRange(value.b, `${field}.b`, errors, 0, 255, "必须是 0–255 的数字");
+}
+function validateOptionalDirection(value, field, errors) {
+  if (value === undefined)
+    return;
+  if (value !== "ltr" && value !== "rtl") {
+    errors.push({ field, message: "direction 必须是 ltr 或 rtl" });
+  }
+}
+function validateOptionalWindow(value, field, errors) {
+  if (value === undefined)
+    return;
+  if (value !== 1 && value !== 2 && value !== 3) {
+    errors.push({ field, message: "window 仅支持 1/2/3" });
+  }
+}
+function validateOptionalNonNegativeNumber(value, field, errors) {
+  if (value === undefined)
+    return;
+  validateNonNegativeNumber(value, field, errors, "必须是 ≥0 的数字");
+}
+function validatePositiveNumber(value, field, errors, message) {
+  if (value === undefined)
+    return;
+  if (!isFiniteNumber(value) || value <= 0) {
+    errors.push({ field, message });
+  }
+}
+function validateNonNegativeNumber(value, field, errors, message) {
+  if (!isFiniteNumber(value) || value < 0) {
+    errors.push({ field, message });
+  }
+}
+function validateNumberInRange(value, field, errors, min, max, message) {
+  if (!isFiniteNumber(value) || value < min || value > max) {
+    errors.push({ field, message });
+  }
+}
+function hasNonZeroRgb(value) {
+  if (!value)
+    return false;
+  return [value.r, value.g, value.b].some((channel) => isFiniteNumber(channel) && channel > 0);
+}
+function detectColorFlowSingleAnchorMisuse(seg, prefix, warnings) {
+  const color = seg.color;
+  const background = seg.background;
+  const fgChannels = extractChannels(color);
+  const bgChannels = extractChannels(background);
+  if (!fgChannels)
+    return;
+  const bgBrightnessRaw = background?.brightness;
+  const bgBrightness = isFiniteNumber(bgBrightnessRaw) ? bgBrightnessRaw : 0;
+  const bgActive = !!bgChannels && bgChannels.some((c) => c > 0) && bgBrightness > 0;
+  if (bgActive)
+    return;
+  const fgActiveChannels = fgChannels.filter((c) => c > 0);
+  if (fgActiveChannels.length !== 1)
+    return;
+  if (fgActiveChannels[0] < 192)
+    return;
+  warnings.push({
+    field: prefix,
+    code: "COLOR_FLOW_SINGLE_ANCHOR_MISUSE",
+    message: "color_flow 仅设置了单一极端纯色前景锚点（无有效底色锚点），实际效果是同色系亮暗环状流动，不是多色调色板流动。" + `若用户期望的是"单色波浪"，请改用 mode='wave'；若期望多色流动，请同时设置 background 作为第二锚点。`
+  });
+}
+function extractChannels(value) {
+  if (!value)
+    return null;
+  const r = isFiniteNumber(value.r) ? value.r : 0;
+  const g = isFiniteNumber(value.g) ? value.g : 0;
+  const b = isFiniteNumber(value.b) ? value.b : 0;
+  return [r, g, b];
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// ../phone-notifications/src/light-rules/names.ts
+var LIGHT_RULE_GATEWAY_METHODS = {
+  list: "lightrules.list",
+  create: "lightrules.create",
+  update: "lightrules.update",
+  delete: "lightrules.delete"
+};
+var LIGHT_RULE_GATEWAY_METHOD_LIST = [
+  LIGHT_RULE_GATEWAY_METHODS.list,
+  LIGHT_RULE_GATEWAY_METHODS.create,
+  LIGHT_RULE_GATEWAY_METHODS.update,
+  LIGHT_RULE_GATEWAY_METHODS.delete
+];
+var LIGHT_RULE_TOOL_NAMES = {
+  list: "lightrules_list",
+  create: "lightrules_create",
+  update: "lightrules_update",
+  delete: "lightrules_delete"
+};
+var LIGHT_RULE_TOOL_NAME_LIST = [
+  LIGHT_RULE_TOOL_NAMES.list,
+  LIGHT_RULE_TOOL_NAMES.create,
+  LIGHT_RULE_TOOL_NAMES.update,
+  LIGHT_RULE_TOOL_NAMES.delete
+];
+
+// ../phone-notifications/src/light-rules/gateway.ts
+function resolveRuleIdentifier(params) {
+  if (!params || typeof params !== "object")
+    return;
+  const raw = params;
+  const candidates = [raw.name, raw.id, raw.ruleId, raw.ruleName];
+  for (const candidate of candidates) {
+    if (typeof candidate !== "string")
+      continue;
+    const normalized = candidate.trim().replace(/\.json$/i, "");
+    if (normalized)
+      return normalized;
+  }
+  return;
+}
+function registerLightRulesGateway(api, registry, logger, rememberBroadcast) {
+  const registerGatewayMethodWithBroadcastCapture = (method, handler) => {
+    api.registerGatewayMethod(method, (opts) => {
+      rememberBroadcast?.(opts.context?.broadcast);
+      return handler(opts);
+    });
+  };
+  registerGatewayMethodWithBroadcastCapture(LIGHT_RULE_GATEWAY_METHODS.list, async ({ respond }) => {
+    try {
+      registry.reload();
+      const rules = registry.list().map((rule) => ({
+        ...rule,
+        id: rule.name
+      }));
+      respond(true, { ok: true, rules });
+    } catch (err) {
+      logger.warn(`${LIGHT_RULE_GATEWAY_METHODS.list} failed: ${err?.message}`);
+      respond(false, null, {
+        code: "INTERNAL_ERROR",
+        message: err?.message ?? "Unknown error"
+      });
+    }
+  });
+  registerGatewayMethodWithBroadcastCapture(LIGHT_RULE_GATEWAY_METHODS.create, async ({ params, respond }) => {
+    const { name, title, description, segments, repeat, repeat_times } = params;
+    const resolvedTitle = typeof title === "string" && title.trim() ? title.trim() : name;
+    if (!name || typeof name !== "string") {
+      respond(false, null, { code: "INVALID_PARAMS", message: "name is required" });
+      return;
+    }
+    if (!description || typeof description !== "string") {
+      respond(false, null, { code: "INVALID_PARAMS", message: "description is required" });
+      return;
+    }
+    const validation = validateSegments(segments);
+    if (!validation.valid) {
+      respond(false, null, {
+        code: "VALIDATION_FAILED",
+        message: JSON.stringify(validation.errors)
+      });
+      return;
+    }
+    let repeatTimes;
+    try {
+      repeatTimes = normalizeRepeatTimes({ repeat, repeat_times });
+      assertAncsRepeatTimes(repeatTimes);
+    } catch (err) {
+      respond(false, null, {
+        code: "VALIDATION_FAILED",
+        message: err?.message ?? "Unknown error"
+      });
+      return;
+    }
+    try {
+      const result = await registry.create({
+        name,
+        title: resolvedTitle,
+        description,
+        segments: validation.segments,
+        repeat_times: repeatTimes
+      });
+      logger.info(`Light rule created: ${name}`);
+      respond(true, {
+        ok: true,
+        id: result.meta.name,
+        name: result.meta.name,
+        title: result.meta.title,
+        rule: result.meta
+      });
+    } catch (err) {
+      if (err instanceof LightRuleError) {
+        respond(false, null, { code: err.code, message: err.message });
+      } else {
+        logger.warn(`${LIGHT_RULE_GATEWAY_METHODS.create} failed: ${err?.message}`);
+        respond(false, null, {
+          code: "INTERNAL_ERROR",
+          message: err?.message ?? "Unknown error"
+        });
+      }
+    }
+  });
+  registerGatewayMethodWithBroadcastCapture(LIGHT_RULE_GATEWAY_METHODS.update, async ({ params, respond }) => {
+    const { title, description, segments, repeat, repeat_times, enabled } = params;
+    const name = resolveRuleIdentifier(params);
+    const resolvedTitle = typeof title === "string" ? title.trim() : undefined;
+    if (!name) {
+      respond(false, null, {
+        code: "INVALID_PARAMS",
+        message: "name is required (or provide id/ruleId/ruleName)"
+      });
+      return;
+    }
+    if (title !== undefined && !resolvedTitle) {
+      respond(false, null, {
+        code: "INVALID_PARAMS",
+        message: "title must be a non-empty string"
+      });
+      return;
+    }
+    if (description !== undefined && typeof description !== "string") {
+      respond(false, null, {
+        code: "INVALID_PARAMS",
+        message: "description must be a string"
+      });
+      return;
+    }
+    let validatedSegments;
+    if (segments !== undefined) {
+      const validation = validateSegments(segments);
+      if (!validation.valid) {
+        respond(false, null, {
+          code: "VALIDATION_FAILED",
+          message: JSON.stringify(validation.errors)
+        });
+        return;
+      }
+      validatedSegments = validation.segments;
+    }
+    let repeatTimes;
+    if (repeat !== undefined || repeat_times !== undefined) {
+      try {
+        repeatTimes = normalizeRepeatTimes({ repeat, repeat_times });
+        assertAncsRepeatTimes(repeatTimes);
+      } catch (err) {
+        respond(false, null, {
+          code: "VALIDATION_FAILED",
+          message: err?.message ?? "Unknown error"
+        });
+        return;
+      }
+    }
+    try {
+      const result = await registry.update({
+        name,
+        title: resolvedTitle,
+        description,
+        segments: validatedSegments,
+        repeat_times: repeatTimes,
+        enabled
+      });
+      logger.info(`Light rule updated: ${name}`);
+      respond(true, {
+        ok: true,
+        id: result.meta.name,
+        name: result.meta.name,
+        title: result.meta.title,
+        updated: true,
+        rule: result.meta
+      });
+    } catch (err) {
+      if (err instanceof LightRuleError) {
+        respond(false, null, { code: err.code, message: err.message });
+      } else {
+        logger.warn(`${LIGHT_RULE_GATEWAY_METHODS.update} failed: ${err?.message}`);
+        respond(false, null, {
+          code: "INTERNAL_ERROR",
+          message: err?.message ?? "Unknown error"
+        });
+      }
+    }
+  });
+  registerGatewayMethodWithBroadcastCapture(LIGHT_RULE_GATEWAY_METHODS.delete, async ({ params, respond }) => {
+    const name = resolveRuleIdentifier(params);
+    if (!name) {
+      respond(false, null, {
+        code: "INVALID_PARAMS",
+        message: "name is required (or provide id/ruleId/ruleName)"
+      });
+      return;
+    }
+    try {
+      const result = await registry.delete(name);
+      logger.info(`Light rule deleted: ${result.name}`);
+      respond(true, {
+        ok: true,
+        id: result.name,
+        name: result.name,
+        deleted: true
+      });
+    } catch (err) {
+      if (err instanceof LightRuleError) {
+        respond(false, null, { code: err.code, message: err.message });
+      } else {
+        logger.warn(`${LIGHT_RULE_GATEWAY_METHODS.delete} failed: ${err?.message}`);
+        respond(false, null, {
+          code: "INTERNAL_ERROR",
+          message: err?.message ?? "Unknown error"
+        });
+      }
+    }
+  });
+}
+// src/notification/query.ts
+var ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})$/;
+function parseIso(value, name) {
+  if (!ISO_RE.test(value)) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", `${name} 必须是 ISO 8601 时间，例如 2026-03-01T09:00:00+08:00`);
+  }
+  const ts = Date.parse(value);
+  if (Number.isNaN(ts)) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", `${name} 不是合法时间`);
+  }
+  return ts;
+}
+function parseLimit(raw, fallback) {
+  if (raw === undefined)
+    return fallback;
+  if (!/^\d+$/.test(raw) || Number(raw) <= 0) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "--limit 必须是大于 0 的整数");
+  }
+  return Number(raw);
+}
+function buildQueryOptions(opts, defaultLimit = 100) {
+  if (opts.conversationType && opts.conversationType !== "group" && opts.conversationType !== "private") {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "--conversation-type 只能是 group 或 private");
+  }
+  const fromTs = opts.from ? parseIso(opts.from, "--from") : null;
+  const toTs = opts.to ? parseIso(opts.to, "--to") : null;
+  if (fromTs !== null && toTs !== null && fromTs > toTs) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "--from 不能晚于 --to");
+  }
+  return {
+    from: opts.from,
+    to: opts.to,
+    app: opts.app,
+    sender: opts.sender,
+    conversationType: opts.conversationType,
+    keyword: opts.keyword,
+    limit: parseLimit(opts.limit, defaultLimit),
+    fromTs,
+    toTs,
+    fromDateKey: opts.from ? opts.from.slice(0, 10) : null,
+    toDateKey: opts.to ? opts.to.slice(0, 10) : null
+  };
+}
+async function queryNotifications(paths, options) {
+  if (!import_node_fs11.existsSync(paths.notifications))
+    return [];
+  return collectMatchingNotifications(paths.notifications, options);
+}
+
+// src/commands/notification.ts
+var MAX_LIMIT = Number.MAX_SAFE_INTEGER;
+async function notificationSearch(ctx, _args, opts) {
+  const options = buildQueryOptions(opts);
+  return queryNotifications(ctx.paths, options);
+}
+function topCounts(items, pick, topN) {
+  const counts = new Map;
+  for (const item of items) {
+    const key = pick(item);
+    if (!key)
+      continue;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([key, count]) => ({ key, count })).sort((a, b) => b.count - a.count || a.key.localeCompare(b.key)).slice(0, topN);
+}
+async function notificationSummary(ctx, _args, opts) {
+  const sample = opts.sample ? Number(opts.sample) : 30;
+  const top = opts.top ? Number(opts.top) : 10;
+  const options = buildQueryOptions({ ...opts, limit: String(MAX_LIMIT) }, MAX_LIMIT);
+  const items = await queryNotifications(ctx.paths, options);
+  return {
+    ok: true,
+    total: items.length,
+    range: { from: opts.from ?? null, to: opts.to ?? null },
+    topApps: topCounts(items, (n) => n.appDisplayName || n.appName, top),
+    topSenders: topCounts(items, (n) => n.senderName || n.title, top),
+    sample: items.slice(0, sample)
+  };
+}
+var HOUR_KEY = (n) => String(new Date(n.timestamp).getHours()).padStart(2, "0");
+async function notificationStats(ctx, _args, opts) {
+  const from = opts.from ?? daysAgo(7);
+  const to = opts.to ?? today();
+  const dim = opts.dim ?? "all";
+  const allowed = ["date", "app", "sender", "hour", "all"];
+  if (!allowed.includes(dim)) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", `--dim 只能是 ${allowed.join("|")}`);
+  }
+  const options = {
+    app: opts.app,
+    limit: MAX_LIMIT,
+    fromTs: null,
+    toTs: null,
+    fromDateKey: from,
+    toDateKey: to
+  };
+  const items = await queryNotifications(ctx.paths, options);
+  const byDate = topCounts(items, (n) => formatDate(new Date(n.timestamp)), MAX_LIMIT);
+  const byApp = topCounts(items, (n) => n.appDisplayName || n.appName, MAX_LIMIT);
+  const bySender = topCounts(items, (n) => n.senderName || n.title, MAX_LIMIT);
+  const byHour = topCounts(items, HOUR_KEY, MAX_LIMIT);
+  const dims = { date: byDate, app: byApp, sender: bySender, hour: byHour };
+  return {
+    ok: true,
+    total: items.length,
+    range: { from, to },
+    dim,
+    ...dim === "all" ? dims : { [dim]: dims[dim] }
+  };
+}
+function notificationStoragePath(ctx) {
+  return { ok: true, path: ctx.paths.notifications };
+}
+async function notificationToday(ctx) {
+  const day = today();
+  const options = buildQueryOptions({
+    from: `${day}T00:00:00${tzOffset()}`,
+    to: `${day}T23:59:59${tzOffset()}`,
+    limit: String(MAX_LIMIT)
+  }, MAX_LIMIT);
+  return queryNotifications(ctx.paths, options);
+}
+async function notificationRecent(ctx) {
+  const fromTs = Date.now() - 60 * 60 * 1000;
+  const options = {
+    limit: MAX_LIMIT,
+    fromTs,
+    toTs: null,
+    fromDateKey: formatDate(new Date(fromTs)),
+    toDateKey: null
+  };
+  return queryNotifications(ctx.paths, options);
+}
+function notificationUnread() {
+  throw new YoooclawError("YOOOCLAW_NOT_IMPLEMENTED", "+unread 预留：需要先落地通知的已读状态模型");
+}
+function tzOffset() {
+  const min = -new Date().getTimezoneOffset();
+  const sign = min >= 0 ? "+" : "-";
+  const abs = Math.abs(min);
+  const hh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const mm = String(abs % 60).padStart(2, "0");
+  return `${sign}${hh}:${mm}`;
+}
+
+// src/notification/sync.ts
+var import_node_fs12 = require("node:fs");
+var import_node_path7 = require("node:path");
+var SYNC_FETCH_LIMIT = 300;
+function checkpointPath(dir) {
+  return import_node_path7.join(dir, ".checkpoint.json");
+}
+function readCheckpoint(dir) {
+  const p = checkpointPath(dir);
+  if (!import_node_fs12.existsSync(p))
+    return {};
+  try {
+    return JSON.parse(import_node_fs12.readFileSync(p, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeCheckpoint(dir, data) {
+  writeJsonFile(checkpointPath(dir), data);
+}
+function listDateKeys(dir) {
+  if (!import_node_fs12.existsSync(dir))
+    return [];
+  const pattern = /^(\d{4}-\d{2}-\d{2})\.json$/;
+  const keys = [];
+  for (const entry of import_node_fs12.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isFile())
+      continue;
+    const m = pattern.exec(entry.name);
+    if (m)
+      keys.push(m[1]);
+  }
+  return keys.sort((a, b) => b.localeCompare(a));
+}
+function readDateFile(dir, dateKey) {
+  const filePath = import_node_path7.join(dir, `${dateKey}.json`);
+  if (!import_node_fs12.existsSync(filePath))
+    return [];
+  try {
+    const parsed = JSON.parse(import_node_fs12.readFileSync(filePath, "utf-8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function parseIndexOption(raw, label) {
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isInteger(n) || String(n) !== raw || n < 0) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", `${label} 必须是非负整数`);
+  }
+  return n;
+}
+function scanSync(dir) {
+  const checkpoint = readCheckpoint(dir);
+  const pending = [];
+  let totalPending = 0;
+  for (const dateKey of listDateKeys(dir)) {
+    const items = readDateFile(dir, dateKey);
+    const lastIndex = checkpoint[dateKey]?.lastIndex ?? -1;
+    const unprocessed = items.length - (lastIndex + 1);
+    if (unprocessed > 0) {
+      pending.push({ date: dateKey, count: unprocessed, startIndex: lastIndex + 1 });
+      totalPending += unprocessed;
+    }
+  }
+  return { ok: true, pending, totalPending };
+}
+function fetchSync(dir, date, maxEndIndexRaw) {
+  const items = readDateFile(dir, date);
+  if (items.length === 0) {
+    throw new YoooclawError("YOOOCLAW_NOT_FOUND", `日期 ${date} 无通知数据`);
+  }
+  const checkpoint = readCheckpoint(dir);
+  const lastIndex = checkpoint[date]?.lastIndex ?? -1;
+  const startIndex = lastIndex + 1;
+  let maxEndIndex = items.length - 1;
+  if (maxEndIndexRaw) {
+    maxEndIndex = Math.min(parseIndexOption(maxEndIndexRaw, "--max-end-index"), items.length - 1);
+  }
+  const snapshotEndExclusive = Math.max(startIndex, maxEndIndex + 1);
+  const unprocessed = items.slice(startIndex, snapshotEndExclusive);
+  const notifications = unprocessed.slice(0, SYNC_FETCH_LIMIT);
+  const endIndex = notifications.length > 0 ? startIndex + notifications.length - 1 : lastIndex;
+  const hasMore = unprocessed.length > notifications.length;
+  return {
+    ok: true,
+    date,
+    startIndex,
+    endIndex,
+    nextStartIndex: hasMore ? endIndex + 1 : null,
+    limit: SYNC_FETCH_LIMIT,
+    maxEndIndex,
+    returned: notifications.length,
+    totalUnprocessed: unprocessed.length,
+    hasMore,
+    notifications
+  };
+}
+function commitSync(dir, date, endIndexRaw) {
+  const items = readDateFile(dir, date);
+  if (items.length === 0) {
+    throw new YoooclawError("YOOOCLAW_NOT_FOUND", `日期 ${date} 无通知数据`);
+  }
+  const checkpoint = readCheckpoint(dir);
+  const lastIndex = checkpoint[date]?.lastIndex ?? -1;
+  let committedIndex;
+  let commitMode;
+  if (endIndexRaw) {
+    committedIndex = parseIndexOption(endIndexRaw, "--end-index");
+    if (committedIndex >= items.length) {
+      throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "--end-index 超出当前日期通知文件范围");
+    }
+    if (committedIndex < lastIndex) {
+      throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "--end-index 早于当前 checkpoint，不能回退消费进度");
+    }
+    if (committedIndex > lastIndex + SYNC_FETCH_LIMIT) {
+      throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "--end-index 超出单批 fetch 上限，不能跳过未处理通知");
+    }
+    commitMode = "exact-end-index";
+  } else {
+    committedIndex = Math.min(items.length - 1, lastIndex + SYNC_FETCH_LIMIT);
+    commitMode = "legacy-batch-limit";
+  }
+  const hasMore = committedIndex < items.length - 1;
+  checkpoint[date] = { lastIndex: committedIndex };
+  writeCheckpoint(dir, checkpoint);
+  return {
+    ok: true,
+    date,
+    committedIndex,
+    commitMode,
+    limit: SYNC_FETCH_LIMIT,
+    hasMore,
+    nextStartIndex: hasMore ? committedIndex + 1 : null
+  };
+}
+
+// src/commands/sync.ts
+function syncScan(ctx) {
+  return scanSync(ctx.paths.notifications);
+}
+function syncFetch(ctx, _args, opts) {
+  if (!opts.date) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "--date 必填（YYYY-MM-DD）");
+  }
+  return fetchSync(ctx.paths.notifications, opts.date, opts.maxEndIndex);
+}
+function syncCommit(ctx, _args, opts) {
+  if (!opts.date) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "--date 必填（YYYY-MM-DD）");
+  }
+  return commitSync(ctx.paths.notifications, opts.date, opts.endIndex);
+}
+
+// src/commands/recording.ts
+var import_node_fs13 = require("node:fs");
+var import_node_path8 = require("node:path");
+function readIndex(ctx) {
+  if (!import_node_fs13.existsSync(ctx.paths.recordings))
+    return [];
+  return readRecordingIndex(ctx.paths.recordings);
+}
+function toListItem(r) {
+  return {
+    id: r.id,
+    name: r.metadata.name,
+    duration_sec: r.metadata.duration_sec,
+    status: r.status,
+    file_size_bytes: r.metadata.file_size_bytes,
+    has_audio: Boolean(r.audioFile),
+    has_transcript: Boolean(r.transcriptFile),
+    created_at: r.metadata.created_at,
+    updated_at: r.updatedAt,
+    error: r.lastError ?? null
+  };
+}
+function recordingList(ctx, _args, opts) {
+  let recordings = readIndex(ctx);
+  if (opts.status)
+    recordings = recordings.filter((r) => r.status === opts.status);
+  return { ok: true, total: recordings.length, recordings: recordings.map(toListItem) };
+}
+function recordingStatus(ctx, args) {
+  const [id] = args;
+  const entry = readIndex(ctx).find((r) => r.id === id);
+  if (!entry) {
+    throw new YoooclawError("YOOOCLAW_NOT_FOUND", `录音不存在：${id}`);
+  }
+  return {
+    ok: true,
+    recording: {
+      id: entry.id,
+      name: entry.metadata.name,
+      duration_sec: entry.metadata.duration_sec,
+      file_size_bytes: entry.metadata.file_size_bytes,
+      status: entry.status,
+      created_at: entry.metadata.created_at,
+      location: entry.metadata.location ?? null,
+      markers: entry.metadata.markers ?? [],
+      audioFile: entry.audioFile ?? null,
+      srtFile: entry.srtFile ?? null,
+      transcriptDataFile: entry.transcriptDataFile ?? null,
+      transcriptFile: entry.transcriptFile ?? null,
+      summaryFile: entry.summaryFile ?? null,
+      title: entry.title ?? null,
+      error: entry.lastError ?? null,
+      ingestedAt: entry.ingestedAt,
+      updatedAt: entry.updatedAt
+    }
+  };
+}
+function recordingStoragePath(ctx) {
+  return { ok: true, path: ctx.paths.recordings };
+}
+function recordingLatest(ctx) {
+  const recordings = readIndex(ctx).sort((a, b) => Date.parse(b.metadata.created_at) - Date.parse(a.metadata.created_at));
+  if (recordings.length === 0) {
+    return { ok: true, recording: null };
+  }
+  return recordingStatus(ctx, [recordings[0].id]);
+}
+async function recordingSetupAsr(ctx, _args, opts) {
+  let provider = opts.provider;
+  let apiKey = opts.apiKey;
+  if (!opts.nonInteractive && isInteractive()) {
+    provider = await ask("ASR provider（volcengine / whisper-local 等）", provider ?? "volcengine");
+    if (provider !== "whisper-local") {
+      apiKey = await ask("ASR API key（留空跳过）", apiKey ?? "");
+    }
+  }
+  if (!provider) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "缺少 --provider（非交互模式必填）");
+  }
+  const config = { provider };
+  if (apiKey)
+    config.apiKey = apiKey;
+  ensureDir(ctx.paths.recordings);
+  const path = import_node_path8.join(ctx.paths.recordings, "asr-config.json");
+  writeJsonFile(path, config);
+  return { ok: true, path, provider, keyConfigured: Boolean(apiKey) };
+}
+
+// src/image/storage.ts
+var import_node_fs14 = require("node:fs");
+var import_node_path9 = require("node:path");
+function imagesIndexPath(paths) {
+  return import_node_path9.join(paths.images, "index.json");
+}
+function readImageIndex(paths) {
+  const indexPath = imagesIndexPath(paths);
+  if (!import_node_fs14.existsSync(indexPath))
+    return [];
+  try {
+    const raw = JSON.parse(import_node_fs14.readFileSync(indexPath, "utf-8"));
+    return Array.isArray(raw?.images) ? raw.images : [];
+  } catch {
+    return [];
+  }
+}
+function resolveImageFile(paths, relative) {
+  return import_node_path9.isAbsolute(relative) ? relative : import_node_path9.join(paths.images, relative);
+}
+
+// src/commands/image.ts
+function byCreatedDesc(a, b) {
+  return Date.parse(b.metadata.created_at) - Date.parse(a.metadata.created_at);
+}
+function imageList(ctx, _args, opts) {
+  let items = readImageIndex(ctx.paths);
+  if (opts.status)
+    items = items.filter((i) => i.status === opts.status);
+  if (opts.app) {
+    const app = opts.app;
+    items = items.filter((i) => matchesNotificationAppFilter({ appName: i.metadata.source_app ?? "", title: "", content: "", timestamp: "" }, app));
+  }
+  if (opts.from) {
+    const fromTs = Date.parse(opts.from);
+    items = items.filter((i) => Date.parse(i.metadata.created_at) >= fromTs);
+  }
+  if (opts.to) {
+    const toTs = Date.parse(opts.to);
+    items = items.filter((i) => Date.parse(i.metadata.created_at) <= toTs);
+  }
+  items = items.sort(byCreatedDesc);
+  const limit = opts.limit ? Number(opts.limit) : 100;
+  return { ok: true, total: items.length, images: items.slice(0, limit) };
+}
+function imageStatus(ctx, args) {
+  const [id] = args;
+  const entry = readImageIndex(ctx.paths).find((i) => i.imageId === id);
+  if (!entry)
+    throw new YoooclawError("YOOOCLAW_NOT_FOUND", `图片不存在：${id}`);
+  return { ok: true, image: entry };
+}
+function imagePath(ctx, args, opts) {
+  const [id] = args;
+  const entry = readImageIndex(ctx.paths).find((i) => i.imageId === id);
+  if (!entry)
+    throw new YoooclawError("YOOOCLAW_NOT_FOUND", `图片不存在：${id}`);
+  const relative = opts.thumbnail ? entry.thumbnail : entry.localFile;
+  if (entry.status !== "synced" || !relative) {
+    throw new YoooclawError("YOOOCLAW_IMAGE_NOT_READY", `图片 ${id} 尚未下载完成`, { status: entry.status, lastError: entry.lastError ?? null });
+  }
+  return { ok: true, path: resolveImageFile(ctx.paths, relative) };
+}
+function imageStoragePath(ctx) {
+  return { ok: true, path: ctx.paths.images };
+}
+function imageLatest(ctx) {
+  const items = readImageIndex(ctx.paths).sort(byCreatedDesc);
+  return { ok: true, image: items[0] ?? null };
+}
+
+// src/log/reader.ts
+var import_node_fs15 = require("node:fs");
+var import_node_path10 = require("node:path");
+var LINE_RE = /^(\d{4}-\d{2}-\d{2})(T\S+)?\s+\[(\w+)\]\s+(.*)$/;
+function logFiles(daemonLog) {
+  const dir = import_node_path10.dirname(daemonLog);
+  const base = import_node_path10.basename(daemonLog);
+  if (!import_node_fs15.existsSync(dir))
+    return [];
+  const rotated = import_node_fs15.readdirSync(dir).filter((f) => f.startsWith(`${base}.`) && /\.\d{4}-\d{2}-\d{2}$/.test(f)).sort((a, b) => b.localeCompare(a)).map((f) => import_node_path10.join(dir, f));
+  const files = [];
+  if (import_node_fs15.existsSync(daemonLog))
+    files.push(daemonLog);
+  files.push(...rotated);
+  return files;
+}
+function parseLine(raw) {
+  const m = LINE_RE.exec(raw);
+  if (!m)
+    return null;
+  return {
+    date: m[1],
+    time: m[1] + (m[2] ?? ""),
+    level: m[3].toLowerCase(),
+    message: m[4],
+    raw
+  };
+}
+function searchLogs(daemonLog, query) {
+  const keyword = query.keyword?.toLowerCase();
+  const level = query.level?.toLowerCase();
+  const results = [];
+  for (const file of logFiles(daemonLog)) {
+    const content = import_node_fs15.readFileSync(file, "utf-8");
+    const lines = content.split(`
+`).filter(Boolean).reverse();
+    for (const raw of lines) {
+      if (results.length >= query.limit)
+        return results;
+      const parsed = parseLine(raw);
+      const date = parsed?.date;
+      if (query.from && date && date < query.from)
+        continue;
+      if (query.to && date && date > query.to)
+        continue;
+      if (level && parsed && parsed.level !== level)
+        continue;
+      if (keyword && !raw.toLowerCase().includes(keyword))
+        continue;
+      results.push(parsed ?? { date: "", time: "", level: "", message: raw, raw });
+    }
+  }
+  return results;
+}
+
+// src/commands/log.ts
+function logSearch(ctx, args, opts) {
+  const [keyword] = args;
+  const lines = searchLogs(ctx.paths.daemonLog, {
+    keyword,
+    level: opts.level,
+    from: opts.from ?? daysAgo(7),
+    to: opts.to ?? today(),
+    limit: opts.limit ? Number(opts.limit) : 50
+  });
+  return { ok: true, keyword: keyword ?? null, total: lines.length, lines };
+}
+function logErrors(ctx) {
+  const lines = searchLogs(ctx.paths.daemonLog, {
+    level: "error",
+    from: daysAgo(1),
+    to: today(),
+    limit: 50
+  });
+  return { ok: true, level: "error", total: lines.length, lines };
+}
+
+// src/commands/migrate.ts
+var import_node_fs16 = require("node:fs");
+var import_node_os4 = require("node:os");
+var import_node_path11 = require("node:path");
+function countFiles(dir) {
+  if (!import_node_fs16.existsSync(dir))
+    return 0;
+  try {
+    return import_node_fs16.readdirSync(dir, { recursive: true }).length;
+  } catch {
+    return 0;
+  }
+}
+function migrateFromOpenclaw(ctx, _args, opts) {
+  const sourceRoot = opts.source ?? import_node_path11.join(import_node_os4.homedir(), ".openclaw");
+  const pluginRoot = import_node_path11.join(sourceRoot, "plugins", "phone-notifications");
+  const plans = [
+    { name: "notifications", source: import_node_path11.join(pluginRoot, "notifications"), target: ctx.paths.notifications },
+    { name: "recordings", source: import_node_path11.join(pluginRoot, "recordings"), target: ctx.paths.recordings },
+    { name: "light-rules", source: import_node_path11.join(pluginRoot, "light-rules"), target: ctx.paths.lightRules },
+    { name: "images", source: import_node_path11.join(pluginRoot, "images"), target: ctx.paths.images }
+  ].map((p) => ({ ...p, exists: import_node_fs16.existsSync(p.source), fileCount: countFiles(p.source) }));
+  const srcCreds = readJsonFile(import_node_path11.join(sourceRoot, "credentials.json"));
+  const srcApiKey = typeof srcCreds?.[API_KEY_FIELD] === "string" ? srcCreds[API_KEY_FIELD] : undefined;
+  const sharedPath = sharedCredentialsPath();
+  const existingShared = readJsonFile(sharedPath);
+  const apiKeyAction = !srcApiKey ? "none" : existingShared?.[API_KEY_FIELD] ? "skip-existing" : "copy";
+  const backupDir = `${ctx.paths.dir}.bak-${Date.now()}`;
+  const willBackup = import_node_fs16.existsSync(ctx.paths.dir) && import_node_fs16.readdirSync(ctx.paths.dir).length > 0;
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      dryRun: true,
+      source: sourceRoot,
+      profile: ctx.profile,
+      backup: willBackup ? backupDir : null,
+      subdirs: plans,
+      apiKey: { action: apiKeyAction },
+      hint: "迁移前请先停止 openclaw 客户端，避免插件还在写 notifications 导致数据竞争"
+    };
+  }
+  if (willBackup) {
+    import_node_fs16.cpSync(ctx.paths.dir, backupDir, { recursive: true });
+  }
+  ensureDir(ctx.paths.dir);
+  const migrated = [];
+  for (const plan of plans) {
+    if (!plan.exists)
+      continue;
+    import_node_fs16.cpSync(plan.source, plan.target, { recursive: true });
+    migrated.push(plan.name);
+  }
+  let apiKeyResult = apiKeyAction;
+  if (apiKeyAction === "copy" && srcApiKey) {
+    const data = existingShared ?? {};
+    data[API_KEY_FIELD] = srcApiKey;
+    writeJsonFile(sharedPath, data, SECRET_FILE_MODE);
+    apiKeyResult = "copied";
+  }
+  return {
+    ok: true,
+    source: sourceRoot,
+    profile: ctx.profile,
+    backup: willBackup ? backupDir : null,
+    migrated,
+    apiKey: { action: apiKeyResult }
+  };
+}
+
+// src/commands/update.ts
+var PACKAGE = "@yoooclaw/cli";
+var REGISTRY = "https://registry.npmjs.org";
+function compareSemver(a, b) {
+  const pa = a.split("-")[0].split(".").map(Number);
+  const pb = b.split("-")[0].split(".").map(Number);
+  for (let i = 0;i < 3; i += 1) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0)
+      return d > 0 ? 1 : -1;
+  }
+  return 0;
+}
+async function updateSelf(_ctx, _args, opts) {
+  const tag = opts.beta ? "beta" : "latest";
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), 8000);
+  let latest;
+  try {
+    const res = await fetch(`${REGISTRY}/${encodeURIComponent(PACKAGE)}`, {
+      signal: controller.signal,
+      headers: { Accept: "application/vnd.npm.install-v1+json" }
+    });
+    if (!res.ok) {
+      throw new YoooclawError("YOOOCLAW_NETWORK_ERROR", `npm registry 返回 ${res.status}`);
+    }
+    const body = await res.json();
+    const resolved = body["dist-tags"]?.[tag];
+    if (!resolved) {
+      throw new YoooclawError("YOOOCLAW_NOT_FOUND", `npm dist-tag \`${tag}\` 不存在`);
+    }
+    latest = resolved;
+  } catch (err) {
+    if (err instanceof YoooclawError)
+      throw err;
+    throw new YoooclawError("YOOOCLAW_NETWORK_ERROR", `查询 npm registry 失败：${err.message}`);
+  } finally {
+    clearTimeout(timer);
+  }
+  const updateAvailable = compareSemver(latest, CLI_VERSION) > 0;
+  return {
+    ok: true,
+    package: PACKAGE,
+    channel: tag,
+    current: CLI_VERSION,
+    latest,
+    updateAvailable,
+    command: updateAvailable ? `npm update -g ${PACKAGE}` : null,
+    hint: updateAvailable ? "发现新版本；CLI 不做自动更新，请手动执行上面的命令" : "已是最新版本"
+  };
+}
+
+// src/commands/doctor.ts
+var import_node_fs17 = require("node:fs");
+var MIN_NODE = [22, 12, 0];
+function checkNode() {
+  const parts = process.versions.node.split(".").map(Number);
+  let ok = true;
+  for (let i = 0;i < 3; i += 1) {
+    if ((parts[i] ?? 0) > MIN_NODE[i])
+      break;
+    if ((parts[i] ?? 0) < MIN_NODE[i]) {
+      ok = false;
+      break;
+    }
+  }
+  return {
+    name: "node-version",
+    status: ok ? "ok" : "fail",
+    detail: `Node ${process.versions.node}（要求 >= ${MIN_NODE.join(".")}）`
+  };
+}
+function checkDir(name, dir, fix) {
+  if (!import_node_fs17.existsSync(dir)) {
+    if (fix) {
+      ensureDir(dir);
+      return { name, status: "ok", detail: `已创建 ${dir}` };
+    }
+    return { name, status: "warn", detail: `目录不存在：${dir}（--fix 可创建）` };
+  }
+  try {
+    import_node_fs17.accessSync(dir, import_node_fs17.constants.R_OK | import_node_fs17.constants.W_OK);
+  } catch {
+    return { name, status: "fail", detail: `目录不可读写：${dir}` };
+  }
+  const mode = import_node_fs17.statSync(dir).mode & 511;
+  const tooOpen = (mode & 63) !== 0;
+  return {
+    name,
+    status: tooOpen ? "warn" : "ok",
+    detail: `${dir}（mode ${mode.toString(8)}${tooOpen ? "，建议收紧到 700" : ""}）`
+  };
+}
+function doctor(ctx, _args, opts) {
+  const fix = Boolean(opts.fix);
+  const checks = [checkNode(), checkDir("root-dir", rootDir(), fix)];
+  if (configExists(ctx.paths)) {
+    try {
+      loadConfig(ctx.paths);
+      checks.push({ name: "profile-config", status: "ok", detail: `${ctx.paths.config} 可解析` });
+    } catch (err) {
+      checks.push({ name: "profile-config", status: "fail", detail: err.message });
+    }
+  } else {
+    checks.push({
+      name: "profile-config",
+      status: "warn",
+      detail: `profile \`${ctx.profile}\` 未初始化（yoooclaw config init）`
+    });
+  }
+  const apiKey = resolveApiKey();
+  checks.push({
+    name: "api-key",
+    status: apiKey.value ? "ok" : "warn",
+    detail: apiKey.value ? `来源 ${apiKey.source}` : "未配置（yoooclaw auth set-api-key）"
+  });
+  if (configExists(ctx.paths)) {
+    const token = resolveGatewayToken(loadConfig(ctx.paths));
+    checks.push({
+      name: "gateway-token",
+      status: token.value ? "ok" : "warn",
+      detail: token.value ? `来源 ${token.source}` : "未设置（yoooclaw auth token-rotate）"
+    });
+  }
+  checks.push({
+    name: "keychain",
+    status: keychainAvailable() ? "ok" : "skip",
+    detail: keychainAvailable() ? "可用" : "当前平台无可用 keychain，凭据将落文件"
+  });
+  const state = daemonState(ctx.paths);
+  checks.push({
+    name: "daemon",
+    status: state.running ? "ok" : state.stale ? "warn" : "skip",
+    detail: state.running ? `运行中（pid ${state.lock?.pid}）` : state.stale ? "锁文件存在但进程已死（陈旧锁）" : "未运行"
+  });
+  const failed = checks.filter((c) => c.status === "fail").length;
+  const warned = checks.filter((c) => c.status === "warn").length;
+  return {
+    ok: failed === 0,
+    profile: ctx.profile,
+    summary: { total: checks.length, failed, warned },
+    checks,
+    note: "网络类自检（relay / OSS 可达性）请用 yoooclaw gateway test / tunnel +test"
+  };
+}
+
+// src/commands/daemon.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs21 = require("node:fs");
+var import_promises3 = require("node:timers/promises");
+
+// src/daemon/main.ts
+var import_node_http = require("node:http");
+
+// src/daemon/logger.ts
+var import_node_fs18 = require("node:fs");
+var import_node_path12 = require("node:path");
+var LEVEL_ORDER = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+function isoLocal(d) {
+  const pad = (n, w = 2) => String(n).padStart(w, "0");
+  const off = -d.getTimezoneOffset();
+  const sign = off >= 0 ? "+" : "-";
+  const abs = Math.abs(off);
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` + `T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}` + `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
+function dateKey(d) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+
+class DaemonLogger {
+  logFile;
+  level;
+  alsoStderr;
+  currentDay;
+  constructor(logFile, level = "info", alsoStderr = false) {
+    this.logFile = logFile;
+    this.level = level;
+    this.alsoStderr = alsoStderr;
+    ensureDir(import_node_path12.dirname(logFile));
+    this.currentDay = dateKey(new Date);
+    this.rotateIfNeeded(new Date);
+  }
+  enabled(level) {
+    return (LEVEL_ORDER[level] ?? 2) <= (LEVEL_ORDER[this.level] ?? 2);
+  }
+  rotateIfNeeded(now) {
+    if (!import_node_fs18.existsSync(this.logFile))
+      return;
+    let fileDay;
+    try {
+      fileDay = dateKey(import_node_fs18.statSync(this.logFile).mtime);
+    } catch {
+      return;
+    }
+    const today2 = dateKey(now);
+    if (fileDay !== today2) {
+      try {
+        import_node_fs18.renameSync(this.logFile, `${this.logFile}.${fileDay}`);
+      } catch {}
+    }
+  }
+  write(level, msg) {
+    if (!this.enabled(level))
+      return;
+    const now = new Date;
+    if (dateKey(now) !== this.currentDay) {
+      this.rotateIfNeeded(now);
+      this.currentDay = dateKey(now);
+    }
+    const line = `${isoLocal(now)} [${level.toUpperCase()}] ${msg}
+`;
+    try {
+      import_node_fs18.appendFileSync(this.logFile, line);
+    } catch {}
+    if (this.alsoStderr)
+      process.stderr.write(line);
+  }
+  debug(msg) {
+    this.write("debug", msg);
+  }
+  info(msg) {
+    this.write("info", msg);
+  }
+  warn(msg) {
+    this.write("warn", msg);
+  }
+  error(msg) {
+    this.write("error", msg);
+  }
+}
+
+// src/daemon/runtime.ts
+class StandaloneRuntime {
+  logger;
+  pluginConfig;
+  stateDir;
+  httpRoutes = new Map;
+  gatewayMethods = new Map;
+  services = [];
+  constructor(logger, pluginConfig, stateDir) {
+    this.logger = logger;
+    this.pluginConfig = pluginConfig;
+    this.stateDir = stateDir;
+  }
+  runtime = {
+    state: {
+      resolveStateDir: () => this.stateDir
+    }
+  };
+  registerHttpRoute(spec) {
+    this.httpRoutes.set(spec.path, spec);
+  }
+  registerGatewayMethod(method, handler) {
+    this.gatewayMethods.set(method, handler);
+  }
+  registerService(name) {
+    this.services.push(typeof name === "string" ? name : "service");
+  }
+  registerCli() {}
+  registerTool() {}
+  on() {}
+  callGateway(method, params) {
+    const handler = this.gatewayMethods.get(method);
+    if (!handler) {
+      return Promise.resolve({
+        ok: false,
+        error: { code: "METHOD_NOT_FOUND", message: `未注册的 gateway 方法：${method}` }
+      });
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      const respond = (ok, data, error) => {
+        if (settled)
+          return;
+        settled = true;
+        resolve({ ok, data, error });
+      };
+      Promise.resolve(handler({ params, respond })).catch((err) => {
+        if (!settled) {
+          settled = true;
+          resolve({
+            ok: false,
+            error: { code: "INTERNAL_ERROR", message: err.message }
+          });
+        }
+      });
+    });
+  }
+}
+
+// src/image/channel.ts
+var import_node_fs19 = require("node:fs");
+var import_node_stream = require("node:stream");
+var import_node_path13 = require("node:path");
+function readAll(paths) {
+  const p = imagesIndexPath(paths);
+  if (!import_node_fs19.existsSync(p))
+    return [];
+  try {
+    const raw = JSON.parse(import_node_fs19.readFileSync(p, "utf-8"));
+    return Array.isArray(raw?.images) ? raw.images : [];
+  } catch {
+    return [];
+  }
+}
+function writeAll(paths, images) {
+  ensureDir(paths.images);
+  writeJsonFile(imagesIndexPath(paths), { images });
+}
+function upsert(paths, entry) {
+  const images = readAll(paths);
+  const idx = images.findIndex((i) => i.imageId === entry.imageId);
+  if (idx >= 0)
+    images[idx] = entry;
+  else
+    images.push(entry);
+  writeAll(paths, images);
+}
+function extFromMime(mime) {
+  if (!mime)
+    return "jpg";
+  if (mime.includes("png"))
+    return "png";
+  if (mime.includes("webp"))
+    return "webp";
+  if (mime.includes("gif"))
+    return "gif";
+  return "jpg";
+}
+function ingestImage(paths, payload, opts) {
+  const { imageId, image } = payload;
+  if (!imageId || !image?.oss_image_url || !image?.created_at) {
+    throw new Error("imageId / image.oss_image_url / image.created_at 必填");
+  }
+  const existing = readAll(paths).find((i) => i.imageId === imageId);
+  if (existing && existing.metadata.oss_image_url === image.oss_image_url && existing.status === "synced") {
+    return { ok: true, imageId, status: "synced", deduped: true };
+  }
+  const entry = {
+    imageId,
+    metadata: image,
+    localFile: null,
+    thumbnail: null,
+    status: "syncing",
+    lastError: null,
+    syncedAt: null
+  };
+  upsert(paths, entry);
+  downloadInBackground(paths, entry, opts).catch((err) => {
+    opts.logger.warn(`image[${imageId}] 后台下载异常：${err.message}`);
+  });
+  return { ok: true, imageId, status: "syncing" };
+}
+async function downloadInBackground(paths, entry, opts) {
+  const filesDir = import_node_path13.join(paths.images, "files");
+  ensureDir(filesDir);
+  const relative = `files/${entry.imageId}.${extFromMime(entry.metadata.mime_type)}`;
+  const dest = import_node_path13.join(paths.images, relative);
+  try {
+    const res = await fetch(entry.metadata.oss_image_url);
+    if (!res.ok || !res.body) {
+      throw new Error(`OSS 返回 ${res.status}`);
+    }
+    const declared = Number(res.headers.get("content-length") ?? "0");
+    if (declared && declared > opts.maxBytes) {
+      throw new Error(`图片超过上限 ${opts.maxBytes} 字节`);
+    }
+    let written = 0;
+    const fileStream = import_node_fs19.createWriteStream(dest);
+    const reader = import_node_stream.Readable.fromWeb(res.body);
+    for await (const chunk of reader) {
+      written += chunk.length;
+      if (written > opts.maxBytes) {
+        fileStream.destroy();
+        throw new Error(`图片超过上限 ${opts.maxBytes} 字节`);
+      }
+      fileStream.write(chunk);
+    }
+    await new Promise((resolve, reject) => {
+      fileStream.end((err) => err ? reject(err) : resolve());
+    });
+    upsert(paths, {
+      ...entry,
+      localFile: relative,
+      status: "synced",
+      lastError: null,
+      syncedAt: new Date().toISOString()
+    });
+    opts.logger.info(`image[${entry.imageId}] 下载完成 (${written} bytes)`);
+  } catch (err) {
+    upsert(paths, {
+      ...entry,
+      status: "sync_failed",
+      lastError: err.message
+    });
+    opts.logger.warn(`image[${entry.imageId}] 下载失败：${err.message}`);
+  }
+}
+
+// src/monitor/store.ts
+var import_node_fs20 = require("node:fs");
+var import_node_path14 = require("node:path");
+function storePath(paths) {
+  return import_node_path14.join(paths.state, "monitors.json");
+}
+function listMonitors(paths) {
+  const p = storePath(paths);
+  if (!import_node_fs20.existsSync(p))
+    return [];
+  try {
+    const raw = JSON.parse(import_node_fs20.readFileSync(p, "utf-8"));
+    return Array.isArray(raw?.monitors) ? raw.monitors : [];
+  } catch {
+    return [];
+  }
+}
+function save(paths, monitors) {
+  ensureDir(paths.state);
+  writeJsonFile(storePath(paths), { monitors });
+}
+function createMonitor(paths, input) {
+  if (!input.name || !input.description || !input.schedule || input.matchRules === undefined) {
+    throw new Error("name / description / matchRules / schedule 均必填");
+  }
+  const monitors = listMonitors(paths);
+  if (monitors.some((m) => m.name === input.name)) {
+    throw new Error(`监控任务已存在：${input.name}`);
+  }
+  const now = new Date().toISOString();
+  const task = {
+    name: input.name,
+    description: input.description,
+    matchRules: input.matchRules,
+    schedule: input.schedule,
+    enabled: true,
+    createdAt: now,
+    updatedAt: now,
+    lastRunAt: null,
+    lastResult: null
+  };
+  monitors.push(task);
+  save(paths, monitors);
+  return task;
+}
+function deleteMonitor(paths, name) {
+  const monitors = listMonitors(paths);
+  const next = monitors.filter((m) => m.name !== name);
+  if (next.length === monitors.length)
+    return false;
+  save(paths, next);
+  return true;
+}
+function setMonitorEnabled(paths, name, enabled) {
+  const monitors = listMonitors(paths);
+  const task = monitors.find((m) => m.name === name);
+  if (!task)
+    return false;
+  task.enabled = enabled;
+  task.updatedAt = new Date().toISOString();
+  save(paths, monitors);
+  return true;
+}
+
+// src/daemon/main.ts
+var PROTOCOL_VERSION = 1;
+var CAPABILITIES = ["notifications", "recordings", "images", "lightrules"];
+async function readBody2(req) {
+  const chunks = [];
+  for await (const chunk of req)
+    chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function sendJson(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+async function runDaemonForeground(ctx, opts) {
+  const state = daemonState(ctx.paths);
+  if (state.running) {
+    throw new YoooclawError("YOOOCLAW_DAEMON_ALREADY_RUNNING", `daemon 已在运行（pid ${state.lock?.pid}）`);
+  }
+  const config = loadConfig(ctx.paths);
+  const bind = opts.bind ?? config.daemon.bind;
+  const port = opts.port ?? config.daemon.port;
+  const logLevel = opts.logLevel ?? config.daemon.logLevel;
+  const token = resolveGatewayToken(config).value;
+  const loopback = bind === "127.0.0.1" || bind === "::1" || bind === "localhost";
+  if (!loopback && !token) {
+    throw new YoooclawError("YOOOCLAW_UNAUTHORIZED", `绑定 ${bind} 需要先设置 gateway token`, { hint: "运行 yoooclaw auth token-rotate 或改回 127.0.0.1" });
+  }
+  ensureDir(ctx.paths.dir);
+  const logger = new DaemonLogger(ctx.paths.daemonLog, logLevel, false);
+  const runtimeState = {
+    startedAt: new Date().toISOString(),
+    lastIngestAt: null,
+    ingestCount: 0
+  };
+  const pluginConfig = {
+    retentionDays: config.notification.retentionDays ?? undefined,
+    ignoredApps: config.notification.ignoredApps
+  };
+  const runtime = new StandaloneRuntime(logger, pluginConfig, ctx.paths.dir);
+  const storage = new NotificationStorage(ctx.paths.notifications, pluginConfig, logger);
+  await storage.init();
+  const lightRuleRegistry = new LightRuleRegistry({ workspaceDir: ctx.paths.dir });
+  const ignored = new Set(config.notification.ignoredApps ?? []);
+  registerNotificationInterfaces({
+    api: runtime,
+    logger,
+    getStorage: () => storage,
+    filterNotifications: (items) => items.filter((n) => !ignored.has(n.app)),
+    registerGatewayMethod: (m, h) => runtime.registerGatewayMethod(m, h),
+    onAfterIngest: (inserted) => {
+      runtimeState.lastIngestAt = new Date().toISOString();
+      runtimeState.ingestCount += inserted.length;
+    }
+  });
+  registerLightRulesGateway(runtime, lightRuleRegistry, logger);
+  const server = import_node_http.createServer((req, res) => {
+    handleRequest(req, res).catch((err) => {
+      logger.error(`请求处理异常：${err.message}`);
+      if (!res.headersSent)
+        sendJson(res, 500, { ok: false, error: { code: "INTERNAL_ERROR", message: err.message } });
+    });
+  });
+  function authorized(req) {
+    if (!token)
+      return true;
+    const header = req.headers["authorization"];
+    return header === `Bearer ${token}`;
+  }
+  async function handleRequest(req, res) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const path = url.pathname;
+    const method = req.method ?? "GET";
+    if (path === "/health" && method === "GET") {
+      sendJson(res, 200, {
+        server: "yoooclaw",
+        version: CLI_VERSION,
+        protocol: PROTOCOL_VERSION,
+        capabilities: CAPABILITIES
+      });
+      return;
+    }
+    if (!authorized(req)) {
+      sendJson(res, 401, { ok: false, error: { code: "YOOOCLAW_UNAUTHORIZED", message: "token 不一致或缺失" } });
+      return;
+    }
+    if (path === "/daemon/status" && method === "GET") {
+      sendJson(res, 200, {
+        ok: true,
+        server: "yoooclaw",
+        version: CLI_VERSION,
+        pid: process.pid,
+        profile: ctx.profile,
+        bind,
+        port,
+        startedAt: runtimeState.startedAt,
+        lastIngestAt: runtimeState.lastIngestAt,
+        ingestCount: runtimeState.ingestCount,
+        lightRules: lightRuleRegistry.list().length,
+        relay: { mode: "standalone-http", connected: false, url: config.relay.url, enabled: config.relay.enabled },
+        memoryRssBytes: process.memoryUsage().rss
+      });
+      return;
+    }
+    if (path === "/daemon/stop" && method === "POST") {
+      sendJson(res, 200, { ok: true, stopping: true });
+      logger.info("收到 /daemon/stop，准备优雅退出");
+      setTimeout(() => void shutdown("stop-endpoint"), 50);
+      return;
+    }
+    if (path === "/tunnel/status" && method === "GET") {
+      sendJson(res, 200, {
+        ok: true,
+        mode: "standalone-http",
+        connected: false,
+        relayUrl: config.relay.url,
+        enabled: config.relay.enabled,
+        note: "独立 daemon 当前走直连 HTTP 接收推送；yoooclaw 托管 Relay 为后续迭代。可用 cloudflared / tailscale serve 反代"
+      });
+      return;
+    }
+    if (path === "/tunnel/reconnect" && method === "POST") {
+      sendJson(res, 200, { ok: true, mode: "standalone-http", reconnected: false, note: "standalone HTTP 模式无 relay 连接可重连" });
+      return;
+    }
+    if (path === "/tunnel/test" && method === "POST") {
+      const echo = await selfEchoCheck(`http://127.0.0.1:${port}`, token);
+      sendJson(res, 200, { ok: echo.ok, mode: "standalone-http", loopback: echo });
+      return;
+    }
+    if (path === "/light/send" && method === "POST") {
+      const body = await parseJson(req, res);
+      if (body === undefined)
+        return;
+      await handleLightSend(body, res);
+      return;
+    }
+    if (path === "/images" && method === "POST") {
+      const body = await parseJson(req, res);
+      if (body === undefined)
+        return;
+      try {
+        const result = ingestImage(ctx.paths, body, {
+          maxBytes: config.image.maxBytes,
+          logger
+        });
+        sendJson(res, 200, result);
+      } catch (err) {
+        sendJson(res, 400, { ok: false, error: { code: "INVALID_PARAMS", message: err.message } });
+      }
+      return;
+    }
+    if (path === "/monitors" && method === "GET") {
+      sendJson(res, 200, { ok: true, monitors: listMonitors(ctx.paths) });
+      return;
+    }
+    if (path === "/monitors" && method === "POST") {
+      const body = await parseJson(req, res);
+      if (body === undefined)
+        return;
+      try {
+        sendJson(res, 200, { ok: true, monitor: createMonitor(ctx.paths, body) });
+      } catch (err) {
+        sendJson(res, 400, { ok: false, error: { code: "INVALID_PARAMS", message: err.message } });
+      }
+      return;
+    }
+    if (path.startsWith("/monitors/") && method === "DELETE") {
+      const name = decodeURIComponent(path.slice("/monitors/".length));
+      sendJson(res, 200, { ok: true, deleted: deleteMonitor(ctx.paths, name) });
+      return;
+    }
+    if (path.startsWith("/monitors/") && method === "POST") {
+      const [, , name, action] = path.split("/");
+      const enabled = action === "enable";
+      sendJson(res, 200, { ok: setMonitorEnabled(ctx.paths, decodeURIComponent(name), enabled), name, enabled });
+      return;
+    }
+    if (path.startsWith("/gateway/") && method === "POST") {
+      const gwMethod = path.slice("/gateway/".length);
+      const body = await parseJson(req, res);
+      if (body === undefined)
+        return;
+      const result = await runtime.callGateway(gwMethod, body);
+      sendJson(res, result.ok ? 200 : 400, result);
+      return;
+    }
+    const route = runtime.httpRoutes.get(path);
+    if (route) {
+      await route.handler(req, res);
+      return;
+    }
+    sendJson(res, 404, { ok: false, error: { code: "YOOOCLAW_NOT_FOUND", message: `未知路径：${path}` } });
+  }
+  async function parseJson(req, res) {
+    try {
+      const raw = await readBody2(req);
+      return raw ? JSON.parse(raw) : {};
+    } catch {
+      sendJson(res, 400, { ok: false, error: { code: "INVALID_PARAMS", message: "请求体不是合法 JSON" } });
+      return;
+    }
+  }
+  async function handleLightSend(body, res) {
+    const input = body;
+    if (!input.segments && !input.preset) {
+      sendJson(res, 400, { ok: false, error: { code: "INVALID_PARAMS", message: "需要 --segments 或 --preset" } });
+      return;
+    }
+    if (input.segments) {
+      const validation = validateSegments(input.segments);
+      if (!validation.valid) {
+        sendJson(res, 400, { ok: false, error: { code: "VALIDATION_FAILED", message: JSON.stringify(validation.errors) } });
+        return;
+      }
+    }
+    logger.info(`/light/send 已接收（preset=${input.preset ?? "-"}）；standalone 无连接设备，未实际投递`);
+    sendJson(res, 200, {
+      ok: true,
+      accepted: true,
+      delivered: false,
+      reason: "standalone daemon 暂无连接的灯效设备会话（需手机端在线 / relay）"
+    });
+  }
+  let serverRef = null;
+  let shuttingDown = false;
+  async function shutdown(reason) {
+    if (shuttingDown)
+      return;
+    shuttingDown = true;
+    logger.info(`daemon 退出（${reason}）`);
+    try {
+      await storage.close();
+    } catch {}
+    serverRef?.close();
+    removeLock(ctx.paths);
+    process.exit(0);
+  }
+  const listenOnce = () => new Promise((resolve, reject) => {
+    const onError = (err) => {
+      server.removeListener("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, bind);
+  });
+  for (let attempt = 0;; attempt += 1) {
+    try {
+      await listenOnce();
+      break;
+    } catch (err) {
+      if (err.code === "EADDRINUSE" && attempt < 10) {
+        await new Promise((r) => setTimeout(r, 200));
+        continue;
+      }
+      throw err;
+    }
+  }
+  serverRef = server;
+  writeLock(ctx.paths, {
+    pid: process.pid,
+    startedAt: runtimeState.startedAt,
+    bind,
+    port,
+    logLevel: String(logLevel)
+  });
+  logger.info(`yoooclaw daemon 启动：${bind}:${port}（profile=${ctx.profile}, pid=${process.pid}）`);
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  await new Promise(() => {});
+}
+async function selfEchoCheck(baseUrl, token) {
+  try {
+    const res = await fetch(`${baseUrl}/notifications`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...token ? { Authorization: `Bearer ${token}` } : {}
+      },
+      body: JSON.stringify({
+        notifications: [
+          { id: `echo_${Date.now()}`, app: "yoooclaw.selftest", title: "tunnel +test", body: "echo", timestamp: new Date().toISOString() }
+        ]
+      })
+    });
+    return { ok: res.ok, status: res.status };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+// src/commands/daemon.ts
+function startOpts(opts) {
+  return {
+    bind: opts.bind,
+    port: opts.port ? Number(opts.port) : undefined,
+    logLevel: opts.logLevel
+  };
+}
+async function daemonRunForeground(ctx, _args, opts) {
+  await runDaemonForeground(ctx, startOpts(opts));
+  return { ok: true };
+}
+async function daemonStart(ctx, _args, opts) {
+  requireConfig(ctx.paths);
+  const state = daemonState(ctx.paths);
+  if (state.running) {
+    throw new YoooclawError("YOOOCLAW_DAEMON_ALREADY_RUNNING", `daemon 已在运行（pid ${state.lock?.pid}）`, { pid: state.lock?.pid });
+  }
+  if (state.stale)
+    removeLock(ctx.paths);
+  if (opts.detach === false) {
+    await runDaemonForeground(ctx, startOpts(opts));
+    return { ok: true };
+  }
+  const binEntry = process.argv[1];
+  const args = [binEntry, "daemon", "run-foreground", "--profile", ctx.profile];
+  if (opts.bind)
+    args.push("--bind", opts.bind);
+  if (opts.port)
+    args.push("--port", opts.port);
+  if (opts.logLevel)
+    args.push("--log-level", opts.logLevel);
+  const child = import_node_child_process2.spawn(process.execPath, args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: process.env
+  });
+  child.unref();
+  for (let i = 0;i < 30; i += 1) {
+    await import_promises3.setTimeout(100);
+    const s = daemonState(ctx.paths);
+    if (s.running) {
+      return { ok: true, pid: s.lock?.pid, bind: s.lock?.bind, port: s.lock?.port, detached: true };
+    }
+  }
+  throw new YoooclawError("YOOOCLAW_UNKNOWN", "daemon 启动超时（3s 内未写出 lock）", { hint: "查看 yoooclaw daemon logs 排查" });
+}
+async function daemonStop(ctx) {
+  const lock = readLock(ctx.paths);
+  if (!lock || !isProcessAlive(lock.pid)) {
+    removeLock(ctx.paths);
+    throw new YoooclawError("YOOOCLAW_DAEMON_NOT_RUNNING", "daemon 未运行");
+  }
+  try {
+    process.kill(lock.pid, "SIGTERM");
+  } catch {}
+  for (let i = 0;i < 100; i += 1) {
+    await import_promises3.setTimeout(100);
+    if (!isProcessAlive(lock.pid)) {
+      removeLock(ctx.paths);
+      return { ok: true, stopped: lock.pid, signal: "SIGTERM" };
+    }
+  }
+  try {
+    process.kill(lock.pid, "SIGKILL");
+  } catch {}
+  removeLock(ctx.paths);
+  return { ok: true, stopped: lock.pid, signal: "SIGKILL" };
+}
+async function daemonRestart(ctx, args, opts) {
+  const lock = readLock(ctx.paths);
+  const inheritedOpts = {
+    ...opts,
+    bind: opts.bind ?? lock?.bind,
+    port: opts.port ?? (lock?.port ? String(lock.port) : undefined),
+    logLevel: opts.logLevel ?? lock?.logLevel
+  };
+  if (lock && isProcessAlive(lock.pid)) {
+    await daemonStop(ctx);
+  }
+  return daemonStart(ctx, args, inheritedOpts);
+}
+async function daemonStatus(ctx) {
+  const state = daemonState(ctx.paths);
+  if (!state.running) {
+    throw new YoooclawError("YOOOCLAW_DAEMON_NOT_RUNNING", "daemon 未运行", { stale: state.stale, hint: "yoooclaw daemon start" });
+  }
+  const client = new DaemonClient(ctx.paths);
+  const res = await client.get("/daemon/status");
+  return res.body;
+}
+function tailLines(file, n) {
+  if (!import_node_fs21.existsSync(file))
+    return [];
+  const content = import_node_fs21.readFileSync(file, "utf-8").split(`
+`).filter(Boolean);
+  return content.slice(-n);
+}
+async function daemonLogs(ctx, _args, opts) {
+  const n = opts.lines ? Number(opts.lines) : 100;
+  const file = ctx.paths.daemonLog;
+  let lines = tailLines(file, n);
+  if (opts.level) {
+    const want = `[${opts.level.toUpperCase()}]`;
+    lines = lines.filter((l) => l.includes(want));
+  }
+  if (!opts.follow) {
+    return { ok: true, file, total: lines.length, lines };
+  }
+  for (const l of lines)
+    process.stdout.write(l + `
+`);
+  let size = import_node_fs21.existsSync(file) ? import_node_fs21.statSync(file).size : 0;
+  await new Promise(() => {
+    import_node_fs21.watchFile(file, { interval: 500 }, () => {
+      if (!import_node_fs21.existsSync(file))
+        return;
+      const cur = import_node_fs21.statSync(file).size;
+      if (cur > size) {
+        const chunk = import_node_fs21.readFileSync(file, "utf-8").slice(-(cur - size));
+        size = cur;
+        process.stdout.write(chunk);
+      } else if (cur < size) {
+        size = cur;
+      }
+    });
+  });
+  return { ok: true };
+}
+
+// src/commands/daemon-services.ts
+var import_node_fs22 = require("node:fs");
+function client(ctx) {
+  assertDaemonRunning(ctx.paths);
+  return new DaemonClient(ctx.paths);
+}
+function parseJsonArg(raw, label) {
+  if (raw === undefined)
+    return;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", `${label} 不是合法 JSON`);
+  }
+}
+async function lightSend(ctx, _args, opts) {
+  const body = {};
+  if (opts.segments)
+    body.segments = parseJsonArg(opts.segments, "--segments");
+  if (opts.preset)
+    body.preset = opts.preset;
+  if (opts.repeat)
+    body.repeat = true;
+  if (opts.repeatTimes !== undefined)
+    body.repeat_times = Number(opts.repeatTimes);
+  const res = await client(ctx).post("/light/send", body);
+  return res.body;
+}
+async function lightBlink(ctx) {
+  const res = await client(ctx).post("/light/send", { preset: "blink" });
+  return res.body;
+}
+async function listRules(c) {
+  const res = await c.post("/gateway/lightrules.list", {});
+  return res.body?.data?.rules ?? [];
+}
+async function lightruleList(ctx) {
+  return { ok: true, rules: await listRules(client(ctx)) };
+}
+async function lightruleShow(ctx, args) {
+  const [id] = args;
+  const rule = (await listRules(client(ctx))).find((r) => r.id === id || r.name === id);
+  if (!rule)
+    throw new YoooclawError("YOOOCLAW_NOT_FOUND", `规则不存在：${id}`);
+  return { ok: true, rule };
+}
+async function buildRuleParams(opts, name) {
+  if (opts.fromFile) {
+    const raw = opts.fromFile === "-" ? await readStdin() : import_node_fs22.readFileSync(opts.fromFile, "utf-8");
+    return JSON.parse(raw);
+  }
+  const params = {};
+  if (name)
+    params.name = name;
+  if (opts.name)
+    params.name = opts.name;
+  if (opts.intent)
+    params.description = opts.intent;
+  const action = parseJsonArg(opts.lightAction, "--light-action");
+  if (action !== undefined) {
+    params.segments = Array.isArray(action) ? action : action.segments ?? action;
+  }
+  const match = parseJsonArg(opts.matchRules, "--match-rules");
+  if (match !== undefined)
+    params.matchRules = match;
+  return params;
+}
+async function lightruleCreate(ctx, _args, opts) {
+  const c = client(ctx);
+  const params = await buildRuleParams(opts);
+  const res = await c.post("/gateway/lightrules.create", params);
+  if (!res.body || res.body.ok === false) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", JSON.stringify(res.body?.error ?? res.body));
+  }
+  return res.body.data ?? res.body;
+}
+async function lightruleUpdate(ctx, args, opts) {
+  const [id] = args;
+  const c = client(ctx);
+  const params = await buildRuleParams(opts, id);
+  params.name = id;
+  const res = await c.post("/gateway/lightrules.update", params);
+  return res.body.data ?? res.body;
+}
+async function lightruleDelete(ctx, args, opts) {
+  const [id] = args;
+  if (!opts.yes && !await confirm(`确认删除规则 \`${id}\`？`, false)) {
+    throw new YoooclawError("YOOOCLAW_CONFIRMATION_REQUIRED", "已取消");
+  }
+  const res = await client(ctx).post("/gateway/lightrules.delete", { name: id });
+  return res.body.data ?? res.body;
+}
+async function lightruleEnable(ctx, args) {
+  const [id] = args;
+  const res = await client(ctx).post("/gateway/lightrules.update", { name: id, enabled: true });
+  return res.body.data ?? res.body;
+}
+async function lightruleDisable(ctx, args) {
+  const [id] = args;
+  const res = await client(ctx).post("/gateway/lightrules.update", { name: id, enabled: false });
+  return res.body.data ?? res.body;
+}
+async function toggleAll(ctx, enabled) {
+  const c = client(ctx);
+  const rules = await listRules(c);
+  const results = [];
+  for (const rule of rules) {
+    const res = await c.post("/gateway/lightrules.update", { name: rule.name, enabled });
+    results.push({ name: rule.name, ok: res.body?.ok !== false });
+  }
+  return { ok: true, enabled, count: results.length, results };
+}
+var lightruleOn = (ctx) => toggleAll(ctx, true);
+var lightruleOff = (ctx) => toggleAll(ctx, false);
+async function tunnelStatus(ctx) {
+  return (await client(ctx).get("/tunnel/status")).body;
+}
+async function tunnelReconnect(ctx) {
+  return (await client(ctx).post("/tunnel/reconnect")).body;
+}
+async function tunnelTest(ctx) {
+  return (await client(ctx).post("/tunnel/test")).body;
+}
+async function monitorList(ctx) {
+  return (await client(ctx).get("/monitors")).body;
+}
+async function monitorShow(ctx, args) {
+  const [name] = args;
+  const res = await client(ctx).get("/monitors");
+  const monitor = res.body?.monitors?.find((m) => m.name === name);
+  if (!monitor)
+    throw new YoooclawError("YOOOCLAW_NOT_FOUND", `监控任务不存在：${name}`);
+  return { ok: true, monitor };
+}
+async function monitorCreate(ctx, args, opts) {
+  const [name] = args;
+  if (!opts.description || !opts.matchRules || !opts.schedule) {
+    throw new YoooclawError("YOOOCLAW_INVALID_ARGUMENT", "--description / --match-rules / --schedule 均必填");
+  }
+  const res = await client(ctx).post("/monitors", {
+    name,
+    description: opts.description,
+    matchRules: parseJsonArg(opts.matchRules, "--match-rules"),
+    schedule: opts.schedule
+  });
+  return res.body;
+}
+async function monitorDelete(ctx, args, opts) {
+  const [name] = args;
+  if (!opts.yes && !await confirm(`确认删除监控任务 \`${name}\`？`, false)) {
+    throw new YoooclawError("YOOOCLAW_CONFIRMATION_REQUIRED", "已取消");
+  }
+  return (await client(ctx).request("DELETE", `/monitors/${encodeURIComponent(name)}`)).body;
+}
+async function monitorEnable(ctx, args) {
+  const [name] = args;
+  return (await client(ctx).post(`/monitors/${encodeURIComponent(name)}/enable`)).body;
+}
+async function monitorDisable(ctx, args) {
+  const [name] = args;
+  return (await client(ctx).post(`/monitors/${encodeURIComponent(name)}/disable`)).body;
+}
+async function gatewayTest(ctx, _args, opts) {
+  const c = client(ctx);
+  if (opts.viaRelay) {
+    return { ok: true, viaRelay: true, result: (await c.post("/tunnel/test")).body };
+  }
+  const probe = {
+    notifications: [
+      { id: `gwtest_${Date.now()}`, app: "yoooclaw.gatewaytest", title: "gateway test", body: "probe", timestamp: new Date().toISOString() }
+    ]
+  };
+  const res = await c.post("/notifications", probe);
+  return {
+    ok: res.status >= 200 && res.status < 300,
+    fromPhoneIp: opts.fromPhoneIp ?? null,
+    status: res.status,
+    response: res.body
+  };
+}
+async function apiRaw(ctx, args, opts) {
+  const [method, path] = args;
+  let data;
+  if (opts.data) {
+    let raw;
+    if (opts.data === "-")
+      raw = await readStdin();
+    else if (opts.data.startsWith("@"))
+      raw = import_node_fs22.readFileSync(opts.data.slice(1), "utf-8");
+    else
+      raw = opts.data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      data = raw;
+    }
+  }
+  const headers = {};
+  const headerList = Array.isArray(opts.header) ? opts.header : opts.header ? [opts.header] : [];
+  for (const h of headerList) {
+    const idx = h.indexOf(":");
+    if (idx > 0)
+      headers[h.slice(0, idx).trim()] = h.slice(idx + 1).trim();
+  }
+  const res = await client(ctx).request(method.toUpperCase(), path, data, headers);
+  return { ok: res.status >= 200 && res.status < 300, status: res.status, body: res.body };
+}
+
+// src/commands/registry.ts
+var HANDLERS = {
+  "config init": configInit,
+  "config show": configShow,
+  "config set": configSet,
+  "config unset": configUnset,
+  "profile list": profileList,
+  "profile use": profileUse,
+  "profile create": profileCreate,
+  "profile delete": profileDelete,
+  "auth set-api-key": authSetApiKey,
+  "auth status": authStatus,
+  "auth token-rotate": authTokenRotate,
+  "auth check": authCheck,
+  "notification search": notificationSearch,
+  "notification summary": notificationSummary,
+  "notification stats": notificationStats,
+  "notification storage-path": notificationStoragePath,
+  "notification +today": notificationToday,
+  "notification +recent": notificationRecent,
+  "notification +unread": notificationUnread,
+  "sync scan": syncScan,
+  "sync fetch": syncFetch,
+  "sync commit": syncCommit,
+  "recording list": recordingList,
+  "recording status": recordingStatus,
+  "recording storage-path": recordingStoragePath,
+  "recording setup-asr": recordingSetupAsr,
+  "recording +latest": recordingLatest,
+  "image list": imageList,
+  "image status": imageStatus,
+  "image path": imagePath,
+  "image storage-path": imageStoragePath,
+  "image +latest": imageLatest,
+  log: logSearch,
+  "log +errors": logErrors,
+  "migrate from-openclaw": migrateFromOpenclaw,
+  "update self": updateSelf,
+  doctor,
+  "daemon start": daemonStart,
+  "daemon stop": daemonStop,
+  "daemon restart": daemonRestart,
+  "daemon status": daemonStatus,
+  "daemon logs": daemonLogs,
+  "daemon run-foreground": daemonRunForeground,
+  "light send": lightSend,
+  "light +blink": lightBlink,
+  "lightrule list": lightruleList,
+  "lightrule show": lightruleShow,
+  "lightrule create": lightruleCreate,
+  "lightrule update": lightruleUpdate,
+  "lightrule delete": lightruleDelete,
+  "lightrule enable": lightruleEnable,
+  "lightrule disable": lightruleDisable,
+  "lightrule +on": lightruleOn,
+  "lightrule +off": lightruleOff,
+  "tunnel status": tunnelStatus,
+  "tunnel reconnect": tunnelReconnect,
+  "tunnel +test": tunnelTest,
+  "monitor list": monitorList,
+  "monitor show": monitorShow,
+  "monitor create": monitorCreate,
+  "monitor delete": monitorDelete,
+  "monitor enable": monitorEnable,
+  "monitor disable": monitorDisable,
+  "gateway test": gatewayTest,
+  api: apiRaw
+};
+
+// src/program.ts
+function wrapAction(handler) {
+  return async (...rawArgs) => {
+    const command = rawArgs.at(-1);
+    const opts = rawArgs.at(-2);
+    const positionals = rawArgs.slice(0, -2);
+    const globals = command.optsWithGlobals();
+    let ctx;
+    try {
+      ctx = buildContext(globals);
+      const result = await handler(ctx, positionals, opts);
+      renderResult(result, { format: ctx.format });
+    } catch (err) {
+      const format = ctx?.format ?? "json";
+      renderError(err, { format });
+      process.exitCode = err instanceof YoooclawError ? err.exitCode : 1;
+    }
+  };
+}
+function resolveHandler(path) {
+  const handler = HANDLERS[path];
+  if (handler)
+    return handler;
+  return () => {
+    throw notImplemented(path);
+  };
+}
+function applyOptions(cmd, options) {
+  for (const opt of options ?? []) {
+    if (opt.default !== undefined) {
+      cmd.option(opt.flags, opt.summary, opt.default);
+    } else {
+      cmd.option(opt.flags, opt.summary);
+    }
+  }
+}
+function attachService(program, spec) {
+  const service = program.command(spec.name).description(spec.summary);
+  if (!spec.subcommands || spec.subcommands.length === 0) {
+    if (spec.args) {
+      service.arguments(spec.args);
+    }
+    applyOptions(service, spec.options);
+    service.action(wrapAction(resolveHandler(spec.name)));
+  } else {
+    for (const sub of spec.subcommands) {
+      const subCmd = service.command(sub.name).description(sub.summary);
+      applyOptions(subCmd, sub.options);
+      subCmd.action(wrapAction(resolveHandler(handlerKey(spec.name, sub.name))));
+    }
+  }
+  for (const shortcut of spec.shortcuts ?? []) {
+    const shortcutCmd = service.command(shortcut.name).description(shortcut.summary);
+    applyOptions(shortcutCmd, shortcut.options);
+    shortcutCmd.action(wrapAction(resolveHandler(handlerKey(spec.name, shortcut.name))));
+  }
+}
+function handlerKey(service, subName) {
+  const bare = subName.split(/\s+/)[0];
+  return `${service} ${bare}`;
 }
 function buildProgram() {
   const program = new import_commander.Command;
@@ -490,5 +4803,5 @@ async function run(argv = process.argv) {
 // src/bin.ts
 run(process.argv);
 
-//# debugId=885B6E71DB5ADDF164756E2164756E21
+//# debugId=9E8D45DFD5AB967964756E2164756E21
 //# sourceMappingURL=bin.cjs.map