@shawnowen/comet-mcp 2.3.1 → 2.4.2

package/dist/window-bindings.js

@@ -0,0 +1,561 @@
+import { mkdir, readFile, rename, rm, unlink, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+import { randomUUID } from "crypto";
+import { execFileSync } from "child_process";
+export class WindowBindingConflictError extends Error {
+    conflicts;
+    constructor(message, conflicts) {
+        super(message);
+        this.conflicts = conflicts;
+        this.name = "WindowBindingConflictError";
+    }
+}
+export class CodexIdentityError extends Error {
+    missingFields;
+    constructor(message, missingFields) {
+        super(message);
+        this.missingFields = missingFields;
+        this.name = "CodexIdentityError";
+    }
+}
+const DEFAULT_BINDING_DIR = path.join(os.homedir(), ".claude", "comet-browser");
+const DEFAULT_BINDING_FILE = path.join(DEFAULT_BINDING_DIR, "window-bindings.json");
+const LOCK_RETRY_MS = 25;
+const LOCK_TIMEOUT_MS = 5_000;
+const VALID_CODEX_ROLES = new Set([
+    "session_agent",
+    "worktree_orchestrator",
+    "fleet_orchestrator",
+]);
+const VALID_PROFILE_OWNERS = new Set([
+    "agent",
+    "human",
+    "shared_legacy",
+    "unknown",
+]);
+function nowIso() {
+    return new Date().toISOString();
+}
+function normalizeRunIds(runIds = []) {
+    return [...new Set(runIds.filter((runId) => runId.trim().length > 0))].sort();
+}
+function firstNonEmpty(...values) {
+    return values.find((value) => value !== undefined && value.trim().length > 0)?.trim();
+}
+function gitOutput(cwd, args) {
+    try {
+        return execFileSync("git", args, {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function repoSlugFromRemote(remoteUrl) {
+    if (!remoteUrl)
+        return undefined;
+    const match = remoteUrl.match(/[:/]([^/:]+\/[^/]+?)(?:\.git)?$/);
+    return match?.[1];
+}
+function deriveRepoSlug(cwd) {
+    return (repoSlugFromRemote(gitOutput(cwd, ["config", "--get", "remote.origin.url"])) ??
+        path.basename(cwd));
+}
+function deriveBranchName(cwd) {
+    return gitOutput(cwd, ["branch", "--show-current"]) || "unknown";
+}
+export function resolveCodexSessionRole(role) {
+    const normalized = role
+        ?.trim()
+        .toLowerCase()
+        .replace(/[-\s]+/g, "_");
+    if (normalized && VALID_CODEX_ROLES.has(normalized)) {
+        return normalized;
+    }
+    if (normalized === "fleet" || normalized === "fleet_orchestrator_agent") {
+        return "fleet_orchestrator";
+    }
+    if (normalized === "orchestrator" || normalized === "worktree") {
+        return "worktree_orchestrator";
+    }
+    return "session_agent";
+}
+export function deriveCodexSessionIdentity(input = {}, context = {}) {
+    const env = context.env ?? process.env;
+    const cwd = path.resolve(input.worktreePath ?? env.CODEX_WORKTREE_PATH ?? context.cwd ?? process.cwd());
+    const codexSessionId = firstNonEmpty(input.codexSessionId, env.CODEX_SESSION_ID, env.CODEX_RUN_ID, input.fallbackAgentId);
+    const projectThreadId = firstNonEmpty(input.projectThreadId, env.CODEX_PROJECT_THREAD_ID, env.COMET_TASK_GROUP, input.fallbackTaskThreadId);
+    const repoSlug = firstNonEmpty(input.repoSlug, env.CODEX_REPO_SLUG) ?? deriveRepoSlug(cwd);
+    const branchName = firstNonEmpty(input.branchName, env.CODEX_BRANCH_NAME, env.GIT_BRANCH) ?? deriveBranchName(cwd);
+    const missingFields = [
+        ["codexSessionId", codexSessionId],
+        ["projectThreadId", projectThreadId],
+        ["worktreePath", cwd],
+        ["repoSlug", repoSlug],
+        ["branchName", branchName],
+    ];
+    const missingFieldNames = missingFields.filter(([, value]) => !value).map(([field]) => field);
+    if (input.strict && missingFieldNames.length > 0) {
+        throw new CodexIdentityError("Missing required Codex identity fields", missingFieldNames);
+    }
+    const resolvedCodexSessionId = codexSessionId ?? "manual-codex-session";
+    const resolvedProjectThreadId = projectThreadId ?? "manual-project-thread";
+    return {
+        codexSessionId: resolvedCodexSessionId,
+        projectThreadId: resolvedProjectThreadId,
+        projectThreadFamily: firstNonEmpty(input.projectThreadFamily, env.CODEX_PROJECT_THREAD_FAMILY),
+        worktreePath: cwd,
+        repoSlug,
+        branchName,
+        sessionKey: firstNonEmpty(input.sessionKey, env.CODEX_SESSION_KEY) ??
+            `${resolvedCodexSessionId}:${resolvedProjectThreadId}`,
+        role: resolveCodexSessionRole(firstNonEmpty(input.role, env.CODEX_SESSION_ROLE, env.CODEX_ROLE)),
+    };
+}
+export function isBindingInWorktreeScope(caller, binding) {
+    if (caller.role === "fleet_orchestrator")
+        return true;
+    if (caller.role === "session_agent")
+        return caller.sessionKey === binding.sessionKey;
+    if (caller.worktreePath === binding.worktreePath)
+        return true;
+    return Boolean(caller.projectThreadFamily &&
+        binding.projectThreadFamily &&
+        caller.projectThreadFamily === binding.projectThreadFamily);
+}
+export function canReadBinding(caller, binding) {
+    return isBindingInWorktreeScope(caller, binding);
+}
+export function canMutateBinding(caller, binding, options = {}) {
+    if (caller.role === "session_agent") {
+        return caller.sessionKey === binding.sessionKey;
+    }
+    if (!isBindingInWorktreeScope(caller, binding))
+        return false;
+    const explicitTarget = options.targetBindingId === binding.bindingId;
+    if (!explicitTarget)
+        return false;
+    if (caller.role === "worktree_orchestrator" || caller.role === "fleet_orchestrator") {
+        return Boolean(options.reason?.trim() && options.audit);
+    }
+    return false;
+}
+export function assertBindingMutationAllowed(caller, binding, options = {}) {
+    if (canMutateBinding(caller, binding, options))
+        return;
+    throw new Error(`BINDING_MUTATION_SCOPE_VIOLATION: ${caller.role} ${caller.sessionKey} cannot mutate binding ${binding.bindingId} without explicit scope, target, reason, and audit`);
+}
+export function normalizeProfileOwner(owner) {
+    const normalized = owner?.trim().toLowerCase();
+    if (normalized && VALID_PROFILE_OWNERS.has(normalized)) {
+        return normalized;
+    }
+    return "unknown";
+}
+export function assertBindingProfileAllowed(identity, binding) {
+    if (identity.role !== "session_agent")
+        return;
+    if (binding.profileOwner === "agent")
+        return;
+    throw new Error(`PROFILE_OWNERSHIP_VIOLATION: binding profile ${binding.profileId} is ${binding.profileOwner}-owned and cannot be mutated by normal agents`);
+}
+function bindingStorePaths(storePath) {
+    const file = storePath ?? DEFAULT_BINDING_FILE;
+    return {
+        file,
+        dir: path.dirname(file),
+        lockDir: `${file}.lock`,
+    };
+}
+function emptySnapshot() {
+    return {
+        version: 1,
+        bindings: {},
+        runBindingIndex: {},
+        updatedAt: nowIso(),
+    };
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withFileLock(lockDir, fn) {
+    const startedAt = Date.now();
+    while (true) {
+        try {
+            await mkdir(lockDir);
+            break;
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "EEXIST" || Date.now() - startedAt > LOCK_TIMEOUT_MS)
+                throw err;
+            await sleep(LOCK_RETRY_MS);
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        await rm(lockDir, { recursive: true, force: true });
+    }
+}
+async function readSnapshot(file) {
+    try {
+        const raw = await readFile(file, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            version: 1,
+            bindings: parsed.bindings ?? {},
+            runBindingIndex: parsed.runBindingIndex ?? {},
+            updatedAt: parsed.updatedAt ?? nowIso(),
+        };
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return emptySnapshot();
+        throw err;
+    }
+}
+async function writeSnapshot(file, dir, snapshot) {
+    await mkdir(dir, { recursive: true });
+    const tmp = `${file}.tmp.${process.pid}.${Date.now()}`;
+    try {
+        await writeFile(tmp, `${JSON.stringify(snapshot, null, 2)}\n`, "utf-8");
+        await rename(tmp, file);
+    }
+    catch (err) {
+        try {
+            await unlink(tmp);
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw err;
+    }
+}
+function sameProjectThread(a, input) {
+    return (a.projectThreadId === input.projectThreadId &&
+        a.worktreePath === input.worktreePath &&
+        a.repoSlug === input.repoSlug);
+}
+function activeBindings(snapshot) {
+    return Object.values(snapshot.bindings).filter((binding) => binding.status === "active");
+}
+function rebuildRunBindingIndex(bindings) {
+    const updatedAt = nowIso();
+    const index = {};
+    for (const binding of Object.values(bindings)) {
+        for (const runId of binding.runIds) {
+            index[runId] = { runId, bindingId: binding.bindingId, updatedAt };
+        }
+    }
+    return index;
+}
+function applyRunIds(binding, runIds, index) {
+    binding.runIds = normalizeRunIds([...binding.runIds, ...runIds]);
+    const updatedAt = nowIso();
+    for (const runId of binding.runIds) {
+        index[runId] = { runId, bindingId: binding.bindingId, updatedAt };
+    }
+}
+function generateSidecarContextKey(input) {
+    return `sidecar:${input.repoSlug}:${input.projectThreadId}:${input.sessionKey}:${randomUUID()}`;
+}
+export class CodexWindowBindingStore {
+    file;
+    dir;
+    lockDir;
+    constructor(storePath) {
+        const paths = bindingStorePaths(storePath);
+        this.file = paths.file;
+        this.dir = paths.dir;
+        this.lockDir = paths.lockDir;
+    }
+    get path() {
+        return this.file;
+    }
+    async load() {
+        return readSnapshot(this.file);
+    }
+    async list() {
+        const snapshot = await this.load();
+        return Object.values(snapshot.bindings);
+    }
+    async get(bindingId) {
+        const snapshot = await this.load();
+        return snapshot.bindings[bindingId] ?? null;
+    }
+    async findActiveByIdentity(identity) {
+        const snapshot = await this.load();
+        return activeBindings(snapshot).find((binding) => sameProjectThread(binding, identity)) ?? null;
+    }
+    async findByRunId(runId) {
+        const snapshot = await this.load();
+        const indexEntry = snapshot.runBindingIndex[runId];
+        if (!indexEntry)
+            return null;
+        return snapshot.bindings[indexEntry.bindingId] ?? null;
+    }
+    async createOrReuse(input) {
+        return withFileLock(this.lockDir, async () => {
+            const snapshot = await readSnapshot(this.file);
+            const existing = activeBindings(snapshot).find((binding) => sameProjectThread(binding, input));
+            const runIds = normalizeRunIds(input.runIds);
+            const timestamp = nowIso();
+            if (existing) {
+                const repaired = existing.windowId !== input.windowId ||
+                    existing.targetId !== (input.targetId ?? null) ||
+                    existing.tabGroupId !== (input.tabGroupId ?? null);
+                existing.windowId = input.windowId;
+                existing.tabGroupId = input.tabGroupId ?? null;
+                existing.targetId = input.targetId ?? null;
+                existing.profileId = input.profileId ?? existing.profileId ?? "agent";
+                existing.profileAlias = input.profileAlias ?? existing.profileAlias ?? "oe";
+                existing.profileOwner = normalizeProfileOwner(input.profileOwner ?? existing.profileOwner);
+                existing.updatedAt = timestamp;
+                applyRunIds(existing, runIds, snapshot.runBindingIndex);
+                snapshot.updatedAt = timestamp;
+                this.assertNoActiveConflicts(snapshot);
+                await writeSnapshot(this.file, this.dir, snapshot);
+                return { binding: existing, action: repaired ? "repaired" : "reused" };
+            }
+            const conflictingWindowOwners = activeBindings(snapshot).filter((binding) => binding.windowId === input.windowId);
+            if (conflictingWindowOwners.length > 0) {
+                throw new WindowBindingConflictError(`Window ${input.windowId} is already owned by an active Codex binding`, conflictingWindowOwners);
+            }
+            if (input.sidecarContextKey &&
+                Object.values(snapshot.bindings).some((binding) => binding.sidecarContextKey === input.sidecarContextKey)) {
+                throw new WindowBindingConflictError(`Sidecar context ${input.sidecarContextKey} is already owned by an active Codex binding`, Object.values(snapshot.bindings).filter((binding) => binding.sidecarContextKey === input.sidecarContextKey));
+            }
+            const binding = {
+                bindingId: randomUUID(),
+                codexSessionId: input.codexSessionId,
+                projectThreadId: input.projectThreadId,
+                projectThreadFamily: input.projectThreadFamily,
+                worktreePath: input.worktreePath,
+                repoSlug: input.repoSlug,
+                branchName: input.branchName,
+                sessionKey: input.sessionKey,
+                role: input.role,
+                runIds,
+                windowId: input.windowId,
+                tabGroupId: input.tabGroupId ?? null,
+                targetId: input.targetId ?? null,
+                profileId: input.profileId ?? "agent",
+                profileAlias: input.profileAlias ?? "oe",
+                profileOwner: normalizeProfileOwner(input.profileOwner ?? "agent"),
+                sidecarContextKey: input.sidecarContextKey ?? generateSidecarContextKey(input),
+                status: "active",
+                createdAt: timestamp,
+                updatedAt: timestamp,
+            };
+            snapshot.bindings[binding.bindingId] = binding;
+            applyRunIds(binding, runIds, snapshot.runBindingIndex);
+            snapshot.updatedAt = timestamp;
+            this.assertNoActiveConflicts(snapshot);
+            await writeSnapshot(this.file, this.dir, snapshot);
+            return { binding, action: "created" };
+        });
+    }
+    async addRunId(bindingId, runId) {
+        return withFileLock(this.lockDir, async () => {
+            const snapshot = await readSnapshot(this.file);
+            const binding = snapshot.bindings[bindingId];
+            if (!binding)
+                throw new Error(`Unknown bindingId: ${bindingId}`);
+            binding.updatedAt = nowIso();
+            applyRunIds(binding, [runId], snapshot.runBindingIndex);
+            snapshot.updatedAt = binding.updatedAt;
+            await writeSnapshot(this.file, this.dir, snapshot);
+            return binding;
+        });
+    }
+    async transition(bindingId, status) {
+        return withFileLock(this.lockDir, async () => {
+            const snapshot = await readSnapshot(this.file);
+            const binding = snapshot.bindings[bindingId];
+            if (!binding)
+                throw new Error(`Unknown bindingId: ${bindingId}`);
+            binding.status = status;
+            binding.updatedAt = nowIso();
+            snapshot.updatedAt = binding.updatedAt;
+            await writeSnapshot(this.file, this.dir, snapshot);
+            return binding;
+        });
+    }
+    async transitionByRunId(runId, status) {
+        return withFileLock(this.lockDir, async () => {
+            const snapshot = await readSnapshot(this.file);
+            const indexEntry = snapshot.runBindingIndex[runId];
+            if (!indexEntry)
+                return null;
+            const binding = snapshot.bindings[indexEntry.bindingId];
+            if (!binding)
+                return null;
+            binding.status = status;
+            binding.updatedAt = nowIso();
+            snapshot.runBindingIndex[runId] = {
+                runId,
+                bindingId: binding.bindingId,
+                updatedAt: binding.updatedAt,
+            };
+            snapshot.updatedAt = binding.updatedAt;
+            await writeSnapshot(this.file, this.dir, snapshot);
+            return binding;
+        });
+    }
+    async classifyConflicts() {
+        return withFileLock(this.lockDir, async () => {
+            const snapshot = await readSnapshot(this.file);
+            const conflicts = this.findActiveConflicts(snapshot);
+            const timestamp = nowIso();
+            for (const conflict of conflicts) {
+                conflict.status = "conflict";
+                conflict.updatedAt = timestamp;
+            }
+            if (conflicts.length > 0) {
+                snapshot.updatedAt = timestamp;
+                snapshot.runBindingIndex = rebuildRunBindingIndex(snapshot.bindings);
+                await writeSnapshot(this.file, this.dir, snapshot);
+            }
+            return conflicts;
+        });
+    }
+    async markStaleForMissingWindows(liveWindowIds) {
+        const live = new Set(liveWindowIds);
+        return withFileLock(this.lockDir, async () => {
+            const snapshot = await readSnapshot(this.file);
+            const stale = activeBindings(snapshot).filter((binding) => !live.has(binding.windowId));
+            const timestamp = nowIso();
+            for (const binding of stale) {
+                binding.status = "stale";
+                binding.updatedAt = timestamp;
+            }
+            if (stale.length > 0) {
+                snapshot.updatedAt = timestamp;
+                await writeSnapshot(this.file, this.dir, snapshot);
+            }
+            return stale;
+        });
+    }
+    /**
+     * Reconcile every binding against the live window set and reap (delete) those
+     * whose window has been missing for at least {@link ReapOptions.ttlMs}.
+     *
+     * - Window live → clear `missingSince`, reactivate if the reaper marked it stale, retain.
+     * - Window missing, no `missingSince` → record `missingSince=now`, mark stale, retain (grace starts).
+     * - Window missing ≥ TTL, profile-owned → skip.
+     * - Window missing ≥ TTL, not owned → `archive()` then delete.
+     *
+     * Atomic + file-locked + idempotent. A no-op when nothing needs changing.
+     */
+    async reapExpiredBindings(opts) {
+        const live = new Set(opts.liveWindowIds);
+        const now = opts.now ?? Date.now();
+        const ttlMs = opts.ttlMs;
+        const isOwned = opts.isProfileOwned ??
+            ((b) => b.profileOwner != null && b.profileOwner !== "agent");
+        const result = {
+            evaluated: 0,
+            newlyMissing: 0,
+            retainedLive: 0,
+            reaped: 0,
+            skippedOwned: 0,
+            reapedBindingIds: [],
+        };
+        return withFileLock(this.lockDir, async () => {
+            const snapshot = await readSnapshot(this.file);
+            let mutated = false;
+            const reapCandidates = [];
+            for (const binding of Object.values(snapshot.bindings)) {
+                result.evaluated += 1;
+                if (live.has(binding.windowId)) {
+                    if (binding.missingSince != null) {
+                        delete binding.missingSince;
+                        if (binding.status === "stale") {
+                            binding.status = "active";
+                        }
+                        binding.updatedAt = nowIso();
+                        mutated = true;
+                    }
+                    result.retainedLive += 1;
+                    continue;
+                }
+                // Window is missing from the live set.
+                if (binding.missingSince == null) {
+                    binding.missingSince = new Date(now).toISOString();
+                    binding.status = "stale";
+                    binding.updatedAt = nowIso();
+                    mutated = true;
+                    result.newlyMissing += 1;
+                    continue; // retained this cycle; grace period starts
+                }
+                const missingForMs = now - Date.parse(binding.missingSince);
+                if (!Number.isFinite(missingForMs) || missingForMs < ttlMs) {
+                    continue; // still within grace (or unparseable) → retain
+                }
+                if (isOwned(binding)) {
+                    result.skippedOwned += 1;
+                    continue;
+                }
+                reapCandidates.push(binding);
+            }
+            for (const binding of reapCandidates) {
+                if (opts.archive) {
+                    try {
+                        await opts.archive(binding);
+                    }
+                    catch {
+                        // Archive failed — do NOT delete (fail-safe, recoverable next cycle).
+                        continue;
+                    }
+                }
+                delete snapshot.bindings[binding.bindingId];
+                result.reaped += 1;
+                result.reapedBindingIds.push(binding.bindingId);
+                mutated = true;
+            }
+            if (mutated) {
+                snapshot.updatedAt = nowIso();
+                snapshot.runBindingIndex = rebuildRunBindingIndex(snapshot.bindings);
+                await writeSnapshot(this.file, this.dir, snapshot);
+            }
+            return result;
+        });
+    }
+    assertNoActiveConflicts(snapshot) {
+        const conflicts = this.findActiveConflicts(snapshot);
+        if (conflicts.length > 0) {
+            throw new WindowBindingConflictError("Active Codex window binding conflict", conflicts);
+        }
+    }
+    findActiveConflicts(snapshot) {
+        const active = activeBindings(snapshot);
+        const conflicted = new Set();
+        const byWindow = new Map();
+        const byProject = new Map();
+        for (const binding of active) {
+            const windowGroup = byWindow.get(binding.windowId) ?? [];
+            windowGroup.push(binding);
+            byWindow.set(binding.windowId, windowGroup);
+            const projectKey = `${binding.repoSlug}\0${binding.worktreePath}\0${binding.projectThreadId}`;
+            const projectGroup = byProject.get(projectKey) ?? [];
+            projectGroup.push(binding);
+            byProject.set(projectKey, projectGroup);
+        }
+        for (const group of [...byWindow.values(), ...byProject.values()]) {
+            if (group.length > 1) {
+                for (const binding of group)
+                    conflicted.add(binding.bindingId);
+            }
+        }
+        return active.filter((binding) => conflicted.has(binding.bindingId));
+    }
+}
+export const windowBindingStore = new CodexWindowBindingStore();
+//# sourceMappingURL=window-bindings.js.map