lunel-cli 0.1.43 → 0.1.45

package/dist/ai/opencode.js

@@ -0,0 +1,315 @@
+// OpenCode AI provider — wraps @opencode-ai/sdk.
+// All logic extracted verbatim from cli/src/index.ts AI handlers section.
+import * as crypto from "crypto";
+import { createOpencodeServer, createOpencodeClient } from "@opencode-ai/sdk";
+const VERBOSE_AI_LOGS = process.env.LUNEL_DEBUG_AI === "1";
+const SSE_BACKOFF_INITIAL_MS = 500;
+const SSE_BACKOFF_CAP_MS = 30_000;
+const SSE_MAX_RETRIES = 20;
+function redactSensitive(input) {
+    const text = typeof input === "string" ? input : JSON.stringify(input);
+    return text
+        .replace(/([A-Za-z0-9\-_]{20,}\.[A-Za-z0-9\-_]{20,}\.[A-Za-z0-9\-_]{20,})/g, "[redacted_jwt]")
+        .replace(/(password|token|authorization|resumeToken|x-manager-password)\s*[:=]\s*["']?[^"',\s}]+/gi, "$1=[redacted]")
+        .replace(/[A-Za-z0-9+/=_-]{40,}/g, "[redacted_secret]");
+}
+function requireData(response, label) {
+    if (!response.data) {
+        const errMsg = response.error
+            ? (typeof response.error === "string" ? response.error : JSON.stringify(response.error))
+            : `${label} returned no data`;
+        console.error(`[ai] ${label} failed:`, redactSensitive(errMsg), "raw response:", redactSensitive(JSON.stringify(response).substring(0, 500)));
+        throw new Error(errMsg);
+    }
+    return response.data;
+}
+export class OpenCodeProvider {
+    client = null;
+    server = null;
+    lastActiveSessionId = null;
+    shuttingDown = false;
+    emitter = null;
+    async init() {
+        const opencodeUsername = "lunel";
+        const opencodePassword = crypto.randomBytes(32).toString("base64url");
+        const authHeader = `Basic ${Buffer.from(`${opencodeUsername}:${opencodePassword}`).toString("base64")}`;
+        process.env.OPENCODE_SERVER_USERNAME = opencodeUsername;
+        process.env.OPENCODE_SERVER_PASSWORD = opencodePassword;
+        console.log("Starting OpenCode...");
+        this.server = await createOpencodeServer({
+            hostname: "127.0.0.1",
+            port: 0,
+            timeout: 15000,
+        });
+        console.log(`OpenCode server listening on ${this.server.url}`);
+        this.client = createOpencodeClient({
+            baseUrl: this.server.url,
+            headers: { Authorization: authHeader },
+        });
+        console.log("OpenCode ready.\n");
+    }
+    async destroy() {
+        this.shuttingDown = true;
+    }
+    subscribe(emitter) {
+        this.emitter = emitter;
+        this.shuttingDown = false;
+        // Run the SSE loop in the background — it will call emitter for each event.
+        this.runSseLoop();
+        return () => {
+            this.emitter = null;
+        };
+    }
+    setActiveSession(sessionId) {
+        this.lastActiveSessionId = sessionId;
+    }
+    // -------------------------------------------------------------------------
+    // Session management
+    // -------------------------------------------------------------------------
+    async createSession(title) {
+        if (VERBOSE_AI_LOGS)
+            console.log("[ai] createSession called");
+        try {
+            const response = await this.client.session.create({ body: { title } });
+            if (VERBOSE_AI_LOGS) {
+                console.log("[ai] createSession response ok:", !!response.data, "error:", response.error ? redactSensitive(JSON.stringify(response.error).substring(0, 200)) : "none");
+            }
+            return { session: requireData(response, "session.create") };
+        }
+        catch (err) {
+            console.error("[ai] createSession exception:", redactSensitive(err.message));
+            throw err;
+        }
+    }
+    async listSessions() {
+        if (VERBOSE_AI_LOGS)
+            console.log("[ai] listSessions called");
+        try {
+            const response = await this.client.session.list();
+            const data = requireData(response, "session.list");
+            if (VERBOSE_AI_LOGS) {
+                console.log("[ai] listSessions returned", Array.isArray(data) ? data.length : typeof data, "sessions");
+            }
+            return { sessions: data };
+        }
+        catch (err) {
+            console.error("[ai] listSessions exception:", err.message);
+            throw err;
+        }
+    }
+    async getSession(id) {
+        const response = await this.client.session.get({ path: { id } });
+        return { session: requireData(response, "session.get") };
+    }
+    async deleteSession(id) {
+        const response = await this.client.session.delete({ path: { id } });
+        if (response.error)
+            throw new Error(JSON.stringify(response.error));
+        return {};
+    }
+    // -------------------------------------------------------------------------
+    // Messages
+    // -------------------------------------------------------------------------
+    async getMessages(sessionId) {
+        if (VERBOSE_AI_LOGS)
+            console.log("[ai] getMessages called");
+        try {
+            const response = await this.client.session.messages({ path: { id: sessionId } });
+            const raw = requireData(response, "session.messages");
+            const messages = raw.map((m) => ({
+                id: m.info.id,
+                role: m.info.role,
+                parts: m.parts || [],
+                time: m.info.time,
+            }));
+            if (VERBOSE_AI_LOGS)
+                console.log("[ai] getMessages returned", messages.length, "messages");
+            return { messages };
+        }
+        catch (err) {
+            console.error("[ai] getMessages exception:", err.message);
+            throw err;
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Interaction
+    // -------------------------------------------------------------------------
+    async prompt(sessionId, text, model, agent) {
+        if (sessionId)
+            this.lastActiveSessionId = sessionId;
+        if (VERBOSE_AI_LOGS) {
+            console.log("[ai] prompt called", {
+                hasSessionId: Boolean(sessionId),
+                model: redactSensitive(JSON.stringify(model || {})),
+                hasAgent: Boolean(agent),
+                textLength: typeof text === "string" ? text.length : 0,
+            });
+        }
+        // Fire-and-forget — results come back through the SSE event stream.
+        this.client.session.prompt({
+            path: { id: sessionId },
+            body: {
+                parts: [{ type: "text", text }],
+                ...(model ? { model } : {}),
+                ...(agent ? { agent } : {}),
+            },
+        }).catch((err) => {
+            console.error("[ai] prompt error:", err.message);
+            this.emitter?.({
+                type: "prompt_error",
+                properties: { sessionId, error: err.message },
+            });
+        });
+        return { ack: true };
+    }
+    async abort(sessionId) {
+        await this.client.session.abort({ path: { id: sessionId } });
+        return {};
+    }
+    // -------------------------------------------------------------------------
+    // Metadata
+    // -------------------------------------------------------------------------
+    async agents() {
+        if (VERBOSE_AI_LOGS)
+            console.log("[ai] getAgents called");
+        try {
+            const response = await this.client.app.agents();
+            const data = requireData(response, "app.agents");
+            if (VERBOSE_AI_LOGS) {
+                console.log("[ai] getAgents returned:", redactSensitive(JSON.stringify(data).substring(0, 300)));
+            }
+            return { agents: data };
+        }
+        catch (err) {
+            console.error("[ai] getAgents exception:", err.message);
+            throw err;
+        }
+    }
+    async providers() {
+        if (VERBOSE_AI_LOGS)
+            console.log("[ai] getProviders called");
+        try {
+            const response = await this.client.config.providers();
+            const data = requireData(response, "config.providers");
+            if (VERBOSE_AI_LOGS) {
+                console.log("[ai] getProviders returned", data.providers?.length, "providers, defaults:", redactSensitive(JSON.stringify(data.default)));
+            }
+            return { providers: data.providers, default: data.default };
+        }
+        catch (err) {
+            console.error("[ai] getProviders exception:", err.message);
+            throw err;
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Auth
+    // -------------------------------------------------------------------------
+    async setAuth(providerId, key) {
+        await this.client.auth.set({
+            path: { id: providerId },
+            body: { type: "api", key },
+        });
+        return {};
+    }
+    // -------------------------------------------------------------------------
+    // Session operations
+    // -------------------------------------------------------------------------
+    async command(sessionId, command, args) {
+        const response = await this.client.session.command({
+            path: { id: sessionId },
+            body: { command, arguments: args },
+        });
+        return { result: response.data ?? null };
+    }
+    async revert(sessionId, messageId) {
+        await this.client.session.revert({
+            path: { id: sessionId },
+            body: { messageID: messageId },
+        });
+        return {};
+    }
+    async unrevert(sessionId) {
+        await this.client.session.unrevert({ path: { id: sessionId } });
+        return {};
+    }
+    async share(sessionId) {
+        const response = await this.client.session.share({ path: { id: sessionId } });
+        return { share: requireData(response, "session.share") };
+    }
+    async permissionReply(sessionId, permissionId, response) {
+        await this.client.postSessionIdPermissionsPermissionId({
+            path: { id: sessionId, permissionID: permissionId },
+            body: { response },
+        });
+        return {};
+    }
+    // -------------------------------------------------------------------------
+    // SSE event loop (private)
+    // -------------------------------------------------------------------------
+    async runSseLoop() {
+        let attempt = 0;
+        const backoffMs = (n) => {
+            const base = Math.min(SSE_BACKOFF_INITIAL_MS * 2 ** n, SSE_BACKOFF_CAP_MS);
+            const jitter = Math.random() * base * 0.3;
+            return Math.round(base + jitter);
+        };
+        while (!this.shuttingDown) {
+            try {
+                // On reconnect, verify the active session is still alive.
+                if (attempt > 0 && this.lastActiveSessionId) {
+                    const checkResp = await this.client.session.get({
+                        path: { id: this.lastActiveSessionId },
+                    });
+                    if (checkResp.error) {
+                        console.warn(`[sse] OpenCode session ${this.lastActiveSessionId} was garbage-collected. Notifying app.`);
+                        const gcSessionId = this.lastActiveSessionId;
+                        this.lastActiveSessionId = null;
+                        this.emitter?.({ type: "session_gc", properties: { sessionId: gcSessionId } });
+                    }
+                    else {
+                        console.log(`[sse] Active session ${this.lastActiveSessionId} still valid.`);
+                    }
+                }
+                const events = await this.client.event.subscribe();
+                if (attempt > 0) {
+                    console.log(`[sse] reconnected after ${attempt} attempt(s)`);
+                }
+                attempt = 0;
+                for await (const raw of events.stream) {
+                    if (this.shuttingDown)
+                        return;
+                    // Handle two SSE payload shapes across SDK versions:
+                    //   { type, properties, ... }
+                    //   { payload: { type, properties, ... }, directory: "..." }
+                    const parsed = raw;
+                    const base = parsed?.payload && typeof parsed.payload === "object"
+                        ? parsed.payload
+                        : parsed;
+                    if (!base || typeof base.type !== "string") {
+                        console.warn("[sse] Dropped malformed event:", redactSensitive(JSON.stringify(parsed).substring(0, 200)));
+                        continue;
+                    }
+                    console.log("[sse]", base.type);
+                    this.emitter?.({ type: base.type, properties: base.properties || {} });
+                }
+                console.log("[sse] Event stream ended, reconnecting...");
+            }
+            catch (err) {
+                if (this.shuttingDown)
+                    return;
+                attempt++;
+                const delay = backoffMs(attempt - 1);
+                console.error(`[sse] Stream error (attempt ${attempt}/${SSE_MAX_RETRIES}): ${err.message}. Retrying in ${delay}ms`);
+                if (attempt >= SSE_MAX_RETRIES) {
+                    console.error("[sse] Max retries reached. Sending error event to app and giving up.");
+                    this.emitter?.({
+                        type: "sse_dead",
+                        properties: { error: err.message, attempts: attempt },
+                    });
+                    return;
+                }
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+}