standout 0.5.26 → 0.5.28

package/dist/cli.js

@@ -5,6 +5,7 @@ import { createInterface } from "readline";
 import { markWrappedShared, STANDOUT_API_URL } from "./api.js";
 import { gatherFullEnrichment, gatherProfileBasics, gatherUsageStats, } from "./gather.js";
 import { startMcpServer } from "./mcp.js";
+import { configureProxyFromEnv } from "./proxy.js";
 import { SYSTEM_PROMPT } from "./prompt.js";
 import { TOOLS, executeTool } from "./tools.js";
 import { renderWrappedAll } from "./wrapped/render.js";
@@ -119,7 +120,7 @@ async function maybeShareWrapped(wrapped) {
         process.stderr.write(`  opened: ${wrapped.share_url}\n\n`);
     }
     catch (err) {
-        process.stderr.write(`  couldn't open browser — open it manually: ${wrapped.share_url}\n`);
+        process.stderr.write(`  couldn't open browser. open it manually: ${wrapped.share_url}\n`);
         process.stderr.write(`  (${err instanceof Error ? err.message : err})\n\n`);
     }
 }
@@ -197,7 +198,7 @@ async function runAgent(jobId) {
         await maybeShareWrapped(wrapped);
     }
     else {
-        process.stderr.write("  (couldn't generate wrapped right now — continuing profile setup.)\n\n");
+        process.stderr.write("  (couldn't generate wrapped right now. continuing profile setup.)\n\n");
     }
     if (!profileChatEnabled()) {
         return;
@@ -326,6 +327,11 @@ async function runAgent(jobId) {
 }
 async function main() {
     const args = process.argv.slice(2);
+    // Route fetch through a configured proxy before any network call — Node's fetch
+    // ignores HTTP(S)_PROXY otherwise, which breaks users behind a corporate proxy.
+    const proxy = configureProxyFromEnv();
+    if (proxy)
+        process.stderr.write(`  (using proxy ${proxy})\n`);
     if (args.includes("--gather")) {
         await confirmPrivacy();
         const data = await gatherFullEnrichment();

package/dist/payload.js

@@ -104,6 +104,19 @@ export function capPayload(payload) {
             }
         }
     }
+    // 2b. Display-only prompt samples (not read by any server card).
+    if (over()) {
+        for (const t of TOOLS) {
+            const tool = asRecord(aiUsage[t]);
+            if (tool &&
+                Array.isArray(tool.prompt_samples) &&
+                tool.prompt_samples.length) {
+                tool.prompt_samples = [];
+                if (!dropped.includes("prompt_samples"))
+                    dropped.push("prompt_samples");
+            }
+        }
+    }
     // 3. Commit subjects + repo README excerpts (contributions/blurbs inputs).
     if (over()) {
         const aiCoding = asRecord(p.ai_coding);

package/dist/proxy.d.ts

@@ -0,0 +1 @@
+export declare function configureProxyFromEnv(): string | null;

package/dist/proxy.js

@@ -0,0 +1,27 @@
+import { ProxyAgent, setGlobalDispatcher } from "undici";
+// Node's built-in fetch (undici) ignores HTTP(S)_PROXY env vars by default. On a
+// corporate network that forces traffic through a proxy, undici then connects
+// directly, the proxy/firewall transparently intercepts the TLS handshake, and the
+// client sees a mangled stream (ERR_SSL_PACKET_LENGTH_TOO_LONG / "packet length too
+// long"). Routing fetch through the configured proxy fixes that.
+//
+// Honors the standard env vars (upper + lower case). NO_PROXY is intentionally not
+// handled — we only ever talk to one host (the Standout API), so a global proxy is
+// correct when one is set.
+export function configureProxyFromEnv() {
+    const proxy = process.env.HTTPS_PROXY ||
+        process.env.https_proxy ||
+        process.env.HTTP_PROXY ||
+        process.env.http_proxy ||
+        process.env.ALL_PROXY ||
+        process.env.all_proxy;
+    if (!proxy)
+        return null;
+    try {
+        setGlobalDispatcher(new ProxyAgent(proxy));
+        return proxy;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/wrapped-client.js

@@ -10,18 +10,21 @@ const HEADERS = {
     // node-fetch UAs on certain paths. Set a clear identity.
     "User-Agent": "Standout/0.4.0 (node)",
 };
-// The request holds a connection open while the backend runs the wrapped's
-// LLM cards, so a transient blip shouldn't permanently drop the wrapped.
 const MAX_ATTEMPTS = 3;
-// Matches the server route's 300s maxDuration: the client only gives up once the
-// server itself would have. A shorter client timeout would abort a still-valid
-// slow run and orphan the wrapped the server goes on to create.
-const REQUEST_TIMEOUT_MS = 300000;
+// The POST now returns as soon as the pending row is created (the LLM card deck
+// runs server-side in the background), so it resolves in a couple seconds. The
+// deck is then read by polling GET /wrapped/[id] — short requests that can't be
+// silently dropped mid-generation the way the old long-held POST was.
+const POST_TIMEOUT_MS = 60000;
+const POLL_REQUEST_TIMEOUT_MS = 15000;
+const POLL_INTERVAL_MS = 2000;
+// Generous ceiling — the deck normally lands in well under a minute; this only
+// bounds a stuck/never-completing background pass.
+const POLL_TIMEOUT_MS = 180000;
 const RETRY_BASE_DELAY_MS = 1000;
-// Wrapped creation is NOT idempotent — each POST makes a new row + LLM run. Only
-// retry failures that prove the request never reached the backend; a timeout or a
-// mid-flight drop may mean the server already created it, so replaying would
-// duplicate the wrapped.
+// The POST is NOT idempotent — each one makes a new row + background LLM run. Only
+// retry failures that prove the request never reached the backend; a mid-flight
+// drop may mean the row was already created, so replaying would duplicate it.
 const RETRYABLE_CONNECT_CODES = new Set([
     "ECONNREFUSED",
     "ENOTFOUND",
@@ -37,46 +40,121 @@ function isPreConnectError(err) {
     }
     return false;
 }
+// `fetch failed` is undici's catch-all message — the real reason (ECONNRESET,
+// UND_ERR_HEADERS_TIMEOUT, …) lives in err.cause. Walk the chain so failures are
+// actually diagnosable instead of all collapsing to "fetch failed".
+function describeError(err) {
+    const parts = [];
+    let node = err;
+    for (let depth = 0; node && depth < 4; depth++) {
+        const e = node;
+        const code = typeof e.code === "string" ? e.code : null;
+        const message = typeof e.message === "string" ? e.message : null;
+        const label = [code, message].filter(Boolean).join(" ");
+        if (label && !parts.includes(label))
+            parts.push(label);
+        node = node?.cause;
+    }
+    return parts.join(" <- ") || String(err);
+}
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function isReady(computed) {
+    if (!computed)
+        return false;
+    // status is the explicit signal; archetype is a backstop for any response that
+    // predates the status field.
+    return computed.status === "ready" || computed.archetype != null;
+}
+// Poll GET /wrapped/[id] until the background card deck is persisted. Each request
+// is short and idempotent, so transient blips are retried freely (unlike the POST).
+async function pollComputed(id) {
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    // The deck never lands in under a second; wait once before the first read.
+    await sleep(POLL_INTERVAL_MS);
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(`${STANDOUT_API_URL}/api/public/wrapped/${id}`, {
+                headers: HEADERS,
+                signal: AbortSignal.timeout(POLL_REQUEST_TIMEOUT_MS),
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                if (isReady(data.computed))
+                    return data.computed ?? null;
+            }
+        }
+        catch {
+            // Transient — keep polling until the deadline.
+        }
+        await sleep(POLL_INTERVAL_MS);
+    }
+    return null;
+}
 export async function createWrapped(args) {
     // Keep the request under Vercel's 4.5MB body cap (else a heavy history 413s
     // before the handler runs). Trims the bulkiest raw fields only when oversized.
-    const { payload: profile } = capPayload(args.profile);
+    const { payload: profile, bytesAfter } = capPayload(args.profile);
     const body = JSON.stringify({
         profile,
         submission_id: args.submissionId ?? undefined,
     });
+    const bodyKb = Math.round(bytesAfter / 1024);
+    let created = null;
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
         try {
             const res = await fetch(`${STANDOUT_API_URL}/api/public/wrapped`, {
                 method: "POST",
                 headers: HEADERS,
                 body,
-                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+                signal: AbortSignal.timeout(POST_TIMEOUT_MS),
             });
             // Any HTTP response means the request reached the server; don't replay it
             // (a 5xx could land after the row was already created).
             if (!res.ok) {
                 const text = await res.text().catch(() => "");
-                process.stderr.write(`[wrapped] backend returned ${res.status}${text ? `: ${text.slice(0, 200)}` : ""}\n`);
+                process.stderr.write(`  Standout had a server error (${res.status}) while building your wrapped. Please try again in a minute.\n` +
+                    (text ? `  (details: ${text.slice(0, 200)})\n` : ""));
                 return null;
             }
-            const data = (await res.json());
-            const view = aggregateView({
-                profile: args.profile,
-                computed: data.computed,
-                share_url: data.share_url,
-            });
-            return { id: data.id, share_url: data.share_url, view };
+            created = (await res.json());
+            break;
         }
         catch (err) {
             if (isPreConnectError(err) && attempt < MAX_ATTEMPTS) {
                 await sleep(RETRY_BASE_DELAY_MS * attempt);
                 continue;
             }
-            process.stderr.write(`[wrapped] failed to reach backend: ${err instanceof Error ? err.message : err}\n`);
+            const detail = describeError(err);
+            // A TLS-layer failure means something is intercepting HTTPS (VPN, proxy, or
+            // antivirus), not a transient drop — give targeted guidance.
+            const tlsIntercept = /ERR_SSL|ERR_TLS|packet length too long|SSL routines|wrong version number|DECRYPTION|sslv3|unknown ca|self.signed|unable to (verify|get local)/i.test(detail);
+            if (tlsIntercept) {
+                process.stderr.write(`  Couldn't reach Standout: a VPN, proxy, or antivirus is intercepting the HTTPS connection.\n` +
+                    `  Try one of: disconnect the VPN/proxy, switch networks, or set HTTPS_PROXY to your\n` +
+                    `  corporate proxy (and NODE_EXTRA_CA_CERTS if it uses a custom certificate), then re-run: npx standout\n` +
+                    `  (details: ${detail}; body ${bodyKb}KB)\n`);
+            }
+            else {
+                process.stderr.write(`  Couldn't reach Standout to build your wrapped. Your network (or a VPN/proxy) dropped the connection.\n` +
+                    `  Check your connection and re-run: npx standout\n` +
+                    `  (details: ${detail}; body ${bodyKb}KB)\n`);
+            }
             return null;
         }
     }
-    return null;
+    if (!created)
+        return null;
+    // The POST only created a pending row; poll for the finished deck.
+    const computed = await pollComputed(created.id);
+    if (!computed) {
+        process.stderr.write("  Your wrapped is taking longer than usual to finish generating.\n" +
+            "  Re-run to try again: npx standout\n");
+        return null;
+    }
+    const view = aggregateView({
+        profile: args.profile,
+        computed,
+        share_url: created.share_url,
+    });
+    return { id: created.id, share_url: created.share_url, view };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "standout",
-  "version": "0.5.26",
+  "version": "0.5.28",
   "description": "Build your developer profile with AI. One command, zero friction.",
   "type": "module",
   "main": "./dist/cli.js",
@@ -32,6 +32,7 @@
     "gradient-string": "^3.0.0",
     "open": "^11.0.0",
     "playwright-core": "^1.59.1",
+    "undici": "^6.26.0",
     "zod": "^3.24.0"
   },
   "devDependencies": {