@psnext/slingcli 2.5.20260623-1 → 2.5.20260705-1

package/node_modules/@earendil-works/pi-orchestrator/dist/rpc-process.js

@@ -0,0 +1,168 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { isBunBinary } from "./config.js";
+const require = createRequire(import.meta.url);
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+export class RpcProcessInstance {
+    process;
+    exited = false;
+    nextRequestId = 0;
+    stdoutBuffer = "";
+    stderrBuffer = "";
+    pendingRequests = new Map();
+    eventListeners = new Set();
+    exitListeners = new Set();
+    uiRequestHandler;
+    constructor(options) {
+        const rpcCommand = this.getSpawnCommand();
+        this.process = spawn(rpcCommand.command, rpcCommand.args, {
+            cwd: options.cwd,
+            env: process.env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (!this.process.stdin || !this.process.stdout) {
+            throw new Error("Failed to create RPC process stdio");
+        }
+        this.attachListeners();
+    }
+    getSpawnCommand() {
+        if (isBunBinary) {
+            return {
+                command: join(dirname(process.execPath), process.platform === "win32" ? "pi.exe" : "pi"),
+                args: ["--mode", "rpc"],
+            };
+        }
+        return {
+            command: process.execPath,
+            args: [require.resolve("@earendil-works/pi-coding-agent/rpc-entry")],
+        };
+    }
+    attachListeners() {
+        this.process.stdout?.setEncoding("utf8");
+        this.process.stdout?.on("data", (chunk) => {
+            this.stdoutBuffer += chunk;
+            while (true) {
+                const newlineIndex = this.stdoutBuffer.indexOf("\n");
+                if (newlineIndex === -1) {
+                    break;
+                }
+                const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+                this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+                if (!line) {
+                    continue;
+                }
+                this.handleLine(line);
+            }
+        });
+        this.process.stderr?.setEncoding("utf8");
+        this.process.stderr?.on("data", (chunk) => {
+            this.stderrBuffer += chunk;
+        });
+        this.process.once("error", (error) => {
+            this.exited = true;
+            const wrapped = new Error(`RPC process error: ${error.message}. Stderr: ${this.stderrBuffer}`);
+            this.rejectAllPending(wrapped);
+            this.notifyExit(wrapped);
+        });
+        this.process.once("exit", (code, signal) => {
+            this.exited = true;
+            const error = new Error(`RPC process exited (code=${code} signal=${signal}). Stderr: ${this.stderrBuffer}`);
+            this.rejectAllPending(error);
+            this.notifyExit(error);
+        });
+    }
+    handleLine(line) {
+        const parsed = JSON.parse(line);
+        switch (parsed.type) {
+            case "response": {
+                if (!parsed.id) {
+                    return;
+                }
+                const pending = this.pendingRequests.get(parsed.id);
+                if (!pending) {
+                    return;
+                }
+                this.pendingRequests.delete(parsed.id);
+                pending.resolve(parsed);
+                return;
+            }
+            case "extension_ui_request": {
+                this.uiRequestHandler?.(parsed);
+                return;
+            }
+            default: {
+                for (const listener of this.eventListeners) {
+                    listener(parsed);
+                }
+            }
+        }
+    }
+    rejectAllPending(error) {
+        for (const [id, pending] of this.pendingRequests) {
+            this.pendingRequests.delete(id);
+            pending.reject(error);
+        }
+    }
+    notifyExit(error) {
+        for (const listener of this.exitListeners) {
+            listener(error);
+        }
+    }
+    send(command) {
+        if (this.exited) {
+            throw new Error(`RPC process is not running. Stderr: ${this.stderrBuffer}`);
+        }
+        const id = command.id ?? `orchestrator_${++this.nextRequestId}_${randomUUID()}`;
+        const fullCommand = { ...command, id };
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, { resolve, reject });
+            this.process.stdin?.write(`${JSON.stringify(fullCommand)}\n`, (error) => {
+                if (!error) {
+                    return;
+                }
+                this.pendingRequests.delete(id);
+                reject(toError(error));
+            });
+        });
+    }
+    handleUiResponse(response) {
+        if (this.exited) {
+            return;
+        }
+        this.process.stdin?.write(`${JSON.stringify(response)}\n`);
+    }
+    setUiRequestHandler(handler) {
+        this.uiRequestHandler = handler;
+    }
+    onEvent(listener) {
+        this.eventListeners.add(listener);
+        return () => {
+            this.eventListeners.delete(listener);
+        };
+    }
+    onExit(listener) {
+        this.exitListeners.add(listener);
+        return () => {
+            this.exitListeners.delete(listener);
+        };
+    }
+    async dispose() {
+        this.uiRequestHandler = undefined;
+        this.rejectAllPending(new Error("RPC process disposed"));
+        if (this.exited) {
+            return;
+        }
+        this.process.kill("SIGTERM");
+        await new Promise((resolve) => {
+            this.process.once("exit", () => resolve());
+        });
+    }
+}
+export function createRpcProcessInstance(options) {
+    return new RpcProcessInstance(options);
+}
+//# sourceMappingURL=rpc-process.js.map

package/node_modules/@earendil-works/pi-orchestrator/dist/serve.js

@@ -0,0 +1,70 @@
+import { existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { dirname } from "node:path";
+import { getSocketPath } from "./config.js";
+import { handleIpcRequest, openRpcStream } from "./handler.js";
+import { startIpcServer } from "./ipc/server.js";
+import { getRadiusOrchestratorBaseUrl, isRadiusEnabled, radiusPresence } from "./radius.js";
+import { supervisor } from "./supervisor.js";
+export async function serve() {
+    const socketPath = getSocketPath();
+    mkdirSync(dirname(socketPath), { recursive: true });
+    const server = await startIpcServer(Object.assign(handleIpcRequest, {
+        openRpcStream,
+    }));
+    try {
+        await supervisor.recoverAfterRestart();
+        if (isRadiusEnabled()) {
+            const machine = await radiusPresence.start();
+            console.log(`radius integration enabled: ${socketPath} -> ${getRadiusOrchestratorBaseUrl()}`);
+            if (machine) {
+                console.log(`radius machine id: ${machine.id}`);
+            }
+        }
+        else {
+            console.log("radius integration disabled: login radius in ~/.pi/agent/auth.json or set PI_RADIUS_API_KEY");
+        }
+    }
+    catch (error) {
+        server.close();
+        if (existsSync(socketPath)) {
+            unlinkSync(socketPath);
+        }
+        throw error;
+    }
+    console.log(`orchestrator listening on ${socketPath}`);
+    let shutdownPromise;
+    const shutdown = async (exitCode) => {
+        if (shutdownPromise) {
+            await shutdownPromise;
+            process.exit(exitCode);
+        }
+        shutdownPromise = (async () => {
+            server.close();
+            await supervisor.shutdown();
+            await radiusPresence.stop();
+            if (existsSync(socketPath)) {
+                unlinkSync(socketPath);
+            }
+        })();
+        await shutdownPromise;
+        process.exit(exitCode);
+    };
+    process.on("SIGINT", () => {
+        void shutdown(0);
+    });
+    process.on("SIGTERM", () => {
+        void shutdown(0);
+    });
+    process.on("uncaughtException", (error) => {
+        console.error(error);
+        void shutdown(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+        console.error(reason);
+        void shutdown(1);
+    });
+    await new Promise(() => {
+        // Keep the process alive until a signal or fatal error triggers shutdown.
+    });
+}
+//# sourceMappingURL=serve.js.map

package/node_modules/@earendil-works/pi-orchestrator/dist/storage.js

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { getInstancesPath, getMachinePath, getOrchestratorDir } from "./config.js";
+function ensureOrchestratorDir() {
+    const orchestratorDir = getOrchestratorDir();
+    if (!existsSync(orchestratorDir)) {
+        mkdirSync(orchestratorDir, { recursive: true });
+    }
+}
+export function loadMachine() {
+    const machinePath = getMachinePath();
+    if (!existsSync(machinePath)) {
+        return undefined;
+    }
+    const data = readFileSync(machinePath, "utf-8");
+    return JSON.parse(data);
+}
+export function saveMachine(machine) {
+    ensureOrchestratorDir();
+    writeFileSync(getMachinePath(), JSON.stringify(machine, null, 2));
+}
+export function deleteMachine() {
+    const machinePath = getMachinePath();
+    if (!existsSync(machinePath)) {
+        return;
+    }
+    rmSync(machinePath);
+}
+export function loadInstances() {
+    const instancesPath = getInstancesPath();
+    if (!existsSync(instancesPath)) {
+        return [];
+    }
+    const data = readFileSync(instancesPath, "utf-8");
+    return JSON.parse(data);
+}
+export function saveInstances(instances) {
+    ensureOrchestratorDir();
+    writeFileSync(getInstancesPath(), JSON.stringify(instances, null, 2));
+}
+export function getInstance(instanceId) {
+    return loadInstances().find((instance) => instance.id === instanceId);
+}
+export function upsertInstance(instance) {
+    const instances = loadInstances();
+    const index = instances.findIndex((existing) => existing.id === instance.id);
+    if (index === -1) {
+        instances.push(instance);
+        saveInstances(instances);
+        return;
+    }
+    instances[index] = instance;
+    saveInstances(instances);
+}
+export function removeInstance(instanceId) {
+    const instances = loadInstances().filter((instance) => instance.id !== instanceId);
+    saveInstances(instances);
+}
+//# sourceMappingURL=storage.js.map

package/node_modules/@earendil-works/pi-orchestrator/dist/supervisor.js

@@ -0,0 +1,290 @@
+import { randomUUID } from "node:crypto";
+import { radiusPresence } from "./radius.js";
+import { createRpcProcessInstance } from "./rpc-process.js";
+import { getInstance, loadInstances, removeInstance, saveInstances, upsertInstance } from "./storage.js";
+function cloneInstance(record) {
+    return { ...record };
+}
+// Only refresh persisted session metadata after commands that can plausibly change
+// the instance identity/details we store in instances.json. Most RPCs mutate transient
+// runtime state only, so forcing a follow-up get_state after every command is wasted IO.
+//
+// - new_session / switch_session / fork / clone can change sessionId/sessionFile
+// - set_session_name changes a persisted session detail we may want reflected externally
+// - prompt can materialize or advance persisted session state after the child processes it
+const SESSION_METADATA_COMMANDS = new Set([
+    "new_session",
+    "switch_session",
+    "fork",
+    "clone",
+    "set_session_name",
+    "prompt",
+]);
+function shouldRefreshSessionMetadata(command) {
+    return SESSION_METADATA_COMMANDS.has(command.type);
+}
+function isGetStateSuccess(response) {
+    return response.success === true && response.command === "get_state" && "data" in response;
+}
+export class OrchestratorSupervisor {
+    liveInstances = new Map();
+    setStatus(live, status) {
+        live.record = {
+            ...live.record,
+            status,
+            lastSeenAt: new Date().toISOString(),
+        };
+        upsertInstance(live.record);
+    }
+    updateRecord(live, updates) {
+        live.record = {
+            ...live.record,
+            ...updates,
+            lastSeenAt: new Date().toISOString(),
+        };
+        if (updates.radiusPiId !== undefined) {
+            live.resources.radiusPiId = updates.radiusPiId;
+        }
+        if (updates.sessionId !== undefined) {
+            live.resources.sessionId = updates.sessionId;
+        }
+        upsertInstance(live.record);
+    }
+    clearBindings(live) {
+        live.unsubscribeEvents?.();
+        live.unsubscribeExit?.();
+        live.unsubscribeEvents = undefined;
+        live.unsubscribeExit = undefined;
+        live.onUiRequest = undefined;
+        live.resources.rpcProcess?.setUiRequestHandler(undefined);
+    }
+    bindRpcProcess(live, rpcProcess) {
+        this.clearBindings(live);
+        live.resources.rpcProcess = rpcProcess;
+        live.unsubscribeEvents = rpcProcess.onEvent((event) => {
+            for (const subscriber of live.subscribers) {
+                subscriber(event);
+            }
+        });
+        live.unsubscribeExit = rpcProcess.onExit((error) => {
+            void this.handleUnexpectedRpcExit(live, error);
+        });
+        rpcProcess.setUiRequestHandler((request) => {
+            live.onUiRequest?.(request);
+        });
+    }
+    async handleUnexpectedRpcExit(live, _error) {
+        if (this.liveInstances.get(live.record.id) !== live) {
+            return;
+        }
+        if (live.record.status === "stopping" || live.record.status === "stopped") {
+            return;
+        }
+        this.setStatus(live, "error");
+        this.clearBindings(live);
+        live.resources.rpcProcess = undefined;
+        if (live.resources.radiusPiId) {
+            try {
+                await radiusPresence.disconnectPi(live.record);
+                this.updateRecord(live, { radiusPiId: undefined });
+            }
+            catch (error) {
+                console.error(`Failed to disconnect Radius Pi ${live.record.id}: ${String(error)}`);
+            }
+        }
+        this.liveInstances.delete(live.record.id);
+    }
+    getRpcProcess(live) {
+        return live.resources.rpcProcess;
+    }
+    async syncInstanceRecord(live) {
+        const rpcProcess = this.getRpcProcess(live);
+        if (!rpcProcess) {
+            this.updateRecord(live, {});
+            return;
+        }
+        const response = await rpcProcess.send({ type: "get_state" });
+        if (!isGetStateSuccess(response)) {
+            this.updateRecord(live, {});
+            return;
+        }
+        this.updateRecord(live, {
+            sessionId: response.data.sessionId,
+            sessionFile: response.data.sessionFile,
+        });
+    }
+    async cleanupAcquiredResources(live) {
+        const rpcProcess = live.resources.rpcProcess;
+        this.clearBindings(live);
+        if (live.resources.radiusPiId) {
+            await radiusPresence.disconnectPi(live.record);
+            live.resources.radiusPiId = undefined;
+            live.record = {
+                ...live.record,
+                radiusPiId: undefined,
+                lastSeenAt: new Date().toISOString(),
+            };
+        }
+        live.resources.sessionId = undefined;
+        if (rpcProcess) {
+            live.resources.rpcProcess = undefined;
+            await rpcProcess.dispose();
+        }
+    }
+    async failSpawn(live, error) {
+        this.setStatus(live, "error");
+        try {
+            await this.cleanupAcquiredResources(live);
+        }
+        finally {
+            this.setStatus(live, "stopped");
+            this.liveInstances.delete(live.record.id);
+        }
+        throw error;
+    }
+    updateInstance(instance) {
+        const live = this.liveInstances.get(instance.id);
+        if (live) {
+            live.record = instance;
+            live.resources.radiusPiId = instance.radiusPiId;
+            live.resources.sessionId = instance.sessionId;
+        }
+        upsertInstance(instance);
+    }
+    openRpcStream(instanceId, onEvent, onUiRequest) {
+        const live = this.liveInstances.get(instanceId);
+        const rpcProcess = live ? this.getRpcProcess(live) : undefined;
+        if (!live || !rpcProcess) {
+            return undefined;
+        }
+        live.subscribers.add(onEvent);
+        live.onUiRequest = onUiRequest;
+        return {
+            handleRpc: async (command) => {
+                const response = await rpcProcess.send(command);
+                if (shouldRefreshSessionMetadata(command)) {
+                    await this.syncInstanceRecord(live);
+                }
+                return response;
+            },
+            handleUiResponse: (response) => {
+                rpcProcess.handleUiResponse(response);
+            },
+            close: () => {
+                if (live.onUiRequest === onUiRequest) {
+                    live.onUiRequest = undefined;
+                }
+                live.subscribers.delete(onEvent);
+            },
+        };
+    }
+    getLiveInstance(instanceId) {
+        const live = this.liveInstances.get(instanceId);
+        return live ? cloneInstance(live.record) : undefined;
+    }
+    listLiveInstances() {
+        return [...this.liveInstances.values()].map((live) => cloneInstance(live.record));
+    }
+    async recoverAfterRestart() {
+        const recoveredAt = new Date().toISOString();
+        const instances = loadInstances().map((instance) => ({
+            ...instance,
+            status: instance.status === "online" || instance.status === "starting" ? "stopped" : instance.status,
+            lastSeenAt: recoveredAt,
+        }));
+        for (const instance of instances) {
+            await radiusPresence.disconnectPi(instance);
+        }
+        saveInstances(instances);
+    }
+    listInstances() {
+        return loadInstances().map(cloneInstance);
+    }
+    getInstance(instanceId) {
+        const live = this.liveInstances.get(instanceId);
+        if (live) {
+            return cloneInstance(live.record);
+        }
+        const stored = getInstance(instanceId);
+        return stored ? cloneInstance(stored) : undefined;
+    }
+    async spawnInstance(options) {
+        const now = new Date().toISOString();
+        const live = {
+            record: {
+                id: randomUUID(),
+                status: "starting",
+                cwd: options.cwd,
+                createdAt: now,
+                lastSeenAt: now,
+                label: options.label,
+            },
+            resources: {},
+            subscribers: new Set(),
+        };
+        this.liveInstances.set(live.record.id, live);
+        upsertInstance(live.record);
+        try {
+            const rpcProcess = createRpcProcessInstance({ cwd: options.cwd });
+            this.bindRpcProcess(live, rpcProcess);
+            await this.syncInstanceRecord(live);
+            const registeredRecord = await radiusPresence.registerPi(live.record);
+            this.updateRecord(live, { radiusPiId: registeredRecord.radiusPiId });
+            this.setStatus(live, "online");
+            return cloneInstance(live.record);
+        }
+        catch (error) {
+            return await this.failSpawn(live, error);
+        }
+    }
+    async stopInstance(instanceId) {
+        const live = this.liveInstances.get(instanceId);
+        if (!live) {
+            return undefined;
+        }
+        this.setStatus(live, "stopping");
+        try {
+            await this.cleanupAcquiredResources(live);
+        }
+        finally {
+            live.record = {
+                ...live.record,
+                status: "stopped",
+                lastSeenAt: new Date().toISOString(),
+            };
+            this.liveInstances.delete(instanceId);
+            removeInstance(instanceId);
+        }
+        return cloneInstance(live.record);
+    }
+    async handleRpc(instanceId, command) {
+        const live = this.liveInstances.get(instanceId);
+        const rpcProcess = live ? this.getRpcProcess(live) : undefined;
+        if (!live || !rpcProcess) {
+            return undefined;
+        }
+        const response = await rpcProcess.send(command);
+        if (shouldRefreshSessionMetadata(command)) {
+            await this.syncInstanceRecord(live);
+        }
+        return response;
+    }
+    async shutdown() {
+        for (const instanceId of [...this.liveInstances.keys()]) {
+            await this.stopInstance(instanceId);
+        }
+    }
+}
+export const supervisor = new OrchestratorSupervisor();
+radiusPresence.setCoordinator({
+    getLiveInstance(instanceId) {
+        return supervisor.getLiveInstance(instanceId);
+    },
+    listLiveInstances() {
+        return supervisor.listLiveInstances();
+    },
+    updateInstance(instance) {
+        supervisor.updateInstance(instance);
+    },
+});
+//# sourceMappingURL=supervisor.js.map

package/node_modules/@earendil-works/pi-orchestrator/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/node_modules/@earendil-works/pi-orchestrator/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@earendil-works/pi-orchestrator",
+	"version": "0.80.3",
+	"description": "experimental orchestrator package for pi",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"clean": "shx rm -rf dist",
+		"dev": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
+		"build": "tsgo -p tsconfig.build.json && shx chmod +x dist/cli.js",
+		"prepublishOnly": "npm run clean && npm run build"
+	},
+	"keywords": [
+		"pi",
+		"orchestrator"
+	],
+	"author": "Earendil Works",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/earendil-works/pi.git",
+		"directory": "packages/orchestrator"
+	},
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"dependencies": {
+		"@earendil-works/pi-coding-agent": "^0.80.3"
+	},
+	"devDependencies": {
+		"shx": "0.4.0"
+	}
+}

package/node_modules/@earendil-works/pi-tui/dist/components/markdown.js

@@ -371,6 +371,9 @@ export class Markdown {
         };
         for (const token of tokens) {
             switch (token.type) {
+                case "escape":
+                    result += applyTextWithNewlines(this.options.preserveBackslashEscapes ? token.raw : token.text);
+                    break;
                 case "text":
                     // Text tokens in list items can have nested tokens for inline formatting
                     if (token.tokens && token.tokens.length > 0) {

package/node_modules/@earendil-works/pi-tui/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@earendil-works/pi-tui",
-	"version": "0.79.10",
+	"version": "0.80.3",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",