@shawnowen/comet-mcp 2.3.1 → 2.4.2

package/dist/project-config.js

@@ -0,0 +1,166 @@
+// Spec 087 / T040 / FR-006, FR-007, FR-008, FR-009
+//
+// Per-project configuration loader. Reads <project_root>/.comet/config.json
+// when present, validates against a small schema, and re-reads on each access
+// (mirrors bridge-config.ts pattern — no per-session caching of file contents).
+//
+// Discovery: walks upward from cwd to repo root or $HOME, looking for .comet/config.json.
+// Caches only the discovered PATH for the session, not the file contents.
+//
+// All fields optional. Backwards-compatible: absent config = pre-Spec 087 behavior.
+import { readFileSync, existsSync, statSync } from "fs";
+import { homedir } from "os";
+import { join, resolve, sep } from "path";
+const VALID_PLAYBOOKS = new Set(["qbo", "mercury", "salt", "github", "google"]);
+let discoveryCache = null;
+/**
+ * Walk up from `cwd` to either a directory containing `.comet/config.json`,
+ * the user's $HOME (boundary), or filesystem root. Returns the absolute path
+ * to the config file, or null.
+ */
+export function discoverProjectConfigPath(cwd = process.cwd()) {
+    // Cache discovery by cwd — file contents are NOT cached.
+    if (discoveryCache && discoveryCache.cwd === cwd) {
+        return discoveryCache.path;
+    }
+    const home = homedir();
+    let dir = resolve(cwd);
+    let result = null;
+    while (true) {
+        const candidate = join(dir, ".comet", "config.json");
+        if (existsSync(candidate)) {
+            try {
+                if (statSync(candidate).isFile()) {
+                    result = candidate;
+                    break;
+                }
+            }
+            catch {
+                // unreadable: keep walking
+            }
+        }
+        if (dir === home || dir === sep || dir === resolve(dir, ".."))
+            break;
+        dir = resolve(dir, "..");
+    }
+    discoveryCache = { cwd, path: result };
+    return result;
+}
+/** Clear the discovery cache. Test-only / on cwd change. */
+export function clearProjectConfigCache() {
+    discoveryCache = null;
+}
+/**
+ * Validate a parsed config object. Returns the cleaned config + a list of
+ * warning strings for any keys that were ignored. Unknown keys are warned
+ * about but do not cause failure.
+ */
+export function validateProjectConfig(raw) {
+    const warnings = [];
+    const config = {};
+    if (raw == null || typeof raw !== "object") {
+        warnings.push("project-config: root must be an object — falling back to defaults");
+        return { config, warnings };
+    }
+    const obj = raw;
+    const known = new Set([
+        "organization",
+        "default_profile",
+        "entity_skills",
+        "domain_playbooks",
+        "tab_group_prefix",
+        "google_drive_root",
+        "mcp_pin",
+    ]);
+    for (const key of Object.keys(obj)) {
+        if (!known.has(key)) {
+            warnings.push(`project-config: unknown key '${key}' ignored`);
+        }
+    }
+    if (typeof obj.organization === "string" && obj.organization.length <= 32) {
+        config.organization = obj.organization;
+    }
+    else if (obj.organization !== undefined) {
+        warnings.push("project-config: 'organization' must be a string ≤ 32 chars — ignored");
+    }
+    if (typeof obj.default_profile === "string" && /^[a-z0-9_-]{1,16}$/.test(obj.default_profile)) {
+        config.default_profile = obj.default_profile;
+    }
+    else if (obj.default_profile !== undefined) {
+        warnings.push("project-config: 'default_profile' must match /^[a-z0-9_-]{1,16}$/ — falling back to 'oe'");
+    }
+    if (Array.isArray(obj.entity_skills) && obj.entity_skills.every((x) => typeof x === "string")) {
+        config.entity_skills = obj.entity_skills;
+    }
+    else if (obj.entity_skills !== undefined) {
+        warnings.push("project-config: 'entity_skills' must be string[] — ignored");
+    }
+    if (Array.isArray(obj.domain_playbooks)) {
+        const valid = [];
+        for (const item of obj.domain_playbooks) {
+            if (typeof item === "string" && VALID_PLAYBOOKS.has(item)) {
+                valid.push(item);
+            }
+            else {
+                warnings.push(`project-config: unknown domain_playbook '${item}' ignored`);
+            }
+        }
+        if (valid.length > 0)
+            config.domain_playbooks = valid;
+    }
+    else if (obj.domain_playbooks !== undefined) {
+        warnings.push("project-config: 'domain_playbooks' must be string[] — ignored");
+    }
+    if (typeof obj.tab_group_prefix === "string" &&
+        obj.tab_group_prefix.length <= 16 &&
+        !/[,:]/.test(obj.tab_group_prefix)) {
+        config.tab_group_prefix = obj.tab_group_prefix;
+    }
+    else if (obj.tab_group_prefix !== undefined) {
+        warnings.push("project-config: 'tab_group_prefix' must be ≤ 16 chars with no comma or colon — ignored");
+    }
+    if (typeof obj.google_drive_root === "string" &&
+        (obj.google_drive_root.startsWith("drive://") ||
+            obj.google_drive_root.startsWith("https://drive.google.com/"))) {
+        config.google_drive_root = obj.google_drive_root;
+    }
+    else if (obj.google_drive_root !== undefined) {
+        warnings.push("project-config: 'google_drive_root' must start with drive:// or https://drive.google.com/ — ignored");
+    }
+    if (typeof obj.mcp_pin === "string" && /^\d+\.\d+\.\d+(-[A-Za-z0-9.-]+)?$/.test(obj.mcp_pin)) {
+        config.mcp_pin = obj.mcp_pin;
+    }
+    else if (obj.mcp_pin !== undefined) {
+        warnings.push("project-config: 'mcp_pin' must be a semver string — ignored");
+    }
+    return { config, warnings };
+}
+/**
+ * Read and validate the project config. Returns an empty config + warnings if
+ * the file is absent, unreadable, or invalid JSON. NEVER throws.
+ *
+ * Per Spec 087 U-1 / clarify.md C-1 (revised): re-reads on every call.
+ * Discovery (walking up from cwd) IS cached by cwd; file contents are NOT.
+ */
+export function readProjectConfig(cwd = process.cwd()) {
+    const path = discoverProjectConfigPath(cwd);
+    if (!path) {
+        return { config: {}, path: null, warnings: [] };
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (err) {
+        return {
+            config: {},
+            path,
+            warnings: [
+                `project-config: failed to parse ${path} — ${err.message} — falling back to defaults`,
+            ],
+        };
+    }
+    const { config, warnings } = validateProjectConfig(raw);
+    return { config, path, warnings };
+}
+//# sourceMappingURL=project-config.js.map

package/dist/session-registry.d.ts

@@ -0,0 +1,57 @@
+import { CometCDPClient } from "./cdp-client.js";
+import { CometAI } from "./comet-ai.js";
+import type { AgentSession, ManifestEntry, TabGroupColor, ConsumerRole } from "./types.js";
+export interface RegisterOptions {
+    agentId?: string;
+    taskThreadId?: string;
+    url?: string;
+    tabGroupColor?: TabGroupColor;
+    port?: number;
+    role?: ConsumerRole;
+    taskGoal?: string;
+    codexSessionId?: string;
+    projectThreadId?: string;
+    projectThreadFamily?: string;
+    worktreePath?: string;
+    repoSlug?: string;
+    branchName?: string;
+    codexSessionRole?: string;
+    codexSessionKey?: string;
+    strictCodexIdentity?: boolean;
+    profile?: string;
+}
+export declare function generateSessionName(taskGoal: string): string;
+export interface ReleaseOptions {
+    closeTabs?: boolean;
+    updateGroupColor?: TabGroupColor;
+    taskStatus?: "success" | "failed" | "abandoned" | "in-progress";
+}
+export declare class SessionRegistry {
+    private sessions;
+    private currentSessionKey;
+    private tabGroupMutex;
+    register(options?: RegisterOptions): Promise<AgentSession & {
+        cdpClient: CometCDPClient;
+        cometAI: CometAI;
+    }>;
+    get(sessionKey: string): (AgentSession & {
+        cdpClient: CometCDPClient;
+        cometAI: CometAI;
+    }) | undefined;
+    getCurrent(): (AgentSession & {
+        cdpClient: CometCDPClient;
+        cometAI: CometAI;
+    }) | undefined;
+    updateSessionUrl(sessionKey: string, orchestratorUrl: string): void;
+    getManifestEntryByThread(taskThreadId: string): ManifestEntry | undefined;
+    release(sessionKey: string, options?: ReleaseOptions): Promise<void>;
+    reapOrphans(): Promise<number>;
+    ensureBrowserRunning(port?: number): Promise<string>;
+    private createTabGroup;
+    private getWindowIdForTarget;
+    private loadManifest;
+    private writeManifest;
+    private persistManifest;
+}
+export declare const sessionRegistry: SessionRegistry;
+//# sourceMappingURL=session-registry.d.ts.map