@pugi/cli 0.1.0-beta.5 → 0.1.0-beta.51

package/dist/core/share/uploader.js

@@ -0,0 +1,267 @@
+/**
+ * Upload paths for `pugi share` (Leak L20, 2026-05-27).
+ *
+ * Two targets:
+ *
+ *   - `gist`  shells out to `gh gist create` (requires the `gh` CLI in
+ *             PATH AND `gh auth status` ok, OR `GITHUB_TOKEN` env). The
+ *             gist is created with a fixed filename so the URL paths
+ *             stay stable across re-shares.
+ *   - `pugi`  POSTs to admin-api `/api/pugi/share`. The endpoint is NOT
+ *             present in admin-api today (2026-05-27 audit) — the
+ *             handler degrades gracefully: it surfaces a clear "endpoint
+ *             not yet wired" message and tells the operator to use
+ *             `--gist` for now. The structured payload is otherwise
+ *             ready for the server-side handler to consume; landing the
+ *             endpoint is a separate sprint.
+ *
+ * The two paths share one decision shape (`UploadResult`) so the
+ * command handler renders identical telemetry regardless of which target
+ * was chosen.
+ *
+ * Why we shell out for gist instead of using octokit: octokit would add
+ * a transitive HTTP client + ~200 KB to the npm package surface for a
+ * single feature. `gh gist create` is the operator-friendly form
+ * (already auth'd, public URL on stdout, attribution in the gist
+ * metadata) and degrades cleanly when `gh` is absent.
+ */
+import { spawn } from 'node:child_process';
+/**
+ * Default execa shim. Spawns the binary with `args`, pipes `input` into
+ * stdin if provided, captures stdout + stderr in memory. The CLI ships
+ * with `execa` already pulled for other paths; we use the lighter
+ * `child_process.spawn` here so the share module stays import-clean.
+ */
+export const defaultExecaLike = (file, args, options) => {
+    return new Promise((resolveProm, rejectProm) => {
+        const child = spawn(file, [...args], { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString('utf8');
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString('utf8');
+        });
+        child.on('error', (err) => {
+            // ENOENT (binary missing) lands here; the caller maps it.
+            rejectProm(err);
+        });
+        child.on('close', (code) => {
+            resolveProm({ exitCode: code ?? 0, stdout, stderr });
+        });
+        if (options?.input) {
+            child.stdin.write(options.input);
+        }
+        child.stdin.end();
+    });
+};
+/**
+ * Top-level upload dispatch. The handler picks the right path and
+ * surfaces a uniform result envelope.
+ */
+export async function uploadShare(req) {
+    if (req.target === 'gist') {
+        return uploadGist(req);
+    }
+    return uploadPugi(req);
+}
+/**
+ * Gist upload. Two-step: probe `gh --version` (fast, costs nothing) to
+ * detect a missing binary cleanly, then run `gh gist create`. We pipe
+ * the markdown into stdin to avoid temp files + the OS-level argv
+ * length cap.
+ */
+async function uploadGist(req) {
+    const exec = req.execaLike ?? defaultExecaLike;
+    const description = req.description ?? `Pugi session ${req.sessionId}`;
+    try {
+        // Probe step. `gh --version` returns 0 quickly and surfaces a
+        // distinctive "command not found" via ENOENT on the reject path.
+        const probe = await exec('gh', ['--version']);
+        if (probe.exitCode !== 0) {
+            return {
+                ok: false,
+                target: 'gist',
+                reason: 'gh_not_installed',
+                message: 'gh CLI not available. Install from https://cli.github.com or use --pugi instead.',
+            };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            target: 'gist',
+            reason: 'gh_not_installed',
+            message: 'gh CLI not available. Install from https://cli.github.com or use --pugi instead.',
+        };
+    }
+    // Create the gist. `gh` reads stdin when `-` is the filename arg, which
+    // works with our `--filename` override. The `--public` flag is
+    // intentionally omitted — gists default to secret (unlisted URL), which
+    // is the right default for a session transcript. Operators who want a
+    // public gist can run `gh gist edit --add-public <id>` after the fact.
+    const createArgs = [
+        'gist',
+        'create',
+        '--filename',
+        'pugi-session.md',
+        '--desc',
+        description,
+        '-',
+    ];
+    try {
+        const result = await exec('gh', createArgs, { input: req.markdown });
+        if (result.exitCode !== 0) {
+            // Auth failure is the common case. `gh` prints "gh auth login" to
+            // stderr; we tag it specifically so the gate banner can hint.
+            const looksLikeAuth = /auth/i.test(result.stderr) || /authenticated/i.test(result.stderr);
+            return {
+                ok: false,
+                target: 'gist',
+                reason: looksLikeAuth ? 'gh_unauthenticated' : 'gh_failed',
+                message: looksLikeAuth
+                    ? 'gh is installed but not authenticated. Run `gh auth login` first.'
+                    : `gh gist create exited ${result.exitCode}: ${result.stderr.trim().slice(0, 200)}`,
+            };
+        }
+        // gh prints the URL on stdout. Trim newline + any leading whitespace.
+        const url = result.stdout.trim().split('\n').pop() ?? '';
+        if (!/^https?:\/\//.test(url)) {
+            return {
+                ok: false,
+                target: 'gist',
+                reason: 'gh_failed',
+                message: `gh did not return a URL (stdout: "${result.stdout.trim().slice(0, 200)}")`,
+            };
+        }
+        const remoteId = url.split('/').pop() ?? undefined;
+        return remoteId !== undefined
+            ? { ok: true, target: 'gist', url, remoteId }
+            : { ok: true, target: 'gist', url };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            target: 'gist',
+            reason: 'gh_failed',
+            message: `gh gist create threw: ${message}`,
+        };
+    }
+}
+/**
+ * Pugi.io upload. POSTs the transcript to admin-api `/api/pugi/share`.
+ * The endpoint is NOT yet wired (audit 2026-05-27); when it returns 404
+ * we surface a friendly hint instead of a stack trace. When the operator
+ * is signed-out we surface `pugi_auth_missing` so the gate banner can
+ * point at `pugi login`.
+ *
+ * The wire payload is intentionally minimal so a future server-side
+ * implementation has a stable contract to build against:
+ *
+ *   { sessionId, markdown, description?, cliVersion? }
+ *
+ * Response (when wired):
+ *
+ *   200 { ok: true, url, id }     URL is the pugi.io/share/<id> public link.
+ *   404 / 501                     endpoint not yet implemented — graceful skip.
+ *   401                           auth missing/expired — operator runs `pugi login`.
+ */
+async function uploadPugi(req) {
+    const fetchFn = req.fetchLike ?? globalThis.fetch;
+    if (typeof fetchFn !== 'function') {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_network_error',
+            message: 'No fetch implementation available (Node >=18 expected).',
+        };
+    }
+    if (!req.apiUrl) {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_auth_missing',
+            message: 'pugi.io share requires a signed-in session. Run `pugi login` and retry.',
+        };
+    }
+    const url = `${req.apiUrl.replace(/\/+$/u, '')}/api/pugi/share`;
+    const headers = {
+        'content-type': 'application/json',
+        accept: 'application/json',
+    };
+    if (req.apiToken) {
+        headers.authorization = `Bearer ${req.apiToken}`;
+    }
+    const body = JSON.stringify({
+        sessionId: req.sessionId,
+        markdown: req.markdown,
+        description: req.description ?? `Pugi session ${req.sessionId}`,
+    });
+    let res;
+    try {
+        res = await fetchFn(url, { method: 'POST', headers, body });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_network_error',
+            message: `pugi.io upload failed: ${message}`,
+        };
+    }
+    // 404 / 501 → endpoint not yet wired. Surface a friendly hint instead
+    // of dumping the response body.
+    if (res.status === 404 || res.status === 501) {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_endpoint_unimplemented',
+            message: 'pugi.io /api/pugi/share is not yet wired in admin-api. ' +
+                'Use `--gist` for now; the pugi.io upload lands in a follow-up sprint.',
+        };
+    }
+    if (res.status === 401 || res.status === 403) {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_auth_missing',
+            message: 'pugi.io rejected the credentials. Run `pugi login` and retry.',
+        };
+    }
+    if (!res.ok) {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_network_error',
+            message: `pugi.io upload returned ${res.status} ${res.statusText}.`,
+        };
+    }
+    let payload;
+    try {
+        payload = (await res.json());
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_network_error',
+            message: `pugi.io upload returned non-JSON: ${message}`,
+        };
+    }
+    if (!payload.ok || !payload.url) {
+        return {
+            ok: false,
+            target: 'pugi',
+            reason: 'pugi_network_error',
+            message: 'pugi.io upload succeeded but the response was missing { ok, url }.',
+        };
+    }
+    return payload.id !== undefined
+        ? { ok: true, target: 'pugi', url: payload.url, remoteId: payload.id }
+        : { ok: true, target: 'pugi', url: payload.url };
+}
+//# sourceMappingURL=uploader.js.map