@psnext/slingcli 2.5.20260623-1 → 2.5.20260629-1

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

@@ -0,0 +1,12 @@
+export function encodeMessage(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+export function parseRequestLine(line) {
+    const value = JSON.parse(line);
+    return value;
+}
+export function parseResponseLine(line) {
+    const value = JSON.parse(line);
+    return value;
+}
+//# sourceMappingURL=protocol.js.map

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

@@ -0,0 +1,145 @@
+import { existsSync, unlinkSync } from "node:fs";
+import { createConnection, createServer } from "node:net";
+import { getSocketPath } from "../config.js";
+import { encodeMessage, parseRequestLine, } from "./protocol.js";
+export async function startIpcServer(handler) {
+    const socketPath = getSocketPath();
+    await removeStaleSocketIfNeeded(socketPath);
+    const server = createServer((socket) => {
+        let buffer = "";
+        socket.on("data", async (chunk) => {
+            buffer += chunk.toString();
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).trim();
+            buffer = buffer.slice(newlineIndex + 1);
+            if (!line) {
+                return;
+            }
+            try {
+                const request = parseRequestLine(line);
+                if (request.type === "rpc_stream") {
+                    const response = await handler(request);
+                    if (!response.ok || response.type !== "rpc_ready" || !response.instance) {
+                        socket.end(encodeMessage(response));
+                        return;
+                    }
+                    socket.removeAllListeners("data");
+                    const rpcStream = handler.openRpcStream(request.instanceId, (response) => {
+                        socket.write(encodeMessage(response));
+                    }, (event) => {
+                        socket.write(encodeMessage(event));
+                    }, (request) => {
+                        socket.write(encodeMessage(request));
+                    });
+                    if (!rpcStream) {
+                        socket.end(encodeMessage({ type: "error", ok: false, error: `Unknown instance: ${request.instanceId}` }));
+                        return;
+                    }
+                    socket.write(encodeMessage(response));
+                    let rpcRequestQueue = Promise.resolve();
+                    socket.on("data", (rpcChunk) => {
+                        buffer += rpcChunk.toString();
+                        for (;;) {
+                            const rpcNewlineIndex = buffer.indexOf("\n");
+                            if (rpcNewlineIndex === -1) {
+                                break;
+                            }
+                            const rpcLine = buffer.slice(0, rpcNewlineIndex).trim();
+                            buffer = buffer.slice(rpcNewlineIndex + 1);
+                            if (!rpcLine) {
+                                continue;
+                            }
+                            rpcRequestQueue = rpcRequestQueue
+                                .then(async () => {
+                                try {
+                                    await rpcStream.handleRequest(JSON.parse(rpcLine));
+                                }
+                                catch (rpcError) {
+                                    socket.write(encodeMessage({
+                                        type: "error",
+                                        ok: false,
+                                        error: rpcError instanceof Error ? rpcError.message : String(rpcError),
+                                    }));
+                                }
+                            })
+                                .catch((rpcError) => {
+                                socket.write(encodeMessage({
+                                    type: "error",
+                                    ok: false,
+                                    error: rpcError.message,
+                                }));
+                            });
+                        }
+                    });
+                    socket.once("close", () => rpcStream.close());
+                    return;
+                }
+                const response = await handler(request);
+                socket.end(encodeMessage(response));
+            }
+            catch (error) {
+                const response = {
+                    type: "error",
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+                socket.end(encodeMessage(response));
+            }
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(socketPath, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    return server;
+}
+async function removeStaleSocketIfNeeded(socketPath) {
+    if (!existsSync(socketPath)) {
+        return;
+    }
+    const isLive = await isSocketLive(socketPath);
+    if (isLive) {
+        throw new Error(`orchestrator is already running: ${socketPath}`);
+    }
+    unlinkSync(socketPath);
+}
+async function isSocketLive(socketPath) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(socketPath);
+        let settled = false;
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(result);
+        };
+        socket.on("connect", () => finish(true));
+        socket.on("error", (error) => {
+            if (error.code === "ECONNREFUSED" || error.code === "ENOENT") {
+                finish(false);
+                return;
+            }
+            if (error.code === "EPIPE" || error.code === "ECONNRESET") {
+                finish(false);
+                return;
+            }
+            if (settled) {
+                return;
+            }
+            settled = true;
+            socket.removeAllListeners();
+            socket.destroy();
+            reject(error);
+        });
+    });
+}
+//# sourceMappingURL=server.js.map

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

@@ -0,0 +1,365 @@
+import { hostname, platform } from "node:os";
+import { AuthStorage } from "@earendil-works/pi-coding-agent";
+import { getOrchestratorDir, getSocketPath, VERSION } from "./config.js";
+import { loadMachine, saveMachine } from "./storage.js";
+const DEFAULT_RADIUS_URL = "https://radius.pi.dev/";
+const DEFAULT_ORCHESTRATOR_BASE_PATH = "/v1/";
+const NOT_FOUND_RETRY_THRESHOLD = 3;
+const HEARTBEAT_BACKOFF_BASE_MS = 1_000;
+const HEARTBEAT_BACKOFF_MAX_MS = 30_000;
+const RADIUS_PROVIDER = "radius";
+class RadiusHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = "RadiusHttpError";
+        this.status = status;
+    }
+}
+async function post(path, body) {
+    const response = await fetch(new URL(path, getRadiusOrchestratorBaseUrl()), {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${getRadiusAccessToken()}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        throw new RadiusHttpError(response.status, `Radius request failed: ${response.status} ${await response.text()}`);
+    }
+    return (await response.json());
+}
+async function maybePost(path, body) {
+    const response = await fetch(new URL(path, getRadiusOrchestratorBaseUrl()), {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${getRadiusAccessToken()}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        throw new RadiusHttpError(response.status, `Radius request failed: ${response.status} ${await response.text()}`);
+    }
+}
+function isNotFoundError(error) {
+    return error instanceof RadiusHttpError && error.status === 404;
+}
+function computeBackoffDelayMs(failureCount) {
+    const exponentialDelay = Math.min(HEARTBEAT_BACKOFF_MAX_MS, HEARTBEAT_BACKOFF_BASE_MS * 2 ** Math.max(0, failureCount - 1));
+    const jitterMs = Math.floor(Math.random() * Math.max(250, exponentialDelay / 4));
+    return Math.min(HEARTBEAT_BACKOFF_MAX_MS, exponentialDelay + jitterMs);
+}
+function formatRadiusError(error) {
+    if (error instanceof RadiusHttpError) {
+        return `HTTP ${error.status}: ${error.message}`;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function logRadiusRetry(scope, action, delayMs, failureCount, error) {
+    console.error(`${scope} ${action} failed (attempt ${failureCount}); retrying in ${delayMs}ms: ${formatRadiusError(error)}`);
+}
+export function getRadiusUrl() {
+    return process.env.PI_RADIUS_URL || DEFAULT_RADIUS_URL;
+}
+export function getRadiusOrchestratorBaseUrl() {
+    const explicitUrl = process.env.PI_RADIUS_ORCHESTRATOR_URL;
+    if (explicitUrl) {
+        return explicitUrl;
+    }
+    return new URL(DEFAULT_ORCHESTRATOR_BASE_PATH, getRadiusUrl()).toString();
+}
+const radiusAuthStorage = AuthStorage.create();
+function getStoredRadiusCredential() {
+    radiusAuthStorage.reload();
+    const credential = radiusAuthStorage.get(RADIUS_PROVIDER);
+    if (!credential || credential.type !== "oauth") {
+        return undefined;
+    }
+    return credential;
+}
+export function getRadiusAccessToken() {
+    const storedCredential = getStoredRadiusCredential();
+    if (typeof storedCredential?.access === "string" && storedCredential.access) {
+        return storedCredential.access;
+    }
+    const apiKey = process.env.PI_RADIUS_API_KEY;
+    if (apiKey) {
+        return apiKey;
+    }
+    throw new Error("Radius credentials are required in ~/.pi/agent/auth.json or PI_RADIUS_API_KEY");
+}
+export function isRadiusEnabled() {
+    return !!getStoredRadiusCredential()?.access || !!process.env.PI_RADIUS_API_KEY;
+}
+export class RadiusPresence {
+    machineHeartbeatTimer;
+    machineHeartbeatIntervalMs = 0;
+    machineConsecutiveNotFoundCount = 0;
+    machineTransientFailureCount = 0;
+    piHeartbeatStates = new Map();
+    machine;
+    coordinator;
+    setCoordinator(coordinator) {
+        this.coordinator = coordinator;
+    }
+    async start(label) {
+        if (!isRadiusEnabled()) {
+            return undefined;
+        }
+        const registered = await this.registerMachine(label);
+        this.startMachineHeartbeat(registered.heartbeatIntervalMs);
+        return this.machine;
+    }
+    async stop() {
+        if (this.machineHeartbeatTimer) {
+            clearTimeout(this.machineHeartbeatTimer);
+            this.machineHeartbeatTimer = undefined;
+        }
+        for (const [instanceId, state] of this.piHeartbeatStates) {
+            if (state.timer) {
+                clearTimeout(state.timer);
+            }
+            this.piHeartbeatStates.delete(instanceId);
+        }
+        if (!this.machine || !isRadiusEnabled()) {
+            return;
+        }
+        try {
+            await maybePost(`machines/${this.machine.id}/disconnect`, {});
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                throw error;
+            }
+        }
+    }
+    async registerPi(instance) {
+        if (!isRadiusEnabled()) {
+            return instance;
+        }
+        const machine = this.machine ?? loadMachine();
+        if (!machine) {
+            throw new Error("No registered machine available for Pi registration");
+        }
+        const registered = await post("pis/register", {
+            machineId: machine.id,
+            label: instance.label,
+            cwd: instance.cwd,
+            hostname: hostname(),
+            pid: process.pid,
+            transport: "local-rpc",
+            capabilities: { rpc: true, relay: false, iroh: false },
+            sessionId: instance.sessionId,
+        });
+        const registeredInstance = { ...instance, radiusPiId: registered.id };
+        this.startPiHeartbeat(instance.id, registered.heartbeatIntervalMs, registered.id);
+        return registeredInstance;
+    }
+    async disconnectPi(instance) {
+        const state = this.piHeartbeatStates.get(instance.id);
+        if (state) {
+            if (state.timer) {
+                clearTimeout(state.timer);
+            }
+            this.piHeartbeatStates.delete(instance.id);
+        }
+        if (!isRadiusEnabled() || !instance.radiusPiId) {
+            return;
+        }
+        try {
+            await maybePost(`pis/${instance.radiusPiId}/disconnect`, {});
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                throw error;
+            }
+        }
+    }
+    async registerMachine(label) {
+        const existingMachine = this.machine ?? loadMachine();
+        const registered = await post("machines/register", {
+            machineId: existingMachine?.id,
+            label,
+            hostname: hostname(),
+            platform: platform(),
+            arch: process.arch,
+            version: VERSION,
+            capabilities: { spawn: true, relay: false, iroh: false },
+        });
+        const timestamp = new Date().toISOString();
+        this.machine = {
+            id: registered.id,
+            createdAt: existingMachine?.createdAt ?? timestamp,
+            lastSeenAt: timestamp,
+            label,
+        };
+        saveMachine(this.machine);
+        this.machineConsecutiveNotFoundCount = 0;
+        this.machineTransientFailureCount = 0;
+        return registered;
+    }
+    startMachineHeartbeat(intervalMs) {
+        this.machineHeartbeatIntervalMs = intervalMs;
+        this.scheduleMachineHeartbeat(intervalMs);
+    }
+    scheduleMachineHeartbeat(delayMs) {
+        if (this.machineHeartbeatTimer) {
+            clearTimeout(this.machineHeartbeatTimer);
+        }
+        this.machineHeartbeatTimer = setTimeout(() => {
+            void this.heartbeatMachine();
+        }, delayMs);
+    }
+    startPiHeartbeat(instanceId, intervalMs, radiusPiId) {
+        const existingState = this.piHeartbeatStates.get(instanceId);
+        if (existingState?.timer) {
+            clearTimeout(existingState.timer);
+        }
+        const state = existingState ?? {
+            intervalMs,
+            radiusPiId,
+            consecutiveNotFoundCount: 0,
+            transientFailureCount: 0,
+        };
+        state.intervalMs = intervalMs;
+        state.radiusPiId = radiusPiId;
+        state.consecutiveNotFoundCount = 0;
+        state.transientFailureCount = 0;
+        this.piHeartbeatStates.set(instanceId, state);
+        this.schedulePiHeartbeat(instanceId, intervalMs);
+    }
+    schedulePiHeartbeat(instanceId, delayMs) {
+        const state = this.piHeartbeatStates.get(instanceId);
+        if (!state) {
+            return;
+        }
+        if (state.timer) {
+            clearTimeout(state.timer);
+        }
+        state.timer = setTimeout(() => {
+            void this.heartbeatPi(instanceId);
+        }, delayMs);
+    }
+    async heartbeatMachine() {
+        if (!this.machine || !isRadiusEnabled()) {
+            return;
+        }
+        try {
+            await maybePost(`machines/${this.machine.id}/heartbeat`, {
+                cwd: getOrchestratorDir(),
+                socketPath: getSocketPath(),
+            });
+            this.machineConsecutiveNotFoundCount = 0;
+            this.machineTransientFailureCount = 0;
+            this.scheduleMachineHeartbeat(this.machineHeartbeatIntervalMs);
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                this.machineTransientFailureCount += 1;
+                const delayMs = computeBackoffDelayMs(this.machineTransientFailureCount);
+                logRadiusRetry("Radius machine", "heartbeat", delayMs, this.machineTransientFailureCount, error);
+                this.scheduleMachineHeartbeat(delayMs);
+                return;
+            }
+            this.machineTransientFailureCount = 0;
+            this.machineConsecutiveNotFoundCount += 1;
+            if (this.machineConsecutiveNotFoundCount < NOT_FOUND_RETRY_THRESHOLD) {
+                this.scheduleMachineHeartbeat(this.machineHeartbeatIntervalMs);
+                return;
+            }
+            try {
+                await this.reRegisterMachineAndPis();
+            }
+            catch (recoveryError) {
+                this.machineTransientFailureCount += 1;
+                const delayMs = computeBackoffDelayMs(this.machineTransientFailureCount);
+                logRadiusRetry("Radius machine", "re-registration", delayMs, this.machineTransientFailureCount, recoveryError);
+                this.scheduleMachineHeartbeat(delayMs);
+            }
+        }
+    }
+    async heartbeatPi(instanceId) {
+        if (!isRadiusEnabled()) {
+            return;
+        }
+        const state = this.piHeartbeatStates.get(instanceId);
+        if (!state) {
+            return;
+        }
+        try {
+            await maybePost(`pis/${state.radiusPiId}/heartbeat`, {});
+            state.consecutiveNotFoundCount = 0;
+            state.transientFailureCount = 0;
+            this.schedulePiHeartbeat(instanceId, state.intervalMs);
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                state.transientFailureCount += 1;
+                const delayMs = computeBackoffDelayMs(state.transientFailureCount);
+                logRadiusRetry(`Radius Pi ${instanceId}`, "heartbeat", delayMs, state.transientFailureCount, error);
+                this.schedulePiHeartbeat(instanceId, delayMs);
+                return;
+            }
+            state.transientFailureCount = 0;
+            state.consecutiveNotFoundCount += 1;
+            if (state.consecutiveNotFoundCount < NOT_FOUND_RETRY_THRESHOLD) {
+                this.schedulePiHeartbeat(instanceId, state.intervalMs);
+                return;
+            }
+            try {
+                const recovered = await this.reRegisterPi(instanceId);
+                if (!recovered) {
+                    const delayMs = computeBackoffDelayMs(1);
+                    console.error(`Radius Pi ${instanceId} re-registration skipped; retrying in ${delayMs}ms`);
+                    this.schedulePiHeartbeat(instanceId, delayMs);
+                }
+            }
+            catch (recoveryError) {
+                state.transientFailureCount += 1;
+                const delayMs = computeBackoffDelayMs(state.transientFailureCount);
+                logRadiusRetry(`Radius Pi ${instanceId}`, "re-registration", delayMs, state.transientFailureCount, recoveryError);
+                this.schedulePiHeartbeat(instanceId, delayMs);
+            }
+        }
+    }
+    async reRegisterMachineAndPis() {
+        const registered = await this.registerMachine(this.machine?.label);
+        this.startMachineHeartbeat(registered.heartbeatIntervalMs);
+        const instances = this.coordinator?.listLiveInstances() ?? [];
+        for (const instance of instances) {
+            try {
+                await this.reRegisterPi(instance.id);
+            }
+            catch (error) {
+                console.error(`Radius Pi ${instance.id} re-registration failed: ${formatRadiusError(error)}`);
+            }
+        }
+    }
+    async reRegisterPi(instanceId) {
+        const instance = this.coordinator?.getLiveInstance(instanceId);
+        if (!instance) {
+            const state = this.piHeartbeatStates.get(instanceId);
+            if (state) {
+                if (state.timer) {
+                    clearTimeout(state.timer);
+                }
+                this.piHeartbeatStates.delete(instanceId);
+            }
+            return false;
+        }
+        if (!this.machine) {
+            await this.reRegisterMachineAndPis();
+            return true;
+        }
+        const registeredInstance = await this.registerPi(instance);
+        this.coordinator?.updateInstance(registeredInstance);
+        return true;
+    }
+}
+export const radiusPresence = new RadiusPresence();
+//# sourceMappingURL=radius.js.map

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