@psnext/slingcli 2.5.20260623-1 → 2.5.20260629-1

package/node_modules/@earendil-works/pi-coding-agent/dist/rpc-entry.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { APP_NAME } from "./config.js";
+import { configureHttpDispatcher } from "./core/http-dispatcher.js";
+import { main } from "./main.js";
+process.title = `${APP_NAME}-rpc`;
+process.env.PI_CODING_AGENT = "true";
+process.emitWarning = (() => { });
+configureHttpDispatcher();
+main(["--mode", "rpc", ...process.argv.slice(2)]);
+//# sourceMappingURL=rpc-entry.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/utils/image-convert.js

@@ -1,31 +1,18 @@
 import { applyExifOrientation } from "./exif-orientation.js";
 import { loadPhoton } from "./photon.js";
-/**
- * Convert image to PNG format for terminal display.
- * Kitty graphics protocol requires PNG format (f=100).
- */
-export async function convertToPng(base64Data, mimeType) {
-    // Already PNG, no conversion needed
-    if (mimeType === "image/png") {
-        return { data: base64Data, mimeType };
-    }
+export async function convertImageBytesToPng(bytes) {
     const photon = await loadPhoton();
     if (!photon) {
         // Photon not available, can't convert
         return null;
     }
     try {
-        const bytes = new Uint8Array(Buffer.from(base64Data, "base64"));
         const rawImage = photon.PhotonImage.new_from_byteslice(bytes);
         const image = applyExifOrientation(photon, rawImage, bytes);
         if (image !== rawImage)
             rawImage.free();
         try {
-            const pngBuffer = image.get_bytes();
-            return {
-                data: Buffer.from(pngBuffer).toString("base64"),
-                mimeType: "image/png",
-            };
+            return new Uint8Array(image.get_bytes());
         }
         finally {
             image.free();
@@ -36,4 +23,23 @@ export async function convertToPng(base64Data, mimeType) {
         return null;
     }
 }
+/**
+ * Convert image to PNG format for terminal display.
+ * Kitty graphics protocol requires PNG format (f=100).
+ */
+export async function convertToPng(base64Data, mimeType) {
+    // Already PNG, no conversion needed
+    if (mimeType === "image/png") {
+        return { data: base64Data, mimeType };
+    }
+    const bytes = new Uint8Array(Buffer.from(base64Data, "base64"));
+    const pngBytes = await convertImageBytesToPng(bytes);
+    if (!pngBytes) {
+        return null;
+    }
+    return {
+        data: Buffer.from(pngBytes).toString("base64"),
+        mimeType: "image/png",
+    };
+}
 //# sourceMappingURL=image-convert.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/utils/image-process.js

@@ -0,0 +1,83 @@
+import { convertImageBytesToPng } from "./image-convert.js";
+import { formatDimensionNote, resizeImage } from "./image-resize.js";
+function baseMimeType(mimeType) {
+    return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
+}
+function normalizeSupportedImageMimeType(mimeType) {
+    switch (baseMimeType(mimeType)) {
+        case "image/png":
+            return "image/png";
+        case "image/jpeg":
+        case "image/jpg":
+            return "image/jpeg";
+        case "image/gif":
+            return "image/gif";
+        case "image/webp":
+            return "image/webp";
+        default:
+            return null;
+    }
+}
+async function normalizeImage(bytes, mimeType) {
+    const normalizedMimeType = normalizeSupportedImageMimeType(mimeType);
+    if (normalizedMimeType) {
+        return { bytes, mimeType: normalizedMimeType };
+    }
+    const pngBytes = await convertImageBytesToPng(bytes);
+    if (!pngBytes) {
+        return null;
+    }
+    return {
+        bytes: pngBytes,
+        mimeType: "image/png",
+        convertedFrom: baseMimeType(mimeType),
+    };
+}
+function conversionHint(from, to) {
+    if (!from || from === to)
+        return undefined;
+    return `[Image converted from ${from} to ${to}.]`;
+}
+export async function processImage(bytes, mimeType, options) {
+    const autoResizeImages = options?.autoResizeImages ?? true;
+    const normalized = await normalizeImage(bytes, mimeType);
+    if (!normalized) {
+        return {
+            ok: false,
+            message: "[Image omitted: could not be converted to a supported inline image format.]",
+        };
+    }
+    if (autoResizeImages) {
+        const resized = await resizeImage(normalized.bytes, normalized.mimeType, options?.resizeOptions);
+        if (!resized) {
+            return {
+                ok: false,
+                message: "[Image omitted: could not be resized below the inline image size limit.]",
+            };
+        }
+        const hints = [];
+        const convertedHint = conversionHint(normalized.convertedFrom, resized.mimeType);
+        if (convertedHint)
+            hints.push(convertedHint);
+        const dimensionNote = formatDimensionNote(resized);
+        if (dimensionNote)
+            hints.push(dimensionNote);
+        return {
+            ok: true,
+            data: resized.data,
+            mimeType: resized.mimeType,
+            hints,
+        };
+    }
+    const hints = [];
+    const convertedHint = conversionHint(normalized.convertedFrom, normalized.mimeType);
+    if (convertedHint)
+        hints.push(convertedHint);
+    return {
+        ok: true,
+        data: Buffer.from(normalized.bytes).toString("base64"),
+        mimeType: normalized.mimeType,
+        hints,
+    };
+}
+//# sourceMappingURL=image-process.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/utils/mime.js

@@ -14,6 +14,9 @@ export function detectSupportedImageMimeType(buffer) {
     if (startsWithAscii(buffer, 0, "RIFF") && startsWithAscii(buffer, 8, "WEBP")) {
         return "image/webp";
     }
+    if (startsWithAscii(buffer, 0, "BM") && isBmp(buffer)) {
+        return "image/bmp";
+    }
     return null;
 }
 export async function detectSupportedImageMimeTypeFromFile(filePath) {
@@ -46,12 +49,50 @@ function isAnimatedPng(buffer) {
     }
     return false;
 }
+function isBmp(buffer) {
+    if (buffer.length < 26)
+        return false;
+    const declaredFileSize = readUint32LE(buffer, 2);
+    const pixelDataOffset = readUint32LE(buffer, 10);
+    const dibHeaderSize = readUint32LE(buffer, 14);
+    if (declaredFileSize !== 0 && declaredFileSize < 26)
+        return false;
+    if (pixelDataOffset < 14 + dibHeaderSize)
+        return false;
+    if (declaredFileSize !== 0 && pixelDataOffset >= declaredFileSize)
+        return false;
+    let colorPlanes;
+    let bitsPerPixel;
+    if (dibHeaderSize === 12) {
+        colorPlanes = readUint16LE(buffer, 22);
+        bitsPerPixel = readUint16LE(buffer, 24);
+    }
+    else if (dibHeaderSize >= 40 && dibHeaderSize <= 124) {
+        if (buffer.length < 30)
+            return false;
+        colorPlanes = readUint16LE(buffer, 26);
+        bitsPerPixel = readUint16LE(buffer, 28);
+    }
+    else {
+        return false;
+    }
+    return colorPlanes === 1 && [1, 4, 8, 16, 24, 32].includes(bitsPerPixel);
+}
+function readUint16LE(buffer, offset) {
+    return (buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8);
+}
 function readUint32BE(buffer, offset) {
     return ((buffer[offset] ?? 0) * 0x1000000 +
         ((buffer[offset + 1] ?? 0) << 16) +
         ((buffer[offset + 2] ?? 0) << 8) +
         (buffer[offset + 3] ?? 0));
 }
+function readUint32LE(buffer, offset) {
+    return ((buffer[offset] ?? 0) +
+        ((buffer[offset + 1] ?? 0) << 8) +
+        ((buffer[offset + 2] ?? 0) << 16) +
+        (buffer[offset + 3] ?? 0) * 0x1000000);
+}
 function startsWith(buffer, bytes) {
     if (buffer.length < bytes.length)
         return false;

package/node_modules/@earendil-works/pi-coding-agent/npm-shrinkwrap.json

@@ -1,17 +1,17 @@
 {
 	"name": "@earendil-works/pi-coding-agent",
-	"version": "0.79.10",
+	"version": "0.80.2",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@earendil-works/pi-coding-agent",
-			"version": "0.79.10",
+			"version": "0.80.2",
 			"license": "MIT",
 			"dependencies": {
-				"@earendil-works/pi-agent-core": "^0.79.10",
-				"@earendil-works/pi-ai": "^0.79.10",
-				"@earendil-works/pi-tui": "^0.79.10",
+				"@earendil-works/pi-agent-core": "^0.80.2",
+				"@earendil-works/pi-ai": "^0.80.2",
+				"@earendil-works/pi-tui": "^0.80.2",
 				"@silvia-odwyer/photon-node": "0.3.4",
 				"chalk": "5.6.2",
 				"cross-spawn": "7.0.6",
@@ -474,11 +474,11 @@
 			}
 		},
 		"node_modules/@earendil-works/pi-agent-core": {
-			"version": "0.79.10",
-			"resolved": "https://registry.npmjs.org/@earendil-works/pi-agent-core/-/pi-agent-core-0.79.10.tgz",
+			"version": "0.80.2",
+			"resolved": "https://registry.npmjs.org/@earendil-works/pi-agent-core/-/pi-agent-core-0.80.2.tgz",
 			"license": "MIT",
 			"dependencies": {
-				"@earendil-works/pi-ai": "^0.79.10",
+				"@earendil-works/pi-ai": "^0.80.2",
 				"ignore": "7.0.5",
 				"typebox": "1.1.38",
 				"yaml": "2.9.0"
@@ -488,8 +488,8 @@
 			}
 		},
 		"node_modules/@earendil-works/pi-ai": {
-			"version": "0.79.10",
-			"resolved": "https://registry.npmjs.org/@earendil-works/pi-ai/-/pi-ai-0.79.10.tgz",
+			"version": "0.80.2",
+			"resolved": "https://registry.npmjs.org/@earendil-works/pi-ai/-/pi-ai-0.80.2.tgz",
 			"license": "MIT",
 			"dependencies": {
 				"@anthropic-ai/sdk": "0.91.1",
@@ -512,8 +512,8 @@
 			}
 		},
 		"node_modules/@earendil-works/pi-tui": {
-			"version": "0.79.10",
-			"resolved": "https://registry.npmjs.org/@earendil-works/pi-tui/-/pi-tui-0.79.10.tgz",
+			"version": "0.80.2",
+			"resolved": "https://registry.npmjs.org/@earendil-works/pi-tui/-/pi-tui-0.80.2.tgz",
 			"license": "MIT",
 			"dependencies": {
 				"get-east-asian-width": "1.6.0",

package/node_modules/@earendil-works/pi-coding-agent/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@earendil-works/pi-coding-agent",
-	"version": "0.79.10",
+	"version": "0.80.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -16,6 +16,9 @@
 		".": {
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
+		},
+		"./rpc-entry": {
+			"import": "./dist/rpc-entry.js"
 		}
 	},
 	"files": [
@@ -28,7 +31,7 @@
 	],
 	"scripts": {
 		"clean": "shx rm -rf dist",
-		"build": "tsgo -p tsconfig.build.json && shx chmod +x dist/cli.js && npm run copy-assets",
+		"build": "tsgo -p tsconfig.build.json && shx chmod +x dist/cli.js dist/rpc-entry.js && npm run copy-assets",
 		"build:binary": "npm --prefix ../tui run build && npm --prefix ../ai run build && npm --prefix ../agent run build && npm run build && bun build --compile ./dist/bun/cli.js ./src/utils/image-resize-worker.ts --outfile dist/pi && npm run copy-binary-assets",
 		"copy-assets": "shx mkdir -p dist/modes/interactive/theme && shx cp src/modes/interactive/theme/*.json dist/modes/interactive/theme/ && shx mkdir -p dist/modes/interactive/assets && shx cp src/modes/interactive/assets/*.png dist/modes/interactive/assets/ && shx mkdir -p dist/core/export-html/vendor && shx cp src/core/export-html/template.html src/core/export-html/template.css src/core/export-html/template.js dist/core/export-html/ && shx cp src/core/export-html/vendor/*.js dist/core/export-html/vendor/",
 		"copy-binary-assets": "shx cp package.json dist/ && shx cp README.md dist/ && shx cp CHANGELOG.md dist/ && shx mkdir -p dist/theme && shx cp src/modes/interactive/theme/*.json dist/theme/ && shx mkdir -p dist/assets && shx cp src/modes/interactive/assets/*.png dist/assets/ && shx mkdir -p dist/export-html/vendor && shx cp src/core/export-html/template.html dist/export-html/ && shx cp src/core/export-html/vendor/*.js dist/export-html/vendor/ && shx cp -r docs dist/ && shx cp -r examples dist/ && shx cp ../../node_modules/@silvia-odwyer/photon-node/photon_rs_bg.wasm dist/",
@@ -37,9 +40,9 @@
 		"prepublishOnly": "npm run clean && npm run build && npm run shrinkwrap"
 	},
 	"dependencies": {
-		"@earendil-works/pi-agent-core": "^0.79.10",
-		"@earendil-works/pi-ai": "^0.79.10",
-		"@earendil-works/pi-tui": "^0.79.10",
+		"@earendil-works/pi-agent-core": "^0.80.2",
+		"@earendil-works/pi-ai": "^0.80.2",
+		"@earendil-works/pi-tui": "^0.80.2",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"chalk": "5.6.2",
 		"cross-spawn": "7.0.6",

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

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { createConnection } from "node:net";
+import { dirname, join } from "node:path";
+import { cwd } from "node:process";
+import { fileURLToPath } from "node:url";
+import { getSocketPath } from "./config.js";
+import { sendIpcRequest } from "./ipc/client.js";
+import { encodeMessage } from "./ipc/protocol.js";
+import { serve } from "./serve.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
+function printHelp() {
+    console.log(`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator rpc <instance-id> <json-command>\n  orchestrator rpc-stream <instance-id>\n  orchestrator --help\n  orchestrator --version\n\nRPC stream stdin expects JSONL RpcCommand or extension_ui_response messages.`);
+}
+function printResponse(response) {
+    console.log(JSON.stringify(response, null, 2));
+}
+function getFlagValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1 || index + 1 >= args.length) {
+        return undefined;
+    }
+    return args[index + 1];
+}
+async function rpcStream(instanceId) {
+    const socket = createConnection(getSocketPath());
+    let stdinBuffer = "";
+    process.stdin.setEncoding("utf8");
+    await new Promise((resolve, reject) => {
+        socket.once("connect", () => {
+            socket.write(encodeMessage({ type: "rpc_stream", instanceId }));
+            resolve();
+        });
+        socket.once("error", reject);
+    });
+    socket.on("data", (chunk) => {
+        process.stdout.write(chunk.toString());
+    });
+    console.error(`connected to rpc stream ${instanceId}; send JSONL RpcCommand or extension_ui_response on stdin`);
+    socket.on("error", (error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+    socket.on("end", () => {
+        process.exit(0);
+    });
+    process.stdin.on("data", (chunk) => {
+        stdinBuffer += chunk;
+        while (true) {
+            const newlineIndex = stdinBuffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            const line = stdinBuffer.slice(0, newlineIndex).trim();
+            stdinBuffer = stdinBuffer.slice(newlineIndex + 1);
+            if (!line) {
+                continue;
+            }
+            const parsed = JSON.parse(line);
+            socket.write(encodeMessage(parsed));
+        }
+    });
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        printHelp();
+        process.exit(0);
+    }
+    if (args[0] === "--version" || args[0] === "-v") {
+        console.log(packageJson.version);
+        process.exit(0);
+    }
+    if (args[0] === "serve") {
+        await serve();
+        return;
+    }
+    if (args[0] === "list") {
+        printResponse(await sendIpcRequest({ type: "list" }));
+        return;
+    }
+    if (args[0] === "spawn") {
+        const spawnCwd = getFlagValue(args, "--cwd") ?? cwd();
+        const label = getFlagValue(args, "--label");
+        printResponse(await sendIpcRequest({ type: "spawn", cwd: spawnCwd, label }));
+        return;
+    }
+    if (args[0] === "status") {
+        const instanceId = args[1];
+        if (!instanceId) {
+            console.error("Usage: orchestrator status <instance-id>");
+            process.exit(1);
+        }
+        printResponse(await sendIpcRequest({ type: "status", instanceId }));
+        return;
+    }
+    if (args[0] === "stop") {
+        const instanceId = args[1];
+        if (!instanceId) {
+            console.error("Usage: orchestrator stop <instance-id>");
+            process.exit(1);
+        }
+        printResponse(await sendIpcRequest({ type: "stop", instanceId }));
+        return;
+    }
+    if (args[0] === "rpc") {
+        const instanceId = args[1];
+        const commandJson = args[2];
+        if (!instanceId || !commandJson) {
+            console.error("Usage: orchestrator rpc <instance-id> <json-command>");
+            process.exit(1);
+        }
+        printResponse(await sendIpcRequest({
+            type: "rpc",
+            instanceId,
+            command: JSON.parse(commandJson),
+        }));
+        return;
+    }
+    if (args[0] === "rpc-stream") {
+        const instanceId = args[1];
+        if (!instanceId) {
+            console.error("Usage: orchestrator rpc-stream <instance-id>");
+            process.exit(1);
+        }
+        await rpcStream(instanceId);
+        return;
+    }
+    console.error(`Unknown command: ${args[0]}`);
+    printHelp();
+    process.exit(1);
+}
+await main();
+//# sourceMappingURL=cli.js.map

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

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const CONFIG_DIR_NAME = ".pi";
+const ENV_ORCHESTRATOR_DIR = "PI_ORCHESTRATOR_DIR";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Detect if we're running as a Bun compiled binary.
+ * Bun binaries have import.meta.url containing "$bunfs", "~BUN", or "%7EBUN" (Bun's virtual filesystem path)
+ */
+export const isBunBinary = import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN") || import.meta.url.includes("%7EBUN");
+function getPackageJsonPath() {
+    let dir = __dirname;
+    while (dir !== dirname(dir)) {
+        const packageJsonPath = join(dir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        dir = dirname(dir);
+    }
+    return join(__dirname, "package.json");
+}
+let pkg = {};
+try {
+    pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8"));
+}
+catch (e) {
+    const err = e;
+    if (err.code !== "ENOENT")
+        throw e;
+}
+export const VERSION = pkg.version || "0.0.0";
+export function getOrchestratorDir() {
+    const envDir = process.env[ENV_ORCHESTRATOR_DIR];
+    if (envDir) {
+        return envDir;
+    }
+    const piDir = process.env.PI_CONFIG_DIR || join(homedir(), CONFIG_DIR_NAME);
+    return join(piDir, "orchestrator");
+}
+export function getAuthPath() {
+    return join(getOrchestratorDir(), "auth.json");
+}
+export function getMachinePath() {
+    return join(getOrchestratorDir(), "machine.json");
+}
+export function getInstancesPath() {
+    return join(getOrchestratorDir(), "instances.json");
+}
+export function getSocketPath() {
+    return join(getOrchestratorDir(), "orchestrator.sock");
+}
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,105 @@
+import { supervisor } from "./supervisor.js";
+function toInstanceSummary(instance) {
+    return {
+        id: instance.id,
+        status: instance.status,
+        cwd: instance.cwd,
+        label: instance.label,
+        sessionId: instance.sessionId,
+        sessionFile: instance.sessionFile,
+        radiusPiId: instance.radiusPiId,
+    };
+}
+function unknownInstanceError(instanceId) {
+    return {
+        type: "error",
+        ok: false,
+        error: `Unknown instance: ${instanceId}`,
+    };
+}
+export async function handleIpcRequest(request) {
+    switch (request.type) {
+        case "spawn": {
+            const instance = await supervisor.spawnInstance({
+                cwd: request.cwd,
+                label: request.label,
+            });
+            return {
+                type: "spawn_result",
+                ok: true,
+                instance: toInstanceSummary(instance),
+            };
+        }
+        case "list": {
+            return {
+                type: "list_result",
+                ok: true,
+                instances: supervisor.listInstances().map(toInstanceSummary),
+            };
+        }
+        case "status": {
+            const instance = supervisor.getInstance(request.instanceId);
+            if (!instance) {
+                return unknownInstanceError(request.instanceId);
+            }
+            return {
+                type: "status_result",
+                ok: true,
+                instance: toInstanceSummary(instance),
+            };
+        }
+        case "stop": {
+            const instance = await supervisor.stopInstance(request.instanceId);
+            if (!instance) {
+                return unknownInstanceError(request.instanceId);
+            }
+            return {
+                type: "stop_result",
+                ok: true,
+                instanceId: request.instanceId,
+            };
+        }
+        case "rpc": {
+            const response = await supervisor.handleRpc(request.instanceId, request.command);
+            if (!response) {
+                return unknownInstanceError(request.instanceId);
+            }
+            return {
+                type: "rpc_result",
+                ok: true,
+                response,
+            };
+        }
+        case "rpc_stream": {
+            const instance = supervisor.getInstance(request.instanceId);
+            if (!instance) {
+                return unknownInstanceError(request.instanceId);
+            }
+            return {
+                type: "rpc_ready",
+                ok: true,
+                instance: toInstanceSummary(instance),
+            };
+        }
+    }
+}
+export function openRpcStream(instanceId, onResponse, onSessionEvent, onUiRequest) {
+    const handle = supervisor.openRpcStream(instanceId, onSessionEvent, onUiRequest);
+    if (!handle) {
+        return undefined;
+    }
+    return {
+        async handleRequest(request) {
+            if (request.type === "extension_ui_response") {
+                handle.handleUiResponse(request);
+                return;
+            }
+            const response = await handle.handleRpc(request);
+            onResponse(response);
+        },
+        close() {
+            handle.close();
+        },
+    };
+}
+//# sourceMappingURL=handler.js.map

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

@@ -0,0 +1,11 @@
+export * from "./config.js";
+export * from "./handler.js";
+export * from "./ipc/client.js";
+export * from "./ipc/protocol.js";
+export * from "./ipc/server.js";
+export * from "./rpc-process.js";
+export * from "./serve.js";
+export * from "./storage.js";
+export * from "./supervisor.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,56 @@
+import { createConnection } from "node:net";
+import { getSocketPath } from "../config.js";
+import { encodeMessage, parseResponseLine } from "./protocol.js";
+export async function sendIpcRequest(request) {
+    const socketPath = getSocketPath();
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(socketPath);
+        let buffer = "";
+        let settled = false;
+        const cleanup = () => {
+            socket.removeAllListeners();
+            socket.end();
+        };
+        socket.on("connect", () => {
+            socket.write(encodeMessage(request));
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString();
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).trim();
+            if (!line) {
+                return;
+            }
+            try {
+                settled = true;
+                resolve(parseResponseLine(line));
+                cleanup();
+            }
+            catch (error) {
+                settled = true;
+                reject(error);
+                cleanup();
+            }
+        });
+        socket.on("error", (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            reject(error);
+            cleanup();
+        });
+        socket.on("end", () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            reject(new Error(`Orchestrator socket closed before a response was received: ${socketPath}`));
+            cleanup();
+        });
+    });
+}
+//# sourceMappingURL=client.js.map