@imricci/zaker 0.1.2 → 0.1.3

package/dist/commands/app-server.d.ts

@@ -0,0 +1,67 @@
+import { Command } from "commander";
+import { ConversationRuntime } from "../infra/dialog-session";
+import { ModelProviderId } from "../infra/provider-registry";
+import { loginOpenAICodexOAuth } from "../infra/openai-codex-oauth";
+import { TaskBoardState } from "./dialog-handlers";
+export declare const APP_SERVER_PROTOCOL_VERSION = "zaker.app/1";
+export declare const APP_SERVER_METHODS: readonly ["initialize", "ping", "session.get", "command.execute", "menu.context", "oauth.start", "oauth.cancel", "shutdown"];
+export declare const APP_SERVER_EVENTS: readonly ["session.update", "run.stage", "audit.result", "oauth.status"];
+type JsonRpcId = string | number | null;
+type AppServerEventName = (typeof APP_SERVER_EVENTS)[number];
+interface JsonRpcRequest {
+    jsonrpc?: string;
+    id?: JsonRpcId;
+    method?: string;
+    params?: unknown;
+}
+interface JsonRpcResult {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result: unknown;
+}
+interface JsonRpcErrorResult {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface AppServerEvent {
+    event: AppServerEventName;
+    timestamp: string;
+    payload: Record<string, unknown>;
+}
+type OAuthLoginAdapter = typeof loginOpenAICodexOAuth;
+interface PendingOAuthRequest {
+    request_id: string;
+    provider: ModelProviderId;
+    started_at: string;
+    controller: AbortController;
+}
+export interface AppServerState {
+    cwd: string;
+    defaultSopOut: string;
+    defaultCheckpointOut: string;
+    protocolInitialized: boolean;
+    terminated: boolean;
+    board: TaskBoardState;
+    conversations: ConversationRuntime;
+    oauthRequestSeq: number;
+    pendingOAuthRequests: Map<string, PendingOAuthRequest>;
+    oauthLogin: OAuthLoginAdapter;
+}
+export declare function createAppServerState(cwd?: string, options?: {
+    sopOut?: string;
+    checkpointOut?: string;
+    oauthLogin?: OAuthLoginAdapter;
+}): Promise<AppServerState>;
+export declare function handleAppServerRequest(state: AppServerState, request: JsonRpcRequest, emitEvent: (event: AppServerEvent) => Promise<void>): Promise<JsonRpcResult | JsonRpcErrorResult | undefined>;
+export declare function runAppServer(cwd?: string, options?: {
+    sopOut?: string;
+    checkpointOut?: string;
+    oauthLogin?: OAuthLoginAdapter;
+}): Promise<void>;
+export declare function registerAppServerCommand(program: Command): void;
+export {};

package/dist/commands/app-server.js

@@ -0,0 +1,601 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APP_SERVER_EVENTS = exports.APP_SERVER_METHODS = exports.APP_SERVER_PROTOCOL_VERSION = void 0;
+exports.createAppServerState = createAppServerState;
+exports.handleAppServerRequest = handleAppServerRequest;
+exports.runAppServer = runAppServer;
+exports.registerAppServerCommand = registerAppServerCommand;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_readline_1 = __importDefault(require("node:readline"));
+const dialog_session_1 = require("../infra/dialog-session");
+const intent_1 = require("../infra/intent");
+const model_accounts_1 = require("../infra/model-accounts");
+const provider_registry_1 = require("../infra/provider-registry");
+const session_status_1 = require("../infra/session-status");
+const openai_codex_oauth_1 = require("../infra/openai-codex-oauth");
+const config_1 = require("../infra/config");
+const dialog_1 = require("./dialog");
+exports.APP_SERVER_PROTOCOL_VERSION = "zaker.app/1";
+exports.APP_SERVER_METHODS = [
+    "initialize",
+    "ping",
+    "session.get",
+    "command.execute",
+    "menu.context",
+    "oauth.start",
+    "oauth.cancel",
+    "shutdown"
+];
+exports.APP_SERVER_EVENTS = [
+    "session.update",
+    "run.stage",
+    "audit.result",
+    "oauth.status"
+];
+function now() {
+    return new Date().toISOString();
+}
+function resolveServerVersion() {
+    try {
+        const packagePath = (0, node_path_1.resolve)(__dirname, "..", "..", "package.json");
+        const raw = (0, node_fs_1.readFileSync)(packagePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === "string" && parsed.version.trim()
+            ? parsed.version.trim()
+            : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneBoard(board) {
+    return { ...board };
+}
+async function buildSessionSnapshot(state) {
+    const session = await (0, intent_1.readSessionStore)(state.cwd);
+    const draft = await (0, intent_1.readIntentCard)(state.cwd);
+    const confirmed = await (0, intent_1.readConfirmedIntent)(state.cwd);
+    const statusLines = session
+        ? (0, session_status_1.formatSessionStatusLines)(session, draft, confirmed, {
+            includeDialog: true,
+            recentRoundLimit: 5
+        })
+        : ["session_state: UNINITIALIZED"];
+    const history = session?.dialog?.history
+        ? session.dialog.history.slice(-80).map((entry) => ({
+            turn: entry.turn,
+            timestamp: entry.timestamp,
+            role: entry.role,
+            kind: entry.kind,
+            content: entry.content
+        }))
+        : [];
+    return {
+        session_state: session?.state ?? "UNINITIALIZED",
+        active_conversation_id: state.conversations.index.active_id || null,
+        draft_intent_id: draft?.intent_id ?? null,
+        confirmed_intent_id: confirmed?.intent_id ?? null,
+        current_intent_id: session?.current_intent_id ?? null,
+        board: cloneBoard(state.board),
+        status_lines: statusLines,
+        history
+    };
+}
+async function buildMenuContext(state) {
+    const config = await (0, config_1.readConfig)(state.cwd);
+    const modelMenu = (0, model_accounts_1.buildModelMenuSnapshot)(config);
+    const sessionIds = await (0, dialog_session_1.listConversationIds)(state.conversations.index, state.cwd);
+    const providerIds = (0, provider_registry_1.getModelProviderIds)().filter((providerId) => providerId !== "mock");
+    return {
+        sessions: {
+            active_id: state.conversations.index.active_id || null,
+            ids: sessionIds
+        },
+        model_menu: modelMenu,
+        login: {
+            providers: providerIds.map((id) => ({
+                id,
+                supports_oauth: (0, provider_registry_1.providerSupportsOAuth)(id)
+            }))
+        },
+        logout: {
+            targets: [...providerIds, "ollama", "all"]
+        },
+        oauth: {
+            pending: [...state.pendingOAuthRequests.values()].map((request) => ({
+                request_id: request.request_id,
+                provider: request.provider,
+                started_at: request.started_at
+            }))
+        },
+        current_model: {
+            provider: config.model.provider,
+            planner_model: config.model.planner_model,
+            auditor_model: config.model.auditor_model,
+            execution_model: config.execution.model
+        }
+    };
+}
+function toError(id, code, message, data) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+            code,
+            message,
+            data
+        }
+    };
+}
+function toResult(id, result) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        result
+    };
+}
+function parseExecuteParams(params, fallbackSopOut, fallbackCheckpointOut) {
+    if (!isRecord(params)) {
+        return null;
+    }
+    const input = typeof params.input === "string" ? params.input : "";
+    const sopOut = typeof params.sop_out === "string" && params.sop_out.trim()
+        ? params.sop_out.trim()
+        : fallbackSopOut;
+    const checkpointOut = typeof params.checkpoint_out === "string" && params.checkpoint_out.trim()
+        ? params.checkpoint_out.trim()
+        : fallbackCheckpointOut;
+    if (!input.trim()) {
+        return null;
+    }
+    return {
+        input,
+        sopOut,
+        checkpointOut
+    };
+}
+function parseOAuthStartParams(params) {
+    if (!isRecord(params)) {
+        return null;
+    }
+    const provider = typeof params.provider === "string" ? params.provider.trim() : "";
+    if (!provider) {
+        return null;
+    }
+    return { provider };
+}
+function parseOAuthCancelParams(params) {
+    if (!isRecord(params)) {
+        return {};
+    }
+    const requestId = typeof params.request_id === "string" ? params.request_id.trim() : "";
+    if (!requestId) {
+        return {};
+    }
+    return { requestId };
+}
+function parseOAuthCommandShortcut(input) {
+    const tokens = input.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length === 3 && tokens[0] === "/login" && tokens[2].toLowerCase() === "oauth") {
+        return { provider: tokens[1] || "" };
+    }
+    return null;
+}
+async function emitSessionUpdate(state, emitEvent, snapshot) {
+    await emitEvent({
+        event: "session.update",
+        timestamp: now(),
+        payload: {
+            session_state: snapshot.session_state,
+            active_conversation_id: snapshot.active_conversation_id,
+            current_intent_id: snapshot.current_intent_id
+        }
+    });
+}
+async function emitOAuthStatus(emitEvent, payload) {
+    await emitEvent({
+        event: "oauth.status",
+        timestamp: now(),
+        payload
+    });
+}
+function nextOAuthRequestId(state) {
+    state.oauthRequestSeq += 1;
+    return `oauth_${Date.now()}_${state.oauthRequestSeq}`;
+}
+async function performOAuthStart(state, providerInput, emitEvent) {
+    let provider;
+    try {
+        provider = (0, provider_registry_1.toLoginProviderId)(providerInput);
+    }
+    catch {
+        throw new Error(`Unsupported provider: ${providerInput}`);
+    }
+    if (!(0, provider_registry_1.providerSupportsOAuth)(provider)) {
+        throw new Error(`Provider \"${provider}\" does not support oauth login.`);
+    }
+    if (provider !== "openai-codex") {
+        throw new Error(`UNSUPPORTED_OAUTH_PROVIDER: ${provider}`);
+    }
+    const requestId = nextOAuthRequestId(state);
+    const controller = new AbortController();
+    const requestState = {
+        request_id: requestId,
+        provider,
+        started_at: now(),
+        controller
+    };
+    state.pendingOAuthRequests.set(requestId, requestState);
+    await emitOAuthStatus(emitEvent, {
+        request_id: requestId,
+        provider,
+        phase: "started",
+        status: "OAuth started"
+    });
+    void (async () => {
+        try {
+            const config = await (0, config_1.readConfig)(state.cwd);
+            const endpoint = config.model.endpoint?.trim() || "";
+            const oauth = await state.oauthLogin({
+                onAuth: async ({ url, instructions }) => {
+                    await emitOAuthStatus(emitEvent, {
+                        request_id: requestId,
+                        provider,
+                        phase: "authorize",
+                        status: instructions,
+                        url
+                    });
+                },
+                onProgress: async (message) => {
+                    await emitOAuthStatus(emitEvent, {
+                        request_id: requestId,
+                        provider,
+                        phase: "progress",
+                        status: message
+                    });
+                },
+                onPrompt: async () => "",
+                open_browser: true,
+                originator: "pi",
+                abort_signal: controller.signal
+            });
+            const loginLine = `/login ${provider} oauth ${oauth.access_token}${endpoint ? ` ${endpoint}` : ""}`;
+            await (0, dialog_1.handleDialogInput)(loginLine, state.cwd, {
+                sopOut: state.defaultSopOut,
+                checkpointOut: state.defaultCheckpointOut,
+                interactive: true,
+                quiet: true,
+                board: state.board,
+                conversations: state.conversations,
+                redraw: async (nextNotice) => {
+                    await emitEvent({
+                        event: "run.stage",
+                        timestamp: now(),
+                        payload: {
+                            notice: nextNotice ?? "",
+                            run_stage: state.board.run_stage,
+                            run_status: state.board.run_status,
+                            verification_status: state.board.verification_status,
+                            verification_passed: state.board.verification_passed,
+                            verification_total: state.board.verification_total,
+                            risk_hit: state.board.risk_hit,
+                            audit_verdict: state.board.audit_verdict,
+                            budget_plan_calls: state.board.budget_plan_calls,
+                            budget_audit_calls: state.board.budget_audit_calls,
+                            budget_challenge_used: state.board.budget_challenge_used
+                        }
+                    });
+                }
+            });
+            const snapshot = await buildSessionSnapshot(state);
+            await emitSessionUpdate(state, emitEvent, snapshot);
+            await emitOAuthStatus(emitEvent, {
+                request_id: requestId,
+                provider,
+                phase: "success",
+                status: "OAuth login completed"
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const phase = /cancel/i.test(message) || controller.signal.aborted ? "cancelled" : "failed";
+            await emitOAuthStatus(emitEvent, {
+                request_id: requestId,
+                provider,
+                phase,
+                status: message
+            });
+        }
+        finally {
+            state.pendingOAuthRequests.delete(requestId);
+        }
+    })();
+    return {
+        request_id: requestId,
+        status: "started"
+    };
+}
+async function performOAuthCancel(state, params, emitEvent) {
+    const parsed = parseOAuthCancelParams(params);
+    const requestId = parsed.requestId || [...state.pendingOAuthRequests.keys()].at(-1) || "";
+    if (!requestId) {
+        throw new Error("No pending OAuth request.");
+    }
+    const pending = state.pendingOAuthRequests.get(requestId);
+    if (!pending) {
+        const error = new Error("OAuth request not found.");
+        error.code = -32004;
+        throw error;
+    }
+    pending.controller.abort();
+    await emitOAuthStatus(emitEvent, {
+        request_id: requestId,
+        provider: pending.provider,
+        phase: "cancel_requested",
+        status: "OAuth cancellation requested"
+    });
+    return {
+        ok: true,
+        cancelled_request_id: requestId
+    };
+}
+async function executeDialogCommand(state, params, emitEvent) {
+    const parsed = parseExecuteParams(params, state.defaultSopOut, state.defaultCheckpointOut);
+    if (!parsed) {
+        throw new Error("Invalid params: input must be non-empty string.");
+    }
+    const trimmedInput = parsed.input.trim();
+    const oauthShortcut = parseOAuthCommandShortcut(trimmedInput);
+    if (oauthShortcut) {
+        const started = await performOAuthStart(state, oauthShortcut.provider, emitEvent);
+        const snapshot = await buildSessionSnapshot(state);
+        await emitSessionUpdate(state, emitEvent, snapshot);
+        return {
+            action: "continue",
+            notice: `oauth started: ${started.request_id}`,
+            snapshot
+        };
+    }
+    const result = await (0, dialog_1.handleDialogInput)(parsed.input, state.cwd, {
+        sopOut: parsed.sopOut,
+        checkpointOut: parsed.checkpointOut,
+        interactive: true,
+        quiet: true,
+        board: state.board,
+        conversations: state.conversations,
+        redraw: async (nextNotice) => {
+            await emitEvent({
+                event: "run.stage",
+                timestamp: now(),
+                payload: {
+                    notice: nextNotice ?? "",
+                    run_stage: state.board.run_stage,
+                    run_status: state.board.run_status,
+                    verification_status: state.board.verification_status,
+                    verification_passed: state.board.verification_passed,
+                    verification_total: state.board.verification_total,
+                    risk_hit: state.board.risk_hit,
+                    audit_verdict: state.board.audit_verdict,
+                    budget_plan_calls: state.board.budget_plan_calls,
+                    budget_audit_calls: state.board.budget_audit_calls,
+                    budget_challenge_used: state.board.budget_challenge_used
+                }
+            });
+            if (/oauth/i.test(nextNotice ?? "")) {
+                await emitOAuthStatus(emitEvent, {
+                    phase: "progress",
+                    status: nextNotice ?? ""
+                });
+            }
+        }
+    });
+    if (result.action === "exit") {
+        state.terminated = true;
+    }
+    const snapshot = await buildSessionSnapshot(state);
+    await emitSessionUpdate(state, emitEvent, snapshot);
+    if (trimmedInput.startsWith("/run")) {
+        await emitEvent({
+            event: "audit.result",
+            timestamp: now(),
+            payload: {
+                verdict: state.board.audit_verdict,
+                reason: state.board.audit_reason,
+                conclusion: state.board.audit_conclusion,
+                retry_allowed: state.board.retry_allowed
+            }
+        });
+    }
+    return {
+        action: result.action,
+        notice: result.notice,
+        snapshot
+    };
+}
+async function createAppServerState(cwd = process.cwd(), options = {}) {
+    return {
+        cwd,
+        defaultSopOut: options.sopOut ?? "sop.json",
+        defaultCheckpointOut: options.checkpointOut ?? "checkpoint.json",
+        protocolInitialized: false,
+        terminated: false,
+        board: (0, dialog_1.createTaskBoardState)(),
+        conversations: {
+            index: await (0, dialog_session_1.readConversationIndex)(cwd)
+        },
+        oauthRequestSeq: 0,
+        pendingOAuthRequests: new Map(),
+        oauthLogin: options.oauthLogin ?? openai_codex_oauth_1.loginOpenAICodexOAuth
+    };
+}
+async function handleAppServerRequest(state, request, emitEvent) {
+    const id = request.id ?? null;
+    if (request.jsonrpc !== "2.0" || typeof request.method !== "string") {
+        if (request.id === undefined) {
+            return undefined;
+        }
+        return toError(id, -32600, "INVALID_REQUEST");
+    }
+    const method = request.method;
+    const needsInitialized = method === "session.get" ||
+        method === "command.execute" ||
+        method === "menu.context" ||
+        method === "oauth.start" ||
+        method === "oauth.cancel" ||
+        method === "shutdown";
+    if (needsInitialized && !state.protocolInitialized) {
+        return toError(id, -32002, "NOT_INITIALIZED");
+    }
+    try {
+        if (method === "initialize") {
+            const params = isRecord(request.params) ? request.params : {};
+            const protocolVersion = typeof params.protocol_version === "string"
+                ? params.protocol_version.trim()
+                : "";
+            if (protocolVersion && protocolVersion !== exports.APP_SERVER_PROTOCOL_VERSION) {
+                return toError(id, -32001, "PROTOCOL_VERSION_MISMATCH", {
+                    expected: exports.APP_SERVER_PROTOCOL_VERSION,
+                    received: protocolVersion
+                });
+            }
+            state.protocolInitialized = true;
+            return toResult(id, {
+                protocol_version: exports.APP_SERVER_PROTOCOL_VERSION,
+                server: {
+                    name: "zaker-app-server",
+                    version: resolveServerVersion()
+                },
+                capabilities: {
+                    methods: [...exports.APP_SERVER_METHODS],
+                    events: [...exports.APP_SERVER_EVENTS]
+                }
+            });
+        }
+        if (method === "ping") {
+            return toResult(id, {
+                ok: true,
+                timestamp: now()
+            });
+        }
+        if (method === "session.get") {
+            return toResult(id, await buildSessionSnapshot(state));
+        }
+        if (method === "menu.context") {
+            return toResult(id, await buildMenuContext(state));
+        }
+        if (method === "oauth.start") {
+            const parsed = parseOAuthStartParams(request.params);
+            if (!parsed) {
+                return toError(id, -32602, "INVALID_PARAMS", {
+                    expected: { provider: "openai-codex" }
+                });
+            }
+            try {
+                return toResult(id, await performOAuthStart(state, parsed.provider, emitEvent));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return toError(id, -32003, "COMMAND_EXECUTION_FAILED", { message });
+            }
+        }
+        if (method === "oauth.cancel") {
+            try {
+                return toResult(id, await performOAuthCancel(state, request.params, emitEvent));
+            }
+            catch (error) {
+                const errorCode = typeof error === "object" && error !== null && "code" in error
+                    ? Number(error.code)
+                    : NaN;
+                const message = error instanceof Error ? error.message : String(error);
+                if (Number.isFinite(errorCode) && errorCode === -32004) {
+                    return toError(id, -32004, "OAUTH_REQUEST_NOT_FOUND", { message });
+                }
+                return toError(id, -32003, "COMMAND_EXECUTION_FAILED", { message });
+            }
+        }
+        if (method === "command.execute") {
+            try {
+                const executed = await executeDialogCommand(state, request.params, emitEvent);
+                return toResult(id, executed);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return toError(id, -32003, "COMMAND_EXECUTION_FAILED", { message });
+            }
+        }
+        if (method === "shutdown") {
+            for (const pending of state.pendingOAuthRequests.values()) {
+                pending.controller.abort();
+            }
+            state.pendingOAuthRequests.clear();
+            state.terminated = true;
+            return toResult(id, { ok: true });
+        }
+        return toError(id, -32601, "METHOD_NOT_FOUND");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return toError(id, -32603, "INTERNAL_ERROR", { message });
+    }
+}
+function writeJsonLine(payload) {
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
+async function runAppServer(cwd = process.cwd(), options = {}) {
+    const state = await createAppServerState(cwd, options);
+    const input = node_readline_1.default.createInterface({
+        input: process.stdin,
+        crlfDelay: Infinity,
+        terminal: false
+    });
+    const emitEvent = async (event) => {
+        writeJsonLine({
+            jsonrpc: "2.0",
+            method: "event",
+            params: event
+        });
+    };
+    for await (const line of input) {
+        if (!line.trim()) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            writeJsonLine(toError(null, -32700, "PARSE_ERROR"));
+            continue;
+        }
+        const response = await handleAppServerRequest(state, parsed, emitEvent);
+        if (response && parsed.id !== undefined) {
+            writeJsonLine(response);
+        }
+        if (state.terminated) {
+            break;
+        }
+    }
+    input.close();
+}
+function registerAppServerCommand(program) {
+    program
+        .command("app-server")
+        .description("start zaker JSON-RPC app server over stdio")
+        .option("--cwd <path>", "workspace directory", process.cwd())
+        .option("-o, --sop-out <path>", "default sop output path", "sop.json")
+        .option("-c, --checkpoint-out <path>", "default checkpoint output path", "checkpoint.json")
+        .action(async (options) => {
+        await runAppServer(options.cwd, {
+            sopOut: options.sopOut,
+            checkpointOut: options.checkpointOut
+        });
+    });
+}
+//# sourceMappingURL=app-server.js.map