@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/run-executor/dist/run-heartbeat.d.ts

@@ -0,0 +1,14 @@
+import type { Run } from "@codebridge/work-items";
+export declare class RunHeartbeat {
+    private readonly options;
+    private timer;
+    constructor(options: {
+        runId: string;
+        owner: string;
+        renew: (runId: string, owner: string) => Run | null;
+        onLeaseLost: () => void;
+    });
+    start(): void;
+    close(): void;
+}
+//# sourceMappingURL=run-heartbeat.d.ts.map

package/node_modules/@codebridge/run-executor/dist/run-heartbeat.js

@@ -0,0 +1,24 @@
+export class RunHeartbeat {
+    options;
+    timer = null;
+    constructor(options) {
+        this.options = options;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            if (!this.options.renew(this.options.runId, this.options.owner)) {
+                this.close();
+                this.options.onLeaseLost();
+            }
+        }, 15_000);
+    }
+    close() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+}
+//# sourceMappingURL=run-heartbeat.js.map

package/node_modules/@codebridge/run-executor/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@codebridge/run-executor",
+  "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"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@codebridge/core": "0.1.0",
+    "@codebridge/policy": "0.1.0",
+    "@codebridge/session-coordinator": "0.1.0",
+    "@codebridge/work-items": "0.1.0"
+  }
+}

package/node_modules/@codebridge/runner-client/dist/index.d.ts

@@ -0,0 +1,142 @@
+import type { AgentAvailableCommand, AgentEvent, BackendConfigOption, RunRequest } from "@codebridge/core";
+import type { AgentSetupInstallResult, AgentSetupRecord, CliSessionSummary, ProviderSessionHistoryEvent, SkillAgentId, SkillCatalogSnapshot, SkillMutationPlan, SkillMutationResult } from "@codebridge/backends";
+export interface RunnerClientOptions {
+    baseUrl: string;
+    token: string;
+    directoryAuthorizationTimeoutMs?: number;
+    sessionHistoryTimeoutMs?: number;
+}
+export type { CliSessionSummary, ProviderSessionHistoryEvent, SkillAgentId, SkillCatalogSnapshot, SkillMutationPlan, SkillMutationResult, };
+export interface WorkspaceDirectoryEntry {
+    name: string;
+    path: string;
+    absolutePath: string;
+    kind: "directory" | "file";
+}
+export interface WorkspaceDirectoryListing {
+    ok: boolean;
+    root?: string;
+    path?: string;
+    relativePath?: string;
+    entries?: WorkspaceDirectoryEntry[];
+    error?: string;
+}
+export interface AgentSetupListResponse {
+    agents: AgentSetupRecord[];
+    error?: string;
+    message?: string;
+    details?: string;
+}
+export declare class RunnerCancellationError extends Error {
+    readonly name = "RunnerCancellationError";
+}
+export declare class RunnerApiError extends Error {
+    readonly status: number;
+    readonly details?: string | undefined;
+    readonly code?: string | undefined;
+    readonly name = "RunnerApiError";
+    constructor(message: string, status: number, details?: string | undefined, code?: string | undefined);
+}
+export declare class RunnerClient {
+    private readonly options;
+    constructor(options: RunnerClientOptions);
+    health(): Promise<{
+        ok: boolean;
+        version?: string;
+    }>;
+    doctor(): Promise<unknown>;
+    listSessions(backend: string, cwd: string, options?: {
+        all?: boolean;
+        limit?: number;
+    }): Promise<{
+        sessions: CliSessionSummary[];
+        error?: string;
+    }>;
+    loadSessionHistory(backend: string, cwd: string, sessionId: string, additionalDirectories?: string[]): Promise<ProviderSessionHistoryEvent[]>;
+    listConfigOptions(backend: string, cwd: string, model?: string | null): Promise<{
+        options: BackendConfigOption[];
+        error?: string;
+    }>;
+    listPiProviderPresets(): Promise<unknown>;
+    listAgentSetup(): Promise<AgentSetupListResponse>;
+    detectAgent(agentId: string): Promise<AgentSetupRecord>;
+    detectAllAgents(): Promise<AgentSetupListResponse>;
+    installAgent(agentId: string, strategyId: string): Promise<AgentSetupInstallResult>;
+    listSkills(): Promise<SkillCatalogSnapshot>;
+    addSkillSource(sourcePath: string): Promise<SkillCatalogSnapshot>;
+    previewSkillAdopt(skillId: string, actorId: string): Promise<SkillMutationPlan>;
+    previewSkillAssignment(input: {
+        skill_id: string;
+        agent_id: SkillAgentId;
+        enabled: boolean;
+        actor_id: string;
+    }): Promise<SkillMutationPlan>;
+    previewSkillGlobalState(input: {
+        skill_id: string;
+        enabled: boolean;
+        actor_id: string;
+    }): Promise<SkillMutationPlan>;
+    previewSkillUnmanage(skillId: string, actorId: string): Promise<SkillMutationPlan>;
+    applySkillPlan(kind: "adopt" | "global-state" | "assignment" | "unmanage", planId: string, actorId: string): Promise<SkillMutationResult>;
+    listPiProviders(): Promise<unknown>;
+    savePiProviders(file: unknown): Promise<{
+        ok: boolean;
+    }>;
+    testPiProvider(provider: {
+        baseUrl: string;
+        apiKey?: string;
+        authHeader?: boolean;
+        api?: string;
+        model?: string;
+    }): Promise<{
+        ok: boolean;
+        detail: string;
+        compatSuggestion?: Record<string, unknown>;
+    }>;
+    listCommands(backend: string, cwd: string): Promise<{
+        commands: AgentAvailableCommand[];
+        error?: string;
+    }>;
+    authorizeDirectory(directory: string): Promise<{
+        ok: boolean;
+        path?: string;
+        error?: string;
+    }>;
+    listDirectory(root: string, relativePath?: string): Promise<WorkspaceDirectoryListing>;
+    pickDirectory(): Promise<{
+        ok: boolean;
+        path?: string;
+        cancelled?: boolean;
+        error?: string;
+    }>;
+    closeSession(backend: string, cwd: string, sessionId: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    deleteSession(backend: string, cwd: string, sessionId: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    forkSession(backend: string, cwd: string, sessionId: string, targetCwd: string): Promise<{
+        ok: boolean;
+        sessionId?: string;
+        cwd?: string;
+        error?: string;
+    }>;
+    cancel(runId: string): Promise<void>;
+    steer(runId: string, prompt: string): Promise<{
+        ok: boolean;
+        outcome?: string;
+        error?: string;
+    }>;
+    /** prompt_feishu：回应 run 挂起的权限请求（/approve /deny） */
+    resolvePermission(runId: string, approve: boolean): Promise<boolean>;
+    run(request: RunRequest, options?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<AgentEvent>;
+    private mapStreamError;
+    private sessionLifecycle;
+    private requestSetup;
+    private fetch;
+}
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@codebridge/runner-client/dist/index.js

@@ -0,0 +1,439 @@
+export class RunnerCancellationError extends Error {
+    name = "RunnerCancellationError";
+}
+export class RunnerApiError extends Error {
+    status;
+    details;
+    code;
+    name = "RunnerApiError";
+    constructor(message, status, details, code) {
+        super(message);
+        this.status = status;
+        this.details = details;
+        this.code = code;
+    }
+}
+export class RunnerClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async health() {
+        const res = await this.fetch("/health");
+        return res.json();
+    }
+    async doctor() {
+        const res = await this.fetch("/doctor");
+        return res.json();
+    }
+    async listSessions(backend, cwd, options) {
+        const params = new URLSearchParams({
+            backend,
+            cwd,
+            limit: String(options?.limit ?? 20),
+        });
+        if (options?.all)
+            params.set("all", "true");
+        const res = await this.fetch(`/sessions?${params}`);
+        if (!res.ok) {
+            throw new Error(`Runner error: ${res.status} ${await res.text()}`);
+        }
+        return res.json();
+    }
+    async loadSessionHistory(backend, cwd, sessionId, additionalDirectories) {
+        const params = new URLSearchParams({ backend, cwd });
+        if (additionalDirectories?.length) {
+            params.set("additional_directories", JSON.stringify(additionalDirectories));
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.options.sessionHistoryTimeoutMs ?? 20_000);
+        timer.unref?.();
+        try {
+            const res = await this.fetch(`/sessions/${encodeURIComponent(sessionId)}/history?${params}`, { signal: controller.signal });
+            if (!res.ok)
+                throw new Error(`Runner error: ${res.status} ${await res.text()}`);
+            const body = (await res.json());
+            return body.events ?? [];
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async listConfigOptions(backend, cwd, model) {
+        const params = new URLSearchParams({ backend, cwd });
+        if (model)
+            params.set("model", model);
+        const res = await this.fetch(`/config-options?${params}`);
+        if (!res.ok) {
+            throw new Error(`Runner error: ${res.status} ${await res.text()}`);
+        }
+        return res.json();
+    }
+    async listPiProviderPresets() {
+        const res = await this.fetch("/pi/providers/presets");
+        if (!res.ok)
+            throw new Error(`Runner error: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async listAgentSetup() {
+        return this.requestSetup("/agents/setup");
+    }
+    async detectAgent(agentId) {
+        return this.requestSetup(`/agents/${encodeURIComponent(agentId)}/detect`, {
+            method: "POST",
+        });
+    }
+    async detectAllAgents() {
+        return this.requestSetup("/agents/detect", { method: "POST" });
+    }
+    async installAgent(agentId, strategyId) {
+        return this.requestSetup(`/agents/${encodeURIComponent(agentId)}/install`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ strategy_id: strategyId }),
+        });
+    }
+    async listSkills() {
+        return this.requestSetup("/skills");
+    }
+    async addSkillSource(sourcePath) {
+        return this.requestSetup("/skills/sources", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ path: sourcePath }),
+        });
+    }
+    async previewSkillAdopt(skillId, actorId) {
+        return this.requestSetup(`/skills/${encodeURIComponent(skillId)}/adopt/preview`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ actor_id: actorId }),
+        });
+    }
+    async previewSkillAssignment(input) {
+        return this.requestSetup("/skills/assignments/preview", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(input),
+        });
+    }
+    async previewSkillGlobalState(input) {
+        return this.requestSetup(`/skills/${encodeURIComponent(input.skill_id)}/global-state/preview`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ enabled: input.enabled, actor_id: input.actor_id }),
+        });
+    }
+    async previewSkillUnmanage(skillId, actorId) {
+        return this.requestSetup(`/skills/${encodeURIComponent(skillId)}/unmanage/preview`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ actor_id: actorId }),
+        });
+    }
+    async applySkillPlan(kind, planId, actorId) {
+        return this.requestSetup(`/skills/${kind}-plans/${encodeURIComponent(planId)}/apply`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ actor_id: actorId }),
+        });
+    }
+    async listPiProviders() {
+        const res = await this.fetch("/pi/providers");
+        if (!res.ok)
+            throw new Error(`Runner error: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async savePiProviders(file) {
+        const res = await this.fetch("/pi/providers", {
+            method: "PUT",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(file),
+        });
+        const payload = (await res.json().catch(() => ({})));
+        if (!res.ok)
+            throw new Error(payload.issues?.join("; ") ?? payload.error ?? `Runner error: ${res.status}`);
+        return { ok: true };
+    }
+    async testPiProvider(provider) {
+        const res = await this.fetch("/pi/providers/test", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(provider),
+        });
+        if (!res.ok)
+            throw new Error(`Runner error: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async listCommands(backend, cwd) {
+        const params = new URLSearchParams({ backend, cwd });
+        const res = await this.fetch(`/commands?${params}`);
+        if (!res.ok)
+            throw new Error(`Runner error: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async authorizeDirectory(directory) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.options.directoryAuthorizationTimeoutMs ?? 45_000);
+        timer.unref?.();
+        try {
+            const res = await this.fetch("/directories/authorize", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ path: directory }),
+                signal: controller.signal,
+            });
+            const body = (await res.json().catch(() => ({})));
+            return {
+                ok: res.ok && body.ok === true,
+                path: body.path,
+                error: body.error ?? (res.ok ? undefined : `Runner error: ${res.status}`),
+            };
+        }
+        catch (err) {
+            if (controller.signal.aborted) {
+                return {
+                    ok: false,
+                    path: directory,
+                    error: "Runner 目录授权请求超时，请检查 macOS 系统弹窗或隐私与安全性设置。",
+                };
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async listDirectory(root, relativePath = "") {
+        const params = new URLSearchParams({ root, path: relativePath });
+        const res = await this.fetch(`/directories/list?${params}`);
+        const body = await res.json();
+        if (!res.ok && !body.error)
+            body.error = `Runner error: ${res.status}`;
+        return body;
+    }
+    async pickDirectory() {
+        const res = await this.fetch("/directories/pick", { method: "POST" });
+        const body = (await res.json().catch(() => ({})));
+        return {
+            ok: res.ok && body.ok === true,
+            path: body.path,
+            cancelled: body.cancelled,
+            error: body.error ?? (res.ok ? undefined : `Runner error: ${res.status}`),
+        };
+    }
+    async closeSession(backend, cwd, sessionId) {
+        return this.sessionLifecycle("close", backend, cwd, sessionId);
+    }
+    async deleteSession(backend, cwd, sessionId) {
+        return this.sessionLifecycle("delete", backend, cwd, sessionId);
+    }
+    async forkSession(backend, cwd, sessionId, targetCwd) {
+        const res = await this.fetch(`/sessions/${encodeURIComponent(sessionId)}/fork`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ backend, cwd, targetCwd }),
+        });
+        const body = (await res.json().catch(() => ({})));
+        return {
+            ok: res.ok && body.ok === true,
+            sessionId: body.sessionId,
+            cwd: body.cwd,
+            error: body.error ?? (res.ok ? undefined : `Runner error: ${res.status}`),
+        };
+    }
+    async cancel(runId) {
+        let res;
+        try {
+            res = await this.fetch(`/runs/${runId}/cancel`, { method: "POST" });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new RunnerCancellationError(`Runner cancellation failed: ${message}`);
+        }
+        const body = (await res.json().catch(() => ({})));
+        if (!res.ok || body.ok !== true) {
+            throw new RunnerCancellationError(`Runner cancellation failed: ${res.status}`);
+        }
+    }
+    async steer(runId, prompt) {
+        const res = await this.fetch(`/runs/${runId}/steer`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt }),
+        });
+        const body = (await res.json().catch(() => ({})));
+        return {
+            ok: res.ok && body.ok === true,
+            outcome: body.outcome,
+            error: body.error ?? (res.ok ? undefined : `Runner error: ${res.status}`),
+        };
+    }
+    /** prompt_feishu：回应 run 挂起的权限请求（/approve /deny） */
+    async resolvePermission(runId, approve) {
+        const res = await this.fetch(`/runs/${runId}/permission`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ approve }),
+        });
+        if (!res.ok)
+            return false;
+        const body = (await res.json());
+        return body.resolved === true;
+    }
+    async *run(request, options) {
+        const signal = options?.signal;
+        let reader;
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let sawDone = false;
+        let cancelPromise;
+        const cancelRemote = () => (cancelPromise ??= this.cancel(request.runId));
+        const onAbort = () => {
+            void cancelRemote().catch(() => { });
+            void reader?.cancel().catch(() => { });
+        };
+        if (signal?.aborted) {
+            await cancelRemote();
+            return;
+        }
+        signal?.addEventListener("abort", onAbort, { once: true });
+        try {
+            let res;
+            try {
+                res = await this.fetch("/runs", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(request),
+                    signal,
+                });
+            }
+            catch (err) {
+                if (signal?.aborted) {
+                    await cancelRemote();
+                    return;
+                }
+                throw err;
+            }
+            if (!res.ok || !res.body) {
+                throw new Error(`Runner error: ${res.status} ${await res.text()}`);
+            }
+            reader = res.body.getReader();
+            if (signal?.aborted) {
+                await reader.cancel().catch(() => { });
+                await cancelRemote();
+                return;
+            }
+            let yieldedAt = performance.now();
+            while (true) {
+                if (signal?.aborted) {
+                    await reader.cancel().catch(() => { });
+                    break;
+                }
+                let done = false;
+                let value;
+                try {
+                    ({ done, value } = await reader.read());
+                }
+                catch (err) {
+                    if (signal?.aborted)
+                        break;
+                    throw this.mapStreamError(err, sawDone);
+                }
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const parts = buffer.split("\n\n");
+                buffer = parts.pop() ?? "";
+                for (const part of parts) {
+                    const line = part.trim();
+                    if (!line.startsWith("data:"))
+                        continue;
+                    const json = line.slice(5).trim();
+                    if (!json)
+                        continue;
+                    const event = JSON.parse(json);
+                    if (event.type === "done")
+                        sawDone = true;
+                    yield event;
+                    // A buffered SSE backlog resolves read()/yield through microtasks only.
+                    // Bound that work so lease heartbeats and cancellation timers can run,
+                    // including when the consumer performs synchronous persistence work.
+                    if (performance.now() - yieldedAt >= 16) {
+                        await new Promise((resolve) => setTimeout(resolve, 0));
+                        yieldedAt = performance.now();
+                    }
+                    if (signal?.aborted)
+                        break;
+                }
+            }
+            if (!sawDone && !signal?.aborted) {
+                throw new Error("Runner 连接意外断开（无完成信号）。请执行 `./scripts/start.sh stop && ./scripts/start.sh start` 重启服务后重试。");
+            }
+        }
+        finally {
+            try {
+                // Consumer errors (for example lost persistence ownership) invoke return()
+                // without aborting the signal. The remote execution still belongs to this
+                // stream and must stop before another attempt can reuse the session.
+                if (signal?.aborted || (reader && !sawDone)) {
+                    const cancellation = cancelRemote();
+                    await reader?.cancel().catch(() => { });
+                    await cancellation;
+                }
+            }
+            finally {
+                signal?.removeEventListener("abort", onAbort);
+                reader?.releaseLock();
+            }
+        }
+    }
+    mapStreamError(err, sawDone) {
+        if (sawDone) {
+            return err instanceof Error ? err : new Error(String(err));
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        if (message === "terminated" || message.includes("other side closed")) {
+            return new Error("Runner 连接意外断开（常见于 Runner 僵尸进程）。请执行 `./scripts/start.sh restart` 重启后重试。");
+        }
+        return err instanceof Error ? err : new Error(message);
+    }
+    async sessionLifecycle(action, backend, cwd, sessionId) {
+        const suffix = action === "close" ? "/close" : "";
+        const res = await this.fetch(`/sessions/${encodeURIComponent(sessionId)}${suffix}`, {
+            method: action === "close" ? "POST" : "DELETE",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ backend, cwd }),
+        });
+        const body = (await res.json().catch(() => ({})));
+        return {
+            ok: res.ok && body.ok === true,
+            error: body.error ?? (res.ok ? undefined : `Runner error: ${res.status}`),
+        };
+    }
+    async requestSetup(path, init) {
+        const res = await this.fetch(path, init);
+        const body = await res.json().catch(() => null);
+        if (!res.ok) {
+            throw setupErrorFromResponse(res.status, body);
+        }
+        return (body ?? {});
+    }
+    fetch(path, init) {
+        const url = `${this.options.baseUrl.replace(/\/$/, "")}${path}`;
+        return fetch(url, {
+            ...init,
+            headers: {
+                Authorization: `Bearer ${this.options.token}`,
+                ...init?.headers,
+            },
+        });
+    }
+}
+function setupErrorFromResponse(status, body) {
+    const payload = body && typeof body === "object" ? body : null;
+    const message = payload?.message ?? payload?.error ?? `Runner error: ${status}`;
+    const details = payload?.details;
+    return new RunnerApiError(message, status, details, payload?.code ?? payload?.error);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,18 @@
+{
+  "name": "@codebridge/runner-client",
+  "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"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@codebridge/backends": "0.1.0",
+    "@codebridge/core": "0.1.0"
+  }
+}

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

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map