standout 0.5.27 → 0.5.29

package/dist/ai-usage.d.ts

@@ -99,7 +99,7 @@ export type RawStats = {
     sessions: Map<string, {
         firstTs: number;
         lastTs: number;
-        eventTimestamps: number[];
+        eventTimestamps: Set<number>;
         cwd: string | null;
         models: Set<string>;
         modelTurnCounts: Map<string, number>;

package/dist/ai-usage.js

@@ -305,13 +305,14 @@ function registerFile(raw, filePath) {
     raw.filePaths.add(filePath);
 }
 function recordSessionMeta(raw, sessionId, ts, cwd, model, version) {
+    const minute = Math.floor(ts / 60_000);
     const existing = raw.sessions.get(sessionId);
     if (existing) {
         if (ts < existing.firstTs)
             existing.firstTs = ts;
         if (ts > existing.lastTs)
             existing.lastTs = ts;
-        existing.eventTimestamps.push(ts);
+        existing.eventTimestamps.add(minute);
         if (!existing.cwd && cwd)
             existing.cwd = cwd;
         if (model)
@@ -323,7 +324,7 @@ function recordSessionMeta(raw, sessionId, ts, cwd, model, version) {
         raw.sessions.set(sessionId, {
             firstTs: ts,
             lastTs: ts,
-            eventTimestamps: [ts],
+            eventTimestamps: new Set([minute]),
             cwd,
             models: model ? new Set([model]) : new Set(),
             modelTurnCounts: new Map(),
@@ -804,10 +805,11 @@ export function computeStreaks(activeDays) {
         current = 0;
     return { longest, current };
 }
-function estimateActiveDurationMs(timestamps) {
-    const sorted = [...new Set(timestamps)]
-        .filter((ts) => Number.isFinite(ts))
-        .sort((a, b) => a - b);
+function estimateActiveDurationMs(minuteBuckets) {
+    const sorted = [...new Set(minuteBuckets)]
+        .filter((m) => Number.isFinite(m))
+        .sort((a, b) => a - b)
+        .map((m) => m * 60_000);
     if (sorted.length === 0)
         return 0;
     if (sorted.length === 1)
@@ -840,10 +842,11 @@ function compactCwd(cwd) {
 }
 // Split a session's events into active segments (consecutive events <= 15min
 // apart), so concurrency reflects real work, not a tab idle for days.
-function activeSegments(timestamps) {
-    const sorted = [...new Set(timestamps)]
-        .filter((t) => Number.isFinite(t))
-        .sort((a, b) => a - b);
+function activeSegments(minuteBuckets) {
+    const sorted = [...new Set(minuteBuckets)]
+        .filter((m) => Number.isFinite(m))
+        .sort((a, b) => a - b)
+        .map((m) => m * 60_000);
     if (sorted.length === 0)
         return [];
     const maxGapMs = MAX_ACTIVE_GAP_MINUTES * 60 * 1000;

package/dist/cli.js

@@ -4,7 +4,9 @@ import chalk from "chalk";
 import { createInterface } from "readline";
 import { markWrappedShared, STANDOUT_API_URL } from "./api.js";
 import { gatherFullEnrichment, gatherProfileBasics, gatherUsageStats, } from "./gather.js";
+import { ensureHeapHeadroom } from "./heap.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";
@@ -325,7 +327,13 @@ async function runAgent(jobId) {
     console.log(`  Tokens: ${totalInputTokens.toLocaleString()} in / ${totalOutputTokens.toLocaleString()} out${cacheNote} in ${elapsed}s\n`);
 }
 async function main() {
+    ensureHeapHeadroom();
     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/heap.d.ts

@@ -0,0 +1 @@
+export declare function ensureHeapHeadroom(): void;

package/dist/heap.js

@@ -0,0 +1,25 @@
+import { spawnSync } from "child_process";
+import { totalmem } from "os";
+// Node caps old-space at ~4GB by default regardless of physical RAM, so a big
+// machine OOMs at the same point as a small one. On machines with headroom,
+// re-exec once with a higher --max-old-space-size (half of RAM, capped at 8GB)
+// so heavy log archives have room. The real bound is algorithmic (see
+// ai-usage.ts); this is just a safety net.
+export function ensureHeapHeadroom() {
+    if (process.env.STANDOUT_HEAP_BOOSTED === "1")
+        return;
+    if (process.execArgv.some((a) => a.startsWith("--max-old-space-size")))
+        return;
+    const totalMb = Math.floor(totalmem() / (1024 * 1024));
+    const desiredMb = Math.min(8192, Math.floor(totalMb / 2));
+    if (desiredMb <= 4096)
+        return;
+    const entry = process.argv[1];
+    if (!entry)
+        return;
+    const res = spawnSync(process.execPath, [`--max-old-space-size=${desiredMb}`, entry, ...process.argv.slice(2)], {
+        stdio: "inherit",
+        env: { ...process.env, STANDOUT_HEAP_BOOSTED: "1" },
+    });
+    process.exit(res.status ?? 0);
+}

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

@@ -124,9 +124,21 @@ export async function createWrapped(args) {
                 await sleep(RETRY_BASE_DELAY_MS * attempt);
                 continue;
             }
-            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: ${describeError(err)}; body ${bodyKb}KB)\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;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "standout",
-  "version": "0.5.27",
+  "version": "0.5.29",
   "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": {