@mandipadk7/kavi 0.1.0 → 0.1.2

package/dist/approvals.js

@@ -59,6 +59,73 @@ export function describeToolUse(payload) {
         matchKey: `${toolName}:${normalized.toLowerCase()}`
     };
 }
+export function describeCodexApprovalRequest(method, params) {
+    const reason = readString(params, "reason") ?? "";
+    switch(method){
+        case "item/commandExecution/requestApproval":
+            {
+                const command = normalizeWhitespace(readString(params, "command") ?? "");
+                const detail = command || normalizeWhitespace(reason) || safeJson(params);
+                return {
+                    toolName: "CommandExecution",
+                    summary: `CommandExecution: ${truncate(detail || "(no details)", 140)}`,
+                    matchKey: `CommandExecution:${detail.toLowerCase()}`
+                };
+            }
+        case "item/fileChange/requestApproval":
+            {
+                const grantRoot = normalizeWhitespace(readString(params, "grantRoot") ?? "");
+                const detail = grantRoot || normalizeWhitespace(reason) || safeJson(params);
+                return {
+                    toolName: "FileChange",
+                    summary: `FileChange: ${truncate(detail || "(no details)", 140)}`,
+                    matchKey: `FileChange:${detail.toLowerCase()}`
+                };
+            }
+        case "item/permissions/requestApproval":
+            {
+                const permissions = readObject(params, "permissions");
+                const detail = normalizeWhitespace([
+                    reason,
+                    safeJson(permissions)
+                ].filter(Boolean).join(" "));
+                return {
+                    toolName: "Permissions",
+                    summary: `Permissions: ${truncate(detail || "(no details)", 140)}`,
+                    matchKey: `Permissions:${detail.toLowerCase()}`
+                };
+            }
+        case "execCommandApproval":
+            {
+                const command = Array.isArray(params.command) ? normalizeWhitespace(params.command.map((part)=>String(part)).join(" ")) : normalizeWhitespace(readString(params, "command") ?? "");
+                const detail = command || normalizeWhitespace(reason) || safeJson(params);
+                return {
+                    toolName: "ExecCommand",
+                    summary: `ExecCommand: ${truncate(detail || "(no details)", 140)}`,
+                    matchKey: `ExecCommand:${detail.toLowerCase()}`
+                };
+            }
+        case "applyPatchApproval":
+            {
+                const grantRoot = normalizeWhitespace(readString(params, "grantRoot") ?? "");
+                const detail = grantRoot || normalizeWhitespace(reason) || safeJson(params);
+                return {
+                    toolName: "ApplyPatch",
+                    summary: `ApplyPatch: ${truncate(detail || "(no details)", 140)}`,
+                    matchKey: `ApplyPatch:${detail.toLowerCase()}`
+                };
+            }
+        default:
+            {
+                const detail = normalizeWhitespace(reason) || safeJson(params);
+                return {
+                    toolName: method,
+                    summary: `${method}: ${truncate(detail || "(no details)", 140)}`,
+                    matchKey: `${method}:${detail.toLowerCase()}`
+                };
+            }
+    }
+}
 async function loadRequests(paths) {
     if (!await fileExists(paths.approvalsFile)) {
         return [];
@@ -74,7 +141,11 @@ export async function listApprovalRequests(paths, options = {}) {
     return filtered.sort((left, right)=>left.createdAt.localeCompare(right.createdAt));
 }
 export async function createApprovalRequest(paths, input) {
-    const descriptor = describeToolUse(input.payload);
+    const descriptor = input.toolName && input.summary && input.matchKey ? {
+        toolName: input.toolName,
+        summary: input.summary,
+        matchKey: input.matchKey
+    } : describeToolUse(input.payload);
     const timestamp = nowIso();
     const request = {
         id: randomUUID(),

package/dist/codex-app-server.js

@@ -0,0 +1,310 @@
+import { spawn } from "node:child_process";
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+    return typeof value === "string" ? value : null;
+}
+function formatRpcError(method, error) {
+    const errorObject = asObject(error);
+    const message = asString(errorObject.message);
+    return new Error(message ? `${method} failed: ${message}` : `${method} failed.`);
+}
+function buildTurnError(completion) {
+    const message = completion.turn.error?.message ?? `Codex turn ${completion.turn.id} failed.`;
+    const details = completion.turn.error?.additionalDetails?.trim();
+    return new Error(details ? `${message}\n${details}` : message);
+}
+export class CodexAppServerClient {
+    child;
+    pending = new Map();
+    bufferedMessages = new Map();
+    completedTurns = new Map();
+    turnResolvers = new Map();
+    onRequest;
+    nextId = 0;
+    stdoutBuffer = "";
+    stderrBuffer = "";
+    closed = false;
+    closePromise = null;
+    constructor(runtime, cwd, onRequest){
+        this.onRequest = onRequest;
+        this.child = spawn(runtime.codexExecutable, [
+            "app-server",
+            "--listen",
+            "stdio://",
+            "--session-source",
+            "cli"
+        ], {
+            cwd,
+            stdio: [
+                "pipe",
+                "pipe",
+                "pipe"
+            ]
+        });
+        this.child.stdout.setEncoding("utf8");
+        this.child.stderr.setEncoding("utf8");
+        this.child.stdout.on("data", (chunk)=>{
+            this.handleStdout(chunk);
+        });
+        this.child.stderr.on("data", (chunk)=>{
+            this.stderrBuffer += chunk;
+        });
+        this.child.on("error", (error)=>{
+            this.rejectAll(error);
+        });
+        this.child.on("close", (code, signal)=>{
+            if (!this.closed) {
+                this.closed = true;
+            }
+            const suffix = this.stderrBuffer.trim();
+            const reason = new Error(`Codex app-server exited before the turn completed (code=${code ?? "null"}, signal=${signal ?? "null"})${suffix ? `\n${suffix}` : ""}`);
+            this.rejectAll(reason);
+        });
+    }
+    async initialize() {
+        await this.request("initialize", {
+            clientInfo: {
+                name: "kavi",
+                title: "Kavi",
+                version: "0.1.0"
+            },
+            capabilities: {
+                experimentalApi: true
+            }
+        });
+    }
+    async startThread(params) {
+        const response = asObject(await this.request("thread/start", params));
+        const thread = asObject(response.thread);
+        const threadId = asString(thread.id);
+        if (!threadId) {
+            throw new Error("Codex thread/start did not return a thread id.");
+        }
+        return threadId;
+    }
+    async resumeThread(params) {
+        const response = asObject(await this.request("thread/resume", params));
+        const thread = asObject(response.thread);
+        const threadId = asString(thread.id);
+        if (!threadId) {
+            throw new Error("Codex thread/resume did not return a thread id.");
+        }
+        return threadId;
+    }
+    async runTurn(params) {
+        const response = asObject(await this.request("turn/start", params));
+        const turn = asObject(response.turn);
+        const turnId = asString(turn.id);
+        if (!turnId) {
+            throw new Error("Codex turn/start did not return a turn id.");
+        }
+        const threadId = asString(params.threadId);
+        if (!threadId) {
+            throw new Error("Codex turn/start requires a thread id.");
+        }
+        const initialStatus = asString(turn.status);
+        if (initialStatus === "completed") {
+            return {
+                threadId,
+                turnId,
+                assistantMessage: this.bufferedMessages.get(turnId) ?? "",
+                turnStatus: initialStatus,
+                stderr: this.stderrBuffer.trim()
+            };
+        }
+        if (initialStatus === "failed" || initialStatus === "interrupted") {
+            throw buildTurnError({
+                threadId,
+                turn: {
+                    id: turnId,
+                    status: initialStatus,
+                    error: asObject(turn.error)
+                }
+            });
+        }
+        const completion = this.completedTurns.get(turnId) ?? await new Promise((resolve, reject)=>{
+            this.turnResolvers.set(turnId, {
+                resolve,
+                reject
+            });
+        });
+        const turnStatus = completion.turn.status;
+        if (turnStatus !== "completed") {
+            throw buildTurnError(completion);
+        }
+        return {
+            threadId,
+            turnId,
+            assistantMessage: this.bufferedMessages.get(turnId) ?? "",
+            turnStatus,
+            stderr: this.stderrBuffer.trim()
+        };
+    }
+    async close() {
+        if (this.closePromise) {
+            await this.closePromise;
+            return;
+        }
+        this.closePromise = new Promise((resolve)=>{
+            if (this.closed) {
+                resolve();
+                return;
+            }
+            this.closed = true;
+            const timeout = setTimeout(()=>{
+                this.child.kill("SIGTERM");
+            }, 1_000);
+            this.child.once("close", ()=>{
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.child.stdin.end();
+        });
+        await this.closePromise;
+    }
+    async request(method, params) {
+        const id = ++this.nextId;
+        const payload = {
+            id,
+            method,
+            params
+        };
+        return await new Promise((resolve, reject)=>{
+            this.pending.set(id, {
+                method,
+                resolve,
+                reject
+            });
+            this.child.stdin.write(`${JSON.stringify(payload)}\n`, "utf8", (error)=>{
+                if (!error) {
+                    return;
+                }
+                this.pending.delete(id);
+                reject(error);
+            });
+        });
+    }
+    handleStdout(chunk) {
+        this.stdoutBuffer += chunk;
+        while(true){
+            const newlineIndex = this.stdoutBuffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+            this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+            if (!line) {
+                continue;
+            }
+            let message;
+            try {
+                message = JSON.parse(line);
+            } catch (error) {
+                this.rejectAll(new Error(`Failed to parse Codex app-server output: ${error instanceof Error ? error.message : String(error)}\n${line}`));
+                return;
+            }
+            if (typeof message.id === "number" && typeof message.method === "string") {
+                void this.handleServerRequest({
+                    id: message.id,
+                    method: message.method,
+                    params: asObject(message.params)
+                });
+                continue;
+            }
+            if (typeof message.id === "number") {
+                this.handleResponse(message);
+                continue;
+            }
+            if (typeof message.method === "string") {
+                this.handleNotification(message.method, asObject(message.params));
+            }
+        }
+    }
+    handleResponse(message) {
+        const pending = this.pending.get(message.id);
+        if (!pending) {
+            return;
+        }
+        this.pending.delete(message.id);
+        if (message.error) {
+            pending.reject(formatRpcError(pending.method, message.error));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+    handleNotification(method, params) {
+        if (method === "item/agentMessage/delta") {
+            const turnId = asString(params.turnId);
+            const delta = asString(params.delta);
+            if (turnId && delta) {
+                this.bufferedMessages.set(turnId, `${this.bufferedMessages.get(turnId) ?? ""}${delta}`);
+            }
+            return;
+        }
+        if (method === "turn/completed") {
+            const turn = asObject(params.turn);
+            const turnId = asString(turn.id);
+            const threadId = asString(params.threadId);
+            const status = asString(turn.status);
+            if (!turnId || !threadId || !status) {
+                return;
+            }
+            const completion = {
+                threadId,
+                turn: {
+                    id: turnId,
+                    status,
+                    error: asObject(turn.error)
+                }
+            };
+            this.completedTurns.set(turnId, completion);
+            const resolver = this.turnResolvers.get(turnId);
+            if (resolver) {
+                this.turnResolvers.delete(turnId);
+                resolver.resolve(completion);
+            }
+            return;
+        }
+        if (method === "error") {
+            const message = asString(params.message) ?? "Codex app-server returned an error notification.";
+            this.rejectAll(new Error(message));
+        }
+    }
+    async handleServerRequest(request) {
+        try {
+            const result = await this.onRequest(request);
+            this.child.stdin.write(`${JSON.stringify({
+                id: request.id,
+                result
+            })}\n`);
+        } catch (error) {
+            this.child.stdin.write(`${JSON.stringify({
+                id: request.id,
+                error: {
+                    message: error instanceof Error ? error.message : String(error)
+                }
+            })}\n`);
+        }
+    }
+    rejectAll(error) {
+        const pending = [
+            ...this.pending.values()
+        ];
+        this.pending.clear();
+        for (const request of pending){
+            request.reject(error);
+        }
+        const turnResolvers = [
+            ...this.turnResolvers.values()
+        ];
+        this.turnResolvers.clear();
+        for (const turn of turnResolvers){
+            turn.reject(error);
+        }
+    }
+}
+
+
+//# sourceURL=codex-app-server.ts

package/dist/command-queue.js

@@ -11,6 +11,7 @@ export async function appendCommand(paths, type, payload) {
     };
     await ensureDir(paths.runtimeDir);
     await fs.appendFile(paths.commandsFile, `${JSON.stringify(command)}\n`, "utf8");
+    return command;
 }
 export async function consumeCommands(paths) {
     if (!await fileExists(paths.commandsFile)) {