@psnext/slingcli 2.5.20260623-1 → 2.5.20260629-1

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.2",
+	"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.2"
+	},
+	"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.2",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",

package/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Fri, 19 Jun 2026 07:14:38 GMT
+ * Last updated: Wed, 24 Jun 2026 20:32:59 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/node/diagnostics_channel.d.ts

@@ -33,7 +33,10 @@ declare module "node:diagnostics_channel" {
      * @param name The channel name
      * @return The named channel object
      */
-    function channel(name: string | symbol): Channel;
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+    function channel<ContextType = any, StoreType = ContextType>(
+        name: string | symbol,
+    ): Channel<ContextType, StoreType>;
     type ChannelListener = (message: unknown, name: string | symbol) => void;
     /**
      * Register a message handler to subscribe to this channel. This message handler
@@ -96,12 +99,9 @@ declare module "node:diagnostics_channel" {
      * @param nameOrChannels Channel name or object containing all the `TracingChannel Channels`
      * @return Collection of channels to trace with
      */
-    function tracingChannel<
-        StoreType = unknown,
-        ContextType extends object = StoreType extends object ? StoreType : object,
-    >(
-        nameOrChannels: string | TracingChannelCollection<StoreType, ContextType>,
-    ): TracingChannel<StoreType, ContextType>;
+    function tracingChannel<ContextType extends object = object, StoreType = ContextType>(
+        nameOrChannels: string | TracingChannelCollection<ContextType, StoreType>,
+    ): TracingChannel<ContextType, StoreType>;
     /**
      * The class `Channel` represents an individual named channel within the data
      * pipeline. It is used to track subscribers and to publish messages when there
@@ -111,7 +111,7 @@ declare module "node:diagnostics_channel" {
      * with `new Channel(name)` is not supported.
      * @since v15.1.0, v14.17.0
      */
-    class Channel<StoreType = unknown, ContextType = StoreType> {
+    class Channel<ContextType = any, StoreType = ContextType> {
         readonly name: string | symbol;
         /**
          * Check if there are active subscribers to this channel. This is helpful if
@@ -304,12 +304,12 @@ declare module "node:diagnostics_channel" {
             },
         ) => void;
     }
-    interface TracingChannelCollection<StoreType = unknown, ContextType = StoreType> {
-        start: Channel<StoreType, ContextType>;
-        end: Channel<StoreType, ContextType>;
-        asyncStart: Channel<StoreType, ContextType>;
-        asyncEnd: Channel<StoreType, ContextType>;
-        error: Channel<StoreType, ContextType>;
+    interface TracingChannelCollection<ContextType extends object = object, StoreType = ContextType> {
+        start: Channel<ContextType, StoreType>;
+        end: Channel<ContextType, StoreType>;
+        asyncStart: Channel<ContextType, StoreType>;
+        asyncEnd: Channel<ContextType, StoreType>;
+        error: Channel<ContextType, StoreType>;
     }
     /**
      * The class `TracingChannel` is a collection of `TracingChannel Channels` which
@@ -320,12 +320,9 @@ declare module "node:diagnostics_channel" {
      * @since v19.9.0
      * @experimental
      */
-    class TracingChannel<StoreType = unknown, ContextType extends object = {}> implements TracingChannelCollection {
-        start: Channel<StoreType, ContextType>;
-        end: Channel<StoreType, ContextType>;
-        asyncStart: Channel<StoreType, ContextType>;
-        asyncEnd: Channel<StoreType, ContextType>;
-        error: Channel<StoreType, ContextType>;
+    interface TracingChannel<ContextType extends object = object, StoreType = ContextType>
+        extends TracingChannelCollection<ContextType, StoreType>
+    {
         /**
          * Helper to subscribe a collection of functions to the corresponding channels.
          * This is the same as calling `channel.subscribe(onMessage)` on each channel

package/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "26.0.0",
+    "version": "26.0.1",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -150,6 +150,6 @@
         "undici-types": "~8.3.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "b97b21d94288bc153e105a65f4c8fe609dd471f179c5bbd931ba27f959bd0744",
+    "typesPublisherContentHash": "a354aaa75dcea5eab474337cc3c7f8ab35ebed8c28d8cdb987dc31049b0fc0c6",
     "typeScriptVersion": "5.6"
 }

package/node_modules/brace-expansion/dist/commonjs/index.js

@@ -95,19 +95,23 @@ function gte(i, y) {
 function expand_(str, max, isTop) {
     /** @type {string[]} */
     const expansions = [];
-    const m = (0, balanced_match_1.balanced)('{', '}', str);
-    if (!m)
-        return [str];
-    // no need to expand pre, since it is guaranteed to be free of brace-sets
-    const pre = m.pre;
-    const post = m.post.length ? expand_(m.post, max, false) : [''];
-    if (/\$$/.test(m.pre)) {
-        for (let k = 0; k < post.length && k < max; k++) {
-            const expansion = pre + '{' + m.body + '}' + post[k];
-            expansions.push(expansion);
+    // The `{a},b}` rewrite below restarts expansion on a rewritten string with
+    // the same `max` and `isTop = true`. Loop instead of recursing so a long run
+    // of non-expanding `{}` groups can't exhaust the call stack.
+    for (;;) {
+        const m = (0, balanced_match_1.balanced)('{', '}', str);
+        if (!m)
+            return [str];
+        // no need to expand pre, since it is guaranteed to be free of brace-sets
+        const pre = m.pre;
+        if (/\$$/.test(m.pre)) {
+            const post = m.post.length ? expand_(m.post, max, false) : [''];
+            for (let k = 0; k < post.length && k < max; k++) {
+                const expansion = pre + '{' + m.body + '}' + post[k];
+                expansions.push(expansion);
+            }
+            return expansions;
         }
-    }
-    else {
         const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
         const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
         const isSequence = isNumericSequence || isAlphaSequence;
@@ -116,10 +120,16 @@ function expand_(str, max, isTop) {
             // {a},b}
             if (m.post.match(/,(?!,).*\}/)) {
                 str = m.pre + '{' + m.body + escClose + m.post;
-                return expand_(str, max, true);
+                isTop = true;
+                continue;
             }
             return [str];
         }
+        // Only expand post once we know this brace set actually expands. Computing
+        // it before the early returns above expanded post a second time on every
+        // non-expanding `{}`, which is what made inputs like `a{},{},{}...` blow up
+        // exponentially.
+        const post = m.post.length ? expand_(m.post, max, false) : [''];
         let n;
         if (isSequence) {
             n = m.body.split(/\.\./);
@@ -195,7 +205,7 @@ function expand_(str, max, isTop) {
                 }
             }
         }
+        return expansions;
     }
-    return expansions;
 }
 //# sourceMappingURL=index.js.map