@mkterswingman/5mghost-wonder 0.0.1

package/dist/auth/runtime.js

@@ -0,0 +1,15 @@
+// src/auth/runtime.ts
+// Factory for the auth SDK instance injected into CommandContext.
+// Reads MKTERSWINGMAN_AUTH_URL from env so tests and staging can override it.
+// All auth logic lives in @mkterswingman/5mghost-auth; this file only wires the URL.
+import { DEFAULT_AUTH_URL, getAuthStatus, logout, runOAuthLogin, writeAuthState, writePatAuth, } from "@mkterswingman/5mghost-auth";
+export function createWonderAuthSdk(env = process.env) {
+    const authUrl = env["MKTERSWINGMAN_AUTH_URL"] ?? DEFAULT_AUTH_URL;
+    return {
+        getAuthStatus: (options = {}) => getAuthStatus({ homeDir: options.homeDir, authUrl }),
+        runOAuthLogin: (options) => runOAuthLogin({ ...options, authUrl }),
+        writeAuthState: (state, opts) => writeAuthState(state, opts),
+        writePatAuth: (token, opts) => writePatAuth(token, opts),
+        logout: (opts) => logout(opts),
+    };
+}

package/dist/cli.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// src/cli.ts
+// Main entry point for the `wonder` CLI.
+// Telemetry wired by P1-05. Auth wired by P1-04.
+import { resolveWonderPaths } from "./platform/paths.js";
+import { dispatchWonderCommand } from "./commands/index.js";
+import { runHelpCommand } from "./commands/help.js";
+import { createWonderTelemetryRuntime } from "./telemetry/runtime.js";
+import { createWonderAuthSdk } from "./auth/runtime.js";
+import { resolveTelemetryCommand, classifyUnhandledCliError, } from "./telemetry/policy.js";
+import { buildCompletionTelemetry } from "./telemetry/events.js";
+// ── Global error handlers (catch errors outside async dispatch) ─────────────
+process.on("uncaughtException", (err) => {
+    process.stderr.write(`Unhandled exception: ${String(err)}\n`);
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`Unhandled rejection: ${String(reason)}\n`);
+    process.exit(1);
+});
+const argv = process.argv.slice(2);
+const paths = resolveWonderPaths();
+const io = {
+    stdout: (m) => process.stdout.write(m + "\n"),
+    stderr: (m) => process.stderr.write(m + "\n"),
+};
+const telemetry = createWonderTelemetryRuntime({
+    homeDir: paths.homeDir,
+    env: process.env,
+});
+// Flush any queued events from the previous run before starting.
+telemetry?.triggerFlush("startup");
+// authSdk wired by P1-04.
+const context = {
+    io,
+    homeDir: paths.homeDir,
+    authSdk: createWonderAuthSdk(process.env),
+    telemetrySdk: telemetry,
+};
+const startMs = Date.now();
+const cmdInfo = resolveTelemetryCommand(argv);
+try {
+    // No arguments → show help, exit 0
+    if (argv.length === 0) {
+        const result = await runHelpCommand(io);
+        process.exit(result.exitCode);
+    }
+    const result = await dispatchWonderCommand(argv, context);
+    if (cmdInfo && telemetry) {
+        try {
+            telemetry.recordCompletion(buildCompletionTelemetry(cmdInfo, result, Date.now() - startMs));
+        }
+        catch {
+            // Telemetry failure must never change the CLI exit code.
+        }
+    }
+    process.exit(result.exitCode);
+}
+catch (err) {
+    // Classify and record unhandled errors before exiting.
+    if (cmdInfo && telemetry) {
+        try {
+            const meta = classifyUnhandledCliError(cmdInfo.toolName, err);
+            telemetry.recordCompletion({
+                ...meta,
+                durationMs: Date.now() - startMs,
+            });
+        }
+        catch {
+            // Telemetry failure in error path — ignore.
+        }
+    }
+    io.stderr(`Unhandled error: ${String(err)}`);
+    process.exit(1);
+}

package/dist/commands/auth.js

@@ -0,0 +1,100 @@
+// src/commands/auth.ts
+// Implements: wonder auth status | login | login --pat <token> | logout
+// Auth SDK injected via CommandContext.authSdk (DI pattern).
+// Falls back to direct SDK imports when authSdk is not provided in context.
+import { buildOAuthFailureHelpText, buildPatFailureHelpText, buildUnauthedHelpText, getAuthStatus, logout as sharedLogout, runOAuthLogin, writeAuthState, writePatAuth, } from "@mkterswingman/5mghost-auth";
+function renderAuthHelp() {
+    return [
+        "Usage:",
+        "  wonder auth status",
+        "  wonder auth login",
+        "  wonder auth login --pat <TOKEN>",
+        "  wonder auth logout",
+        "",
+        "Login defaults to OAuth.",
+        "Use --pat <TOKEN> for the explicit PAT fallback.",
+    ].join("\n");
+}
+export async function runAuthCommand(args, context) {
+    const [subcommand] = args;
+    // ── help ──────────────────────────────────────────────────────────────────
+    if (!subcommand ||
+        subcommand === "help" ||
+        subcommand === "--help" ||
+        subcommand === "-h") {
+        context.io.stdout(renderAuthHelp());
+        return { exitCode: 0 };
+    }
+    // ── status ────────────────────────────────────────────────────────────────
+    if (subcommand === "status") {
+        const readStatus = context.authSdk?.getAuthStatus ?? getAuthStatus;
+        let status;
+        try {
+            status = await readStatus({ homeDir: context.homeDir });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            context.io.stderr(`Authentication status check failed: ${reason}`);
+            return { exitCode: 1 };
+        }
+        if (!status.authenticated) {
+            context.io.stdout(buildUnauthedHelpText("wonder"));
+            return { exitCode: 1 };
+        }
+        context.io.stdout([
+            "Logged in.",
+            `Type: ${status.type ?? "unknown"}`,
+            `Source: ${status.source ?? "unknown"}`,
+            `Auth file: ${status.authJsonPath}`,
+        ].join("\n"));
+        return { exitCode: 0 };
+    }
+    // ── logout ────────────────────────────────────────────────────────────────
+    if (subcommand === "logout") {
+        const doLogout = context.authSdk?.logout ?? sharedLogout;
+        doLogout({ homeDir: context.homeDir });
+        context.io.stdout("Logged out.");
+        return { exitCode: 0 };
+    }
+    // ── login ─────────────────────────────────────────────────────────────────
+    if (subcommand === "login") {
+        const patFlagIndex = args.indexOf("--pat");
+        // login --pat <TOKEN>
+        if (patFlagIndex >= 0) {
+            const token = args[patFlagIndex + 1]?.trim();
+            if (!token) {
+                context.io.stdout(buildPatFailureHelpText("wonder"));
+                return { exitCode: 1 };
+            }
+            const savePat = context.authSdk?.writePatAuth ?? writePatAuth;
+            savePat(token, { homeDir: context.homeDir });
+            context.io.stdout("PAT saved.");
+            return { exitCode: 0 };
+        }
+        // login (OAuth)
+        const doOAuthLogin = context.authSdk?.runOAuthLogin ?? runOAuthLogin;
+        const saveJwt = context.authSdk?.writeAuthState ?? writeAuthState;
+        try {
+            const result = await doOAuthLogin({ clientName: "wonder" });
+            saveJwt({
+                type: "jwt",
+                access_token: result.accessToken,
+                refresh_token: result.refreshToken,
+                expires_at: Date.now() + result.expiresIn * 1000,
+                client_id: result.clientId,
+            }, { homeDir: context.homeDir });
+            context.io.stdout("Authentication complete.");
+            return { exitCode: 0 };
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            context.io.stderr(`Authentication failed: ${reason}`);
+            context.io.stdout(buildOAuthFailureHelpText("wonder"));
+            return { exitCode: 1 };
+        }
+    }
+    // ── unknown subcommand ────────────────────────────────────────────────────
+    context.io.stderr(`Unknown auth subcommand: ${subcommand}`);
+    context.io.stdout(renderAuthHelp());
+    return { exitCode: 1 };
+}

package/dist/commands/check.js

@@ -0,0 +1,258 @@
+// src/commands/check.ts
+// Checks all runtime dependencies wonder needs.
+//
+// Fields checked:
+//   - auth: mkterswingman auth JWT/PAT
+//   - wecom-cookie: WeCom cookies.json presence + live validity probe
+//   - pandoc: CLI on PATH (used by use-skill for docx/pptx text)
+//   - soffice: CLI on PATH + real executable (broken symlinks are rejected)
+//   - docx-skill: docx SKILL.md present in plugin cache or user skills dir
+//   - pptx-skill: pptx SKILL.md present in plugin cache or user skills dir
+//   - cache: local export cache directory state (informational)
+//   - cookies-perms: POSIX 0600 on cookies.json (informational)
+//
+// Each check produces { label, ok, hint? }. The command exits 0 iff all
+// required checks pass. docx/pptx skills are optional because some consumers
+// (raw JSON, non-Claude AI clients) do not need the Anthropic bundled skills.
+import { accessSync, constants, existsSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { delimiter, join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import { resolveWonderPaths } from "../platform/paths.js";
+import { getCookieStatus } from "../wecom/cookies.js";
+import { describeCacheDir } from "../wecom/cache.js";
+function findOnPath(binName) {
+    const pathEnv = process.env["PATH"] ?? "";
+    const exts = process.platform === "win32"
+        ? (process.env["PATHEXT"] ?? ".EXE;.CMD;.BAT").split(";")
+        : [""];
+    for (const dir of pathEnv.split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const candidate = resolve(dir, `${binName}${ext.toLowerCase()}`);
+            try {
+                accessSync(candidate, constants.X_OK);
+                return candidate;
+            }
+            catch {
+                /* try next */
+            }
+        }
+    }
+    return null;
+}
+function checkExecutable(binName, installHints) {
+    const found = findOnPath(binName);
+    if (!found) {
+        return {
+            label: binName,
+            ok: false,
+            hint: installHints[process.platform] ?? installHints["default"] ?? `install ${binName}`,
+        };
+    }
+    // Resolve symlinks — catches the classic `/opt/homebrew/bin/soffice → /Applications/LibreOffice.app/...`
+    // broken-symlink case where `which` returns a path but the target is gone.
+    let realTarget = null;
+    try {
+        realTarget = realpathSync(found);
+    }
+    catch {
+        return {
+            label: binName,
+            ok: false,
+            hint: `${binName} is a broken symlink at ${found}. Reinstall: ${installHints[process.platform] ?? installHints["default"]}`,
+            detail: found,
+        };
+    }
+    // Cheap liveness probe: does the binary actually run?
+    const probe = spawnSync(found, ["--version"], {
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 5000,
+    });
+    if (probe.error || probe.status === null) {
+        return {
+            label: binName,
+            ok: false,
+            hint: `${binName} is on PATH (${found}) but failed to execute. Reinstall: ${installHints[process.platform] ?? installHints["default"]}`,
+            detail: `realpath=${realTarget}`,
+        };
+    }
+    return {
+        label: binName,
+        ok: true,
+        detail: found === realTarget ? found : `${found} → ${realTarget}`,
+    };
+}
+function checkSkillFile(skillName, opts) {
+    // Check plugin cache first (Anthropic-bundled skills)
+    const pluginGlob = join(opts.home, ".claude-internal", "plugins", "cache", "anthropic-agent-skills");
+    let foundPluginVersion = null;
+    if (existsSync(pluginGlob)) {
+        try {
+            for (const entry of readdirSync(pluginGlob, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                const candidate = join(pluginGlob, entry.name, "skills", skillName, "SKILL.md");
+                if (existsSync(candidate)) {
+                    foundPluginVersion = entry.name;
+                    break;
+                }
+            }
+        }
+        catch {
+            /* fall through to user skills */
+        }
+    }
+    if (foundPluginVersion) {
+        return {
+            label: `${skillName}-skill`,
+            ok: true,
+            detail: `plugin cache (${foundPluginVersion})`,
+        };
+    }
+    // User-installed skills (both -internal and plain variants)
+    for (const claudeRoot of [".claude-internal", ".claude"]) {
+        const userSkill = join(opts.home, claudeRoot, "skills", skillName, "SKILL.md");
+        if (existsSync(userSkill)) {
+            return { label: `${skillName}-skill`, ok: true, detail: userSkill };
+        }
+    }
+    return {
+        label: `${skillName}-skill`,
+        ok: false,
+        optional: true,
+        hint: `For Claude consumers that read .${skillName}: ` +
+            `mkdir -p ~/.claude-internal/skills/${skillName} && ` +
+            `curl -fsSL https://raw.githubusercontent.com/anthropics/skills/main/skills/${skillName}/SKILL.md ` +
+            `-o ~/.claude-internal/skills/${skillName}/SKILL.md`,
+    };
+}
+export async function runCheckCommand(_argv, context) {
+    const paths = resolveWonderPaths({ homeDir: context.homeDir });
+    const items = [];
+    // ── Auth ────────────────────────────────────────────────────────────────
+    if (!context.authSdk) {
+        items.push({
+            label: "auth",
+            ok: false,
+            hint: "mkterswingman auth SDK unavailable — reinstall wonder",
+        });
+    }
+    else {
+        try {
+            const status = await context.authSdk.getAuthStatus({
+                homeDir: context.homeDir,
+            });
+            items.push({
+                label: "auth",
+                ok: status.authenticated,
+                hint: status.authenticated ? undefined : "run: wonder auth login",
+            });
+        }
+        catch (err) {
+            items.push({
+                label: "auth",
+                ok: false,
+                hint: `auth check error: ${String(err)}`,
+            });
+        }
+    }
+    // ── WeCom cookie ────────────────────────────────────────────────────────
+    try {
+        const cs = await getCookieStatus(paths.cookiesPath);
+        if (cs.error) {
+            items.push({ label: "wecom-cookie", ok: false, hint: `cookie error: ${cs.error}` });
+        }
+        else if (!cs.exists) {
+            items.push({ label: "wecom-cookie", ok: false, hint: "run: wonder wecom cookie" });
+        }
+        else if (cs.valid === true) {
+            items.push({ label: "wecom-cookie", ok: true, detail: paths.cookiesPath });
+        }
+        else if (cs.valid === false) {
+            items.push({
+                label: "wecom-cookie",
+                ok: false,
+                hint: "cookie invalid or expired — run: wonder wecom cookie",
+            });
+        }
+        else {
+            items.push({
+                label: "wecom-cookie",
+                ok: false,
+                hint: "cookie status unknown (network?)",
+            });
+        }
+    }
+    catch (err) {
+        items.push({ label: "wecom-cookie", ok: false, hint: `check error: ${String(err)}` });
+    }
+    // ── pandoc ──────────────────────────────────────────────────────────────
+    items.push(checkExecutable("pandoc", {
+        darwin: "brew install pandoc",
+        linux: "sudo apt install -y pandoc  (or: sudo dnf install -y pandoc)",
+        win32: "winget install pandoc",
+        default: "https://pandoc.org/installing.html",
+    }));
+    // ── LibreOffice soffice ─────────────────────────────────────────────────
+    items.push(checkExecutable("soffice", {
+        darwin: "brew install --cask libreoffice",
+        linux: "sudo apt install -y libreoffice  (or: sudo dnf install -y libreoffice)",
+        win32: "winget install LibreOffice.LibreOffice",
+        default: "https://www.libreoffice.org/download",
+    }));
+    // ── docx / pptx skill files ─────────────────────────────────────────────
+    const homeForSkills = context.homeDir || homedir();
+    items.push(checkSkillFile("docx", { home: homeForSkills }));
+    items.push(checkSkillFile("pptx", { home: homeForSkills }));
+    // ── Cache directory (informational) ─────────────────────────────────────
+    const cache = describeCacheDir(paths.cacheDir);
+    items.push({
+        label: "cache",
+        ok: true,
+        detail: cache.exists ? `${paths.cacheDir} (${cache.entries} entries)` : "not yet used",
+        optional: true,
+    });
+    // Cookies file permissions (POSIX only)
+    if (process.platform !== "win32" && existsSync(paths.cookiesPath)) {
+        try {
+            const st = statSync(paths.cookiesPath);
+            const mode = st.mode & 0o777;
+            if (mode & 0o077) {
+                items.push({
+                    label: "cookies-perms",
+                    ok: false,
+                    optional: true,
+                    hint: `cookies.json mode is 0${mode.toString(8)}; expected 0600. Run: chmod 600 ${paths.cookiesPath}`,
+                });
+            }
+        }
+        catch {
+            /* ignore — file may disappear between checks */
+        }
+    }
+    // ── Render ──────────────────────────────────────────────────────────────
+    const requiredFailures = items.filter((i) => !i.ok && !i.optional).length;
+    const optionalFailures = items.filter((i) => !i.ok && i.optional).length;
+    const lines = ["wonder check", ""];
+    for (const i of items) {
+        const icon = i.ok ? "✓" : i.optional ? "!" : "✗";
+        const tail = i.ok
+            ? i.detail ? `  (${i.detail})` : ""
+            : `  — ${i.hint ?? ""}`;
+        lines.push(`  ${icon} ${i.label}${tail}`);
+    }
+    lines.push("");
+    if (requiredFailures === 0 && optionalFailures === 0) {
+        lines.push("Status: ready ✓");
+    }
+    else if (requiredFailures === 0) {
+        lines.push(`Status: ready with ${optionalFailures} warning(s) ⚠`);
+    }
+    else {
+        lines.push(`Status: not ready — ${requiredFailures} required check(s) failed`);
+    }
+    context.io.stdout(lines.join("\n"));
+    return { exitCode: requiredFailures === 0 ? 0 : 1 };
+}

package/dist/commands/help.js

@@ -0,0 +1,38 @@
+// src/commands/help.ts
+// Renders the top-level help text and implements `wonder help` / `wonder --help`.
+export function renderHelpText() {
+    return [
+        "5mghost-wonder",
+        "",
+        "Usage:",
+        "  wonder <command> [options]",
+        "",
+        "Lifecycle:",
+        "  setup              First-time guided setup (auth + wecom cookie + check)",
+        "  check              Check auth + WeCom cookie status",
+        "  update             Update to latest version (npm install -g @latest)",
+        "  version            Print the installed CLI version",
+        "  uninstall          Uninstall (npm uninstall -g)",
+        "",
+        "Auth:",
+        "  auth status        mkterswingman auth status",
+        "  auth login         Browser OAuth login",
+        "  auth login --pat <TOKEN>   PAT login",
+        "  auth logout        Logout",
+        "",
+        "WeCom:",
+        "  wecom cookie       Launch Chrome via CDP to grab WeCom cookies",
+        "  wecom status       Check cookie validity and expiry",
+        "  wecom set-cookie   Manually paste cookies (dev / CI)",
+        "",
+        "Documents:",
+        "  read <url>                    Auto-detect type; xlsx → tab list JSON,",
+        "                                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/)",
+    ].join("\n");
+}
+export async function runHelpCommand(io) {
+    io.stdout(renderHelpText());
+    return { exitCode: 0 };
+}

package/dist/commands/index.js

@@ -0,0 +1,50 @@
+// src/commands/index.ts
+// Top-level command dispatcher.
+// Lifecycle commands are implemented in their own files.
+// auth / wecom / read stubs remain until P1-04, P1-03, P1-07 implement them.
+import { runHelpCommand } from "./help.js";
+import { runVersionCommand } from "./version.js";
+import { runUpdateCommand } from "./update.js";
+import { runUninstallCommand } from "./uninstall.js";
+import { runCheckCommand } from "./check.js";
+import { runSetupCommand } from "./setup.js";
+import { runAuthCommand } from "./auth.js";
+import { runWecom } from "./wecom.js";
+import { runReadCommand } from "./read.js";
+export async function dispatchWonderCommand(argv, context) {
+    const [cmd, ...rest] = argv;
+    switch (cmd) {
+        case "setup":
+            return runSetupCommand(rest, context);
+        case "check":
+            return runCheckCommand(rest, context);
+        case "update":
+            return runUpdateCommand(rest, context);
+        case "uninstall":
+            return runUninstallCommand(rest, context);
+        case "version":
+            return runVersionCommand(rest, context);
+        case "auth":
+            return runAuthCommand(rest, context);
+        case "wecom":
+            return runWecom(rest, context);
+        case "read":
+            return runRead(rest, context);
+        case "--help":
+        case "-h":
+        case "help":
+            return runHelpCommand(context.io);
+        case "--version":
+        case "-v":
+            return runVersionCommand(rest, context);
+        default:
+            context.io.stderr(`Unknown command: ${cmd ?? "(none)"}\nRun "wonder --help" for usage.`);
+            return { exitCode: 1 };
+    }
+}
+// ---------------------------------------------------------------------------
+// read — P1-07
+// ---------------------------------------------------------------------------
+async function runRead(args, context) {
+    return runReadCommand(args, context);
+}