npm - chainlesschain - Versions diffs - 0.162.9 → 0.162.11 - Mend

chainlesschain 0.162.9 → 0.162.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (143) hide show

package/src/commands/notification.js ADDED Viewed

@@ -0,0 +1,260 @@
+/**
+ * `cc notification send` — push a notification to a paired mobile device.
+ *
+ * Wire model: the desktop Electron app (when running with --web-shell) starts
+ * a ws-bridge on an OS-assigned port and writes the bound URL into
+ * `~/.chainlesschain/desktop.port`. We read that file, open a WebSocket, and
+ * invoke the `notification.send-mobile` topic which routes to
+ * remoteGateway.handlers.notification.sendToMobile inside the desktop
+ * process, which in turn pushes over the P2P DC to the paired iPhone/Android.
+ *
+ * Exit codes:
+ *   0  success
+ *   2  desktop port file missing or stale (desktop app not running)
+ *   3  desktop returned ok:false / handler unavailable / network error
+ *   4  invalid args
+ *
+ * Implemented as part of #21 v1.3+ to unblock plan
+ * `iOS_Phase_6_0_RealDevice_E2E_Plan.md` §6 D2/D3/D6 reproducer.
+ */
+import fs from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+import WebSocket from "ws";
+const PORT_FILE = path.join(os.homedir(), ".chainlesschain", "desktop.port");
+const TOPIC = "notification.send-mobile";
+const RESULT_TOPIC = "notification.send-mobile.result";
+export function registerNotificationCommand(program) {
+  const cmd = program
+    .command("notification")
+    .alias("notif")
+    .description("Push notifications to paired mobile devices");
+  cmd
+    .command("send")
+    .description("Send a push notification to a paired iPhone/Android")
+    .requiredOption(
+      "--target <did>",
+      "Target device DID (paired iPhone/Android)",
+    )
+    .requiredOption("--title <title>", "Notification title")
+    .option("--body <body>", "Notification body", "")
+    .option(
+      "--silenced",
+      "Send envelope without ringing (delivery-only, for quiet hours test)",
+    )
+    .option("--type <type>", "Notification type", "app")
+    .option("--timeout <ms>", "RPC timeout in milliseconds", "10000")
+    .option("--json", "Emit machine-readable JSON instead of human text")
+    .action(async (options) => {
+      const exitCode = await runSendNotification(options);
+      process.exit(exitCode);
+    });
+}
+export async function runSendNotification(options, _deps = {}) {
+  const fsDep = _deps.fs || fs;
+  const wsDep = _deps.WebSocket || WebSocket;
+  const portFilePath = _deps.portFilePath || PORT_FILE;
+  const log = _deps.log || console.log;
+  const err = _deps.err || ((m) => console.error(m));
+  let descriptor;
+  try {
+    const raw = fsDep.readFileSync(portFilePath, "utf-8");
+    descriptor = JSON.parse(raw);
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      err(
+        options.json
+          ? JSON.stringify({
+              success: false,
+              error: "desktop_not_running",
+              portFile: portFilePath,
+            })
+          : `桌面未运行（找不到 ${portFilePath}）。请先启动 ChainlessChain 桌面 app (\`cd desktop-app-vue && npm run dev\`)。`,
+      );
+      return 2;
+    }
+    err(
+      options.json
+        ? JSON.stringify({
+            success: false,
+            error: "port_file_unreadable",
+            detail: e.message,
+          })
+        : `读取桌面 port 文件失败: ${e.message}`,
+    );
+    return 2;
+  }
+  if (!descriptor || typeof descriptor.wsUrl !== "string") {
+    err(
+      options.json
+        ? JSON.stringify({
+            success: false,
+            error: "port_file_malformed",
+            descriptor,
+          })
+        : `桌面 port 文件格式错误: ${JSON.stringify(descriptor)}`,
+    );
+    return 2;
+  }
+  // Stale-pid check: if the writing process is gone, the port is dead.
+  if (typeof descriptor.pid === "number" && descriptor.pid > 0) {
+    try {
+      // process.kill with signal 0 doesn't actually send anything — it only
+      // tests if the pid exists and we can signal it.
+      process.kill(descriptor.pid, 0);
+    } catch (e) {
+      if (e.code === "ESRCH") {
+        err(
+          options.json
+            ? JSON.stringify({
+                success: false,
+                error: "desktop_stale_pid",
+                pid: descriptor.pid,
+              })
+            : `桌面 port 文件存在但 pid=${descriptor.pid} 已退出（残留文件，可手动 rm ${portFilePath} 或重启桌面）。`,
+        );
+        return 2;
+      }
+      // EPERM = process exists but we can't signal it (still alive, fine)
+    }
+  }
+  const requestId = crypto.randomUUID();
+  // ws-bridge protocol: frame.type is the topic name; notification semantic
+  // type rides on frame.notificationType.
+  const frame = {
+    type: TOPIC,
+    id: requestId,
+    title: options.title,
+    body: options.body || "",
+    target: options.target,
+    silent: !!options.silenced,
+    notificationType: options.type,
+  };
+  const timeoutMs = Math.max(
+    1000,
+    Math.min(120000, parseInt(options.timeout, 10) || 10000),
+  );
+  const result = await new Promise((resolve) => {
+    let resolved = false;
+    const finish = (value) => {
+      if (resolved) return;
+      resolved = true;
+      resolve(value);
+    };
+    let socket;
+    try {
+      socket = new wsDep(descriptor.wsUrl);
+    } catch (e) {
+      finish({
+        success: false,
+        error: "ws_construct_failed",
+        detail: e.message,
+      });
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        socket.terminate();
+      } catch {
+        /* ignore */
+      }
+      finish({ success: false, error: "rpc_timeout", timeoutMs });
+    }, timeoutMs);
+    socket.on("open", () => {
+      try {
+        socket.send(JSON.stringify(frame));
+      } catch (e) {
+        clearTimeout(timer);
+        finish({ success: false, error: "ws_send_failed", detail: e.message });
+      }
+    });
+    socket.on("message", (raw) => {
+      let response;
+      try {
+        response = JSON.parse(raw.toString("utf-8"));
+      } catch (e) {
+        clearTimeout(timer);
+        try {
+          socket.close();
+        } catch {
+          /* ignore */
+        }
+        finish({
+          success: false,
+          error: "invalid_response_json",
+          detail: e.message,
+        });
+        return;
+      }
+      if (response?.id !== requestId) {
+        // Ignore unrelated frames (ws-bridge may have other subscribers).
+        return;
+      }
+      clearTimeout(timer);
+      try {
+        socket.close();
+      } catch {
+        /* ignore */
+      }
+      if (response.type !== RESULT_TOPIC) {
+        finish({
+          success: false,
+          error: "unexpected_response_topic",
+          response,
+        });
+        return;
+      }
+      if (response.ok === true) {
+        finish({ success: true, result: response.result });
+      } else {
+        finish({ success: false, error: response.error || "unknown_error" });
+      }
+    });
+    socket.on("error", (e) => {
+      clearTimeout(timer);
+      finish({
+        success: false,
+        error: "ws_error",
+        detail: e?.message || String(e),
+      });
+    });
+  });
+  if (result.success) {
+    if (options.json) {
+      log(JSON.stringify(result));
+    } else {
+      log(`✔ 通知已推送 (target=${options.target}, title="${options.title}")`);
+      if (result.result && typeof result.result === "object") {
+        log(`  详情: ${JSON.stringify(result.result)}`);
+      }
+    }
+    return 0;
+  }
+  if (options.json) {
+    err(JSON.stringify(result));
+  } else {
+    err(
+      `✖ 推送失败: ${result.error}${result.detail ? ` — ${result.detail}` : ""}`,
+    );
+  }
+  return 3;
+}

package/src/commands/pack.js CHANGED Viewed

@@ -23,6 +23,7 @@ import {
   scheduleReplace,
   ApplyError,
 } from "../lib/packer/pack-update-applier.js";
+import { askConfirm } from "../lib/prompts.js";
 import { VERSION } from "../constants.js";
 /**
@@ -221,6 +222,9 @@ export function registerPackCommand(program) {
       false,
     )
     .action(async (opts) => {
+      // The shared resolver lives in runAutoUpdate too; kept duplicated here
+      // because check-update's behavior tree (no download, --download alone,
+      // --download --apply) is distinct enough from auto-update's one-shot.
       const manifestUrl =
         opts.manifestUrl ||
         process.env.CC_PACK_UPDATE_MANIFEST ||
@@ -456,8 +460,323 @@ export function registerPackCommand(program) {
         process.exit(4);
       }
     });
+  // Phase 3g (2026-05-20): one-shot OTA orchestration. Same chain as
+  // `check-update --download --apply --restart` but with a confirm prompt
+  // before the destructive apply and a friendlier default flag set.
+  packCmd
+    .command("auto-update")
+    .description(
+      "One-shot OTA: check → confirm → download → apply (Phase 5a+5b+5c)",
+    )
+    .option(
+      "--manifest-url <url>",
+      "Manifest URL (falls back to BAKED.updateManifestUrl or CC_PACK_UPDATE_MANIFEST env)",
+    )
+    .option(
+      "--target <slug>",
+      "pkg target to match against manifest.latest.artifacts (defaults to current host)",
+    )
+    .option(
+      "--current <version>",
+      "Override the current version (defaults to BAKED.packedCliVersion or CLI VERSION)",
+    )
+    .option(
+      "--target-exe <path>",
+      "Path of the exe to replace (defaults to process.execPath)",
+    )
+    .option(
+      "--dest <path>",
+      "Download destination (defaults to `<currentExePath>.new` inside a packed exe)",
+    )
+    .option("-y, --yes", "Skip interactive confirm before applying", false)
+    .option(
+      "--no-restart",
+      "Don't restart the new exe after applying (default: restart)",
+    )
+    .option("--dry-run", "Check only; don't download or apply", false)
+    .option("--json", "Emit JSON instead of human-readable output", false)
+    .action(async (opts) => {
+      await runAutoUpdate({ opts });
+    });
 }
 function formatMB(bytes) {
   return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
 }
+/**
+ * `cc pack auto-update` — one-shot OTA orchestration. Chains Phase 5a (check)
+ * → Phase 5b (download+verify) → Phase 5c (apply) with an interactive confirm
+ * between the check and the destructive apply step.
+ *
+ * Compared to `cc pack check-update --download --apply --restart`:
+ *   - Default --restart=true (one-shot UX expects the new exe to come up)
+ *   - Interactive confirm before apply (skip with -y / --yes)
+ *   - --json implies --yes (can't prompt in JSON mode)
+ *   - --dry-run stops after the check stage, just like `check-update` alone
+ *
+ * Exported separately so tests can call it without standing up a full
+ * commander program. The real registration in registerPackCommand below just
+ * wires options + delegates here.
+ *
+ * @param {object} ctx
+ * @param {object} ctx.opts                      parsed commander flags
+ * @param {typeof checkPackUpdate} [ctx.checkImpl]
+ * @param {typeof downloadAndVerify} [ctx.downloadImpl]
+ * @param {typeof scheduleReplace} [ctx.applyImpl]
+ * @param {typeof askConfirm} [ctx.confirmImpl]
+ * @param {object} [ctx.logger]                  defaults to module logger
+ * @param {(code:number)=>void} [ctx.exit]       defaults to process.exit
+ * @returns {Promise<{action:"check"|"up-to-date"|"declined"|"applied", result?:object}>}
+ */
+export async function runAutoUpdate({
+  opts,
+  checkImpl = checkPackUpdate,
+  downloadImpl = downloadAndVerify,
+  applyImpl = scheduleReplace,
+  confirmImpl = askConfirm,
+  logger: log = logger,
+  exit = (code) => process.exit(code),
+}) {
+  const manifestUrl =
+    opts.manifestUrl ||
+    process.env.CC_PACK_UPDATE_MANIFEST ||
+    (typeof globalThis.BAKED === "object" &&
+      globalThis.BAKED?.updateManifestUrl) ||
+    null;
+  if (!manifestUrl) {
+    const msg =
+      "No manifest URL. Provide --manifest-url, set CC_PACK_UPDATE_MANIFEST, or bake one via `cc pack --update-manifest-url`.";
+    if (opts.json) {
+      log.log(JSON.stringify({ error: msg, code: "NO_MANIFEST_URL" }));
+    } else {
+      log.error(msg);
+    }
+    exit(2);
+    return { action: "check" };
+  }
+  const currentVersion =
+    opts.current ||
+    (typeof globalThis.BAKED === "object" &&
+      globalThis.BAKED?.packedCliVersion) ||
+    VERSION;
+  const target = opts.target || defaultPkgTarget();
+  // ── Stage 1: check ──────────────────────────────────────────────────────
+  let result;
+  try {
+    result = await checkImpl({ manifestUrl, currentVersion, target });
+  } catch (err) {
+    const code = err instanceof PackUpdateError ? err.code : "UNKNOWN";
+    if (opts.json) {
+      log.log(JSON.stringify({ error: err.message, code }));
+    } else {
+      log.error(`check failed [${code}]: ${err.message}`);
+    }
+    exit(3);
+    return { action: "check" };
+  }
+  if (!result.updateAvailable) {
+    if (opts.json) {
+      log.log(JSON.stringify({ action: "up-to-date", ...result }));
+    } else {
+      log.log(
+        chalk.green(
+          `  ✓ You are on the latest version (${result.currentVersion}).`,
+        ),
+      );
+    }
+    return { action: "up-to-date", result };
+  }
+  if (!result.artifact) {
+    const msg = `No artifact for target "${target}" in this manifest.`;
+    if (opts.json) {
+      log.log(JSON.stringify({ error: msg, code: "NO_ARTIFACT" }));
+    } else {
+      log.error(msg);
+    }
+    exit(3);
+    return { action: "check" };
+  }
+  // Surface the check result before prompting for the destructive step.
+  if (!opts.json) {
+    log.log(
+      chalk.bold(
+        `\n  Update available: ${result.currentVersion} → ${chalk.green(result.latestVersion)}`,
+      ),
+    );
+    log.log(`  Artifact (${target}):`);
+    log.log(`    ${result.artifact.url}`);
+    log.log(chalk.dim(`    sha256: ${result.artifact.sha256}`));
+    if (result.releaseNotes) {
+      log.log(chalk.dim(`    Release notes: ${result.releaseNotes}`));
+    }
+  }
+  if (opts.dryRun) {
+    if (opts.json) {
+      log.log(JSON.stringify({ action: "check", ...result }, null, 2));
+    } else {
+      log.log(chalk.dim(`\n  --dry-run: skipping download and apply.`));
+    }
+    return { action: "check", result };
+  }
+  // ── Stage 2: confirm ────────────────────────────────────────────────────
+  // JSON mode skips the interactive prompt — callers in non-TTY contexts
+  // must opt in explicitly via --yes (which also works in human mode).
+  const needsConfirm = !opts.yes && !opts.json;
+  if (needsConfirm) {
+    const ok = await confirmImpl(
+      `Download + apply update ${result.currentVersion} → ${result.latestVersion}?`,
+      true,
+    );
+    if (!ok) {
+      log.log(chalk.dim(`  Cancelled by user.`));
+      return { action: "declined", result };
+    }
+  }
+  // ── Stage 3: download ───────────────────────────────────────────────────
+  // Same default as check-update --download: inside packed exe drop next to
+  // current; outside, drop into cwd so dev-mode invocations are visible.
+  const outputPath = opts.dest
+    ? path.resolve(opts.dest)
+    : process.pkg
+      ? process.execPath + ".new"
+      : path.resolve(
+          process.cwd(),
+          path.basename(new URL(result.artifact.url).pathname) ||
+            "pack-update-artifact",
+        );
+  if (!opts.json) {
+    log.log(
+      chalk.bold(
+        `\n  Downloading ${result.currentVersion} → ${chalk.green(result.latestVersion)}`,
+      ),
+    );
+    log.log(chalk.dim(`  → ${outputPath}`));
+  }
+  let dl;
+  let lastPercent = -1;
+  try {
+    dl = await downloadImpl({
+      url: result.artifact.url,
+      sha256: result.artifact.sha256,
+      outputPath,
+      onProgress: opts.json
+        ? undefined
+        : ({ bytes, total }) => {
+            if (!total) return;
+            const pct = Math.floor((bytes / total) * 100);
+            if (pct !== lastPercent && pct % 10 === 0) {
+              lastPercent = pct;
+              log.log(
+                chalk.dim(
+                  `    ${pct}% (${formatMB(bytes)}/${formatMB(total)})`,
+                ),
+              );
+            }
+          },
+    });
+  } catch (err) {
+    const code = err instanceof DownloadError ? err.code : "UNKNOWN";
+    if (opts.json) {
+      log.log(JSON.stringify({ error: err.message, code }));
+    } else {
+      log.error(`download failed [${code}]: ${err.message}`);
+    }
+    exit(4);
+    return { action: "check", result };
+  }
+  if (!opts.json) {
+    log.log(
+      chalk.green(
+        `\n  ✓ Downloaded + verified ${formatMB(dl.bytes)} to ${dl.outputPath}`,
+      ),
+    );
+  }
+  // ── Stage 4: apply ──────────────────────────────────────────────────────
+  // auto-update defaults restart=true (one-shot UX); --no-restart flips it.
+  const restart = opts.restart !== false;
+  const targetExe = opts.targetExe || process.execPath;
+  if (!opts.json) {
+    log.log(chalk.bold(`\n  Applying update → ${targetExe}`));
+    if (process.platform === "win32") {
+      log.log(
+        chalk.yellow(
+          `  [Windows] This process will exit after scheduling a sidecar cmd; the replacement runs detached. ${restart ? "The new exe will start automatically." : "Re-launch the exe yourself after exit."}`,
+        ),
+      );
+    } else {
+      log.log(
+        chalk.dim(
+          `  [POSIX] Atomic rename; the running inode survives until exit. ${restart ? "A detached copy will be started now." : "Next launch picks up the new bytes."}`,
+        ),
+      );
+    }
+  }
+  let plan;
+  try {
+    plan = await applyImpl({
+      newExePath: dl.outputPath,
+      targetExePath: targetExe,
+      restart,
+    });
+  } catch (err) {
+    const code = err instanceof ApplyError ? err.code : "UNKNOWN";
+    if (opts.json) {
+      log.log(JSON.stringify({ error: err.message, code }));
+    } else {
+      log.error(`apply failed [${code}]: ${err.message}`);
+    }
+    exit(5);
+    return { action: "check", result };
+  }
+  if (opts.json) {
+    log.log(
+      JSON.stringify(
+        {
+          action: "applied",
+          currentVersion: result.currentVersion,
+          latestVersion: result.latestVersion,
+          download: {
+            outputPath: dl.outputPath,
+            bytes: dl.bytes,
+            sha256: dl.sha256,
+          },
+          apply: plan,
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    log.log(
+      chalk.green(
+        `  ✓ Apply scheduled: action=${plan.action}${plan.sidecarPath ? `, sidecar=${plan.sidecarPath}` : ""}`,
+      ),
+    );
+  }
+  // Windows sidecar needs us to exit so its tasklist wait can complete. Give
+  // it a beat to start polling before we vanish (same dance as check-update
+  // --apply at L432-438; harmless on POSIX where action is replace-in-place).
+  if (plan.action === "sidecar-cmd") {
+    setTimeout(() => exit(0), 500).unref?.();
+  }
+  return { action: "applied", result, download: dl, apply: plan };
+}