@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/backends/dist/session-discovery.js

@@ -0,0 +1,340 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+/** Claude Code: ~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl */
+export function encodeClaudeProjectDir(cwd) {
+    return path.resolve(cwd).replace(/\//g, "-");
+}
+export function collectClaudeSessionHistory(entries) {
+    const result = [];
+    for (const entry of entries) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const value = entry;
+        if (value.isMeta === true || value.isSidechain === true)
+            continue;
+        if (value.type === "attachment" && value.attachment?.type === "skill_listing") {
+            const names = Array.isArray(value.attachment.names)
+                ? value.attachment.names.filter((name) => typeof name === "string" && Boolean(name))
+                : [];
+            const lines = typeof value.attachment.content === "string"
+                ? value.attachment.content.split("\n")
+                : [];
+            if (names.length) {
+                result.push({
+                    kind: "agent_event",
+                    event: {
+                        type: "available_commands_update",
+                        availableCommands: names.map((name) => {
+                            const prefix = `- ${name}: `;
+                            const description = lines.find((line) => line.startsWith(prefix))?.slice(prefix.length).trim();
+                            return { name, description: description || "Agent Skill" };
+                        }),
+                    },
+                });
+            }
+            continue;
+        }
+        if (value.type !== "user" && value.type !== "assistant")
+            continue;
+        const role = value.message?.role;
+        const content = value.message?.content;
+        if (role === "assistant") {
+            const blocks = Array.isArray(content) ? content : [{ type: "text", text: content }];
+            for (const block of blocks) {
+                if (!block || typeof block !== "object")
+                    continue;
+                const item = block;
+                if (item.type === "text" && typeof item.text === "string" && item.text) {
+                    result.push({
+                        kind: "agent_event",
+                        event: {
+                            type: "text_delta",
+                            text: item.text,
+                            ...(typeof value.uuid === "string" ? { messageId: value.uuid } : {}),
+                        },
+                    });
+                }
+                else if (item.type === "tool_use" && typeof item.id === "string") {
+                    result.push({
+                        kind: "agent_event",
+                        event: {
+                            type: "tool_start",
+                            toolCallId: item.id,
+                            name: typeof item.name === "string" ? item.name : "tool",
+                            input: item.input,
+                        },
+                    });
+                }
+            }
+            continue;
+        }
+        if (role !== "user")
+            continue;
+        if (typeof content === "string") {
+            if (content && !isClaudeInternalUserMessage(content))
+                result.push({ kind: "message", text: content });
+            continue;
+        }
+        if (!Array.isArray(content))
+            continue;
+        const userText = [];
+        for (const block of content) {
+            if (!block || typeof block !== "object")
+                continue;
+            const item = block;
+            if (item.type === "text" && typeof item.text === "string" && !isClaudeInternalUserMessage(item.text)) {
+                userText.push(item.text);
+            }
+            else if (item.type === "tool_result" && typeof item.tool_use_id === "string") {
+                result.push({
+                    kind: "agent_event",
+                    event: {
+                        type: "tool_end",
+                        toolCallId: item.tool_use_id,
+                        status: item.is_error === true ? "failed" : "completed",
+                        output: textFromClaudeContent(item.content),
+                    },
+                });
+            }
+        }
+        if (userText.length)
+            result.push({ kind: "message", text: userText.join("") });
+    }
+    return result;
+}
+function isClaudeInternalUserMessage(text) {
+    const normalized = text.trimStart();
+    return normalized.startsWith("<command-name>")
+        || normalized.startsWith("<local-command-stdout>")
+        || normalized.startsWith("<local-command-stderr>");
+}
+export async function loadClaudeSessionHistory(cwd, sessionId) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(sessionId)) {
+        throw new Error(`Invalid Claude session id: ${sessionId}`);
+    }
+    const file = path.join(os.homedir(), ".claude", "projects", encodeClaudeProjectDir(cwd), `${sessionId}.jsonl`);
+    const lines = (await fs.readFile(file, "utf8")).split("\n").filter(Boolean);
+    const entries = lines.flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+    return collectClaudeSessionHistory(entries);
+}
+export function collectCodexSessionHistory(entries) {
+    const result = [];
+    const hasEventUserMessages = entries.some((entry) => {
+        if (!entry || typeof entry !== "object")
+            return false;
+        const value = entry;
+        if (value.type !== "event_msg" || !value.payload || typeof value.payload !== "object")
+            return false;
+        const payload = value.payload;
+        return payload.type === "user_message" && typeof payload.message === "string";
+    });
+    const hasEventAgentMessages = entries.some((entry) => {
+        if (!entry || typeof entry !== "object")
+            return false;
+        const value = entry;
+        if (value.type !== "event_msg" || !value.payload || typeof value.payload !== "object")
+            return false;
+        const payload = value.payload;
+        return payload.type === "agent_message" && typeof payload.message === "string";
+    });
+    for (const entry of entries) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const value = entry;
+        if (!value.payload || typeof value.payload !== "object")
+            continue;
+        const payload = value.payload;
+        if (value.type === "event_msg" && payload.type === "user_message" && typeof payload.message === "string") {
+            result.push({ kind: "message", text: payload.message });
+            continue;
+        }
+        if (value.type === "event_msg" && payload.type === "agent_message" && typeof payload.message === "string") {
+            const phase = payload.phase === "commentary" || payload.phase === "final_answer"
+                ? payload.phase
+                : undefined;
+            result.push({
+                kind: "agent_event",
+                event: { type: "text_delta", text: payload.message, ...(phase ? { phase } : {}) },
+            });
+            continue;
+        }
+        if (value.type !== "response_item")
+            continue;
+        if (payload.type === "message" && payload.role === "user" && !hasEventUserMessages) {
+            const content = Array.isArray(payload.content) ? payload.content : [];
+            const text = content
+                .filter((item) => Boolean(item && typeof item === "object"))
+                .filter((item) => item.type === "input_text" && typeof item.text === "string")
+                .map((item) => item.text)
+                .filter((text) => !isCodexContextMessage(text))
+                .join("");
+            if (text)
+                result.push({ kind: "message", text });
+            continue;
+        }
+        if (payload.type === "agent_message" && !hasEventAgentMessages) {
+            const content = Array.isArray(payload.content) ? payload.content : [];
+            for (const item of content) {
+                if (!item || typeof item !== "object")
+                    continue;
+                const block = item;
+                if (block.type !== "input_text" || typeof block.text !== "string" || !block.text)
+                    continue;
+                result.push({
+                    kind: "agent_event",
+                    event: {
+                        type: "text_delta",
+                        text: block.text,
+                        ...(typeof payload.id === "string" ? { messageId: payload.id } : {}),
+                    },
+                });
+            }
+            continue;
+        }
+        if (payload.type === "function_call" || payload.type === "custom_tool_call") {
+            const toolCallId = typeof payload.call_id === "string" ? payload.call_id : undefined;
+            if (!toolCallId)
+                continue;
+            let input = payload.arguments ?? payload.input;
+            if (typeof input === "string") {
+                try {
+                    input = JSON.parse(input);
+                }
+                catch {
+                    // Keep non-JSON provider input as text.
+                }
+            }
+            result.push({
+                kind: "agent_event",
+                event: {
+                    type: "tool_start",
+                    toolCallId,
+                    name: typeof payload.name === "string" ? payload.name : "tool",
+                    input,
+                },
+            });
+            continue;
+        }
+        if (payload.type === "function_call_output" || payload.type === "custom_tool_call_output") {
+            const toolCallId = typeof payload.call_id === "string" ? payload.call_id : undefined;
+            if (!toolCallId)
+                continue;
+            result.push({
+                kind: "agent_event",
+                event: {
+                    type: "tool_end",
+                    toolCallId,
+                    status: "completed",
+                    output: payload.output,
+                },
+            });
+            continue;
+        }
+        if (payload.type === "reasoning" && Array.isArray(payload.summary)) {
+            for (const item of payload.summary) {
+                if (!item || typeof item !== "object")
+                    continue;
+                const text = item.text;
+                if (typeof text === "string" && text) {
+                    result.push({ kind: "agent_event", event: { type: "thought_delta", text } });
+                }
+            }
+            continue;
+        }
+        if (payload.type !== "message" || payload.role !== "assistant" || !Array.isArray(payload.content) || hasEventAgentMessages)
+            continue;
+        const phase = payload.phase === "commentary" || payload.phase === "final_answer"
+            ? payload.phase
+            : undefined;
+        for (const item of payload.content) {
+            if (!item || typeof item !== "object")
+                continue;
+            const block = item;
+            if (block.type !== "output_text" || typeof block.text !== "string" || !block.text)
+                continue;
+            result.push({
+                kind: "agent_event",
+                event: {
+                    type: "text_delta",
+                    text: block.text,
+                    ...(typeof payload.id === "string" ? { messageId: payload.id } : {}),
+                    ...(phase ? { phase } : {}),
+                },
+            });
+        }
+    }
+    return result;
+}
+function isCodexContextMessage(text) {
+    return [
+        "# AGENTS.md instructions",
+        "<environment_context>",
+        "<permissions instructions>",
+        "<collaboration_mode>",
+        "<plugins_instructions>",
+        "<skills_instructions>",
+        "Another language model started to solve this problem",
+    ].some((prefix) => text.startsWith(prefix));
+}
+export async function loadCodexSessionHistory(sessionId) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(sessionId)) {
+        throw new Error(`Invalid Codex session id: ${sessionId}`);
+    }
+    const file = await findCodexSessionFile(path.join(os.homedir(), ".codex", "sessions"), sessionId);
+    if (!file)
+        throw new Error(`Codex session not found: ${sessionId}`);
+    const lines = (await fs.readFile(file, "utf8")).split("\n").filter(Boolean);
+    const entries = lines.flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+    return collectCodexSessionHistory(entries);
+}
+async function findCodexSessionFile(directory, sessionId) {
+    let entries;
+    try {
+        entries = await fs.readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return undefined;
+    }
+    for (const entry of entries) {
+        const candidate = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await findCodexSessionFile(candidate, sessionId);
+            if (nested)
+                return nested;
+        }
+        else if (entry.isFile() && entry.name.endsWith(`-${sessionId}.jsonl`)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function textFromClaudeContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return content == null ? "" : JSON.stringify(content);
+    return content.map((item) => {
+        if (typeof item === "string")
+            return item;
+        if (!item || typeof item !== "object")
+            return "";
+        const block = item;
+        return block.type === "text" && typeof block.text === "string" ? block.text : "";
+    }).join("");
+}
+//# sourceMappingURL=session-discovery.js.map

package/node_modules/@codebridge/backends/dist/skill-control-plane.d.ts

@@ -0,0 +1,147 @@
+export declare const SKILL_AGENT_IDS: readonly ["codex", "claude", "cursor", "opencode", "pi"];
+export type SkillAgentId = (typeof SKILL_AGENT_IDS)[number];
+export type SkillSourceKind = "shared" | "disabled" | "adopted" | "agent_native";
+export type SkillGlobalState = "enabled" | "disabled" | "split_brain" | "external" | "invalid";
+export type SkillDeliveryMode = "shared_native" | "symlink_projection";
+export type SkillOwnership = "codebridge_managed" | "external_observed" | "native_managed";
+export type SkillProjectionState = "follows_global" | "linked" | "absent" | "conflict" | "broken";
+export interface SkillTargetView {
+    agent_id: SkillAgentId;
+    delivery_mode: SkillDeliveryMode;
+    target_path: string;
+    state: SkillProjectionState;
+    mutable: boolean;
+    detail: string | null;
+}
+export interface SkillCatalogEntry {
+    id: string;
+    name: string;
+    description: string | null;
+    source_path: string;
+    source_kind: SkillSourceKind;
+    package_revision: string;
+    revision: string;
+    global_state: SkillGlobalState;
+    ownership: SkillOwnership;
+    can_apply: boolean;
+    tags: string[];
+    updated_at: string;
+    targets: SkillTargetView[];
+}
+export interface SkillTargetDefinition {
+    agent_id: SkillAgentId;
+    display_name: string;
+    root_path: string;
+    delivery_mode: SkillDeliveryMode;
+}
+export interface SkillCatalogSnapshot {
+    skills: SkillCatalogEntry[];
+    targets: SkillTargetDefinition[];
+    summary: {
+        total: number;
+        sources: number;
+        linked: number;
+        issues: number;
+        recovery_required?: number;
+    };
+    scanned_at: string;
+}
+export type SkillMutationKind = "global_state" | "assignment" | "adopt" | "unmanage";
+export interface SkillMutationStep {
+    action: "move" | "create_link" | "remove_link" | "set_ownership" | "set_assignment";
+    source_path?: string;
+    target_path?: string;
+    detail: string;
+}
+export interface SkillMutationPlan {
+    plan_id: string;
+    actor_id: string;
+    kind: SkillMutationKind;
+    skill_id: string;
+    package_revision: string;
+    source_path: string;
+    target_path: string;
+    source_fingerprint: string;
+    target_fingerprint: string;
+    expires_at: string;
+    steps: SkillMutationStep[];
+    can_apply: boolean;
+    detail: string | null;
+    request: {
+        enabled?: boolean;
+        agent_id?: SkillAgentId;
+    };
+}
+export interface SkillMutationResult {
+    plan_id: string;
+    transaction_id: string;
+    snapshot: SkillCatalogSnapshot;
+}
+export interface SkillControlPlaneOptions {
+    dataDir: string;
+    homeDirectory?: string;
+    sharedRoot?: string;
+    disabledRoot?: string;
+    targetRoots?: Record<SkillAgentId, string>;
+}
+export type SkillControlPlaneErrorCode = "skill_not_found" | "skill_source_invalid" | "skill_target_unknown" | "skill_target_conflict" | "skill_unlink_forbidden" | "skill_package_invalid" | "skill_identity_mismatch" | "skill_split_brain" | "skill_revision_mismatch" | "skill_plan_not_found" | "skill_plan_expired" | "skill_plan_actor_mismatch" | "skill_adopt_forbidden" | "skill_transaction_recovery_required";
+export declare class SkillControlPlaneError extends Error {
+    readonly code: SkillControlPlaneErrorCode;
+    readonly status: 400 | 404 | 409 | 422;
+    readonly name = "SkillControlPlaneError";
+    constructor(code: SkillControlPlaneErrorCode, message: string, status?: 400 | 404 | 409 | 422);
+}
+export declare class SkillControlPlane {
+    private readonly homeDirectory;
+    private readonly sharedRoot;
+    private readonly disabledRoot;
+    private readonly targetRoots;
+    private readonly sources;
+    private readonly ownership;
+    private readonly assignments;
+    private readonly plans;
+    private readonly transactions;
+    constructor(options: SkillControlPlaneOptions);
+    scan(): SkillCatalogSnapshot;
+    addSource(rawPath: string): SkillCatalogSnapshot;
+    previewAdopt(input: {
+        skill_id: string;
+        actor_id: string;
+    }): SkillMutationPlan;
+    previewAssignment(input: {
+        skill_id: string;
+        agent_id: SkillAgentId;
+        enabled: boolean;
+        actor_id: string;
+    }): SkillMutationPlan;
+    previewGlobalState(input: {
+        skill_id: string;
+        enabled: boolean;
+        actor_id: string;
+    }): SkillMutationPlan;
+    previewUnmanage(input: {
+        skill_id: string;
+        actor_id: string;
+    }): SkillMutationPlan;
+    applyPlan(input: {
+        plan_id: string;
+        actor_id: string;
+    }): SkillMutationResult;
+    private createPlan;
+    private assertPackageCanMutate;
+    private executePlan;
+    private recoverPendingTransactions;
+    private executeAdopt;
+    private executeAssignment;
+    private executeGlobalState;
+    private ownsProjectedLink;
+    private updateTransaction;
+    private findSkill;
+    private collectRoot;
+    private skillDirectories;
+    private resolveSkillDirectory;
+    private toCatalogEntry;
+    private inspectTarget;
+    private isManagedLink;
+}
+//# sourceMappingURL=skill-control-plane.d.ts.map