@mkterswingman/5mghost-wonder 0.0.13 → 0.0.15

package/dist/commands/browser.js

@@ -0,0 +1,87 @@
+// src/commands/browser.ts
+// Experimental browser runtime commands.
+import { resolveWonderPaths } from "../platform/paths.js";
+import { parseWecomUrl } from "../wecom/url.js";
+import { runBrowserNoExportProbe, runBrowserNoExportRead, } from "../wecom/browser-probe.js";
+export async function runBrowserCommand(argv, context) {
+    const [sub, ...rest] = argv;
+    switch (sub) {
+        case "probe":
+            return runBrowserProbe(rest, context);
+        case "read":
+            return runBrowserRead(rest, context);
+        default:
+            context.io.stderr(`Unknown subcommand: browser ${sub ?? "(none)"}\n` +
+                "Usage: wonder browser probe|read <url> [--headed] [--timeout-ms <ms>] [--save <dir>]");
+            return { exitCode: 1 };
+    }
+}
+async function runBrowserRead(args, context) {
+    return runBrowserAction(args, context, "read");
+}
+async function runBrowserProbe(args, context) {
+    return runBrowserAction(args, context, "probe");
+}
+async function runBrowserAction(args, context, action) {
+    let url;
+    let saveDir;
+    let timeoutMs;
+    let headed = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--save" && args[i + 1]) {
+            saveDir = args[++i];
+        }
+        else if (arg === "--timeout-ms" && args[i + 1]) {
+            timeoutMs = Number(args[++i]);
+        }
+        else if (arg === "--headed") {
+            headed = true;
+        }
+        else if (!arg.startsWith("-")) {
+            url = arg;
+        }
+    }
+    if (!url) {
+        context.io.stderr(JSON.stringify({
+            error: "missing_url",
+            message: `用法：wonder browser ${action} <url> [--headed] [--timeout-ms <ms>] [--save <dir>]`,
+        }));
+        return { exitCode: 1, telemetry: { outcome: "failure", errorKind: "missing_url" } };
+    }
+    const parsed = parseWecomUrl(url);
+    if (!parsed.ok) {
+        context.io.stderr(JSON.stringify({
+            error: "invalid_url",
+            message: "无法识别的 WeCom URL",
+        }));
+        return { exitCode: 1, telemetry: { outcome: "failure", errorKind: "invalid_url" } };
+    }
+    if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs < 1000 || timeoutMs > 60_000)) {
+        context.io.stderr(JSON.stringify({
+            error: "invalid_timeout",
+            message: "--timeout-ms must be between 1000 and 60000",
+        }));
+        return { exitCode: 1, telemetry: { outcome: "failure", errorKind: "invalid_timeout" } };
+    }
+    const paths = resolveWonderPaths({ homeDir: context.homeDir });
+    const options = {
+        url,
+        chromeProfilePath: paths.chromeProfilePath,
+        saveDir,
+        headed,
+        timeoutMs,
+        io: context.io,
+    };
+    const result = action === "read"
+        ? await runBrowserNoExportRead(options)
+        : await runBrowserNoExportProbe(options);
+    context.io.stdout(JSON.stringify(result));
+    return {
+        exitCode: result.status === "fail" ? 1 : 0,
+        telemetry: {
+            outcome: result.status === "fail" ? "failure" : "success",
+            errorKind: result.status === "fail" ? "browser_probe_failed" : undefined,
+        },
+    };
+}

package/dist/commands/help.js

@@ -30,6 +30,12 @@ export function renderHelpText() {
         "                                doc/slide → download file + path JSON",
         "  read <url> --tab <name>       Read specific xlsx tab (cells + merges + images)",
         "  read <url> --save <dir>       Output directory (default: ~/Downloads/5mghost-wonder/)",
+        "",
+        "Experimental browser runtime:",
+        "  browser probe <url>           Open in Wonder browser profile and capture",
+        "                                no-export evidence summaries",
+        "  browser read <url>            Experimental no-export text read",
+        "  browser probe <url> --headed  Show the browser while probing",
     ].join("\n");
 }
 export async function runHelpCommand(io) {

package/dist/commands/index.js

@@ -11,6 +11,7 @@ import { runSetupCommand } from "./setup.js";
 import { runAuthCommand } from "./auth.js";
 import { runWecom } from "./wecom.js";
 import { runReadCommand } from "./read.js";
+import { runBrowserCommand } from "./browser.js";
 export async function dispatchWonderCommand(argv, context) {
     const [cmd, ...rest] = argv;
     switch (cmd) {
@@ -30,6 +31,8 @@ export async function dispatchWonderCommand(argv, context) {
             return runWecom(rest, context);
         case "read":
             return runRead(rest, context);
+        case "browser":
+            return runBrowserCommand(rest, context);
         case "--help":
         case "-h":
         case "help":

package/dist/telemetry/runtime.js

@@ -2,7 +2,7 @@
 // Factory for the wonder telemetry runtime.
 // Returns null on any construction error — telemetry must never crash the CLI.
 import { DEFAULT_AUTH_URL, TokenManager } from "@mkterswingman/5mghost-auth";
-import { TelemetryRuntime, TelemetrySender } from "@mkterswingman/5mghost-telemetry";
+import { TelemetryRuntime, TelemetrySender, } from "@mkterswingman/5mghost-telemetry";
 import packageJson from "../../package.json" with { type: "json" };
 export function createWonderTelemetryRuntime(options = {}) {
     try {
@@ -17,11 +17,12 @@ export function createWonderTelemetryRuntime(options = {}) {
             authUrl,
             homeDir: options.homeDir,
         });
+        const sender = new SafeTelemetrySender(new TelemetrySender(tokenManager, ingestUrl));
         return new TelemetryRuntime({
             product: "5mghost-wonder",
             productVersion: packageJson.version,
             homeDir: options.homeDir,
-            sender: new TelemetrySender(tokenManager, ingestUrl),
+            sender,
         });
     }
     catch {
@@ -29,3 +30,23 @@ export function createWonderTelemetryRuntime(options = {}) {
         return null;
     }
 }
+class SafeTelemetrySender {
+    delegate;
+    constructor(delegate) {
+        this.delegate = delegate;
+    }
+    async sendBatch(events) {
+        try {
+            return await this.delegate.sendBatch(events);
+        }
+        catch (err) {
+            const errorName = err instanceof Error ? err.name : typeof err;
+            return {
+                disposition: {
+                    retryable: true,
+                    reason: `transport:${errorName}`,
+                },
+            };
+        }
+    }
+}