codiedev 0.10.0-beta.4 → 0.10.0-beta.6

package/dist/inboxFormat.js

@@ -2,32 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatInbox = formatInbox;
 const shared_1 = require("./commands/shared");
-/**
- * Render the inbox for BOTH surfaces — `codiedev inbox` and the MCP
- * `codiedev_inbox` tool an agent calls for "any messages?". Shared so the
- * agent path can never drift back to pings-only while the human path shows
- * mentions.
- */
 function formatInbox(opts) {
     const mentions = opts.mentions ?? [];
-    // The backend applies `limit` to each source independently, so asking for N
-    // can return up to 2N — and with no `--limit` it defaults to 50 per source,
-    // i.e. 100 rows, twice the pre-change maximum. Cap the COMBINED list by
-    // recency, always (matching the backend's own default), so the header is
-    // truthful and `--limit` actually holds.
-    //
-    // Selected by identity rather than by a `createdAt >= cutoff` filter: rows
-    // tied on the cutoff millisecond are reachable (Convex freezes Date.now()
-    // per transaction, and seeded activity carries synthetic stamps) and a
-    // threshold filter lets every tied row through, overshooting the limit.
     const DEFAULT_LIMIT = 50;
     const cap = opts.limit ?? DEFAULT_LIMIT;
-    // Pings claim the budget first, then mentions fill whatever is left — both
-    // newest-first. Before this change pings owned the whole budget, so this is
-    // purely additive and can never hide a ping that used to be visible. A flat
-    // recency cap would instead let a busy feed evict every direct ping, and
-    // pings are the actionable half: they carry the id you reply to, and losing
-    // them all takes the mark-read footer with them.
     const byRecency = (xs) => [...xs].sort((a, b) => b.createdAt - a.createdAt);
     const keptPings = byRecency(opts.pings).slice(0, cap);
     const keptMentions = byRecency(mentions).slice(0, Math.max(0, cap - keptPings.length));
@@ -50,8 +28,6 @@ function formatInbox(opts) {
         lines.push(`    id: ${p.pingId}`);
         lines.push("");
     }
-    // Mentions carry no CLI-side body to reply to — the thread lives in the feed
-    // — so each row ends in the deep link rather than an id.
     for (const m of keptMentions) {
         const dot = m.readAt ? "·" : "●";
         const from = m.from?.name ?? "someone";

package/dist/launchContext.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codieLaunchFromArgv = codieLaunchFromArgv;
+exports.cursorLaunchFromCommand = cursorLaunchFromCommand;
+exports.copilotLaunchFromCommand = copilotLaunchFromCommand;
+exports.windowsAncestors = windowsAncestors;
+exports.detectCursorLaunch = detectCursorLaunch;
+exports.detectCopilotLaunch = detectCopilotLaunch;
+exports.hookLaunch = hookLaunch;
+const node_child_process_1 = require("node:child_process");
+const VALUE = /^[a-z0-9][a-z0-9_.:-]{0,39}$/;
+const CODIE_SUBCOMMANDS = ["run", "serve", "acp", "web", "attach"];
+function codieLaunchFromArgv(argv) {
+    const sub = argv.find((a) => CODIE_SUBCOMMANDS.includes(a));
+    return sub ? `codie:${sub}` : "codie:tui";
+}
+function tokenize(command) {
+    const tokens = [];
+    for (const m of command.matchAll(/"([^"]*)"|(\S+)/g))
+        tokens.push(m[1] ?? m[2]);
+    return tokens;
+}
+const CURSOR_AGENT_PATH = /(^|[/\\])cursor-agent([/\\]|\.(exe|cmd|ps1)$|$)/i;
+const AGENT_BIN = /(^|[/\\])(cursor-)?agent(\.(exe|cmd|ps1))?$/i;
+function cursorLaunchFromCommand(command) {
+    const tokens = tokenize(command);
+    const isAgent = tokens.some((t) => CURSOR_AGENT_PATH.test(t) || /[/\\]\.local[/\\]share[/\\]cursor/i.test(t))
+        && tokens.some((t) => AGENT_BIN.test(t) || /index\.js$/i.test(t));
+    if (isAgent) {
+        return cursorFlags(tokens).some((f) => f === "-p" || f === "--print" || f.startsWith("--print="))
+            ? "cursor:print"
+            : "cursor:cli";
+    }
+    if (/Cursor\.app|Cursor Helper|[/\\]cursor(\.exe)?(\s|"|$)/i.test(command))
+        return "cursor:ide";
+    return undefined;
+}
+const CURSOR_VALUE_FLAGS = new Set(["--model", "-m", "--output-format", "--api-key", "--resume", "--workspace", "--mode", "-H", "--header"]);
+function cursorFlags(tokens) {
+    let start = tokens.findIndex((t) => /index\.js$/i.test(t));
+    if (start < 0)
+        start = tokens.findIndex((t) => AGENT_BIN.test(t));
+    const flags = [];
+    for (let i = (start >= 0 ? start : 0) + 1; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (!t.startsWith("-"))
+            break;
+        flags.push(t);
+        if (CURSOR_VALUE_FLAGS.has(t))
+            i++;
+    }
+    return flags;
+}
+const COPILOT_BIN = /(^|[/\\])copilot(\.(exe|cmd|ps1|js))?$/i;
+const NODE_BIN = /(^|[/\\])node(\.exe)?$/i;
+function copilotLaunchFromCommand(command) {
+    const tokens = tokenize(command);
+    const bin = COPILOT_BIN.test(tokens[0] ?? "")
+        ? 0
+        : NODE_BIN.test(tokens[0] ?? "") && COPILOT_BIN.test(tokens[1] ?? "")
+            ? 1
+            : -1;
+    if (bin < 0)
+        return undefined;
+    for (let i = bin + 1; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t === "-p" || t === "--prompt" || t.startsWith("--prompt="))
+            return "copilot:print";
+        if (!t.startsWith("-"))
+            break;
+        if (COPILOT_VALUE_FLAGS.has(t))
+            i++;
+    }
+    return "copilot:cli";
+}
+const COPILOT_VALUE_FLAGS = new Set([
+    "--model", "--add-dir", "--allow-tool", "--deny-tool", "--resume", "--log-dir",
+    "--log-level", "--agent", "--config-dir", "--allow-url", "--deny-url",
+    "--additional-mcp-config", "--stream", "--output-format",
+]);
+const psPosix = (pid) => {
+    const result = (0, node_child_process_1.spawnSync)("ps", ["-o", "ppid=,args=", "-p", String(pid)], { encoding: "utf8", timeout: 500 });
+    const line = result.status === 0 ? result.stdout.trim() : "";
+    const match = line.match(/^(\d+)\s+(.*)$/s);
+    return match ? { ppid: Number(match[1]), command: match[2] } : null;
+};
+function windowsAncestors(startPid, depth) {
+    const script = `$p=${Math.trunc(startPid)};$o=@();for($i=0;$i -lt ${Math.trunc(depth)} -and $p -gt 0;$i++){` +
+        `$x=Get-CimInstance Win32_Process -Filter "ProcessId=$p" -ErrorAction SilentlyContinue;if(!$x){break};` +
+        `$o+=[pscustomobject]@{pid=[int]$p;ppid=[int]$x.ParentProcessId;command=[string]$x.CommandLine};$p=$x.ParentProcessId};` +
+        `ConvertTo-Json -InputObject @($o) -Compress`;
+    const result = (0, node_child_process_1.spawnSync)("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+        encoding: "utf8",
+        timeout: 10000,
+        windowsHide: true,
+    });
+    if (result.status !== 0 || !result.stdout.trim())
+        return null;
+    try {
+        const rows = JSON.parse(result.stdout);
+        return rows.map((r) => ({ pid: Number(r.pid), ppid: Number(r.ppid), command: r.command ?? "" }));
+    }
+    catch {
+        return null;
+    }
+}
+function detectLaunch(fromCommand, startPid, deps) {
+    const depth = deps.depth ?? 5;
+    if ((deps.platform ?? process.platform) === "win32" && !deps.ps) {
+        const chain = (deps.windows ?? windowsAncestors)(startPid, depth);
+        if (!chain)
+            return undefined;
+        for (const row of chain) {
+            const launch = fromCommand(row.command);
+            if (launch)
+                return launch;
+        }
+        return undefined;
+    }
+    const ps = deps.ps ?? psPosix;
+    let pid = startPid;
+    for (let i = 0; i < depth && pid > 1; i++) {
+        const row = ps(pid);
+        if (!row)
+            return undefined;
+        const launch = fromCommand(row.command);
+        if (launch)
+            return launch;
+        pid = row.ppid;
+    }
+    return undefined;
+}
+function detectCursorLaunch(startPid = process.ppid, deps = {}) {
+    return detectLaunch(cursorLaunchFromCommand, startPid, deps);
+}
+function detectCopilotLaunch(startPid = process.ppid, deps = {}) {
+    return detectLaunch(copilotLaunchFromCommand, startPid, deps);
+}
+function hookLaunch(hookCommand, input, deps = {}) {
+    if (typeof input.launch === "string" && VALUE.test(input.launch))
+        return input.launch;
+    if (hookCommand?.endsWith("-cursor"))
+        return detectCursorLaunch();
+    if (hookCommand?.endsWith("-copilot")) {
+        if (deps.copilotClientName === "vscode-agent-host")
+            return "copilot:vscode";
+        return (deps.detectCopilot ?? detectCopilotLaunch)();
+    }
+    return undefined;
+}

package/dist/launcher.js

@@ -0,0 +1,140 @@
+"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.LAUNCHER_FILE = void 0;
+exports.launcherPath = launcherPath;
+exports.usesLauncher = usesLauncher;
+exports.readInstallRecord = readInstallRecord;
+exports.recordCurrentInstall = recordCurrentInstall;
+exports.ensureLauncher = ensureLauncher;
+exports.resetLauncherCacheForTests = resetLauncherCacheForTests;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const configDir_1 = require("./configDir");
+exports.LAUNCHER_FILE = "codiedev-hook-launcher.cjs";
+const LAUNCHER_REVISION = 1;
+function launcherPath() {
+    return path.join((0, configDir_1.codiedevStateDir)(), "bin", exports.LAUNCHER_FILE);
+}
+function installRecordPath() {
+    return path.join((0, configDir_1.codiedevStateDir)(), "install.json");
+}
+function usesLauncher(cmd) {
+    return typeof cmd === "string" && cmd.includes(exports.LAUNCHER_FILE);
+}
+function launcherSource(fallback) {
+    return `// codiedev-hook-launcher revision ${LAUNCHER_REVISION}. Managed by codiedev; safe to delete (re-run \`codiedev connect\`).
+"use strict";
+const fs = require("fs");
+const path = require("path");
+const FALLBACK = ${JSON.stringify(fallback)};
+let target = null;
+try {
+  const rec = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "install.json"), "utf8"));
+  if (rec && typeof rec.hookScript === "string" && fs.existsSync(rec.hookScript)) target = rec.hookScript;
+} catch {}
+if (!target && fs.existsSync(FALLBACK)) target = FALLBACK;
+if (!target) process.exit(0);
+process.env.CODIEDEV_VIA_LAUNCHER = "1";
+process.argv[1] = target;
+require(target);
+`;
+}
+function writeAtomic(target, contents) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const tmp = `${target}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, contents, "utf8");
+    fs.renameSync(tmp, target);
+}
+function readInstallRecord() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(installRecordPath(), "utf8"));
+        return typeof parsed.hookScript === "string" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function packageVersionFor(hookScript) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(path.dirname(path.dirname(hookScript)), "package.json"), "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function recordCurrentInstall(hookScript) {
+    try {
+        const record = {
+            hookScript,
+            version: packageVersionFor(hookScript),
+            recordedAt: Date.now(),
+        };
+        writeAtomic(installRecordPath(), JSON.stringify(record, null, 2));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+let ensuredFor;
+function ensureLauncher(hookScript) {
+    if (ensuredFor !== undefined && ensuredFor === hookScript)
+        return launcherPath();
+    try {
+        const target = launcherPath();
+        const source = launcherSource(hookScript);
+        let current = null;
+        try {
+            current = fs.readFileSync(target, "utf8");
+        }
+        catch {
+        }
+        if (current !== source)
+            writeAtomic(target, source);
+        if (readInstallRecord()?.hookScript !== hookScript && !recordCurrentInstall(hookScript)) {
+            return null;
+        }
+        ensuredFor = hookScript;
+        return target;
+    }
+    catch {
+        return null;
+    }
+}
+function resetLauncherCacheForTests() {
+    ensuredFor = undefined;
+}

package/dist/limitEvent.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyLimitKind = classifyLimitKind;
 exports.parseLimitEventFromTranscript = parseLimitEventFromTranscript;
 exports.parseCodexLimitEventFromTranscript = parseCodexLimitEventFromTranscript;
+exports.parseNativeLimitError = parseNativeLimitError;
+exports.parseNativeLimitEventFromTranscript = parseNativeLimitEventFromTranscript;
 exports.tailForLimitEvent = tailForLimitEvent;
 function classifyLimitKind(text) {
     const t = text.toLowerCase();
@@ -12,7 +14,6 @@ function classifyLimitKind(text) {
         return "org_spend";
     return "other";
 }
-// "… · resets 9:50pm (UTC)" → "9:50pm (UTC)". Null when absent.
 function parseResetText(text) {
     const m = text.match(/resets\s+(.+?)\s*$/i);
     return m ? m[1].trim() : null;
@@ -25,8 +26,6 @@ function messageText(entry) {
         return c.map((x) => (x && typeof x === "object" ? x.text ?? "" : "")).join(" ");
     return "";
 }
-// Scans transcript JSONL for the LAST top-level `error: "rate_limit"` entry.
-// (Validated shape: error/isApiErrorMessage are top-level, not under message.)
 function parseLimitEventFromTranscript(transcript) {
     let found = null;
     for (const line of transcript.split("\n")) {
@@ -51,29 +50,6 @@ function parseLimitEventFromTranscript(transcript) {
     }
     return found;
 }
-/**
- * Codex's `rate_limit_reached_type` is exactly five values (read off the 0.154
- * binary): `rate_limit_reached`, `workspace_{owner,member}_credits_depleted`
- * and `workspace_{owner,member}_usage_limit_reached`.
- *
- * The split that matters to a reader of the dashboard is "someone must act on
- * money" vs "this dev is throttled and it will reset" — so map on what the
- * snapshot actually asserts, not on the word "credits":
- *
- * - A member out of their OWN allowance is a rate limit. Real snapshots carry
- *   `spend_control_reached: null` and `individual_limit: null` — nobody
- *   configured a budget, the window is simply used up. Calling that personal
- *   spend tells a manager the dev overspent, which is not what happened.
- *
- *   Deliberately NOT gated on `individual_limit`: it has only ever been
- *   observed null, so its populated shape and meaning are unknown, and a
- *   wrong guess reinstates the mislabel this exists to remove. The reason
- *   string is the causal signal; `individual_limit` is at best correlative.
- * - A member whose ADMIN capped them (`usage_limit_reached`) is personal spend:
- *   there really is a cap, and someone can raise it.
- * - Anything owner-scoped is org spend — the org's allowance or credits are
- *   gone and somebody has to act.
- */
 function codexLimitKind(reason, spendControlReached) {
     if (spendControlReached || reason.startsWith("workspace_owner_"))
         return "org_spend";
@@ -94,11 +70,6 @@ function codexResetText(rateLimits) {
         .sort((a, b) => a - b)[0];
     return resetAt ? new Date(resetAt * 1000).toISOString() : null;
 }
-/**
- * Codex writes a structured RateLimitSnapshot on token_count events. A normal
- * turn has `rate_limit_reached_type: null`; a blocked turn names the exact
- * boundary. Reading that field avoids locale-dependent terminal copy.
- */
 function parseCodexLimitEventFromTranscript(transcript) {
     let found = null;
     for (const line of transcript.split("\n")) {
@@ -133,10 +104,45 @@ function parseCodexLimitEventFromTranscript(transcript) {
     }
     return found;
 }
-// Tail of the raw transcript to ship with the limit event so the server can
-// summarize "what they were working on" immediately — without waiting for the
-// SessionEnd capture (which can lag hours, or drop entirely on Windows).
-// Resumes at a line boundary so every JSONL line in the tail still parses.
+function parseNativeLimitError(input, now = Date.now()) {
+    const context = input.errorContext ?? input.error_context;
+    if (context !== undefined && context !== "model_call")
+        return null;
+    const error = input.error;
+    const fields = error && typeof error === "object" ? error : {};
+    const code = String(fields.code ?? fields.name ?? input.error_code ?? "");
+    const text = typeof error === "string" ? error
+        : typeof fields.message === "string" ? fields.message
+            : typeof input.error_message === "string" ? input.error_message : "";
+    if (!/^(?:429|rate[_-]?limit(?:ed|_exceeded|_error)?|RateLimitError|quota_exceeded)$/i.test(code)
+        && !/\b(?:rate limit (?:exceeded|reached)|too many requests|usage limit (?:exceeded|reached)|premium requests? (?:exhausted|limit reached))\b/i.test(text))
+        return null;
+    const rawAt = input.timestamp;
+    const parsedAt = typeof rawAt === "number" ? rawAt : typeof rawAt === "string" ? Date.parse(rawAt) : NaN;
+    return { kind: classifyLimitKind(text), at: Number.isFinite(parsedAt) && parsedAt > 0 ? parsedAt : now,
+        resetText: parseResetText(text), reason: code || "rate_limit" };
+}
+function parseNativeLimitEventFromTranscript(transcript) {
+    let found = null;
+    for (const line of transcript.split("\n")) {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.type === "agent.limit" && Number.isFinite(entry.at) && entry.at > 0
+                && ["session", "user_spend", "org_spend", "other"].includes(entry.kind)) {
+                found = { kind: entry.kind, at: entry.at, resetText: typeof entry.resetText === "string" ? entry.resetText : null,
+                    ...(typeof entry.reason === "string" ? { reason: entry.reason } : {}) };
+                continue;
+            }
+            if (!entry.timestamp)
+                continue;
+            if (entry.type === "agent.error" || entry.type === "session.error") {
+                found = parseNativeLimitError({ ...(entry.data ?? entry), timestamp: entry.timestamp }) ?? found;
+            }
+        }
+        catch { }
+    }
+    return found;
+}
 const DEFAULT_TAIL_CHARS = 65536;
 function tailForLimitEvent(transcript, maxChars = DEFAULT_TAIL_CHARS) {
     if (transcript.length <= maxChars)

package/dist/limitEventReporter.js

@@ -76,7 +76,7 @@ function postLimitEvent(config, payload, timeoutMs = 5_000) {
 async function reportTranscriptLimitEvent(args) {
     const parse = args.source === "codex"
         ? limitEvent_1.parseCodexLimitEventFromTranscript
-        : limitEvent_1.parseLimitEventFromTranscript;
+        : args.source === "cursor" || args.source === "copilot" || args.source === "pi" ? limitEvent_1.parseNativeLimitEventFromTranscript : limitEvent_1.parseLimitEventFromTranscript;
     const parsed = parse(args.transcript);
     if (!parsed && !args.emitMinimalOnMiss)
         return false;