@sw-market/openclaw-opencode-bridge 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# @sw-market/openclaw-opencode-bridge
+
+OpenClaw plugin bridge for OpenCode realtime sessions.
+
+## Goals
+
+- Keep long-lived sessions keyed by `conversationKey`/`sessionKey`.
+- Stream OpenCode realtime events back to OpenClaw gateway.
+- Support interactive confirmations (`interaction.required` -> `chat.action` -> `interaction.resolved`).
+- Emit file change summaries (`file.changed`) for downstream clients (Flutter/Feishu/others).
+
+## Installation
+
+```bash
+npm install @sw-market/openclaw-opencode-bridge
+```
+
+## Usage (plugin runtime)
+
+```ts
+import {
+  OpenClawOpenCodeBridge,
+  type OpenCodeSdkAdapter,
+} from "@sw-market/openclaw-opencode-bridge";
+
+const sdk: OpenCodeSdkAdapter = createYourOpenCodeSdkAdapter();
+const bridge = new OpenClawOpenCodeBridge(sdk, {
+  sessionTtlMs: 30 * 60 * 1000,
+});
+
+const started = await bridge.chatSend({
+  sessionKey: "sw:feishu:chat_001",
+  message: "list files and update README",
+});
+
+for await (const frame of started.events) {
+  // forward frame to OpenClaw gateway `event` pipeline
+  console.log(frame);
+}
+```
+
+## Contract
+
+- `chatSend`: start or continue a coding run.
+- `chatAction`: handle action replay (interaction reply, cancel run).
+- `dispose`: stop cleanup timer and release all in-memory sessions.
+
+The bridge is SDK-agnostic. You provide an adapter that knows how to invoke OpenCode SDK and return typed async events.

package/dist/index.d.ts

@@ -0,0 +1,123 @@
+export type GatewayEventName = "agent" | "chat" | "interaction" | "file" | "progress";
+export interface GatewayEventFrame {
+    type: "event";
+    event: GatewayEventName;
+    payload: Record<string, unknown>;
+}
+export interface BridgeInvocation {
+    runId: string;
+    events: AsyncIterable<GatewayEventFrame>;
+}
+export interface ChatSendRequest {
+    sessionKey: string;
+    message: string;
+    runId?: string;
+    idempotencyKey?: string;
+}
+export interface ChatActionRequest {
+    sessionKey: string;
+    runId: string;
+    action: BridgeAction;
+    idempotencyKey?: string;
+}
+export interface InteractionReplyAction {
+    type: "interaction.reply";
+    interactionId: string;
+    decision: "approve" | "reject" | "cancel";
+    source?: string;
+    payload?: Record<string, unknown>;
+}
+export interface CancelRunAction {
+    type: "cancel_run";
+    reason?: string;
+}
+export type BridgeAction = InteractionReplyAction | CancelRunAction;
+export type OpenCodeEvent = {
+    kind: "assistant_delta";
+    delta: string;
+    text?: string;
+} | {
+    kind: "tool_called";
+    tool: string;
+    args?: Record<string, unknown>;
+} | {
+    kind: "tool_result";
+    tool: string;
+    ok: boolean;
+    result?: string;
+} | {
+    kind: "interaction_required";
+    interactionId: string;
+    title: string;
+    message: string;
+    options: Array<{
+        id: string;
+        title: string;
+        description?: string;
+    }>;
+    defaultOption?: string;
+    timeoutSec?: number;
+    interactionType?: string;
+} | {
+    kind: "interaction_resolved";
+    interactionId: string;
+    decision: "approve" | "reject" | "cancel";
+    status?: string;
+    source?: string;
+} | {
+    kind: "file_changed";
+    path: string;
+    op: "create" | "update" | "delete" | "rename";
+    summary: string;
+    language?: string;
+} | {
+    kind: "progress";
+    stage: string;
+    message: string;
+    percent?: number;
+} | {
+    kind: "assistant_final";
+    text: string;
+    summary?: string;
+    status?: "success" | "failed";
+} | {
+    kind: "run_completed";
+    status: "succeeded" | "failed";
+    error?: string;
+};
+export interface OpenCodeSession {
+    sendMessage(args: {
+        runId: string;
+        message: string;
+        idempotencyKey: string;
+    }): AsyncIterable<OpenCodeEvent>;
+    sendAction(args: {
+        runId: string;
+        action: BridgeAction;
+        idempotencyKey: string;
+    }): AsyncIterable<OpenCodeEvent>;
+    close?(): Promise<void>;
+}
+export interface OpenCodeSdkAdapter {
+    createSession(args: {
+        sessionKey: string;
+    }): Promise<OpenCodeSession>;
+}
+export interface OpenClawOpenCodeBridgeOptions {
+    sessionTtlMs?: number;
+    cleanupIntervalMs?: number;
+}
+export declare class OpenClawOpenCodeBridge {
+    private readonly sdk;
+    private readonly sessionTtlMs;
+    private readonly sessions;
+    private readonly cleanupTimer;
+    constructor(sdk: OpenCodeSdkAdapter, options?: OpenClawOpenCodeBridgeOptions);
+    chatSend(request: ChatSendRequest): Promise<BridgeInvocation>;
+    chatAction(request: ChatActionRequest): Promise<BridgeInvocation>;
+    dispose(): Promise<void>;
+    private getOrCreateSession;
+    private cleanupExpiredSessions;
+    private toGatewayEventStream;
+}
+export declare function mapOpenCodeEventToGatewayFrames(event: OpenCodeEvent, runId: string): GatewayEventFrame[];

package/dist/index.js

@@ -0,0 +1,276 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_SESSION_TTL_MS = 30 * 60 * 1000;
+const DEFAULT_CLEANUP_INTERVAL_MS = 60 * 1000;
+export class OpenClawOpenCodeBridge {
+    sdk;
+    sessionTtlMs;
+    sessions = new Map();
+    cleanupTimer;
+    constructor(sdk, options = {}) {
+        this.sdk = sdk;
+        this.sessionTtlMs = Math.max(60_000, options.sessionTtlMs ?? DEFAULT_SESSION_TTL_MS);
+        const cleanupIntervalMs = Math.max(15_000, options.cleanupIntervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS);
+        this.cleanupTimer = setInterval(() => {
+            void this.cleanupExpiredSessions();
+        }, cleanupIntervalMs);
+        this.cleanupTimer.unref();
+    }
+    async chatSend(request) {
+        const session = await this.getOrCreateSession(request.sessionKey);
+        const runId = request.runId ?? createRunId();
+        const idempotencyKey = request.idempotencyKey ?? createIdempotencyKey();
+        const source = session.sendMessage({
+            runId,
+            message: request.message,
+            idempotencyKey,
+        });
+        return {
+            runId,
+            events: this.toGatewayEventStream({
+                source,
+                runId,
+            }),
+        };
+    }
+    async chatAction(request) {
+        const session = await this.getOrCreateSession(request.sessionKey);
+        const idempotencyKey = request.idempotencyKey ?? createIdempotencyKey();
+        const source = session.sendAction({
+            runId: request.runId,
+            action: request.action,
+            idempotencyKey,
+        });
+        return {
+            runId: request.runId,
+            events: this.toGatewayEventStream({
+                source,
+                runId: request.runId,
+            }),
+        };
+    }
+    async dispose() {
+        clearInterval(this.cleanupTimer);
+        const closing = [];
+        for (const [sessionKey, state] of this.sessions) {
+            this.sessions.delete(sessionKey);
+            if (state.session.close) {
+                closing.push(state.session.close());
+            }
+        }
+        await Promise.allSettled(closing);
+    }
+    async getOrCreateSession(sessionKey) {
+        const nowMs = Date.now();
+        const existing = this.sessions.get(sessionKey);
+        if (existing) {
+            existing.lastActiveAtMs = nowMs;
+            return existing.session;
+        }
+        const session = await this.sdk.createSession({ sessionKey });
+        this.sessions.set(sessionKey, {
+            session,
+            lastActiveAtMs: nowMs,
+        });
+        return session;
+    }
+    async cleanupExpiredSessions() {
+        const nowMs = Date.now();
+        for (const [sessionKey, state] of this.sessions) {
+            if (nowMs - state.lastActiveAtMs <= this.sessionTtlMs) {
+                continue;
+            }
+            this.sessions.delete(sessionKey);
+            if (state.session.close) {
+                await state.session.close();
+            }
+        }
+    }
+    async *toGatewayEventStream(args) {
+        let finalSeen = false;
+        let completedSeen = false;
+        let assistantText = "";
+        for await (const event of args.source) {
+            if (event.kind === "assistant_delta") {
+                assistantText += event.delta;
+            }
+            if (event.kind === "assistant_final") {
+                finalSeen = true;
+            }
+            if (event.kind === "run_completed") {
+                completedSeen = true;
+            }
+            for (const frame of mapOpenCodeEventToGatewayFrames(event, args.runId)) {
+                yield frame;
+            }
+        }
+        if (!finalSeen && assistantText.trim()) {
+            yield {
+                type: "event",
+                event: "chat",
+                payload: {
+                    runId: args.runId,
+                    state: "final",
+                    text: assistantText.trim(),
+                },
+            };
+            finalSeen = true;
+        }
+        if (!completedSeen) {
+            yield {
+                type: "event",
+                event: "chat",
+                payload: {
+                    runId: args.runId,
+                    state: "completed",
+                },
+            };
+        }
+    }
+}
+export function mapOpenCodeEventToGatewayFrames(event, runId) {
+    switch (event.kind) {
+        case "assistant_delta":
+            return [
+                {
+                    type: "event",
+                    event: "agent",
+                    payload: {
+                        runId,
+                        stream: "assistant",
+                        data: {
+                            delta: event.delta,
+                            text: event.text,
+                        },
+                    },
+                },
+            ];
+        case "tool_called":
+            return [
+                {
+                    type: "event",
+                    event: "agent",
+                    payload: {
+                        runId,
+                        stream: "tool",
+                        data: {
+                            phase: "start",
+                            tool: event.tool,
+                            args: event.args ?? {},
+                        },
+                    },
+                },
+            ];
+        case "tool_result":
+            return [
+                {
+                    type: "event",
+                    event: "agent",
+                    payload: {
+                        runId,
+                        stream: "tool",
+                        data: {
+                            phase: "result",
+                            tool: event.tool,
+                            ok: event.ok,
+                            result: event.result ?? "",
+                        },
+                    },
+                },
+            ];
+        case "interaction_required":
+            return [
+                {
+                    type: "event",
+                    event: "interaction",
+                    payload: {
+                        runId,
+                        state: "required",
+                        interactionId: event.interactionId,
+                        kind: event.interactionType ?? "approval",
+                        title: event.title,
+                        message: event.message,
+                        options: event.options,
+                        defaultOption: event.defaultOption ?? "approve",
+                        timeoutSec: event.timeoutSec ?? 0,
+                    },
+                },
+            ];
+        case "interaction_resolved":
+            return [
+                {
+                    type: "event",
+                    event: "interaction",
+                    payload: {
+                        runId,
+                        state: "resolved",
+                        interactionId: event.interactionId,
+                        decision: event.decision,
+                        status: event.status ?? "resolved",
+                        source: event.source ?? "openclaw_plugin",
+                    },
+                },
+            ];
+        case "file_changed":
+            return [
+                {
+                    type: "event",
+                    event: "file",
+                    payload: {
+                        runId,
+                        path: event.path,
+                        op: event.op,
+                        summary: event.summary,
+                        language: event.language,
+                    },
+                },
+            ];
+        case "progress":
+            return [
+                {
+                    type: "event",
+                    event: "progress",
+                    payload: {
+                        runId,
+                        stage: event.stage,
+                        message: event.message,
+                        percent: event.percent,
+                    },
+                },
+            ];
+        case "assistant_final":
+            return [
+                {
+                    type: "event",
+                    event: "chat",
+                    payload: {
+                        runId,
+                        state: "final",
+                        text: event.text,
+                        summary: event.summary,
+                        status: event.status ?? "success",
+                    },
+                },
+            ];
+        case "run_completed":
+            return [
+                {
+                    type: "event",
+                    event: "chat",
+                    payload: {
+                        runId,
+                        state: "completed",
+                        status: event.status,
+                        error: event.error,
+                    },
+                },
+            ];
+        default:
+            return [];
+    }
+}
+function createRunId() {
+    return `run_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+}
+function createIdempotencyKey() {
+    return `idem_${randomUUID().replace(/-/g, "")}`;
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@sw-market/openclaw-opencode-bridge",
+  "version": "0.1.0",
+  "description": "OpenClaw plugin bridge for OpenCode realtime streaming and interaction actions",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rimraf dist",
+    "prepare": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "openclaw",
+    "opencode",
+    "plugin",
+    "bridge",
+    "realtime"
+  ],
+  "author": "SW-Market",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}