lunel-cli 0.1.43 → 0.1.45

package/dist/ai/codex.d.ts

@@ -0,0 +1,46 @@
+import type { AIProvider, AiEventEmitter, ModelSelector, MessageInfo, ProviderInfo, SessionInfo, ShareInfo } from "./interface.js";
+export declare class CodexProvider implements AIProvider {
+    private proc;
+    private shuttingDown;
+    private emitter;
+    private nextId;
+    private pending;
+    private sessions;
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    subscribe(emitter: AiEventEmitter): () => void;
+    createSession(title?: string): Promise<{
+        session: SessionInfo;
+    }>;
+    listSessions(): Promise<{
+        sessions: unknown;
+    }>;
+    getSession(id: string): Promise<{
+        session: SessionInfo;
+    }>;
+    deleteSession(id: string): Promise<Record<string, never>>;
+    getMessages(sessionId: string): Promise<{
+        messages: MessageInfo[];
+    }>;
+    prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string): Promise<{
+        ack: true;
+    }>;
+    abort(sessionId: string): Promise<Record<string, never>>;
+    agents(): Promise<{
+        agents: unknown;
+    }>;
+    providers(): Promise<ProviderInfo>;
+    setAuth(providerId: string, key: string): Promise<Record<string, never>>;
+    command(sessionId: string, command: string, args: string): Promise<{
+        result: unknown;
+    }>;
+    revert(sessionId: string, messageId: string): Promise<Record<string, never>>;
+    unrevert(sessionId: string): Promise<Record<string, never>>;
+    share(sessionId: string): Promise<{
+        share: ShareInfo;
+    }>;
+    permissionReply(sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+    private send;
+    private call;
+    private handleLine;
+}

package/dist/ai/codex.js

@@ -0,0 +1,271 @@
+// Codex AI provider — spawns `codex app-server` and speaks JSON-RPC 2.0
+// over stdin/stdout. Maps Codex's thread/turn model to the same AIProvider
+// interface as OpenCode so the rest of the CLI stays unchanged.
+import * as crypto from "crypto";
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+// ---------------------------------------------------------------------------
+// Codex notification method → mobile app event type mapping.
+// Update this map as the Codex app-server protocol evolves.
+// ---------------------------------------------------------------------------
+const NOTIFICATION_TYPE_MAP = {
+    "turn/delta": "message.part.updated",
+    "turn/complete": "message.completed",
+    "turn/error": "message.error",
+    "tool/call": "tool.invoked",
+    "tool/result": "tool.result",
+    "session/permission": "session.permission.needed",
+    "thread/status/changed": "session.status.changed",
+    "thread/tokenUsage/updated": "session.token_usage.updated",
+};
+// ---------------------------------------------------------------------------
+// Provider implementation
+// ---------------------------------------------------------------------------
+export class CodexProvider {
+    proc = null;
+    shuttingDown = false;
+    emitter = null;
+    nextId = 1;
+    pending = new Map();
+    sessions = new Map();
+    // -------------------------------------------------------------------------
+    // Lifecycle
+    // -------------------------------------------------------------------------
+    async init() {
+        console.log("Starting Codex app-server...");
+        this.proc = spawn("codex", ["app-server"], {
+            stdio: ["pipe", "pipe", "inherit"],
+            env: process.env,
+        });
+        const rl = createInterface({ input: this.proc.stdout });
+        rl.on("line", (line) => this.handleLine(line));
+        this.proc.on("error", (err) => {
+            console.error("[codex] Failed to start codex process:", err.message);
+            this.emitter?.({ type: "sse_dead", properties: { error: err.message } });
+        });
+        this.proc.on("exit", (code) => {
+            if (!this.shuttingDown) {
+                const msg = `codex app-server exited with code ${code}`;
+                console.error(`[codex] ${msg}`);
+                this.emitter?.({ type: "sse_dead", properties: { error: msg } });
+            }
+        });
+        // Handshake: initialize the JSON-RPC session.
+        await this.call("initialize", { clientInfo: { name: "lunel", version: "1.0" } });
+        console.log("Codex ready.\n");
+    }
+    async destroy() {
+        this.shuttingDown = true;
+        this.proc?.stdin?.end();
+        this.proc?.kill();
+        this.proc = null;
+    }
+    subscribe(emitter) {
+        this.emitter = emitter;
+        return () => {
+            this.emitter = null;
+        };
+    }
+    // Codex doesn't need session reconnect validation, so setActiveSession is omitted.
+    // -------------------------------------------------------------------------
+    // Session management (emulated locally — Codex has no persistent store)
+    // -------------------------------------------------------------------------
+    async createSession(title) {
+        const id = crypto.randomUUID();
+        const session = { id, title, messages: [], createdAt: Date.now() };
+        this.sessions.set(id, session);
+        // Start a new Codex thread for this session.
+        try {
+            const result = await this.call("thread/start", { title });
+            if (result?.threadId) {
+                session.threadId = result.threadId;
+            }
+        }
+        catch (err) {
+            console.warn("[codex] thread/start failed:", err.message);
+        }
+        return { session: { id, title: title ?? "", created: session.createdAt } };
+    }
+    async listSessions() {
+        return {
+            sessions: Array.from(this.sessions.values()).map((s) => ({
+                id: s.id,
+                title: s.title ?? "",
+                created: s.createdAt,
+            })),
+        };
+    }
+    async getSession(id) {
+        const s = this.sessions.get(id);
+        if (!s)
+            throw Object.assign(new Error(`Session ${id} not found`), { code: "ENOENT" });
+        return { session: { id: s.id, title: s.title ?? "", created: s.createdAt } };
+    }
+    async deleteSession(id) {
+        this.sessions.delete(id);
+        return {};
+    }
+    // -------------------------------------------------------------------------
+    // Messages
+    // -------------------------------------------------------------------------
+    async getMessages(sessionId) {
+        const s = this.sessions.get(sessionId);
+        return { messages: s?.messages ?? [] };
+    }
+    // -------------------------------------------------------------------------
+    // Interaction
+    // -------------------------------------------------------------------------
+    async prompt(sessionId, text, model, agent) {
+        const session = this.sessions.get(sessionId);
+        const threadId = session?.threadId;
+        // Append the user message to local history immediately.
+        if (session) {
+            session.messages.push({
+                id: crypto.randomUUID(),
+                role: "user",
+                parts: [{ type: "text", text }],
+                time: Date.now(),
+            });
+        }
+        // Fire-and-forget — the response streams back as JSON-RPC notifications.
+        this.call("turn/start", {
+            ...(threadId ? { threadId } : { sessionId }),
+            message: { role: "user", content: text },
+            ...(model ? { model: `${model.providerID}/${model.modelID}` } : {}),
+            ...(agent ? { agent } : {}),
+        }).catch((err) => {
+            console.error("[codex] turn/start error:", err.message);
+            this.emitter?.({ type: "prompt_error", properties: { sessionId, error: err.message } });
+        });
+        return { ack: true };
+    }
+    async abort(sessionId) {
+        const session = this.sessions.get(sessionId);
+        await this.call("turn/abort", { ...(session?.threadId ? { threadId: session.threadId } : { sessionId }) });
+        return {};
+    }
+    // -------------------------------------------------------------------------
+    // Metadata
+    // -------------------------------------------------------------------------
+    async agents() {
+        try {
+            const result = await this.call("agent/list", {});
+            return { agents: result ?? [] };
+        }
+        catch {
+            // Codex may not support agents — return empty list gracefully.
+            return { agents: [] };
+        }
+    }
+    async providers() {
+        try {
+            const result = await this.call("provider/list", {});
+            return {
+                providers: result?.providers ?? [],
+                default: result?.default ?? {},
+            };
+        }
+        catch {
+            return { providers: [], default: {} };
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Auth
+    // -------------------------------------------------------------------------
+    async setAuth(providerId, key) {
+        await this.call("auth/set", { providerId, key });
+        return {};
+    }
+    // -------------------------------------------------------------------------
+    // Session operations
+    // -------------------------------------------------------------------------
+    async command(sessionId, command, args) {
+        const session = this.sessions.get(sessionId);
+        const result = await this.call("session/command", {
+            ...(session?.threadId ? { threadId: session.threadId } : { sessionId }),
+            command,
+            arguments: args,
+        });
+        return { result: result ?? null };
+    }
+    async revert(sessionId, messageId) {
+        const session = this.sessions.get(sessionId);
+        await this.call("session/revert", {
+            ...(session?.threadId ? { threadId: session.threadId } : { sessionId }),
+            messageId,
+        });
+        return {};
+    }
+    async unrevert(sessionId) {
+        const session = this.sessions.get(sessionId);
+        await this.call("session/unrevert", {
+            ...(session?.threadId ? { threadId: session.threadId } : { sessionId }),
+        });
+        return {};
+    }
+    async share(sessionId) {
+        // Codex has no share concept — return a null stub so the app degrades gracefully.
+        return { share: { url: null } };
+    }
+    async permissionReply(sessionId, permissionId, response) {
+        const session = this.sessions.get(sessionId);
+        await this.call("session/permission", {
+            ...(session?.threadId ? { threadId: session.threadId } : { sessionId }),
+            permissionId,
+            response,
+        });
+        return {};
+    }
+    // -------------------------------------------------------------------------
+    // JSON-RPC internals
+    // -------------------------------------------------------------------------
+    send(req) {
+        if (!this.proc?.stdin?.writable)
+            return;
+        this.proc.stdin.write(JSON.stringify(req) + "\n");
+    }
+    call(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = this.nextId++;
+            this.pending.set(id, { resolve, reject });
+            this.send({ jsonrpc: "2.0", id, method, params });
+            // Safety timeout: if Codex never responds, don't hang the caller forever.
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`Codex RPC timeout: ${method} (id=${id})`));
+                }
+            }, 30_000);
+        });
+    }
+    handleLine(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return; // ignore non-JSON lines (e.g. startup banners)
+        }
+        // JSON-RPC response (has numeric id + result or error)
+        if ("id" in msg && typeof msg.id === "number") {
+            const resp = msg;
+            const pending = this.pending.get(resp.id);
+            if (pending) {
+                this.pending.delete(resp.id);
+                if (resp.error) {
+                    pending.reject(new Error(resp.error.message));
+                }
+                else {
+                    pending.resolve(resp.result ?? null);
+                }
+            }
+            return;
+        }
+        // JSON-RPC notification (no id — async event from Codex)
+        const notif = msg;
+        const params = (notif.params ?? {});
+        const mappedType = NOTIFICATION_TYPE_MAP[notif.method] ?? notif.method;
+        console.log("[codex]", notif.method);
+        this.emitter?.({ type: mappedType, properties: params });
+    }
+}

package/dist/ai/index.d.ts

@@ -0,0 +1,47 @@
+import type { AiEvent, ModelSelector } from "./interface.js";
+export type AiBackend = "opencode" | "codex";
+export declare class AiManager {
+    private _providers;
+    private _available;
+    init(): Promise<void>;
+    private tryInit;
+    availableBackends(): AiBackend[];
+    private get;
+    subscribe(emitter: (backend: AiBackend, event: AiEvent) => void): () => void;
+    destroy(): Promise<void>;
+    listAllSessions(): Promise<{
+        sessions: Array<Record<string, unknown> & {
+            backend: AiBackend;
+        }>;
+    }>;
+    createSession(backend: AiBackend, title?: string): Promise<{
+        session: import("./interface.js").SessionInfo;
+    }>;
+    getSession(backend: AiBackend, id: string): Promise<{
+        session: import("./interface.js").SessionInfo;
+    }>;
+    deleteSession(backend: AiBackend, id: string): Promise<Record<string, never>>;
+    getMessages(backend: AiBackend, sessionId: string): Promise<{
+        messages: import("./interface.js").MessageInfo[];
+    }>;
+    prompt(backend: AiBackend, sessionId: string, text: string, model?: ModelSelector, agent?: string): Promise<{
+        ack: true;
+    }>;
+    abort(backend: AiBackend, sessionId: string): Promise<Record<string, never>>;
+    agents(backend?: AiBackend): Promise<{
+        agents: unknown;
+    }>;
+    providers(backend?: AiBackend): Promise<import("./interface.js").ProviderInfo>;
+    setAuth(backend: AiBackend, providerId: string, key: string): Promise<Record<string, never>>;
+    command(backend: AiBackend, sessionId: string, command: string, args: string): Promise<{
+        result: unknown;
+    }>;
+    revert(backend: AiBackend, sessionId: string, messageId: string): Promise<Record<string, never>>;
+    unrevert(backend: AiBackend, sessionId: string): Promise<Record<string, never>>;
+    share(backend: AiBackend, sessionId: string): Promise<{
+        share: import("./interface.js").ShareInfo;
+    }>;
+    permissionReply(backend: AiBackend, sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+}
+export declare function createAiManager(): Promise<AiManager>;
+export type { AIProvider, AiEventEmitter, AiEvent, ModelSelector } from "./interface.js";

package/dist/ai/index.js

@@ -0,0 +1,92 @@
+// AI manager — runs both OpenCode and Codex simultaneously and routes calls
+// by the `backend` field in each request. Backends that fail to init are
+// skipped gracefully; the available list is exposed to the app.
+export class AiManager {
+    _providers = {};
+    _available = [];
+    async init() {
+        await Promise.allSettled([
+            this.tryInit("opencode"),
+            this.tryInit("codex"),
+        ]);
+        if (this._available.length === 0) {
+            throw new Error("No AI backend could be started. Ensure opencode or codex is installed.");
+        }
+        console.log(`[ai] Available backends: ${this._available.join(", ")}`);
+    }
+    async tryInit(backend) {
+        try {
+            if (backend === "opencode") {
+                const { OpenCodeProvider } = await import("./opencode.js");
+                const p = new OpenCodeProvider();
+                await p.init();
+                this._providers.opencode = p;
+            }
+            else {
+                const { CodexProvider } = await import("./codex.js");
+                const p = new CodexProvider();
+                await p.init();
+                this._providers.codex = p;
+            }
+            this._available.push(backend);
+        }
+        catch (err) {
+            console.warn(`[ai] ${backend} backend unavailable: ${err.message}`);
+        }
+    }
+    availableBackends() {
+        return [...this._available];
+    }
+    get(backend) {
+        const p = this._providers[backend];
+        if (!p) {
+            throw Object.assign(new Error(`Backend "${backend}" is not available`), { code: "EUNAVAILABLE" });
+        }
+        return p;
+    }
+    // Wire each provider's events to the emitter, tagged with backend name.
+    subscribe(emitter) {
+        const cleanups = this._available.map((backend) => this._providers[backend].subscribe((event) => emitter(backend, event)));
+        return () => cleanups.forEach((c) => c());
+    }
+    async destroy() {
+        await Promise.allSettled(this._available.map((b) => this._providers[b].destroy()));
+    }
+    // List sessions from all available backends, each tagged with its backend.
+    async listAllSessions() {
+        const results = await Promise.allSettled(this._available.map(async (backend) => {
+            const res = await this._providers[backend].listSessions();
+            const sessions = res.sessions ?? [];
+            return sessions.map((s) => ({ ...s, backend }));
+        }));
+        const sessions = results.flatMap((r) => (r.status === "fulfilled" ? r.value : []));
+        return { sessions };
+    }
+    // Session management — all require explicit backend
+    createSession(backend, title) { return this.get(backend).createSession(title); }
+    getSession(backend, id) { return this.get(backend).getSession(id); }
+    deleteSession(backend, id) { return this.get(backend).deleteSession(id); }
+    getMessages(backend, sessionId) { return this.get(backend).getMessages(sessionId); }
+    prompt(backend, sessionId, text, model, agent) {
+        this.get(backend).setActiveSession?.(sessionId);
+        return this.get(backend).prompt(sessionId, text, model, agent);
+    }
+    abort(backend, sessionId) { return this.get(backend).abort(sessionId); }
+    // Metadata — backend is optional, falls back to first available
+    agents(backend) { return this.get(backend ?? this._available[0]).agents(); }
+    providers(backend) { return this.get(backend ?? this._available[0]).providers(); }
+    setAuth(backend, providerId, key) { return this.get(backend).setAuth(providerId, key); }
+    // Session operations
+    command(backend, sessionId, command, args) { return this.get(backend).command(sessionId, command, args); }
+    revert(backend, sessionId, messageId) { return this.get(backend).revert(sessionId, messageId); }
+    unrevert(backend, sessionId) { return this.get(backend).unrevert(sessionId); }
+    share(backend, sessionId) { return this.get(backend).share(sessionId); }
+    permissionReply(backend, sessionId, permissionId, response) {
+        return this.get(backend).permissionReply(sessionId, permissionId, response);
+    }
+}
+export async function createAiManager() {
+    const manager = new AiManager();
+    await manager.init();
+    return manager;
+}

package/dist/ai/interface.d.ts

@@ -0,0 +1,72 @@
+export interface AiEvent {
+    type: string;
+    properties: Record<string, unknown>;
+}
+export type AiEventEmitter = (event: AiEvent) => void;
+export interface ModelSelector {
+    providerID: string;
+    modelID: string;
+}
+export interface MessageInfo {
+    id: string;
+    role: string;
+    parts: unknown[];
+    time: unknown;
+}
+export interface SessionInfo {
+    [key: string]: unknown;
+}
+export interface ShareInfo {
+    [key: string]: unknown;
+}
+export interface ProviderInfo {
+    providers: unknown[];
+    default: Record<string, string>;
+    [key: string]: unknown;
+}
+/**
+ * Every AI backend (OpenCode, Codex, …) implements this interface.
+ * Method names map 1-to-1 with the "ai" namespace actions in index.ts.
+ */
+export interface AIProvider {
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    /**
+     * Register an event emitter. The provider calls it for every async event
+     * (SSE events, streaming tokens, errors, etc.).
+     * Returns a cleanup/unsubscribe function.
+     */
+    subscribe(emitter: AiEventEmitter): () => void;
+    setActiveSession?(sessionId: string): void;
+    createSession(title?: string): Promise<{
+        session: SessionInfo;
+    }>;
+    listSessions(): Promise<{
+        sessions: unknown;
+    }>;
+    getSession(id: string): Promise<{
+        session: SessionInfo;
+    }>;
+    deleteSession(id: string): Promise<Record<string, never>>;
+    getMessages(sessionId: string): Promise<{
+        messages: MessageInfo[];
+    }>;
+    prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string): Promise<{
+        ack: true;
+    }>;
+    abort(sessionId: string): Promise<Record<string, never>>;
+    agents(): Promise<{
+        agents: unknown;
+    }>;
+    providers(): Promise<ProviderInfo>;
+    setAuth(providerId: string, key: string): Promise<Record<string, never>>;
+    command(sessionId: string, command: string, args: string): Promise<{
+        result: unknown;
+    }>;
+    revert(sessionId: string, messageId: string): Promise<Record<string, never>>;
+    unrevert(sessionId: string): Promise<Record<string, never>>;
+    share(sessionId: string): Promise<{
+        share: ShareInfo;
+    }>;
+    permissionReply(sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+}

package/dist/ai/interface.js

@@ -0,0 +1,3 @@
+// Shared types for AI provider abstraction.
+// No runtime imports — pure TypeScript types only.
+export {};

package/dist/ai/opencode.d.ts

@@ -0,0 +1,44 @@
+import type { AIProvider, AiEventEmitter, ModelSelector, MessageInfo, ProviderInfo, SessionInfo, ShareInfo } from "./interface.js";
+export declare class OpenCodeProvider implements AIProvider {
+    private client;
+    private server;
+    private lastActiveSessionId;
+    private shuttingDown;
+    private emitter;
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    subscribe(emitter: AiEventEmitter): () => void;
+    setActiveSession(sessionId: string): void;
+    createSession(title?: string): Promise<{
+        session: SessionInfo;
+    }>;
+    listSessions(): Promise<{
+        sessions: unknown;
+    }>;
+    getSession(id: string): Promise<{
+        session: SessionInfo;
+    }>;
+    deleteSession(id: string): Promise<Record<string, never>>;
+    getMessages(sessionId: string): Promise<{
+        messages: MessageInfo[];
+    }>;
+    prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string): Promise<{
+        ack: true;
+    }>;
+    abort(sessionId: string): Promise<Record<string, never>>;
+    agents(): Promise<{
+        agents: unknown;
+    }>;
+    providers(): Promise<ProviderInfo>;
+    setAuth(providerId: string, key: string): Promise<Record<string, never>>;
+    command(sessionId: string, command: string, args: string): Promise<{
+        result: unknown;
+    }>;
+    revert(sessionId: string, messageId: string): Promise<Record<string, never>>;
+    unrevert(sessionId: string): Promise<Record<string, never>>;
+    share(sessionId: string): Promise<{
+        share: ShareInfo;
+    }>;
+    permissionReply(sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+    private runSseLoop;
+}