@taico/worker 0.0.1

package/dist/runners/OpenCodeAgentRunner.d.ts

@@ -0,0 +1,25 @@
+import { BaseAgentRunner } from "./BaseAgentRunner.js";
+import { AgentModelConfig, AgentRunContext } from "./AgentRunner.js";
+export declare class OpencodeAgentRunner extends BaseAgentRunner {
+    readonly kind = "opencode";
+    private static chdirLock;
+    private formatter;
+    private client;
+    private abortController;
+    private close;
+    private model;
+    constructor(modelConfig?: AgentModelConfig);
+    private static readonly CHDIR_TIMEOUT_MS;
+    initBullshit({ runId, cwd }: {
+        runId: string;
+        cwd: string;
+    }): Promise<void>;
+    private shutdown;
+    init({ runId }: {
+        runId: string;
+    }): Promise<void>;
+    protected runInternal(ctx: AgentRunContext, emit: (msg: string) => Promise<void>, setSession: (id: string) => Promise<void>, onError?: (error: {
+        message: string;
+        rawMessage?: any;
+    }) => void | Promise<void>): Promise<string>;
+}

package/dist/runners/OpenCodeAgentRunner.js

@@ -0,0 +1,163 @@
+// ClaudeAgentRunner.ts
+import { BaseAgentRunner } from "./BaseAgentRunner.js";
+import { createOpencode } from "@opencode-ai/sdk";
+import { OpencodeAsyncMessageFormatter } from "../formatters/OpencodeMessageFormatter.js";
+import { ACCESS_TOKEN, BASE_URL, RUN_ID_HEADER } from "../helpers/config.js";
+export class OpencodeAgentRunner extends BaseAgentRunner {
+    kind = 'opencode';
+    // Mutex for process.chdir: serializes all instances so only one
+    // changes the working directory at a time.
+    static chdirLock = Promise.resolve();
+    formatter = new OpencodeAsyncMessageFormatter();
+    client = null;
+    abortController = new AbortController();
+    close = () => { };
+    model;
+    constructor(modelConfig = {}) {
+        super();
+        const hasCustomModel = Boolean(modelConfig.providerId && modelConfig.modelId);
+        this.model = {
+            providerId: hasCustomModel ? modelConfig.providerId : 'openai',
+            modelId: hasCustomModel ? modelConfig.modelId : 'gpt-5.2-codex',
+        };
+    }
+    static CHDIR_TIMEOUT_MS = 60_000; // 1 min — if we wait longer, something is stuck
+    async initBullshit({ runId, cwd }) {
+        // Disgusting hack to start the server in the working directory
+        // because Opencode has a bug where running a session in a different
+        // folder breaks realtime events (???)
+        //
+        // We serialize via a promise chain so parallel runners don't stomp
+        // on each other's cwd. A timeout prevents waiting forever if a
+        // previous init hangs.
+        let release;
+        const acquired = new Promise(resolve => { release = resolve; });
+        const prev = OpencodeAgentRunner.chdirLock;
+        OpencodeAgentRunner.chdirLock = acquired;
+        // Wait for the previous holder, but not forever.
+        await Promise.race([
+            prev,
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`initBullshit: timed out after ${OpencodeAgentRunner.CHDIR_TIMEOUT_MS}ms waiting for chdir lock — a previous init is likely stuck`)), OpencodeAgentRunner.CHDIR_TIMEOUT_MS)),
+        ]);
+        const originalCwd = process.cwd();
+        process.chdir(cwd);
+        try {
+            await this.init({ runId });
+        }
+        finally {
+            process.chdir(originalCwd);
+            release();
+        }
+    }
+    shutdown() {
+        // Belt and suspenders: abort signal + close().
+        // close() alone is broken (https://github.com/anomalyco/opencode/issues/3841)
+        // but we keep it for when they fix it.
+        this.abortController.abort();
+        this.close();
+    }
+    async init({ runId }) {
+        console.log('Starting Opencode client');
+        let lastError;
+        const PORT_START = 4000;
+        const PORT_END = 4100;
+        for (let port = PORT_START; port < PORT_END; port++) {
+            try {
+                console.log(`Trying port ${port}...`);
+                this.abortController = new AbortController();
+                const opencode = await createOpencode({
+                    port,
+                    timeout: 20 * 3600,
+                    signal: this.abortController.signal,
+                    config: {
+                        mcp: {
+                            tasks: {
+                                type: "remote",
+                                url: `${BASE_URL}/api/v1/tasks/tasks/mcp`,
+                                headers: {
+                                    Authorization: `Bearer ${ACCESS_TOKEN}`,
+                                    [RUN_ID_HEADER]: runId,
+                                },
+                                enabled: true,
+                            }
+                        }
+                    }
+                });
+                this.client = opencode.client;
+                this.close = opencode.server.close;
+                console.log(`Opencode started on port ${port}`);
+                return;
+            }
+            catch (err) {
+                console.warn(`Port ${port} failed, trying next...`);
+                lastError = err;
+            }
+        }
+        throw new Error(`Failed to start Opencode on ports ${PORT_START}–${PORT_END}: ${String(lastError)}`);
+    }
+    async runInternal(ctx, emit, setSession, onError) {
+        // Start client
+        await this.initBullshit({ runId: ctx.runId, cwd: ctx.cwd });
+        // await this.init({ runId: ctx.runId });
+        if (!this.client) {
+            throw new Error("Failed to create Opencode client");
+        }
+        // Create a session for this work
+        const { data: session } = await this.client.session.create({
+            body: {
+                title: `Session ${new Date().toLocaleString()}`,
+            },
+            query: {
+                directory: ctx.cwd,
+            },
+        });
+        if (!session) {
+            this.shutdown();
+            throw new Error("Failed to create Opencode session");
+        }
+        console.log(`created session ${session.id} in ${session.directory}`);
+        // Session is created in the right dir ✅
+        const events = await this.client.event.subscribe(); // SSE stream
+        const prompt = {
+            type: 'text',
+            text: ctx.prompt,
+        };
+        let finalResult = '';
+        this.client.session.promptAsync({
+            path: {
+                id: session.id,
+            },
+            // NOTE: adding a directory breaks realtime events 🤷🏻‍♂️: https://github.com/anomalyco/opencode/issues/11522
+            // NOTE: Good news is we don't need it because the session carries the dir.
+            // NOTE: Acutally we need to. I've implemented a horrible hack to CD before starting the server.
+            // query: {
+            //   directory: ctx.cwd,
+            // },
+            body: {
+                model: {
+                    providerID: this.model.providerId,
+                    modelID: this.model.modelId,
+                },
+                parts: [prompt],
+            }
+        });
+        try {
+            for await (const event of events.stream) {
+                // Detect end of session
+                if (event.type == 'session.idle') {
+                    console.log('session.idle');
+                    break;
+                }
+                const message = this.formatter.format(event);
+                if (message) {
+                    emit(message);
+                }
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+        this.shutdown();
+        return finalResult;
+    }
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@taico/worker",
+  "version": "0.0.1",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "worker": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "start:claude": "dotenv -e .env.claude npm run start",
+    "start:codex": "dotenv -e .env.codex npm run start",
+    "start:reviewer": "dotenv -e .env.reviewer npm run start",
+    "start:qwen": "dotenv -e .env.qwen npm run start",
+    "start:gemini": "dotenv -e .env.gemini npm run start",
+    "start:all": "concurrently -n claude,codex,reviewer,qwen,gemini -c auto \"npm run start:claude\" \"npm run start:codex\" \"npm run start:reviewer\" \"npm run start:qwen\" \"npm run start:gemini\"",
+    "dev": "dotenv -e .env.gemini tsx src/dev.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "pack": "npm run build && npm pack",
+    "release": "npm run build && npm publish --access public"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.1.76",
+    "@github/copilot-sdk": "0.1.22",
+    "@google/adk": "^0.2.4",
+    "@opencode-ai/sdk": "^1.1.28",
+    "@taico/client": "^0.0.1",
+    "@taico/events": "^0.0.2",
+    "socket.io-client": "^4.8.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.7",
+    "dotenv-cli": "^11.0.0",
+    "tsx": "4.21.0",
+    "typescript": "^5.7.3"
+  }
+}