@openlucaskaka/kagent 0.1.7

package/npm/lib/runtime-client.js

@@ -0,0 +1,390 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeSessionClient = createRuntimeSessionClient;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const kagent_home_1 = require("./kagent-home");
+const protocol_1 = require("./protocol");
+const pythonRunner = require("./python-runner");
+const APPROVAL_EXECUTION_INTERRUPTED_MESSAGE = "The approved action was interrupted and was not replayed because its side-effect state is uncertain.";
+function createRuntimeSessionClient() {
+    const sessionId = (0, node_crypto_1.randomUUID)();
+    const configuredPendingApprovalPath = process.env.KAGENT_PENDING_APPROVAL_PATH;
+    const pendingApprovalPath = configuredPendingApprovalPath || (() => {
+        const pendingApprovalDirectory = (0, kagent_home_1.kagentStatePath)("pending-approvals");
+        return node_path_1.default.join(pendingApprovalDirectory, `${sessionId}.json`);
+    })();
+    let child = null;
+    let stdout = null;
+    let currentHandler = null;
+    let busy = false;
+    let closed = false;
+    let generation = 0;
+    let ready = false;
+    let restartUsed = false;
+    let queuedRequest = null;
+    let startupFailure = "";
+    let approvalExecutionUncertain = false;
+    let recoveringActive = false;
+    let recoveryFailureMessage = "";
+    let lifecycleEvent = null;
+    const subscribers = new Set();
+    function spawn() {
+        generation += 1;
+        const childGeneration = generation;
+        ready = false;
+        let nextChild;
+        try {
+            nextChild = pythonRunner.spawnPythonModule("kagent.cli.stdio_runtime", [], {
+                cwd: process.cwd(),
+                env: {
+                    ...process.env,
+                    KAGENT_PENDING_APPROVAL_PATH: pendingApprovalPath,
+                },
+            });
+        }
+        catch (error) {
+            recoverFromChildFailure(childGeneration, errorMessage(error));
+            return;
+        }
+        const nextStdout = node_readline_1.default.createInterface({ input: nextChild.stdout });
+        child = nextChild;
+        stdout = nextStdout;
+        nextStdout.on("line", (line) => {
+            if (childGeneration !== generation) {
+                return;
+            }
+            try {
+                const event = (0, protocol_1.parseRuntimeProtocolLine)(line);
+                if (!event) {
+                    return;
+                }
+                if (event.type === "runtime_ready") {
+                    ready = true;
+                    startupFailure = "";
+                    lifecycleEvent = event;
+                    notify(event);
+                    if (recoveringActive) {
+                        if (event.pending_approval) {
+                            approvalExecutionUncertain = false;
+                            recoveringActive = false;
+                            recoveryFailureMessage = "";
+                        }
+                        else if (event.approval_execution_interrupted) {
+                            approvalExecutionUncertain = true;
+                            recoveringActive = false;
+                            recoveryFailureMessage = "";
+                            queuedRequest = null;
+                        }
+                        else {
+                            const failureMessage = recoveryFailureMessage;
+                            recoveringActive = false;
+                            recoveryFailureMessage = "";
+                            failCurrent(failureMessage);
+                        }
+                    }
+                    if (queuedRequest) {
+                        const request = queuedRequest;
+                        queuedRequest = null;
+                        writeNow(request);
+                    }
+                    return;
+                }
+                if (event.type === "runtime_unavailable") {
+                    ready = false;
+                    startupFailure = event.message;
+                    notify(event);
+                    failCurrent(event.message);
+                    return;
+                }
+                if (!currentHandler) {
+                    return;
+                }
+                if (event.type === "approval_required") {
+                    approvalExecutionUncertain = false;
+                }
+                currentHandler(event);
+                if (event.type === "provider_configured") {
+                    updateProviderLifecycle(event);
+                }
+                if (event.type === "run_completed" ||
+                    event.type === "run_failed" ||
+                    event.type === "provider_configured" ||
+                    event.type === "provider_configuration_failed" ||
+                    event.type === "session_command_completed" ||
+                    event.type === "session_command_failed") {
+                    approvalExecutionUncertain = false;
+                    recoveringActive = false;
+                    recoveryFailureMessage = "";
+                    busy = false;
+                    currentHandler = null;
+                }
+            }
+            catch (error) {
+                failCurrent(errorMessage(error));
+            }
+        });
+        nextChild.stderr.on("data", () => {
+            // Drain the child pipe, but never forward stderr into user-visible events.
+        });
+        nextChild.on("error", (error) => {
+            recoverFromChildFailure(childGeneration, error.message);
+        });
+        nextChild.on("close", (code) => {
+            recoverFromChildFailure(childGeneration, `runtime exited with code ${code ?? 1}`);
+        });
+    }
+    function recoverFromChildFailure(childGeneration, message) {
+        if (childGeneration !== generation || closed) {
+            return;
+        }
+        generation += 1;
+        ready = false;
+        lifecycleEvent = null;
+        stdout?.close();
+        child = null;
+        stdout = null;
+        const activeRequest = busy && currentHandler !== null;
+        if (restartUsed) {
+            const preserveUncertainTombstone = approvalExecutionUncertain;
+            if (activeRequest) {
+                if (preserveUncertainTombstone) {
+                    failCurrentWithEvent({
+                        type: "run_failed",
+                        error_code: "approval_execution_interrupted",
+                        message: APPROVAL_EXECUTION_INTERRUPTED_MESSAGE,
+                    });
+                }
+                else {
+                    failCurrent(message);
+                }
+            }
+            startupFailure = message;
+            notify({ type: "client_failed", message });
+            return;
+        }
+        if (activeRequest) {
+            recoveringActive = true;
+            recoveryFailureMessage = message;
+        }
+        else if (busy) {
+            failCurrent(message);
+        }
+        restartUsed = true;
+        startupFailure = "";
+        setImmediate(() => {
+            if (!closed) {
+                spawn();
+            }
+        });
+    }
+    function writeNow(request) {
+        if (!child ||
+            child.killed ||
+            child.exitCode !== null ||
+            child.signalCode !== null ||
+            !child.stdin.writable) {
+            throw new Error("runtime session is not available");
+        }
+        child.stdin.write(`${JSON.stringify(request)}\n`);
+    }
+    function send(request) {
+        if (startupFailure) {
+            throw new Error(startupFailure);
+        }
+        if (!ready) {
+            queuedRequest = request;
+            return;
+        }
+        writeNow(request);
+    }
+    function notify(event) {
+        for (const subscriber of subscribers) {
+            subscriber(event);
+        }
+    }
+    function updateProviderLifecycle(event) {
+        if (!lifecycleEvent) {
+            return;
+        }
+        lifecycleEvent = { ...lifecycleEvent, provider: event.provider };
+        notify(lifecycleEvent);
+    }
+    function failCurrent(message) {
+        failCurrentWithEvent({ type: "client_failed", message });
+    }
+    function failCurrentWithEvent(event) {
+        const handler = currentHandler;
+        const preserveUncertainTombstone = event.type === "run_failed" &&
+            event.error_code === "approval_execution_interrupted";
+        busy = false;
+        currentHandler = null;
+        queuedRequest = null;
+        approvalExecutionUncertain = preserveUncertainTombstone;
+        recoveringActive = false;
+        recoveryFailureMessage = "";
+        handler?.(event);
+    }
+    spawn();
+    return {
+        subscribe(handler) {
+            subscribers.add(handler);
+            if (lifecycleEvent) {
+                handler(lifecycleEvent);
+            }
+            else if (startupFailure) {
+                handler({ type: "client_failed", message: startupFailure });
+            }
+            return () => subscribers.delete(handler);
+        },
+        configureProvider(config, onEvent) {
+            if (closed) {
+                onEvent({ type: "client_failed", message: "runtime session is closed" });
+                return;
+            }
+            if (busy) {
+                onEvent({ type: "client_failed", message: "runtime session is busy" });
+                return;
+            }
+            busy = true;
+            currentHandler = onEvent;
+            const request = {
+                type: "provider_configure",
+                provider: config.provider,
+                base_url: config.baseUrl,
+                model: config.model,
+                api_key: config.apiKey,
+            };
+            try {
+                send(request);
+            }
+            catch (error) {
+                failCurrent(errorMessage(error));
+            }
+        },
+        run(goal, onEvent, options = {}) {
+            if (closed) {
+                onEvent({ type: "client_failed", message: "runtime session is closed" });
+                return;
+            }
+            if (busy) {
+                onEvent({ type: "client_failed", message: "runtime session is busy" });
+                return;
+            }
+            busy = true;
+            currentHandler = onEvent;
+            const request = {
+                type: "run_request",
+                goal,
+                max_iterations: options.maxIterations ?? 3,
+            };
+            if (options.runtimePlan) {
+                request.runtime_plan = options.runtimePlan;
+            }
+            try {
+                send(request);
+            }
+            catch (error) {
+                failCurrent(errorMessage(error));
+            }
+        },
+        command(command, onEvent) {
+            if (closed) {
+                onEvent({ type: "client_failed", message: "runtime session is closed" });
+                return;
+            }
+            if (busy) {
+                onEvent({ type: "client_failed", message: "runtime session is busy" });
+                return;
+            }
+            busy = true;
+            currentHandler = onEvent;
+            const request = {
+                type: "session_command",
+                command,
+            };
+            try {
+                send(request);
+            }
+            catch (error) {
+                failCurrent(errorMessage(error));
+            }
+        },
+        respondToApproval(actionId, approved) {
+            if (!busy || !currentHandler) {
+                throw new Error("there is no pending runtime request");
+            }
+            const request = {
+                type: "approval_response",
+                action_id: actionId,
+                approved,
+            };
+            approvalExecutionUncertain = approved;
+            try {
+                send(request);
+            }
+            catch (error) {
+                queuedRequest = request;
+                child?.kill();
+                recoverFromChildFailure(generation, errorMessage(error));
+            }
+        },
+        steer(instruction) {
+            if (!busy || !currentHandler) {
+                throw new Error("there is no active runtime request to steer");
+            }
+            const request = {
+                type: "steer_request",
+                instruction,
+            };
+            try {
+                send(request);
+            }
+            catch (error) {
+                failCurrent(errorMessage(error));
+            }
+        },
+        cancel() {
+            if (!busy) {
+                return;
+            }
+            const request = {
+                type: "cancel_request",
+                reason: "user requested cancellation",
+            };
+            try {
+                send(request);
+            }
+            catch (error) {
+                failCurrent(errorMessage(error));
+            }
+        },
+        close() {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            busy = false;
+            currentHandler = null;
+            queuedRequest = null;
+            approvalExecutionUncertain = false;
+            recoveringActive = false;
+            recoveryFailureMessage = "";
+            subscribers.clear();
+            generation += 1;
+            stdout?.close();
+            if (child && !child.killed) {
+                child.kill("SIGTERM");
+            }
+            child = null;
+            stdout = null;
+        },
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/npm/lib/terminal-input.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTerminalInputBridge = createTerminalInputBridge;
+const node_readline_1 = require("node:readline");
+const node_stream_1 = require("node:stream");
+const node_string_decoder_1 = require("node:string_decoder");
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+function createTerminalInputBridge(handler) {
+    const input = new node_stream_1.PassThrough();
+    const decoder = new node_string_decoder_1.StringDecoder("utf8");
+    let pendingInput = "";
+    let pastedInput = null;
+    input.setEncoding("utf8");
+    (0, node_readline_1.emitKeypressEvents)(input);
+    const handleKeypress = (character, key) => {
+        const terminalKey = normalizeTerminalKey(key);
+        const value = terminalKey.ctrl ? terminalKey.name || "" : printableInput(character);
+        handler(value, terminalKey);
+    };
+    input.on("keypress", handleKeypress);
+    const emitPaste = (value, sequence) => {
+        const normalized = normalizePastedInput(value);
+        if (!normalized) {
+            return;
+        }
+        handler(normalized, {
+            sequence,
+            ctrl: false,
+            meta: false,
+            shift: false,
+        });
+    };
+    const writeParsedInput = (value) => {
+        if (value.length > 1 && !value.includes("\x1b") && /[\r\n]/.test(value)) {
+            emitPaste(value, value);
+            return;
+        }
+        input.write(value);
+    };
+    const consume = (value) => {
+        let remaining = pendingInput + value;
+        pendingInput = "";
+        while (remaining) {
+            if (pastedInput !== null) {
+                const combined = pastedInput + remaining;
+                const endIndex = combined.indexOf(BRACKETED_PASTE_END);
+                if (endIndex === -1) {
+                    pastedInput = combined;
+                    return;
+                }
+                const completedPaste = combined.slice(0, endIndex);
+                emitPaste(completedPaste, BRACKETED_PASTE_START + completedPaste + BRACKETED_PASTE_END);
+                pastedInput = null;
+                remaining = combined.slice(endIndex + BRACKETED_PASTE_END.length);
+                continue;
+            }
+            const startIndex = remaining.indexOf(BRACKETED_PASTE_START);
+            if (startIndex !== -1) {
+                writeParsedInput(remaining.slice(0, startIndex));
+                pastedInput = "";
+                remaining = remaining.slice(startIndex + BRACKETED_PASTE_START.length);
+                continue;
+            }
+            const suffixLength = pasteStartSuffixLength(remaining);
+            const parsedEnd = suffixLength > 1 ? remaining.length - suffixLength : remaining.length;
+            writeParsedInput(remaining.slice(0, parsedEnd));
+            pendingInput = remaining.slice(parsedEnd);
+            return;
+        }
+    };
+    return {
+        write(chunk) {
+            consume(typeof chunk === "string" ? chunk : decoder.write(chunk));
+        },
+        close() {
+            consume(decoder.end());
+            writeParsedInput(pendingInput);
+            pendingInput = "";
+            input.removeListener("keypress", handleKeypress);
+            input.end();
+        },
+    };
+}
+function printableInput(character) {
+    if (!character) {
+        return "";
+    }
+    const codePoint = character.codePointAt(0) || 0;
+    return codePoint < 32 || codePoint === 127 ? "" : character;
+}
+function normalizePastedInput(value) {
+    return value
+        .replace(/\r\n|\r/g, "\n")
+        .replace(/\t/g, "  ")
+        .replace(/[\u0000-\u0009\u000b-\u001f\u007f]/g, "");
+}
+function normalizeTerminalKey(key) {
+    const sequence = key.sequence || "";
+    const modifiedReturn = /^\x1b\[13;(\d+)u$/.exec(sequence);
+    if (modifiedReturn) {
+        const modifiers = Number(modifiedReturn[1]) - 1;
+        return {
+            sequence,
+            name: "return",
+            shift: Boolean(modifiers & 1),
+            meta: Boolean(modifiers & 2),
+            ctrl: Boolean(modifiers & 4),
+        };
+    }
+    return {
+        sequence,
+        name: key.name,
+        ctrl: Boolean(key.ctrl),
+        meta: Boolean(key.meta),
+        shift: Boolean(key.shift),
+    };
+}
+function pasteStartSuffixLength(value) {
+    const maxLength = Math.min(value.length, BRACKETED_PASTE_START.length - 1);
+    for (let length = maxLength; length > 1; length -= 1) {
+        if (value.endsWith(BRACKETED_PASTE_START.slice(0, length))) {
+            return length;
+        }
+    }
+    return 0;
+}

package/npm/lib/terminal-text.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitGraphemes = splitGraphemes;
+exports.terminalGraphemeWidth = terminalGraphemeWidth;
+exports.terminalSafeText = terminalSafeText;
+const string_width_1 = __importDefault(require("string-width"));
+const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+function splitGraphemes(value) {
+    return Array.from(GRAPHEME_SEGMENTER.segment(value), ({ segment }) => segment);
+}
+function terminalGraphemeWidth(grapheme) {
+    return (0, string_width_1.default)(grapheme);
+}
+function terminalSafeText(value) {
+    return value.replace(/[\u0000-\u001f\u007f-\u009f]/g, "");
+}

package/npm/lib/terminal-width.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.terminalGraphemeWidth = void 0;
+exports.estimateTextRows = estimateTextRows;
+const terminal_text_1 = require("./terminal-text");
+function estimateTextRows(text, columns) {
+    const safeColumns = Math.max(1, columns);
+    return text.split("\n").reduce((total, line) => {
+        const width = (0, terminal_text_1.splitGraphemes)(line).reduce((lineWidth, grapheme) => lineWidth + (0, terminal_text_1.terminalGraphemeWidth)(grapheme), 0);
+        return total + Math.max(1, Math.ceil(width / safeColumns));
+    }, 0);
+}
+var terminal_text_2 = require("./terminal-text");
+Object.defineProperty(exports, "terminalGraphemeWidth", { enumerable: true, get: function () { return terminal_text_2.terminalGraphemeWidth; } });