codiedev 0.10.0-beta.3 → 0.10.0-beta.5

package/dist/connect.js

@@ -49,26 +49,13 @@ const shared_1 = require("./commands/shared");
 const securityInstall_1 = require("./securityInstall");
 const securityPolicy_1 = require("./securityPolicy");
 const securityFeature_1 = require("./securityFeature");
-// cli.codiedev.com is a Convex custom domain on the prod deployment; the
-// underlying judicious-falcon-861.convex.site URL keeps serving, so configs
-// written by older CLI versions stay valid without a re-connect.
+const harnessDirs_1 = require("./harnessDirs");
 const BACKEND_URL = process.env.CODIEDEV_URL || "https://cli.codiedev.com";
-/**
- * Reads a line from stdin without echoing the typed/pasted characters —
- * for tokens, passwords, anything that shouldn't end up in terminal
- * scrollback or screenshots. Echoes `*` per character so the user gets
- * visual feedback that input is being received.
- *
- * Falls back to the regular `prompt()` if stdin isn't a TTY (e.g., piped
- * input in CI). Without a TTY there's no echo to suppress anyway, and
- * raw mode would error.
- */
 function promptHidden(question) {
     return new Promise((resolve) => {
         const stdin = process.stdin;
         const stdout = process.stdout;
         if (!stdin.isTTY) {
-            // CI / piped input — no terminal to mute. Fall back to readline.
             const rl = readline.createInterface({ input: stdin, output: stdout });
             rl.question(question, (answer) => {
                 rl.close();
@@ -85,23 +72,18 @@ function promptHidden(question) {
         };
         const onData = (chunk) => {
             const key = chunk.toString("utf8");
-            // Iterate so a single `chunk` containing a multi-char paste still
-            // masks each character individually.
             for (const ch of key) {
-                // Ctrl+C — abort like a normal terminal interrupt.
                 if (ch === "") {
                     cleanup();
                     stdout.write("\n");
                     process.exit(130);
                 }
-                // Enter — finalize.
                 if (ch === "\r" || ch === "\n") {
                     cleanup();
                     stdout.write("\n");
                     resolve(buf.trim());
                     return;
                 }
-                // Backspace / DEL — erase one masked char.
                 if (ch === "" || ch === "\b") {
                     if (buf.length > 0) {
                         buf = buf.slice(0, -1);
@@ -109,7 +91,6 @@ function promptHidden(question) {
                     }
                     continue;
                 }
-                // Ignore other control bytes (escape sequences from arrow keys, etc.)
                 if (ch.charCodeAt(0) < 0x20)
                     continue;
                 buf += ch;
@@ -165,11 +146,6 @@ function postJson(url, body, extraHeaders = {}) {
     });
 }
 async function runConnect(args = []) {
-    // `--force` (or `-f`) re-prompts for a token even if `~/.codiedev/config.json`
-    // already has one. Default behavior reuses the saved token so users can
-    // re-run `connect` (e.g., after installing Claude Code) without having to
-    // mint a fresh token from the portal — which is what bit Sonifi's first
-    // engineer when he interpreted "no visible token" as "the old one is gone".
     const force = args.includes("--force") || args.includes("-f");
     console.log("\nWelcome to Codiedev CLI\n");
     await (0, upgradeNudge_1.maybePrintUpgradeNudge)();
@@ -183,8 +159,6 @@ async function runConnect(args = []) {
         console.log(`Reusing API token from ~/.codiedev/config.json (run with --force to use a new one).\n`);
     }
     else {
-        // Hidden prompt — masks the token with `*` as it's typed/pasted so it
-        // doesn't end up in terminal scrollback or screenshots.
         token = await promptHidden("Enter your Codiedev API token: ");
         if (!token) {
             console.error("Error: API token is required.");
@@ -202,7 +176,6 @@ async function runConnect(args = []) {
         console.error(`\nError: Failed to validate token — ${err.message}`);
         process.exit(1);
     }
-    // Extract fields from response
     const companyId = responseData.companyId;
     const companyName = responseData.companyName;
     const agentSecurityEnabled = responseData.agentSecurityEnabled === true;
@@ -230,15 +203,7 @@ 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 });
-    // One-way device status sync. Local config remains authoritative: a network
-    // failure here never removes or weakens an ignored path. This also registers
-    // a freshly connected device with an empty list so the portal can distinguish
-    // "connected, no exclusions" from "old CLI has never reported status".
     try {
         await postJson(`${BACKEND_URL}/api/cli/capture-exclusions`, {
             deviceId: config.deviceId,
@@ -249,17 +214,6 @@ async function runConnect(args = []) {
     catch (err) {
         console.warn(`Warning: Local capture settings are active, but portal status did not sync — ${err.message}`);
     }
-    // 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
-    // cleanup, customers upgrading from any prior version see persistent
-    // "MCP server failed to start" errors in their agent UIs even though
-    // the CLI works fine. Each helper is idempotent and a no-op when the
-    // relevant config file doesn't exist.
-    //
-    // Each call is wrapped because the user's upgrade path matters more
-    // than the cleanup. A locked / wrong-owner config file (rare but real)
-    // shouldn't block the install loop or strand them on an old version.
     for (const [label, fn] of [
         ["Claude Code", utils_1.cleanupClaudeCodeMcp],
         ["Codex", utils_1.cleanupCodexMcp],
@@ -278,29 +232,24 @@ async function runConnect(args = []) {
     const hasCodex = (0, utils_1.codexInstalled)();
     const hasCursor = (0, utils_1.cursorInstalled)();
     const hasOpenCode = (0, utils_1.openCodeInstalled)();
+    const hasCopilot = (0, utils_1.copilotInstalled)();
     (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 });
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "opencode", ok: hasOpenCode });
+    (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "copilot", ok: hasCopilot });
     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 = [];
     const home = os.homedir();
     const securityConfigPaths = [
-        path.join(home, ".claude", "settings.json"),
-        path.join(home, ".codex", "hooks.json"),
+        path.join((0, harnessDirs_1.claudeConfigDir)(), "settings.json"),
+        path.join((0, harnessDirs_1.codexHome)(), "hooks.json"),
         path.join(home, ".cursor", "hooks.json"),
-        path.join(home, ".config", "opencode", "plugins", "codiedev.js"),
-        path.join(home, ".codex", "config.toml"),
+        path.join((0, harnessDirs_1.openCodeConfigDir)(), "plugins", "codiedev.js"),
+        path.join((0, harnessDirs_1.codexHome)(), "config.toml"),
+        (0, utils_1.copilotHooksPath)(),
     ];
-    // Snapshot before any hook update. Rollback is intentionally not automatic:
-    // an administrator can inspect these 0600 copies before restoring them.
     const securitySnapshot = (0, securityInstall_1.createSecurityInstallSnapshot)(securityConfigPaths);
-    // 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 {
             fn();
@@ -320,24 +269,22 @@ async function runConnect(args = []) {
         }
     };
     if (hasClaude) {
-        runInstall("claude-code-hook", () => (0, utils_1.installHook)(agentSecurityEnabled), "Claude Code SessionEnd (capture) + UserPromptSubmit (skill discovery) + Stop (auto-backup) hooks (~/.claude/settings.json)", "claudeCode-hook");
-        runInstall("claude-code-instructions", utils_1.installClaudeCodeInstructions, "Claude Code agent instructions (~/.claude/CLAUDE.md)", "claudeCode-instructions");
+        runInstall("claude-code-hook", () => (0, utils_1.installHook)(agentSecurityEnabled), `Claude Code SessionEnd (capture) + UserPromptSubmit (skill discovery) + Stop (auto-backup) hooks (${(0, harnessDirs_1.displayPath)(path.join((0, harnessDirs_1.claudeConfigDir)(), "settings.json"))})`, "claudeCode-hook");
+        runInstall("claude-code-instructions", utils_1.installClaudeCodeInstructions, `Claude Code agent instructions (${(0, harnessDirs_1.displayPath)(path.join((0, harnessDirs_1.claudeConfigDir)(), "CLAUDE.md"))})`, "claudeCode-instructions");
     }
     if (hasCodex) {
-        runInstall("codex-hook", () => (0, utils_1.installCodexHook)(agentSecurityEnabled), "Codex Stop (capture + auto-backup) hooks (~/.codex/hooks.json)", "codex-hook");
-        runInstall("codex-instructions", utils_1.installCodexInstructions, "Codex agent instructions (~/.codex/AGENTS.md)", "codex-instructions");
+        runInstall("codex-hook", () => (0, utils_1.installCodexHook)(agentSecurityEnabled), `Codex Stop (capture + auto-backup) hooks (${(0, harnessDirs_1.displayPath)(path.join((0, harnessDirs_1.codexHome)(), "hooks.json"))})`, "codex-hook");
+        runInstall("codex-instructions", utils_1.installCodexInstructions, `Codex agent instructions (${(0, harnessDirs_1.displayPath)(path.join((0, harnessDirs_1.codexHome)(), "AGENTS.md"))})`, "codex-instructions");
     }
     if (hasCursor) {
         runInstall("cursor-hook", () => (0, utils_1.installCursorHook)(agentSecurityEnabled), "Cursor sessionStart + prompt security + stop backup + sessionEnd capture hooks (~/.cursor/hooks.json)", "cursor-hook");
         runInstall("cursor-instructions", utils_1.installCursorInstructions, "Cursor agent instructions (~/.cursor/rules/codiedev.mdc)", "cursor-instructions");
     }
-    // Always stage the adapter. It is dormant until OpenCode starts, which lets
-    // a user connect Claude Code today and install the Codie harness tomorrow
-    // without needing a second setup ritual.
-    runInstall("opencode-capture-adapter", () => (0, utils_1.installOpenCodeCapturePlugin)(agentSecurityEnabled), "OpenCode session capture adapter (~/.config/opencode/plugins/codiedev.js)", "opencode-capture");
-    // Record the exact installed hook bytes and the pre-update rollback files.
-    // This supplies health/integrity checks without requiring a package publish
-    // or trusting whichever `node` happens to be first on PATH later.
+    if (hasCopilot) {
+        runInstall("copilot-hook", () => (0, utils_1.installCopilotHook)(agentSecurityEnabled), `GitHub Copilot (VS Code + CLI) sessionStart + agentStop backup + sessionEnd capture hooks (${(0, utils_1.copilotHooksPath)()})`, "copilot-hook");
+        runInstall("copilot-instructions", utils_1.installCopilotInstructions, "GitHub Copilot CLI team artifact instructions", "copilot-instructions");
+    }
+    runInstall("opencode-capture-adapter", () => (0, utils_1.installOpenCodeCapturePlugin)(agentSecurityEnabled), `OpenCode session capture adapter (${(0, harnessDirs_1.displayPath)(path.join((0, harnessDirs_1.openCodeConfigDir)(), "plugins", "codiedev.js"))})`, "opencode-capture");
     try {
         const hookScriptPath = path.join(__dirname, "hook.js");
         if (agentSecurityEnabled && fs.existsSync(hookScriptPath)) {
@@ -348,6 +295,8 @@ async function runConnect(args = []) {
                 targets.push({ surface: "codex", configPath: securityConfigPaths[1] });
             if (installedTargets.includes("cursor-hook"))
                 targets.push({ surface: "cursor", configPath: securityConfigPaths[2] });
+            if (installedTargets.includes("copilot-hook"))
+                targets.push({ surface: "copilot", configPath: (0, utils_1.copilotHooksPath)() });
             if (installedTargets.includes("opencode-capture"))
                 targets.push({ surface: "codie-harness", configPath: securityConfigPaths[3] });
             (0, securityInstall_1.writeSecurityInstallManifest)({ hookScriptPath, snapshot: securitySnapshot, targets });
@@ -356,8 +305,6 @@ async function runConnect(args = []) {
     catch (err) {
         console.warn(`Warning: Security hooks installed, but integrity manifest could not be written — ${err.message}`);
     }
-    // Prime the local cache after installation. Hooks read this file only, so
-    // an endpoint decision never depends on live network latency.
     if (agentSecurityEnabled) {
         try {
             await (0, securityPolicy_1.syncEndpointSecurityPolicy)(config);
@@ -366,10 +313,6 @@ async function runConnect(args = []) {
             console.warn(`Warning: Agent-security policy will use safe defaults until sync succeeds — ${err.message}`);
         }
     }
-    // Tell the backend which targets we wired up so the portal's onboarding
-    // card flips to "Connected" only when something actually installed —
-    // not on bare token validation. Best-effort: a network failure here
-    // doesn't undo the local install, and `codiedev doctor` still works.
     if (installedTargets.length > 0) {
         try {
             await postJson(`${BACKEND_URL}/api/cli/markInstalled`, {
@@ -388,7 +331,7 @@ async function runConnect(args = []) {
             });
         }
     }
-    if (!hasClaude && !hasCodex && !hasCursor && !hasOpenCode) {
+    if (!hasClaude && !hasCodex && !hasCursor && !hasOpenCode && !hasCopilot) {
         console.warn("\nNo existing AI client detected; the Codie/OpenCode adapter is ready for a later install.");
         console.warn("If you just installed Claude Code, launch it once (so ~/.claude is created),");
         console.warn("then re-run `npx codiedev connect` to wire up the capture hook.");
@@ -404,6 +347,7 @@ async function runConnect(args = []) {
     }
     console.log();
     console.log("Run `codiedev doctor` to verify everything's wired up.");
+    console.log("If `codiedev` is not on PATH, run `npx codiedev@latest doctor` instead.");
     if ((0, securityFeature_1.isAgentSecurityEnabled)(config)) {
         console.log("Run `codiedev security pilot` to validate blocking safely.");
     }

package/dist/connectFlow.js

@@ -1,13 +1,4 @@
 "use strict";
-// Pure helper for `npx codiedev connect` — decides where the API token
-// comes from. Splitting this out lets us TDD the policy (re-use vs. re-prompt)
-// without touching readline or fs at all.
-//
-// Motivation: Jackson hit a confusing flow where he had a working token in
-// `~/.codiedev/config.json`, re-ran `connect` (to pick up Claude Code that
-// he'd just installed), and was forced to paste a token again. Since the
-// portal only displays the plaintext on creation, his only option was to
-// generate a new one — leaving him thinking the old one had been lost.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveConnectToken = resolveConnectToken;
 function resolveConnectToken(input) {

package/dist/copilotHooks.js

@@ -0,0 +1,395 @@
+"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.COPILOT_VSCODE_CLIENT = void 0;
+exports.copilotHome = copilotHome;
+exports.copilotSessionDir = copilotSessionDir;
+exports.copilotTranscriptPath = copilotTranscriptPath;
+exports.parseCopilotWorkspace = parseCopilotWorkspace;
+exports.readCopilotWorkspace = readCopilotWorkspace;
+exports.copilotLaunch = copilotLaunch;
+exports.normalizeCopilotHookInput = normalizeCopilotHookInput;
+exports.copilotPreToolBlockResponse = copilotPreToolBlockResponse;
+exports.isCopilotTranscriptEmpty = isCopilotTranscriptEmpty;
+exports.hasCopilotShutdown = hasCopilotShutdown;
+exports.normalizeCopilotTranscript = normalizeCopilotTranscript;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+function copilotHome(env = process.env, home = os.homedir()) {
+    const override = env.COPILOT_HOME?.trim();
+    return override ? path.resolve(override) : path.join(home, ".copilot");
+}
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function copilotSessionDir(sessionId, home = copilotHome()) {
+    return SESSION_ID.test(sessionId) ? path.join(home, "session-state", sessionId) : undefined;
+}
+function copilotTranscriptPath(sessionId, home = copilotHome()) {
+    const dir = sessionId ? copilotSessionDir(sessionId, home) : undefined;
+    return dir ? path.join(dir, "events.jsonl") : undefined;
+}
+function parseCopilotWorkspace(yaml) {
+    const fields = new Map();
+    for (const line of yaml.split(/\r?\n/)) {
+        const match = line.match(/^([a-z_]+):\s*(.*)$/);
+        if (!match)
+            continue;
+        let value = match[2].trim();
+        if (/^(["']).*\1$/.test(value))
+            value = value.slice(1, -1);
+        if (value)
+            fields.set(match[1], value);
+    }
+    const pick = (key) => fields.get(key);
+    return {
+        ...(pick("id") ? { id: pick("id") } : {}),
+        ...(pick("cwd") ? { cwd: pick("cwd") } : {}),
+        ...(pick("git_root") ? { gitRoot: pick("git_root") } : {}),
+        ...(pick("branch") ? { branch: pick("branch") } : {}),
+        ...(pick("client_name") ? { clientName: pick("client_name") } : {}),
+    };
+}
+function readCopilotWorkspace(transcriptPathOrDir) {
+    if (!transcriptPathOrDir)
+        return {};
+    const dir = transcriptPathOrDir.endsWith(".jsonl") ? path.dirname(transcriptPathOrDir) : transcriptPathOrDir;
+    try {
+        return parseCopilotWorkspace(fs.readFileSync(path.join(dir, "workspace.yaml"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+exports.COPILOT_VSCODE_CLIENT = "vscode-agent-host";
+const isVSCodeClient = (name) => name === exports.COPILOT_VSCODE_CLIENT || name === "vscode";
+function copilotLaunch(clientName, detected) {
+    if (isVSCodeClient(clientName))
+        return "copilot:vscode";
+    return detected;
+}
+const firstString = (...values) => values.find((value) => typeof value === "string" && value.trim().length > 0);
+function normalizeCopilotHookInput(input, home = copilotHome()) {
+    const sessionId = firstString(input.session_id, input.sessionId);
+    const transcriptPath = firstString(input.transcript_path, input.transcriptPath)
+        ?? copilotTranscriptPath(sessionId, home);
+    const calls = copilotToolCalls(input);
+    const first = calls[0];
+    const toolResult = input.toolResult ?? input.tool_response;
+    return {
+        ...input,
+        ...(sessionId ? { session_id: sessionId } : {}),
+        ...(transcriptPath ? { transcript_path: transcriptPath } : {}),
+        ...(first ? { tool_name: first.name, tool_input: first.input } : {}),
+        ...(first?.id ? { tool_use_id: first.id } : {}),
+        ...(toolResult !== undefined ? { tool_response: toolResult } : {}),
+        ...(calls.length > 1 ? { copilotToolCalls: calls } : {}),
+    };
+}
+function copilotToolCalls(input) {
+    const parse = (args) => {
+        if (typeof args !== "string")
+            return args;
+        try {
+            return JSON.parse(args);
+        }
+        catch {
+            return args;
+        }
+    };
+    if (Array.isArray(input.toolCalls)) {
+        return input.toolCalls.flatMap((raw) => {
+            const call = raw;
+            const name = firstString(call?.name, call?.toolName);
+            return name
+                ? [{ ...(typeof call.id === "string" ? { id: call.id } : {}), name, input: parse(call.args ?? call.toolArgs) }]
+                : [];
+        });
+    }
+    const name = firstString(input.toolName, input.tool_name);
+    return name ? [{ name, input: parse(input.toolArgs ?? input.tool_input) }] : [];
+}
+function copilotPreToolBlockResponse(reason) {
+    return { permissionDecision: "deny", permissionDecisionReason: reason };
+}
+function isCopilotTranscriptEmpty(content) {
+    return content.trim().length === 0;
+}
+function hasCopilotShutdown(content) {
+    return content.includes('"session.shutdown"');
+}
+function claudeTool(name, args) {
+    const a = (args && typeof args === "object" ? args : {});
+    const lower = name.toLowerCase();
+    const file = firstString(a.path, a.file_path, a.filePath);
+    if (lower === "bash" || lower === "shell" || lower === "powershell") {
+        return { name: "Bash", input: { ...a, command: firstString(a.command, a.cmd) ?? "" } };
+    }
+    if ((lower === "edit" || lower === "str_replace" || lower === "str_replace_editor" || lower === "apply_patch") && file) {
+        return { name: "Edit", input: { ...a, file_path: file } };
+    }
+    if ((lower === "create" || lower === "write") && file)
+        return { name: "Write", input: { ...a, file_path: file } };
+    if (lower === "view" && file)
+        return { name: "Read", input: { ...a, file_path: file } };
+    if (lower === "skill")
+        return { name: "skill", input: {} };
+    return { name, input: args ?? {} };
+}
+const num = (value) => (typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0);
+function copilotUserContent(data) {
+    const content = [];
+    if (typeof data.content === "string" && data.content)
+        content.push({ type: "text", text: data.content });
+    if (Array.isArray(data.attachments)) {
+        for (const attachment of data.attachments) {
+            if (!attachment || typeof attachment !== "object")
+                continue;
+            const { displayName, mimeType, type } = attachment;
+            const name = typeof displayName === "string" ? displayName : "unnamed attachment";
+            const kind = typeof mimeType === "string" ? mimeType : typeof type === "string" ? type : "attachment";
+            content.push({ type: "text", text: `[Attachment: ${name} (${kind}); attachment contents unavailable in captured transcript]` });
+        }
+    }
+    return content.length ? content : [{ type: "text", text: "" }];
+}
+function resultText(data) {
+    const result = data.result;
+    if (typeof result === "string")
+        return result;
+    if (result && typeof result === "object") {
+        const { content, detailedContent } = result;
+        return [content, detailedContent].filter((v) => typeof v === "string").join("\n");
+    }
+    return typeof data.error?.message === "string" ? data.error.message : "";
+}
+const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+function premiumOf(data, at) {
+    return {
+        premiumRequests: count(data.totalPremiumRequests),
+        nanoAiu: count(data.totalNanoAiu),
+        ...(at ? { at } : {}),
+    };
+}
+function sumAgentMetrics(agents) {
+    const totals = {};
+    for (const metrics of agents) {
+        for (const [model, metric] of Object.entries(metrics ?? {})) {
+            const into = (totals[model] ??= {});
+            for (const [key, value] of Object.entries(metric?.usage ?? {}))
+                into[key] = (into[key] ?? 0) + num(value);
+        }
+    }
+    return Object.fromEntries(Object.entries(totals).map(([model, usage]) => [model, { usage }]));
+}
+function normalizeCopilotTranscript(raw, opts = {}) {
+    const out = [];
+    const subagentCalls = new Set();
+    let shutdownAgents = 0;
+    let assistantModel = false;
+    let premium;
+    let checkpointModels = [];
+    let final = false;
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const data = event?.data ?? {};
+        const timestamp = typeof event.timestamp === "string" ? event.timestamp : undefined;
+        const uuid = typeof event.id === "string" ? event.id : undefined;
+        const base = { ...(timestamp ? { timestamp } : {}), ...(uuid ? { uuid } : {}) };
+        switch (event.type) {
+            case "session.start": {
+                const context = data.context ?? {};
+                out.push(JSON.stringify({
+                    type: "system",
+                    subtype: "copilot_session_start",
+                    ...base,
+                    ...(typeof data.sessionId === "string" ? { sessionId: data.sessionId } : {}),
+                    ...(typeof context.cwd === "string" ? { cwd: context.cwd } : {}),
+                    ...(typeof context.branch === "string" ? { gitBranch: context.branch } : {}),
+                    ...(typeof data.copilotVersion === "string" ? { version: data.copilotVersion } : {}),
+                    ...(isVSCodeClient(opts.clientName) ? { entrypoint: "copilot:vscode" } : {}),
+                }));
+                break;
+            }
+            case "session.error":
+                out.push(JSON.stringify({ type: "agent.error", ...base, error: data.error ?? { message: data.message, code: data.errorType } }));
+                break;
+            case "hook.start":
+                if (data.hookType === "sessionEnd" && data.input?.reason === "abort") {
+                    out.push(JSON.stringify({ type: "agent.interruption", ...base, id: uuid }));
+                }
+                break;
+            case "user.message":
+                out.push(JSON.stringify({
+                    type: "user",
+                    ...base,
+                    message: { role: "user", content: copilotUserContent(data) },
+                }));
+                break;
+            case "subagent.started":
+                if (typeof data.toolCallId === "string")
+                    subagentCalls.add(data.toolCallId);
+                break;
+            case "session.usage_checkpoint":
+                if (!final)
+                    premium = premiumOf(data, timestamp);
+                if (Array.isArray(data.modelCacheState)) {
+                    checkpointModels = data.modelCacheState
+                        .map((m) => (m && typeof m === "object" ? m.modelId : undefined))
+                        .filter((m) => typeof m === "string" && m.length > 0);
+                }
+                break;
+            case "assistant.message": {
+                if (typeof data.model === "string" && data.model)
+                    assistantModel = true;
+                const tools = Array.isArray(data.toolRequests) ? data.toolRequests : [];
+                const content = [];
+                if (typeof data.content === "string" && data.content)
+                    content.push({ type: "text", text: data.content });
+                for (const request of tools) {
+                    if (typeof request?.name !== "string")
+                        continue;
+                    const mapped = claudeTool(request.name, request.arguments);
+                    content.push({ type: "tool_use", id: request.toolCallId, name: mapped.name, input: mapped.input });
+                }
+                out.push(JSON.stringify({
+                    type: "assistant",
+                    ...base,
+                    tokensAvailable: false,
+                    message: {
+                        id: firstString(data.apiCallId, data.messageId, uuid),
+                        role: "assistant",
+                        content,
+                        ...(typeof data.model === "string" && data.model
+                            ? {
+                                model: data.model,
+                                usage: { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 },
+                            }
+                            : {}),
+                    },
+                }));
+                break;
+            }
+            case "tool.execution_complete":
+                if (data.error?.code === "user_denied") {
+                    out.push(JSON.stringify({ type: "agent.rejection", ...base, id: data.toolCallId ?? uuid }));
+                }
+                out.push(JSON.stringify({
+                    type: "user",
+                    ...base,
+                    message: {
+                        role: "user",
+                        content: [{
+                                type: "tool_result",
+                                tool_use_id: data.toolCallId,
+                                content: resultText(data),
+                                ...(data.success === false ? { is_error: true } : {}),
+                            }],
+                    },
+                }).replace('"content":[{', '"content":[ {'));
+                break;
+            case "skill.invoked":
+                if (typeof data.name === "string" && data.name) {
+                    out.push(JSON.stringify({ type: "copilot.skill_invoked", ...base, skill: data.name }));
+                }
+                break;
+            case "session.shutdown": {
+                final = true;
+                premium = premiumOf(data, timestamp);
+                const agents = Object.entries(data.agentMetrics ?? {});
+                shutdownAgents = agents.filter(([agent]) => agent !== "main").length;
+                const metrics = data.modelMetrics ?? sumAgentMetrics(agents.map(([, agent]) => agent?.modelMetrics));
+                for (const [model, metric] of Object.entries(metrics)) {
+                    const usage = metric?.usage ?? {};
+                    if (![usage.inputTokens, usage.outputTokens, usage.cacheReadTokens, usage.cacheWriteTokens].some(value => typeof value === "number" && Number.isFinite(value)))
+                        continue;
+                    const cacheRead = num(usage.cacheReadTokens);
+                    out.push(JSON.stringify({
+                        type: "copilot.usage",
+                        ...base,
+                        requests: 0,
+                        message: {
+                            id: `copilot-usage:${model}`,
+                            model,
+                            usage: {
+                                input_tokens: Math.max(0, num(usage.inputTokens) - cacheRead),
+                                output_tokens: num(usage.outputTokens),
+                                cache_read_input_tokens: cacheRead,
+                                cache_creation_input_tokens: num(usage.cacheWriteTokens),
+                            },
+                        },
+                    }));
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    if (!assistantModel) {
+        for (const model of checkpointModels) {
+            out.push(JSON.stringify({
+                type: "copilot.model",
+                tokensAvailable: false,
+                requests: 0,
+                message: {
+                    id: `copilot-model:${model}`,
+                    model,
+                    usage: { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 },
+                },
+            }));
+        }
+    }
+    if (premium && (premium.premiumRequests !== undefined || premium.nanoAiu !== undefined)) {
+        out.push(JSON.stringify({
+            type: "copilot.usage_summary",
+            ...(premium.at ? { timestamp: premium.at } : {}),
+            ...(premium.premiumRequests !== undefined ? { premiumRequests: premium.premiumRequests } : {}),
+            ...(premium.nanoAiu !== undefined ? { nanoAiu: premium.nanoAiu } : {}),
+        }));
+    }
+    return {
+        content: out.join("\n") + (out.length ? "\n" : ""),
+        subagents: { count: Math.max(subagentCalls.size, shutdownAgents), truncated: false },
+        final,
+    };
+}