codiedev 0.10.0-beta.4 → 0.10.0-beta.5

package/dist/copilotInstallation.js

@@ -0,0 +1,64 @@
+"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.inspectCopilotHooks = inspectCopilotHooks;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const copilotHooks_1 = require("./copilotHooks");
+const detection_1 = require("./detection");
+function inspectCopilotHooks(file = path.join((0, copilotHooks_1.copilotHome)(), "hooks", "codiedev.json"), security = false) {
+    if (!fs.existsSync(file))
+        return { status: "not-installed", detail: `${file} not found` };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        const expected = security
+            ? [["userPromptSubmitted", "discover-copilot"], ["preToolUse", "security-pre-copilot"], ["postToolUse", "security-post-copilot"]]
+            : [["sessionStart", "session-start-copilot"], ["agentStop", "backup-copilot"], ["sessionEnd", "capture-copilot"], ["errorOccurred", "limit-copilot"]];
+        const missing = expected.filter(([event, subcommand]) => {
+            const entries = parsed.hooks?.[event];
+            return !Array.isArray(entries) || !entries.some((entry) => {
+                const commands = [entry.bash ?? entry.command, entry.powershell ?? entry.command];
+                return commands.every((command) => typeof command === "string"
+                    && (0, detection_1.isCodiedevHookCommand)(command) && command.trim().endsWith(subcommand));
+            });
+        }).map(([event]) => event);
+        if (parsed.version !== 1 || missing.length)
+            return { status: "fail", detail: `invalid or missing hooks: ${missing.join(", ") || "version"}` };
+        return { status: "pass", detail: security ? "prompt guard and tool telemetry hooks installed" : "session start, backup, capture and limit hooks installed" };
+    }
+    catch {
+        return { status: "fail", detail: "invalid Copilot hook configuration" };
+    }
+}

package/dist/cursorHooks.js

@@ -5,10 +5,8 @@ exports.normalizeCursorTranscript = normalizeCursorTranscript;
 exports.isCursorTranscriptEmpty = isCursorTranscriptEmpty;
 exports.cursorPreToolBlockResponse = cursorPreToolBlockResponse;
 exports.cursorPromptBlockResponse = cursorPromptBlockResponse;
-/** Cursor's native hook payload is close to Claude Code's, but its stable
- * conversation identifier and several tool fields use different names. Keep
- * the translation at the process boundary so the shared capture/security
- * pipeline never has to guess which surface produced an event. */
+exports.cursorTranscriptHasUsage = cursorTranscriptHasUsage;
+exports.cursorObservedModel = cursorObservedModel;
 function normalizeCursorHookInput(input) {
     const sessionId = firstString(input.session_id, input.sessionId, input.conversation_id);
     const roots = Array.isArray(input.workspace_roots)
@@ -29,9 +27,6 @@ function normalizeCursorHookInput(input) {
         ...(duration !== undefined ? { duration_ms: duration } : {}),
     };
 }
-/** Cursor stores JSONL message roles in `role`; the shared capture pipeline
- * uses Claude's top-level `type` discriminator. Preserve all original fields
- * and add only that discriminator so the existing parsers see real messages. */
 function normalizeCursorTranscript(content) {
     return content
         .split("\n")
@@ -40,23 +35,27 @@ function normalizeCursorTranscript(content) {
             return line;
         try {
             const entry = JSON.parse(line);
-            if ((entry.role === "user" || entry.role === "assistant") &&
-                entry.type === undefined) {
-                return JSON.stringify({ ...entry, type: entry.role });
-            }
+            const type = entry.type ?? entry.role;
+            if (type !== "user" && type !== "assistant")
+                return line;
+            const message = entry.message;
+            const content = Array.isArray(message?.content) ? message.content.map((block) => {
+                if (!block || block.type !== "tool_use")
+                    return block;
+                const input = block.input ?? {};
+                const name = block.name === "Shell" ? "Bash" : block.name === "StrReplace" ? "Edit" : block.name;
+                return { ...block, name, input: { ...input,
+                        ...(typeof input.path === "string" && input.file_path === undefined ? { file_path: input.path } : {}),
+                    } };
+            }) : message?.content;
+            return JSON.stringify({ ...entry, type, ...(message ? { message: { ...message, content } } : {}) });
         }
         catch {
-            // Preserve malformed/non-JSON lines; tolerant downstream parsers skip
-            // anything they cannot consume.
         }
         return line;
     })
         .join("\n");
 }
-/** Cursor may change its private JSONL record shape independently of the hook
- * contract. Only a byte-empty snapshot is safe to discard; a non-empty file
- * that the current normalizer cannot parse must still be uploaded for backend
- * recovery and diagnosis. */
 function isCursorTranscriptEmpty(content) {
     return content.trim().length === 0;
 }
@@ -79,3 +78,27 @@ function cursorPromptBlockResponse(reason) {
         user_message: reason,
     };
 }
+function cursorTranscriptHasUsage(content) {
+    return content.split("\n").some((line) => {
+        try {
+            const usage = JSON.parse(line).message?.usage;
+            return usage && ["input_tokens", "output_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"]
+                .some((key) => typeof usage[key] === "number" && Number.isFinite(usage[key]));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function cursorObservedModel(content) {
+    let model;
+    for (const line of content.split("\n")) {
+        try {
+            const event = JSON.parse(line);
+            if (event.subtype === "cursor_model" && typeof event.model === "string")
+                model = event.model;
+        }
+        catch { }
+    }
+    return model;
+}

package/dist/cursorLifecycle.js

@@ -0,0 +1,109 @@
+"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.recordCursorLifecycle = recordCursorLifecycle;
+exports.cursorLifecycleRecords = cursorLifecycleRecords;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const configDir_1 = require("./configDir");
+const limitEvent_1 = require("./limitEvent");
+function fileFor(sessionId) {
+    const key = crypto.createHash("sha256").update(sessionId).digest("hex");
+    return path.join((0, configDir_1.codiedevStateDir)(), "cursor-lifecycle", `${key}.json`);
+}
+function recordCursorLifecycle(input, final) {
+    if (typeof input.session_id !== "string")
+        return;
+    const status = input.status ?? input.reason;
+    const file = fileFor(input.session_id);
+    let state = { ids: [] };
+    try {
+        state = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch { }
+    const model = typeof input.model_id === "string" && input.model_id.trim() ? input.model_id
+        : typeof input.model === "string" && input.model.trim() ? input.model : undefined;
+    if (model)
+        state.model = model;
+    const event = typeof input.hook_event_name === "string" ? input.hook_event_name : final ? "sessionEnd" : "stop";
+    if (event !== "sessionEnd" || !state.observations?.length) {
+        const timestamp = new Date().toISOString();
+        state.observations = [...(state.observations ?? []), { event, timestamp, ...(model ? { model } : {}) }].slice(-1000);
+    }
+    const limit = event === "postToolUse" || event === "postToolUseFailure" ? null : (0, limitEvent_1.parseNativeLimitError)(input);
+    if (limit) {
+        const generationId = typeof input.generation_id === "string" ? input.generation_id : undefined;
+        const last = state.limits?.at(-1);
+        const retry = last && (generationId ? last.generationId === generationId
+            : final && state.lastStatus === "error" && last.reason === limit.reason && last.resetText === limit.resetText);
+        if (!retry)
+            state.limits = [...(state.limits ?? []), { ...limit, ...(generationId ? { generationId } : {}) }].slice(-1000);
+    }
+    if (event === "subagentStart" && typeof input.subagent_id === "string") {
+        state.subagents = [...new Set([...(state.subagents ?? []), input.subagent_id])].slice(-1000);
+    }
+    if (event === "postToolUseFailure" && input.failure_type === "permission_denied") {
+        const rejectionId = typeof input.tool_use_id === "string" ? input.tool_use_id : `${Date.now()}-${state.rejections?.length ?? 0}`;
+        state.rejections = [...new Set([...(state.rejections ?? []), rejectionId])].slice(-1000);
+    }
+    const aborted = status === "aborted" || input.is_interrupt === true;
+    const id = typeof input.generation_id === "string" ? input.generation_id
+        : `${Date.now()}-${state.ids.length}`;
+    if (aborted && !(final && state.lastStatus === "aborted") && !state.ids.includes(id))
+        state.ids.push(id);
+    if (typeof status === "string")
+        state.lastStatus = status;
+    state.ids = state.ids.slice(-1000);
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(file, JSON.stringify(state), { mode: 0o600 });
+}
+function cursorLifecycleRecords(sessionId) {
+    if (!sessionId)
+        return "";
+    try {
+        const state = JSON.parse(fs.readFileSync(fileFor(sessionId), "utf8"));
+        return [...(state.observations ?? []).map((observation) => JSON.stringify({ type: "system", subtype: "cursor_hook_observation", ...observation })),
+            ...(state.model ? [JSON.stringify({ type: "system", subtype: "cursor_model", model: state.model })] : []),
+            ...(state.rejections ?? []).map(id => JSON.stringify({ type: "agent.rejection", id })),
+            ...(state.subagents?.length ? [JSON.stringify({ type: "cursor.subagent_summary", count: state.subagents.length, truncated: state.subagents.length >= 1000 })] : []),
+            ...state.ids.map((id) => JSON.stringify({ type: "agent.interruption", id })),
+            ...(state.limits ?? []).map(({ generationId: _generationId, ...event }) => JSON.stringify({ type: "agent.limit", ...event })),
+        ].join("\n");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/detection.js

@@ -1,44 +1,14 @@
 "use strict";
-// Pure detection helpers — runtime probes (fs / PATH lookup) live in utils.ts
-// and feed these. Splitting them out makes the truth-table testable without
-// mocking fs or process.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectClaudeCode = detectClaudeCode;
 exports.isCodiedevHookCommand = isCodiedevHookCommand;
-/**
- * Claude Code is "installed" if either ~/.claude exists (the user has
- * launched the app at least once) OR the `claude` binary is on PATH (the
- * user installed via npm/brew but hasn't launched yet). Either signal is
- * sufficient — we want to wire up the hook the moment the user has
- * obviously committed to the tool.
- */
 function detectClaudeCode(probe) {
     return probe.dirExists || probe.binOnPath;
 }
-/**
- * True iff `cmd` looks like a hook command codiedev itself wrote. Used
- * both by the install filter (so `connect` replaces the existing entry
- * instead of stacking another one) and by `codiedev doctor` (so it can
- * grade whether the hook is wired up).
- *
- * Must match every form codiedev can write:
- *   - Legacy `npx codiedev-hook <subcommand>`
- *   - Absolute path from npm-registry install:
- *     `<node> /.../node_modules/codiedev/dist/hook.js <subcommand>`
- *   - Absolute path from `npm link` dev install (the monorepo folder
- *     is named `codiedev-cli`, not `codiedev`):
- *     `<node> /.../codiedev-cli/dist/hook.js <subcommand>`
- *
- * The `codiedev[^/\\]*` allows the trailing `-cli` (or any future suffix)
- * without matching unrelated paths like `notcodiedev/dist/hook.js`.
- */
 function isCodiedevHookCommand(cmd) {
     if (!cmd)
         return false;
     if (cmd.includes("codiedev-hook"))
         return true;
-    // Anchor at a path separator (or string start) so we don't match
-    // unrelated paths like `notcodiedev/dist/hook.js` that happen to contain
-    // the substring `codiedev`.
     return /(?:^|[\\/])codiedev[^/\\]*[\\/]dist[\\/]hook/.test(cmd);
 }

package/dist/harnessDirs.js

@@ -0,0 +1,73 @@
+"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.claudeConfigDir = claudeConfigDir;
+exports.claudeUserConfigPath = claudeUserConfigPath;
+exports.codexHome = codexHome;
+exports.openCodeConfigDir = openCodeConfigDir;
+exports.displayPath = displayPath;
+exports.claudeConfigDirInUse = claudeConfigDirInUse;
+exports.codexHomeInUse = codexHomeInUse;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+function override(value) {
+    const trimmed = value?.trim();
+    return trimmed ? path.resolve(trimmed) : undefined;
+}
+function claudeConfigDir(env = process.env, home = os.homedir()) {
+    return override(env.CLAUDE_CONFIG_DIR) ?? path.join(home, ".claude");
+}
+function claudeUserConfigPath(env = process.env, home = os.homedir()) {
+    const dir = override(env.CLAUDE_CONFIG_DIR);
+    return dir ? path.join(dir, ".claude.json") : path.join(home, ".claude.json");
+}
+function codexHome(env = process.env, home = os.homedir()) {
+    return override(env.CODEX_HOME) ?? path.join(home, ".codex");
+}
+function openCodeConfigDir(env = process.env, home = os.homedir()) {
+    return path.join(override(env.XDG_CONFIG_HOME) ?? path.join(home, ".config"), "opencode");
+}
+function displayPath(p, home = os.homedir()) {
+    return p === home || p.startsWith(home + path.sep) ? "~" + p.slice(home.length) : p;
+}
+const CLAUDE_USAGE_MARKERS = ["projects", "history.jsonl", "sessions", "statsig", "todos", "shell-snapshots"];
+function claudeConfigDirInUse(dir = claudeConfigDir(), exists = fs.existsSync) {
+    return CLAUDE_USAGE_MARKERS.some((m) => exists(path.join(dir, m)));
+}
+const CODEX_USAGE_MARKERS = ["sessions", "history.jsonl", "auth.json"];
+function codexHomeInUse(dir = codexHome(), exists = fs.existsSync) {
+    return CODEX_USAGE_MARKERS.some((m) => exists(path.join(dir, m)));
+}