codiedev 0.8.1 → 0.8.2

package/dist/commands/shared.d.ts

@@ -33,6 +33,20 @@ export declare function recordAgentEvent(config: CodiedevConfig, event: {
     latencyMs: number;
     error?: string;
 }): void;
+/**
+ * Per-step install telemetry for `npx codiedev connect`. One row per phase
+ * (started, detect, install_target, validate_token, completed, failed) so
+ * the admin company page can show a timeline when a customer says "it says
+ * connected but it doesn't work." Fire-and-forget, never throws. Auto-stamps
+ * platform + node + cli version so call sites only need step/target/ok/error.
+ */
+export type InstallTelemetryStep = "started" | "detect" | "install_target" | "validate_token" | "completed" | "failed";
+export declare function recordInstallEvent(config: CodiedevConfig, event: {
+    step: InstallTelemetryStep;
+    target?: string;
+    ok: boolean;
+    error?: string;
+}): void;
 /**
  * Wraps a CLI subcommand body so success and failure both record telemetry
  * and the original error propagates after the event is queued. Use this in

package/dist/commands/shared.js

@@ -37,6 +37,7 @@ exports.applyConfigEnvOverrides = applyConfigEnvOverrides;
 exports.requireConfig = requireConfig;
 exports.apiRequest = apiRequest;
 exports.recordAgentEvent = recordAgentEvent;
+exports.recordInstallEvent = recordInstallEvent;
 exports.withTelemetry = withTelemetry;
 exports.timeAgo = timeAgo;
 exports.stripQuotes = stripQuotes;
@@ -155,6 +156,22 @@ function recordAgentEvent(config, event) {
         // Swallow — telemetry must never affect user-facing flow.
     });
 }
+function recordInstallEvent(config, event) {
+    apiRequest("POST", "/api/telemetry/install-event", {
+        config,
+        body: {
+            step: event.step,
+            target: event.target,
+            ok: event.ok,
+            error: event.error,
+            platform: process.platform,
+            nodeVersion: process.version,
+            cliVersion: version_1.CLI_VERSION,
+        },
+    }).catch(() => {
+        // Swallow — telemetry must never affect connect flow.
+    });
+}
 /**
  * Wraps a CLI subcommand body so success and failure both record telemetry
  * and the original error propagates after the event is queued. Use this in

package/dist/connect.js

@@ -41,6 +41,7 @@ const utils_1 = require("./utils");
 const connectFlow_1 = require("./connectFlow");
 const version_1 = require("./version");
 const upgradeNudge_1 = require("./upgradeNudge");
+const shared_1 = require("./commands/shared");
 const BACKEND_URL = process.env.CODIEDEV_URL || "https://judicious-falcon-861.convex.site";
 /**
  * Reads a line from stdin without echoing the typed/pasted characters —
@@ -214,6 +215,11 @@ async function runConnect(args = []) {
         console.error(`\nError: Failed to save config — ${err.message}`);
         process.exit(1);
     }
+    // Once we have a valid token + config, every subsequent step posts a
+    // per-step row to /api/telemetry/install-event so the admin page can show
+    // a timeline when a customer says "it connected but it doesn't work."
+    // Fire-and-forget — never blocks the connect flow.
+    (0, shared_1.recordInstallEvent)(config, { step: "started", ok: true });
     // Migration: strip MCP server entries written by pre-CLI-only versions
     // of `codiedev connect`. These pointed at `npx codiedev-mcp`, a binary
     // that was removed in 0.3.4 and that 0.7.11+ no longer ships. Without
@@ -242,64 +248,46 @@ async function runConnect(args = []) {
     const hasClaude = (0, utils_1.claudeCodeInstalled)();
     const hasCodex = (0, utils_1.codexInstalled)();
     const hasCursor = (0, utils_1.cursorInstalled)();
+    (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "claude-code", ok: hasClaude });
+    (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "codex", ok: hasCodex });
+    (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "cursor", ok: hasCursor });
     const installed = [];
     // Machine-readable target keys reported back to the backend via
     // /api/cli/markInstalled so the portal's "Connected" state reflects
     // what's actually wired up on this machine, not just "token validated."
     const installedTargets = [];
-    if (hasClaude) {
+    // Wrap each per-target write so we emit one install_target row each. The
+    // existing user-visible behavior (console.warn on failure, continue) is
+    // unchanged — telemetry just observes the outcome.
+    const runInstall = (target, fn, label, targetKey) => {
         try {
-            (0, utils_1.installHook)();
-            installed.push("Claude Code SessionEnd hook (~/.claude/settings.json)");
-            installedTargets.push("claudeCode-hook");
-        }
-        catch (err) {
-            console.error(`\nWarning: Failed to install Claude Code hook — ${err.message}`);
-        }
-        try {
-            (0, utils_1.installClaudeCodeInstructions)();
-            installed.push("Claude Code agent instructions (~/.claude/CLAUDE.md)");
-            installedTargets.push("claudeCode-instructions");
+            fn();
+            installed.push(label);
+            installedTargets.push(targetKey);
+            (0, shared_1.recordInstallEvent)(config, { step: "install_target", target, ok: true });
         }
         catch (err) {
-            console.error(`\nWarning: Failed to install Claude Code instructions — ${err.message}`);
+            const message = err.message;
+            console.error(`\nWarning: Failed to install ${label} — ${message}`);
+            (0, shared_1.recordInstallEvent)(config, {
+                step: "install_target",
+                target,
+                ok: false,
+                error: message?.slice(0, 500),
+            });
         }
+    };
+    if (hasClaude) {
+        runInstall("claude-code-hook", utils_1.installHook, "Claude Code SessionEnd hook (~/.claude/settings.json)", "claudeCode-hook");
+        runInstall("claude-code-instructions", utils_1.installClaudeCodeInstructions, "Claude Code agent instructions (~/.claude/CLAUDE.md)", "claudeCode-instructions");
     }
     if (hasCodex) {
-        try {
-            (0, utils_1.installCodexHook)();
-            installed.push("Codex Stop hook (~/.codex/hooks.json)");
-            installedTargets.push("codex-hook");
-        }
-        catch (err) {
-            console.error(`\nWarning: Failed to install Codex hook — ${err.message}`);
-        }
-        try {
-            (0, utils_1.installCodexInstructions)();
-            installed.push("Codex agent instructions (~/.codex/AGENTS.md)");
-            installedTargets.push("codex-instructions");
-        }
-        catch (err) {
-            console.error(`\nWarning: Failed to install Codex instructions — ${err.message}`);
-        }
+        runInstall("codex-hook", utils_1.installCodexHook, "Codex Stop hook (~/.codex/hooks.json)", "codex-hook");
+        runInstall("codex-instructions", utils_1.installCodexInstructions, "Codex agent instructions (~/.codex/AGENTS.md)", "codex-instructions");
     }
     if (hasCursor) {
-        try {
-            (0, utils_1.installCursorHook)();
-            installed.push("Cursor sessionEnd hook (~/.cursor/hooks.json)");
-            installedTargets.push("cursor-hook");
-        }
-        catch (err) {
-            console.error(`\nWarning: Failed to install Cursor hook — ${err.message}`);
-        }
-        try {
-            (0, utils_1.installCursorInstructions)();
-            installed.push("Cursor agent instructions (~/.cursor/rules/codiedev.mdc)");
-            installedTargets.push("cursor-instructions");
-        }
-        catch (err) {
-            console.error(`\nWarning: Failed to install Cursor instructions — ${err.message}`);
-        }
+        runInstall("cursor-hook", utils_1.installCursorHook, "Cursor sessionEnd hook (~/.cursor/hooks.json)", "cursor-hook");
+        runInstall("cursor-instructions", utils_1.installCursorInstructions, "Cursor agent instructions (~/.cursor/rules/codiedev.mdc)", "cursor-instructions");
     }
     // Tell the backend which targets we wired up so the portal's onboarding
     // card flips to "Connected" only when something actually installed —
@@ -310,10 +298,17 @@ async function runConnect(args = []) {
             await postJson(`${BACKEND_URL}/api/cli/markInstalled`, {
                 installedTargets,
             }, { Authorization: `Bearer ${token}` });
+            (0, shared_1.recordInstallEvent)(config, { step: "completed", ok: true });
         }
         catch (err) {
-            console.error(`\nWarning: Failed to report install to backend — ${err.message}`);
+            const message = err.message;
+            console.error(`\nWarning: Failed to report install to backend — ${message}`);
             console.error("Local install succeeded; portal may not reflect it until you re-run.");
+            (0, shared_1.recordInstallEvent)(config, {
+                step: "failed",
+                ok: false,
+                error: message?.slice(0, 500),
+            });
         }
     }
     if (!hasClaude && !hasCodex && !hasCursor) {

package/dist/hookTransport.d.ts

@@ -0,0 +1,13 @@
+import * as http from "http";
+export declare const DEFAULT_HOOK_HTTP_TIMEOUT_MS = 8000;
+/** Hard cap for GET requests used in sync-context (e.g. auto-pull skill list).
+ *  If the backend accepts the connection but never writes a response the hook
+ *  would stall every Claude Code session start — we cap it well below any
+ *  reasonable UX threshold. */
+export declare const GET_JSON_TIMEOUT_MS = 5000;
+export declare function getHookHttpTimeoutMs(): number;
+type RequestImpl = typeof http.request;
+export declare function getJson<T>(url: string, bearerToken: string): Promise<T>;
+export declare function postJson(url: string, body: Record<string, unknown>, bearerToken: string, requestImpl?: RequestImpl): Promise<void>;
+export declare function postJsonWithHookTimeout(url: string, body: Record<string, unknown>, bearerToken: string, requestImpl?: RequestImpl): Promise<void>;
+export {};

package/dist/hookTransport.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET_JSON_TIMEOUT_MS = exports.DEFAULT_HOOK_HTTP_TIMEOUT_MS = void 0;
+exports.getHookHttpTimeoutMs = getHookHttpTimeoutMs;
+exports.getJson = getJson;
+exports.postJson = postJson;
+exports.postJsonWithHookTimeout = postJsonWithHookTimeout;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const version_1 = require("./version");
+exports.DEFAULT_HOOK_HTTP_TIMEOUT_MS = 8_000;
+/** Hard cap for GET requests used in sync-context (e.g. auto-pull skill list).
+ *  If the backend accepts the connection but never writes a response the hook
+ *  would stall every Claude Code session start — we cap it well below any
+ *  reasonable UX threshold. */
+exports.GET_JSON_TIMEOUT_MS = 5_000;
+function getHookHttpTimeoutMs() {
+    const raw = process.env.CODIEDEV_HOOK_HTTP_TIMEOUT_MS;
+    if (!raw)
+        return exports.DEFAULT_HOOK_HTTP_TIMEOUT_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return exports.DEFAULT_HOOK_HTTP_TIMEOUT_MS;
+    }
+    return parsed;
+}
+function requestJson(method, url, bearerToken, body, requestImpl, useTimeout = false, 
+/** When set, overrides getHookHttpTimeoutMs() for this request. */
+explicitTimeoutMs) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const data = body === undefined ? undefined : JSON.stringify(body);
+        const headers = {
+            Authorization: `Bearer ${bearerToken}`,
+            "X-Codiedev-Cli-Version": version_1.CLI_VERSION,
+        };
+        if (data !== undefined) {
+            headers["Content-Type"] = "application/json";
+            headers["Content-Length"] = Buffer.byteLength(data);
+        }
+        const options = {
+            hostname: parsed.hostname,
+            port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+            path: parsed.pathname + parsed.search,
+            method,
+            headers,
+        };
+        const lib = parsed.protocol === "https:" ? https : http;
+        const request = requestImpl ?? lib.request;
+        let settled = false;
+        const timeoutMs = explicitTimeoutMs ?? getHookHttpTimeoutMs();
+        let timer;
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            fn();
+        };
+        const req = request(options, (res) => {
+            let responseData = "";
+            res.on("data", (chunk) => {
+                responseData += chunk;
+            });
+            res.on("end", () => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    try {
+                        const parsedBody = responseData.length === 0 ? undefined : JSON.parse(responseData);
+                        finish(() => resolve(parsedBody));
+                    }
+                    catch (e) {
+                        finish(() => reject(e));
+                    }
+                }
+                else {
+                    finish(() => reject(new Error(`HTTP ${res.statusCode}: ${responseData}`)));
+                }
+            });
+        });
+        if (useTimeout) {
+            timer = setTimeout(() => {
+                req.destroy(new Error(`request timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+        }
+        req.on("error", (err) => finish(() => reject(err)));
+        if (data !== undefined) {
+            req.write(data);
+        }
+        req.end();
+    });
+}
+function getJson(url, bearerToken) {
+    // Always apply a 5-second cap so a hanging backend cannot stall a
+    // SessionStart hook (which would freeze every Claude Code session start).
+    return requestJson("GET", url, bearerToken, undefined, undefined, true, exports.GET_JSON_TIMEOUT_MS);
+}
+function postJson(url, body, bearerToken, requestImpl) {
+    return requestJson("POST", url, bearerToken, body, requestImpl);
+}
+function postJsonWithHookTimeout(url, body, bearerToken, requestImpl) {
+    return requestJson("POST", url, bearerToken, body, requestImpl, true);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Connect Claude Code, Codex, Cursor, or VS Code Copilot to CodieDev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "dist/cli.js",