@nuraly/lumenjs 0.1.2 → 0.1.4

package/dist/dev-server/ssr-render.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import fs from 'fs';
 import { resolvePageFile, extractRouteParams } from './plugins/vite-plugin-loaders.js';
-import { stripOuterLitMarkers, dirToLayoutTagName, filePathToTagName } from '../shared/utils.js';
+import { stripOuterLitMarkers, dirToLayoutTagName, filePathToTagName, patchLoaderDataSpread } from '../shared/utils.js';
 import { installDomShims } from '../shared/dom-shims.js';
 import { loadTranslationsFromDisk } from './plugins/vite-plugin-i18n.js';
 /**
@@ -10,7 +10,7 @@ import { loadTranslationsFromDisk } from './plugins/vite-plugin-i18n.js';
  *
  * Returns pre-rendered HTML and loader data, or null on failure (falls back to CSR).
  */
-export async function ssrRenderPage(server, pagesDir, pathname, headers, locale) {
+export async function ssrRenderPage(server, pagesDir, pathname, headers, locale, user) {
     try {
         const filePath = resolvePageFile(pagesDir, pathname);
         if (!filePath)
@@ -20,32 +20,27 @@ export async function ssrRenderPage(server, pagesDir, pathname, headers, locale)
         await server.ssrLoadModule('@lit-labs/ssr/lib/install-global-dom-shim.js');
         // Patch missing DOM APIs that NuralyUI components may use during SSR
         installDomShims();
-        // Initialize i18n in the SSR context so t() works during render
-        if (locale) {
-            const projectDir = path.resolve(pagesDir, '..');
-            const translations = loadTranslationsFromDisk(projectDir, locale);
-            try {
-                // Load the same i18n module the page will import (via resolve.alias)
-                const i18nMod = await server.ssrLoadModule('@lumenjs/i18n');
-                if (i18nMod?.initI18n) {
-                    i18nMod.initI18n({ locales: [], defaultLocale: locale, prefixDefault: false }, locale, translations);
-                }
-            }
-            catch {
-                // i18n module not available — translations will show keys
-            }
-        }
         // Invalidate SSR module cache so we always get fresh content after file edits.
         // Also clear the custom element from the SSR registry so the new class is used.
+        // IMPORTANT: This must happen BEFORE i18n/auth init, because invalidation
+        // recursively clears all SSR-imported modules (including @lumenjs/i18n).
+        // If we init i18n first, then invalidate, the page reload gets a fresh i18n
+        // module instance with empty translations.
         const g = globalThis;
         invalidateSsrModule(server, filePath);
         clearSsrCustomElement(g);
         // Load the page module via Vite (registers the custom element, applies transforms)
+        // Bypass get() so auto-define re-registers fresh classes
+        const registry = g.customElements;
+        if (registry)
+            registry.__nk_bypass_get = true;
         const mod = await server.ssrLoadModule(filePath);
+        if (registry)
+            registry.__nk_bypass_get = false;
         // Run loader if present
         let loaderData = undefined;
         if (mod.loader && typeof mod.loader === 'function') {
-            loaderData = await mod.loader({ params, query: {}, url: pathname, headers: headers || {}, locale });
+            loaderData = await mod.loader({ params, query: {}, url: pathname, headers: headers || {}, locale, user: user ?? null });
             if (loaderData && typeof loaderData === 'object' && loaderData.__nk_redirect) {
                 return { html: '', loaderData: null, redirect: { location: loaderData.location, status: loaderData.status || 302 } };
             }
@@ -53,8 +48,8 @@ export async function ssrRenderPage(server, pagesDir, pathname, headers, locale)
         // Determine the custom element tag name from file path (matches client router)
         const relPath = path.relative(pagesDir, filePath).replace(/\\/g, '/');
         const tagName = filePathToTagName(relPath);
-        // Discover layout chain for this page
-        const layoutChain = discoverLayoutChain(pagesDir, filePath);
+        // Standalone pages skip all layouts
+        const layoutChain = mod.standalone ? [] : discoverLayoutChain(pagesDir, filePath);
         const layoutsData = [];
         // Load layout modules and run their loaders
         const layoutModules = [];
@@ -62,10 +57,14 @@ export async function ssrRenderPage(server, pagesDir, pathname, headers, locale)
             // Invalidate layout module cache and clear SSR element registry
             invalidateSsrModule(server, layout.filePath);
             clearSsrCustomElement(g);
+            if (registry)
+                registry.__nk_bypass_get = true;
             const layoutMod = await server.ssrLoadModule(layout.filePath);
+            if (registry)
+                registry.__nk_bypass_get = false;
             let layoutLoaderData = undefined;
             if (layoutMod.loader && typeof layoutMod.loader === 'function') {
-                layoutLoaderData = await layoutMod.loader({ params: {}, query: {}, url: pathname, headers: headers || {}, locale });
+                layoutLoaderData = await layoutMod.loader({ params: {}, query: {}, url: pathname, headers: headers || {}, locale, user: user ?? null });
                 if (layoutLoaderData && typeof layoutLoaderData === 'object' && layoutLoaderData.__nk_redirect) {
                     return { html: '', loaderData: null, redirect: { location: layoutLoaderData.location, status: layoutLoaderData.status || 302 } };
                 }
@@ -74,6 +73,38 @@ export async function ssrRenderPage(server, pagesDir, pathname, headers, locale)
             layoutModules.push({ tagName: layoutTagName, loaderData: layoutLoaderData });
             layoutsData.push({ loaderPath: layout.dir, data: layoutLoaderData });
         }
+        // Patch element classes to spread loaderData into individual properties
+        for (const lm of layoutModules) {
+            patchLoaderDataSpread(lm.tagName);
+        }
+        patchLoaderDataSpread(tagName);
+        // Initialize i18n in the SSR context AFTER all page/layout modules are loaded.
+        // This ensures t() uses the same module instance the components imported.
+        // Must happen after invalidation + module loading, because invalidateSsrModule
+        // recursively clears cached modules — if i18n was initialized before, the
+        // reloaded page/layout would get a fresh i18n instance with empty translations.
+        if (locale) {
+            const projectDir = path.resolve(pagesDir, '..');
+            const translations = loadTranslationsFromDisk(projectDir, locale);
+            try {
+                const i18nMod = await server.ssrLoadModule('@lumenjs/i18n');
+                if (i18nMod?.initI18n) {
+                    i18nMod.initI18n({ locales: [], defaultLocale: locale, prefixDefault: false }, locale, translations);
+                }
+            }
+            catch {
+                // i18n module not available — translations will show keys
+            }
+        }
+        // Initialize auth in the SSR context (same reason — after module loading)
+        if (user) {
+            try {
+                const authMod = await server.ssrLoadModule('@nuraly/lumenjs-auth');
+                if (authMod?.initAuth)
+                    authMod.initAuth(user);
+            }
+            catch { }
+        }
         // Load SSR render + lit/static-html.js through Vite (same module registry as page)
         const { render } = await server.ssrLoadModule('@lit-labs/ssr');
         const { html, unsafeStatic } = await server.ssrLoadModule('lit/static-html.js');
@@ -106,7 +137,7 @@ export async function ssrRenderPage(server, pagesDir, pathname, headers, locale)
                 htmlStr = layoutHtml + htmlStr;
             }
         }
-        return { html: htmlStr, loaderData, layoutsData: layoutsData.length > 0 ? layoutsData : undefined };
+        return { html: htmlStr, loaderData, layoutsData: layoutsData.length > 0 ? layoutsData : undefined, authUser: user ?? undefined };
     }
     catch (err) {
         console.error('[LumenJS] SSR render failed, falling back to CSR:', err);
@@ -145,41 +176,69 @@ function findLayoutFile(dir) {
     return null;
 }
 /**
- * Aggressively invalidate a module for SSR re-execution.
+ * Aggressively invalidate a module and all its SSR-imported dependencies.
+ * Without this, editing a component imported by a page/layout serves stale SSR.
  */
 function invalidateSsrModule(server, filePath) {
-    const byFile = server.moduleGraph.getModulesByFile(filePath);
-    if (byFile) {
-        for (const m of byFile) {
-            server.moduleGraph.invalidateModule(m);
-            m.ssrModule = null;
-            m.ssrTransformResult = null;
+    const visited = new Set();
+    function invalidateRecursive(id) {
+        if (visited.has(id))
+            return;
+        visited.add(id);
+        const mods = server.moduleGraph.getModulesByFile(id);
+        if (mods) {
+            for (const m of mods) {
+                server.moduleGraph.invalidateModule(m);
+                m.ssrModule = null;
+                m.ssrTransformResult = null;
+                // Recurse into SSR-imported modules
+                if (m.ssrImportedModules) {
+                    for (const dep of m.ssrImportedModules) {
+                        if (dep.file)
+                            invalidateRecursive(dep.file);
+                    }
+                }
+            }
+        }
+        const urlMod = server.moduleGraph.getModuleById(id);
+        if (urlMod) {
+            server.moduleGraph.invalidateModule(urlMod);
+            urlMod.ssrModule = null;
+            urlMod.ssrTransformResult = null;
         }
     }
-    const urlMod = server.moduleGraph.getModuleById(filePath);
-    if (urlMod) {
-        server.moduleGraph.invalidateModule(urlMod);
-        urlMod.ssrModule = null;
-        urlMod.ssrTransformResult = null;
-    }
+    invalidateRecursive(filePath);
 }
 /**
- * Patch the SSR customElements registry to allow re-registration.
+ * Patch the SSR customElements registry to allow re-registration,
+ * and proactively clear all definitions so auto-define guards pass.
  */
 function clearSsrCustomElement(g) {
     const registry = g.customElements;
-    if (!registry || registry.__nk_patched)
+    if (!registry)
         return;
-    registry.__nk_patched = true;
-    const origDefine = registry.define.bind(registry);
-    registry.define = (name, ctor) => {
-        if (registry.__definitions && registry.__definitions.has(name)) {
-            const oldCtor = registry.__definitions.get(name)?.ctor;
-            registry.__definitions.delete(name);
-            if (oldCtor && registry.__reverseDefinitions) {
-                registry.__reverseDefinitions.delete(oldCtor);
+    // Patch define() to allow re-registration and get() to bypass
+    // auto-define guards (one-time)
+    if (!registry.__nk_patched) {
+        registry.__nk_patched = true;
+        const origDefine = registry.define.bind(registry);
+        registry.define = (name, ctor) => {
+            if (registry.__definitions && registry.__definitions.has(name)) {
+                const oldCtor = registry.__definitions.get(name)?.ctor;
+                registry.__definitions.delete(name);
+                if (oldCtor && registry.__reverseDefinitions) {
+                    registry.__reverseDefinitions.delete(oldCtor);
+                }
             }
-        }
-        return origDefine(name, ctor);
-    };
+            return origDefine(name, ctor);
+        };
+        // Patch get() so auto-define's `if (!customElements.get('tag'))` guard
+        // always passes, allowing define() to re-register the fresh class.
+        const origGet = registry.get.bind(registry);
+        registry.get = (name) => {
+            if (registry.__nk_bypass_get)
+                return undefined;
+            return origGet(name);
+        };
+    }
 }

package/dist/editor/ai/backend.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AI backend router — selects between Claude Code and OpenCode based on:
+ *   1. AI_BACKEND env var ('claude-code' | 'opencode')
+ *   2. Auto-detection: Claude Code CLI first, then OpenCode server
+ */
+import type { AiChatOptions, AiChatResult, AiStatusResult } from './types.js';
+export type { AiChatOptions, AiChatResult, AiStatusResult } from './types.js';
+/**
+ * Stream an AI chat message using the configured backend.
+ */
+export declare function streamAiChat(projectDir: string, options: AiChatOptions): AiChatResult;
+/**
+ * Warm up the AI backend session in the background.
+ * Call on editor startup so the first user request is fast.
+ */
+export declare function warmUpAiSession(projectDir: string): Promise<void>;
+/**
+ * Check if any AI backend is available.
+ */
+export declare function checkAiStatus(): Promise<AiStatusResult>;

package/dist/editor/ai/backend.js

@@ -0,0 +1,104 @@
+/**
+ * AI backend router — selects between Claude Code and OpenCode based on:
+ *   1. AI_BACKEND env var ('claude-code' | 'opencode')
+ *   2. Auto-detection: Claude Code CLI first, then OpenCode server
+ */
+let resolvedBackend = null;
+async function detectBackend() {
+    if (resolvedBackend)
+        return resolvedBackend;
+    const explicit = process.env.AI_BACKEND;
+    if (explicit === 'claude-code' || explicit === 'opencode') {
+        resolvedBackend = explicit;
+        console.log(`[LumenJS] AI backend: ${explicit} (from AI_BACKEND env)`);
+        return resolvedBackend;
+    }
+    // Auto-detect: try Claude Code first (subscription-based, no server needed)
+    try {
+        const cc = await import('./claude-code-client.js');
+        const status = await cc.checkAiStatus();
+        if (status.configured) {
+            resolvedBackend = 'claude-code';
+            console.log('[LumenJS] AI backend: claude-code (auto-detected)');
+            return resolvedBackend;
+        }
+    }
+    catch {
+        // SDK not installed or CLI not found
+    }
+    // Fall back to OpenCode
+    resolvedBackend = 'opencode';
+    console.log('[LumenJS] AI backend: opencode (fallback)');
+    return resolvedBackend;
+}
+async function getClient() {
+    const backend = await detectBackend();
+    if (backend === 'claude-code') {
+        return import('./claude-code-client.js');
+    }
+    return import('./opencode-client.js');
+}
+/**
+ * Stream an AI chat message using the configured backend.
+ */
+export function streamAiChat(projectDir, options) {
+    const tokenCallbacks = [];
+    const doneCallbacks = [];
+    const errorCallbacks = [];
+    let innerResult = null;
+    const run = async () => {
+        try {
+            const client = await getClient();
+            innerResult = client.streamAiChat(projectDir, options);
+            // Forward callbacks registered before the client loaded
+            for (const cb of tokenCallbacks)
+                innerResult.onToken(cb);
+            for (const cb of doneCallbacks)
+                innerResult.onDone(cb);
+            for (const cb of errorCallbacks)
+                innerResult.onError(cb);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            for (const cb of errorCallbacks)
+                cb(error);
+        }
+    };
+    run();
+    return {
+        get sessionId() { return innerResult?.sessionId || options.sessionId || ''; },
+        onToken: (cb) => { tokenCallbacks.push(cb); innerResult?.onToken(cb); },
+        onDone: (cb) => { doneCallbacks.push(cb); innerResult?.onDone(cb); },
+        onError: (cb) => { errorCallbacks.push(cb); innerResult?.onError(cb); },
+        abort: () => innerResult?.abort(),
+    };
+}
+/**
+ * Warm up the AI backend session in the background.
+ * Call on editor startup so the first user request is fast.
+ */
+export async function warmUpAiSession(projectDir) {
+    const backend = await detectBackend();
+    if (backend === 'claude-code') {
+        try {
+            const cc = await import('./claude-code-client.js');
+            await cc.warmUpSession(projectDir);
+            console.log('[LumenJS] AI session warmed up');
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+}
+/**
+ * Check if any AI backend is available.
+ */
+export async function checkAiStatus() {
+    try {
+        const client = await getClient();
+        return client.checkAiStatus();
+    }
+    catch {
+        return { configured: false, backend: 'opencode' };
+    }
+}

package/dist/editor/ai/claude-code-client.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Claude Code AI client — uses the Claude Agent SDK (@anthropic-ai/claude-agent-sdk).
+ * Spawns the `claude` CLI as a subprocess. Requires Claude Code CLI installed and logged in.
+ * Works with Pro/Max subscription — no API key needed.
+ */
+import type { AiChatOptions, AiChatResult, AiStatusResult } from './types.js';
+/**
+ * Warm up by pre-spawning a Claude Code session. The first real request
+ * will resume this session, skipping CLI cold-start entirely.
+ */
+export declare function warmUpSession(projectDir: string): Promise<void>;
+/**
+ * Stream an AI chat message via Claude Code Agent SDK.
+ */
+export declare function streamAiChat(projectDir: string, options: AiChatOptions): AiChatResult;
+/**
+ * Check if Claude Code CLI is installed and the Agent SDK is importable.
+ * Both are required — the CLI alone isn't enough.
+ */
+export declare function checkAiStatus(): Promise<AiStatusResult>;

package/dist/editor/ai/claude-code-client.js

@@ -0,0 +1,145 @@
+/**
+ * Claude Code AI client — uses the Claude Agent SDK (@anthropic-ai/claude-agent-sdk).
+ * Spawns the `claude` CLI as a subprocess. Requires Claude Code CLI installed and logged in.
+ * Works with Pro/Max subscription — no API key needed.
+ */
+import { SYSTEM_PROMPT, buildPrompt } from './types.js';
+import { execSync } from 'child_process';
+// ── SDK Cache & Session Warm-up ──────────────────────────────────
+let _sdkCache = null;
+let _warmSessionId = null;
+async function getSdk() {
+    if (_sdkCache)
+        return _sdkCache;
+    const sdk = await import('@anthropic-ai/claude-agent-sdk');
+    const query = sdk.query || sdk.default?.query;
+    if (!query)
+        throw new Error('Claude Agent SDK loaded but query() not found');
+    _sdkCache = { query };
+    return _sdkCache;
+}
+/**
+ * Warm up by pre-spawning a Claude Code session. The first real request
+ * will resume this session, skipping CLI cold-start entirely.
+ */
+export async function warmUpSession(projectDir) {
+    try {
+        const { query } = await getSdk();
+        const stream = query({
+            prompt: 'Ready.',
+            options: {
+                cwd: projectDir,
+                systemPrompt: SYSTEM_PROMPT,
+                allowedTools: ['Read', 'Edit', 'Write', 'Glob', 'Grep', 'Bash'],
+                maxTurns: 1,
+                model: 'sonnet',
+                effort: 'low',
+                persistSession: true,
+            },
+        });
+        for await (const msg of stream) {
+            if (msg.session_id) {
+                _warmSessionId = msg.session_id;
+                break;
+            }
+        }
+    }
+    catch {
+        // Non-fatal — first request will just be slower
+    }
+}
+/**
+ * Stream an AI chat message via Claude Code Agent SDK.
+ */
+export function streamAiChat(projectDir, options) {
+    const tokenCallbacks = [];
+    const doneCallbacks = [];
+    const errorCallbacks = [];
+    let aborted = false;
+    let sessionId = options.sessionId || '';
+    const enrichedPrompt = buildPrompt(options);
+    const run = async () => {
+        try {
+            const { query } = await getSdk();
+            let fullText = '';
+            const queryOptions = {
+                cwd: projectDir,
+                systemPrompt: SYSTEM_PROMPT,
+                allowedTools: ['Read', 'Edit', 'Write', 'Glob', 'Grep', 'Bash'],
+                maxTurns: 10,
+                persistSession: true,
+                model: 'sonnet',
+            };
+            // Use Sonnet + low effort for fast mode (quick actions like text improvement, spacing)
+            if (options.model === 'fast') {
+                queryOptions.model = 'sonnet';
+                queryOptions.effort = 'low';
+                queryOptions.maxTurns = 5;
+            }
+            // Resume existing session, or use pre-warmed session for instant first request
+            if (sessionId) {
+                queryOptions.resume = sessionId;
+            }
+            else if (_warmSessionId) {
+                queryOptions.resume = _warmSessionId;
+                sessionId = _warmSessionId;
+                _warmSessionId = null;
+            }
+            const stream = query({
+                prompt: enrichedPrompt,
+                options: queryOptions,
+            });
+            for await (const msg of stream) {
+                if (aborted)
+                    break;
+                // Capture session ID from any message
+                if (msg.session_id && !sessionId) {
+                    sessionId = msg.session_id;
+                }
+                if (msg.type === 'assistant' && msg.message?.content) {
+                    for (const block of msg.message.content) {
+                        if (block.type === 'text' && block.text) {
+                            fullText += block.text;
+                            for (const cb of tokenCallbacks)
+                                cb(block.text);
+                        }
+                    }
+                }
+            }
+            if (!aborted) {
+                for (const cb of doneCallbacks)
+                    cb(fullText);
+            }
+        }
+        catch (err) {
+            if (aborted)
+                return;
+            for (const cb of errorCallbacks)
+                cb(err instanceof Error ? err : new Error(String(err)));
+        }
+    };
+    // Start the async flow
+    run();
+    return {
+        get sessionId() { return sessionId; },
+        onToken: (cb) => { tokenCallbacks.push(cb); },
+        onDone: (cb) => { doneCallbacks.push(cb); },
+        onError: (cb) => { errorCallbacks.push(cb); },
+        abort: () => { aborted = true; },
+    };
+}
+/**
+ * Check if Claude Code CLI is installed and the Agent SDK is importable.
+ * Both are required — the CLI alone isn't enough.
+ */
+export async function checkAiStatus() {
+    try {
+        execSync('claude --version', { timeout: 5000, stdio: 'pipe' });
+        // Verify the SDK is actually importable (it's an optional dependency)
+        await import('@anthropic-ai/claude-agent-sdk');
+        return { configured: true, backend: 'claude-code' };
+    }
+    catch {
+        return { configured: false, backend: 'claude-code' };
+    }
+}

package/dist/editor/ai/opencode-client.d.ts

@@ -0,0 +1,14 @@
+/**
+ * OpenCode AI client — wraps the OpenCode REST API for AI coding agent integration.
+ * Connects to an OpenCode server (`opencode serve`) that handles LLM calls and file editing.
+ */
+import type { AiChatOptions, AiChatResult, AiStatusResult } from './types.js';
+/**
+ * Stream an AI chat message via OpenCode's REST API.
+ * Uses the /api/session and /api/message endpoints.
+ */
+export declare function streamAiChat(projectDir: string, options: AiChatOptions): AiChatResult;
+/**
+ * Check if OpenCode server is reachable.
+ */
+export declare function checkAiStatus(): Promise<AiStatusResult>;

package/dist/editor/ai/opencode-client.js

@@ -0,0 +1,125 @@
+/**
+ * OpenCode AI client — wraps the OpenCode REST API for AI coding agent integration.
+ * Connects to an OpenCode server (`opencode serve`) that handles LLM calls and file editing.
+ */
+import { SYSTEM_PROMPT, buildPrompt } from './types.js';
+const OPENCODE_URL = process.env.OPENCODE_URL || 'http://localhost:3500';
+const OPENCODE_PASSWORD = process.env.OPENCODE_SERVER_PASSWORD || '';
+function buildHeaders() {
+    const headers = { 'Content-Type': 'application/json' };
+    if (OPENCODE_PASSWORD) {
+        headers['Authorization'] = `Bearer ${OPENCODE_PASSWORD}`;
+    }
+    return headers;
+}
+/**
+ * Stream an AI chat message via OpenCode's REST API.
+ * Uses the /api/session and /api/message endpoints.
+ */
+export function streamAiChat(projectDir, options) {
+    const tokenCallbacks = [];
+    const doneCallbacks = [];
+    const errorCallbacks = [];
+    const controller = new AbortController();
+    let sessionId = options.sessionId || '';
+    const enrichedPrompt = buildPrompt(options);
+    const run = async () => {
+        try {
+            // Create a new session if we don't have one
+            if (!sessionId) {
+                const createRes = await fetch(`${OPENCODE_URL}/api/session`, {
+                    method: 'POST',
+                    headers: buildHeaders(),
+                    body: JSON.stringify({ path: projectDir, system: SYSTEM_PROMPT }),
+                    signal: controller.signal,
+                });
+                if (!createRes.ok) {
+                    throw new Error(`Failed to create OpenCode session: ${createRes.status}`);
+                }
+                const sessionData = await createRes.json();
+                sessionId = sessionData.id || sessionData.sessionId || '';
+            }
+            // Send message and stream response
+            const msgRes = await fetch(`${OPENCODE_URL}/api/session/${sessionId}/message`, {
+                method: 'POST',
+                headers: { ...buildHeaders(), 'Accept': 'text/event-stream' },
+                body: JSON.stringify({ content: enrichedPrompt }),
+                signal: controller.signal,
+            });
+            if (!msgRes.ok) {
+                throw new Error(`OpenCode message failed: ${msgRes.status}`);
+            }
+            const reader = msgRes.body?.getReader();
+            if (!reader)
+                throw new Error('No response body from OpenCode');
+            const decoder = new TextDecoder();
+            let fullText = '';
+            let buffer = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6).trim();
+                        if (data === '[DONE]')
+                            continue;
+                        try {
+                            const parsed = JSON.parse(data);
+                            // Handle different event formats from OpenCode
+                            const text = parsed.content || parsed.text || parsed.delta || '';
+                            if (text) {
+                                fullText += text;
+                                for (const cb of tokenCallbacks)
+                                    cb(text);
+                            }
+                        }
+                        catch {
+                            // Non-JSON data line, treat as raw text
+                            if (data) {
+                                fullText += data;
+                                for (const cb of tokenCallbacks)
+                                    cb(data);
+                            }
+                        }
+                    }
+                }
+            }
+            for (const cb of doneCallbacks)
+                cb(fullText);
+        }
+        catch (err) {
+            if (err?.name === 'AbortError')
+                return;
+            for (const cb of errorCallbacks)
+                cb(err instanceof Error ? err : new Error(String(err)));
+        }
+    };
+    // Start the async flow
+    run();
+    return {
+        get sessionId() { return sessionId; },
+        onToken: (cb) => { tokenCallbacks.push(cb); },
+        onDone: (cb) => { doneCallbacks.push(cb); },
+        onError: (cb) => { errorCallbacks.push(cb); },
+        abort: () => controller.abort(),
+    };
+}
+/**
+ * Check if OpenCode server is reachable.
+ */
+export async function checkAiStatus() {
+    try {
+        const res = await fetch(`${OPENCODE_URL}/api/status`, {
+            headers: buildHeaders(),
+            signal: AbortSignal.timeout(3000),
+        });
+        return { configured: res.ok, backend: 'opencode' };
+    }
+    catch {
+        return { configured: false, backend: 'opencode' };
+    }
+}