@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/runner-host/dist/session-lease.d.ts

@@ -0,0 +1,12 @@
+export interface SessionLease {
+    lost: Promise<Error>;
+    release(): Promise<void>;
+}
+export declare class SessionLeaseStore {
+    private readonly leaseDir;
+    constructor(dataDir: string);
+    acquire(sessionId: string, runId: string): Promise<SessionLease | null>;
+    private acquireKernelLock;
+    private releaseKernelLock;
+}
+//# sourceMappingURL=session-lease.d.ts.map

package/node_modules/@codebridge/runner-host/dist/session-lease.js

@@ -0,0 +1,146 @@
+import crypto from "node:crypto";
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+const LOCK_READY = "__CODEBRIDGE_LOCKED__";
+const LOCK_HELPER = [
+    `process.stdout.write(${JSON.stringify(`${LOCK_READY}\n`)});`,
+    "process.stdin.resume();",
+].join("");
+function lockCommand(lockPath) {
+    if (process.platform === "darwin") {
+        return {
+            command: "/usr/bin/lockf",
+            args: [
+                "-k",
+                "-n",
+                "-s",
+                "-t",
+                "0",
+                lockPath,
+                process.execPath,
+                "-e",
+                LOCK_HELPER,
+            ],
+        };
+    }
+    if (process.platform === "linux") {
+        return {
+            command: "/usr/bin/flock",
+            args: [
+                "-n",
+                "-E",
+                "75",
+                lockPath,
+                process.execPath,
+                "-e",
+                LOCK_HELPER,
+            ],
+        };
+    }
+    throw new Error(`Session leases are unsupported on ${process.platform}`);
+}
+export class SessionLeaseStore {
+    leaseDir;
+    constructor(dataDir) {
+        this.leaseDir = path.join(dataDir, "session-leases");
+    }
+    async acquire(sessionId, runId) {
+        await fs.mkdir(this.leaseDir, { recursive: true });
+        const hash = crypto.createHash("sha256").update(sessionId).digest("hex");
+        const lockPath = path.join(this.leaseDir, `${hash}.lock`);
+        const handle = await fs.open(lockPath, "a", 0o600);
+        await handle.close();
+        const holder = await this.acquireKernelLock(lockPath);
+        if (!holder)
+            return null;
+        let released = false;
+        let reportLost = () => { };
+        const lost = new Promise((resolve) => {
+            reportLost = resolve;
+        });
+        holder.once("exit", (code, signal) => {
+            if (released)
+                return;
+            reportLost(new Error(`Session kernel-lock holder exited unexpectedly (code=${code ?? "none"}, signal=${signal ?? "none"})`));
+        });
+        holder.once("error", (error) => {
+            if (!released)
+                reportLost(error);
+        });
+        try {
+            await fs.writeFile(lockPath, `${JSON.stringify({
+                sessionId,
+                runId,
+                pid: process.pid,
+                holderPid: holder.pid,
+            })}\n`, { encoding: "utf8", mode: 0o600 });
+        }
+        catch (error) {
+            await this.releaseKernelLock(holder);
+            throw error;
+        }
+        return {
+            lost,
+            release: async () => {
+                if (released)
+                    return;
+                released = true;
+                await this.releaseKernelLock(holder);
+            },
+        };
+    }
+    async acquireKernelLock(lockPath) {
+        const { command, args } = lockCommand(lockPath);
+        const holder = spawn(command, args, {
+            stdio: ["pipe", "pipe", "ignore"],
+        });
+        return await new Promise((resolve, reject) => {
+            let stdout = "";
+            let settled = false;
+            const finish = (result, error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                holder.removeListener("error", onError);
+                holder.removeListener("exit", onExit);
+                holder.stdout?.removeListener("data", onData);
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            };
+            const onError = (error) => finish(null, error);
+            const onExit = () => finish(null);
+            const onData = (chunk) => {
+                stdout += chunk.toString("utf8");
+                if (!stdout.includes("\n"))
+                    return;
+                if (stdout.trim() !== LOCK_READY) {
+                    finish(null, new Error("Session lock helper returned invalid output"));
+                    return;
+                }
+                finish(holder);
+            };
+            const timeout = setTimeout(() => {
+                holder.kill();
+                finish(null, new Error("Timed out while acquiring the session lock"));
+            }, 5_000);
+            holder.once("error", onError);
+            holder.once("exit", onExit);
+            holder.stdout?.on("data", onData);
+            holder.stdin?.on("error", () => { });
+        });
+    }
+    async releaseKernelLock(holder) {
+        if (holder.exitCode !== null || holder.signalCode !== null)
+            return;
+        const exited = new Promise((resolve) => {
+            holder.once("exit", () => resolve());
+        });
+        holder.stdin?.end();
+        await exited;
+    }
+}
+//# sourceMappingURL=session-lease.js.map

package/node_modules/@codebridge/runner-host/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@codebridge/runner-host",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "codebridge-runner": "./dist/cli.js"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@codebridge/backends": "0.1.0",
+    "@codebridge/agent-registry": "0.1.0",
+    "@codebridge/core": "0.1.0",
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "hono": "4.12.27",
+    "@hono/node-server": "1.19.14",
+    "zod": "3.25.76"
+  }
+}

package/node_modules/@codebridge/session-catalog/dist/index.d.ts

@@ -0,0 +1,124 @@
+import { type ChannelSlot } from "@codebridge/core";
+export type SessionStatus = "active" | "idle" | "closed" | "unavailable";
+export type SessionConfigOverrides = Record<string, string | boolean>;
+export type AgentSetupInstallation = "installed" | "missing" | "unknown";
+export type AgentSetupConfiguration = "configured" | "needs_configuration" | "unknown";
+export type AgentSetupRuntime = "healthy" | "unavailable" | "not_started";
+export type AgentSetupStage = "detect" | "install" | "configure" | "health";
+export interface AgentDiagnostic {
+    stage: AgentSetupStage;
+    code: string;
+    message: string;
+    details?: string;
+    exitCode?: number;
+}
+export interface AgentInstallStrategy {
+    id: string;
+    label: string;
+    command: string;
+    args: string[];
+    available: boolean;
+    requiresConfirmation: true;
+}
+export interface AgentSetupManifest {
+    agentId: string;
+    displayName: string;
+    adapter: "sdk" | "acp" | "cli";
+    installStrategies: AgentInstallStrategy[];
+    configurationOwner: "codebridge" | "agent";
+    configurationPath?: string;
+    documentationUrl?: string;
+    supportsManagedConfiguration: boolean;
+}
+export interface AgentSetupState {
+    installation: AgentSetupInstallation;
+    configuration: AgentSetupConfiguration;
+    runtime: AgentSetupRuntime;
+    version?: string;
+    executablePath?: string;
+    diagnostic?: AgentDiagnostic;
+    canSelectDefault: boolean;
+    canCreateSession: boolean;
+}
+export interface AgentProfile {
+    agentId: string;
+    displayName: string;
+    adapter: "sdk" | "acp" | "cli";
+    status: "healthy" | "unavailable" | "needs_setup";
+    capabilities: string[];
+    models: string[];
+    sessionFeatures: string[];
+    setup?: AgentSetupState;
+    setupManifest?: AgentSetupManifest;
+}
+export interface AgentSession {
+    schemaVersion: 1;
+    id: string;
+    agentId: string;
+    providerSessionId: string | null;
+    taskRecordId: string | null;
+    model: string | null;
+    effort: string | null;
+    configOverrides: SessionConfigOverrides;
+    permissionMode: string | null;
+    folderId: string | null;
+    cwd: string | null;
+    additionalDirectories: string[];
+    title: string | null;
+    status: SessionStatus;
+    pinnedAt: string | null;
+    archivedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ChannelSessionBinding extends ChannelSlot {
+    sessionId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateSessionInput {
+    id?: string;
+    agentId: string;
+    providerSessionId?: string | null;
+    taskRecordId?: string | null;
+    model?: string | null;
+    effort?: string | null;
+    configOverrides?: SessionConfigOverrides;
+    permissionMode?: string | null;
+    folderId?: string | null;
+    cwd?: string | null;
+    additionalDirectories?: string[];
+    title?: string | null;
+    updatedAt?: string;
+}
+export type UpdateSessionInput = Partial<Omit<CreateSessionInput, "id" | "agentId">> & {
+    status?: SessionStatus;
+    pinned?: boolean;
+    archived?: boolean;
+};
+export interface ListSessionsOptions {
+    includeArchived?: boolean;
+}
+export declare class SessionCatalogStore {
+    private readonly database;
+    constructor(databasePath: string, options?: {
+        defaultCwd?: string;
+    });
+    private migrateLegacyChannelBindings;
+    createSession(input: CreateSessionInput): AgentSession;
+    getSession(id: string): AgentSession | undefined;
+    getByProviderSession(agentId: string, providerSessionId: string): AgentSession | undefined;
+    listSessions(agentId?: string, options?: ListSessionsOptions): AgentSession[];
+    bindChannelConversation(slot: ChannelSlot, sessionId: string): ChannelSessionBinding;
+    bindHistoricalSession(slot: ChannelSlot, sessionId: string): ChannelSessionBinding;
+    getChannelBinding(slot: ChannelSlot): ChannelSessionBinding | undefined;
+    getChannelSession(slot: ChannelSlot): AgentSession | undefined;
+    listChannelBindings(channel: string, conversationId: string): ChannelSessionBinding[];
+    unbindChannelConversation(slot: ChannelSlot): boolean;
+    getOrCreateBoundSession(slot: ChannelSlot, input: CreateSessionInput): AgentSession;
+    createAndBindHistoricalSession(slot: ChannelSlot, providerSessionId: string): AgentSession;
+    updateSession(id: string, input: UpdateSessionInput): AgentSession | undefined;
+    deleteSession(id: string): boolean;
+    close(): void;
+}
+//# sourceMappingURL=index.d.ts.map