@psnext/slingcli 2.4.20260526-1 → 2.4.20260527-3

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/login-dialog.js

@@ -68,7 +68,7 @@ export class LoginDialogComponent extends Container {
     /**
      * Called by onAuth callback - show URL and optional instructions
      */
-    showAuth(url, instructions) {
+    showAuth(url, instructions, options = {}) {
         this.contentContainer.clear();
         this.contentContainer.addChild(new Spacer(1));
         const linkedUrl = `\x1b]8;;${url}\x07${url}\x1b]8;;\x07`;
@@ -80,11 +80,36 @@ export class LoginDialogComponent extends Container {
             this.contentContainer.addChild(new Spacer(1));
             this.contentContainer.addChild(new Text(theme.fg("warning", instructions), 1, 0));
         }
-        // Try to open browser
-        const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-        exec(`${openCmd} "${url}"`);
+        if (options.autoOpenBrowser ?? true) {
+            this.openUrl(url);
+        }
+        this.tui.requestRender();
+    }
+    /**
+     * Called by onDeviceCode callback - show URL and user code.
+     */
+    showDeviceCode(info) {
+        this.contentContainer.clear();
+        this.contentContainer.addChild(new Spacer(1));
+        const linkedUrl = `\x1b]8;;${info.verificationUri}\x07${info.verificationUri}\x1b]8;;\x07`;
+        this.contentContainer.addChild(new Text(theme.fg("accent", linkedUrl), 1, 0));
+        const clickHint = process.platform === "darwin" ? "Cmd+click to open" : "Ctrl+click to open";
+        const hyperlink = `\x1b]8;;${info.verificationUri}\x07${clickHint}\x1b]8;;\x07`;
+        this.contentContainer.addChild(new Text(theme.fg("dim", hyperlink), 1, 0));
+        this.contentContainer.addChild(new Spacer(1));
+        this.contentContainer.addChild(new Text(theme.fg("warning", `Enter code: ${info.userCode}`), 1, 0));
+        this.openUrl(info.verificationUri);
         this.tui.requestRender();
     }
+    openUrl(url) {
+        const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        try {
+            exec(`${openCmd} "${url}"`, () => { });
+        }
+        catch {
+            // Ignore browser launch failures. The URL remains visible for manual opening/copying.
+        }
+    }
     /**
      * Show input for manual code/URL entry (for callback server providers)
      */

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/user-message.js

@@ -13,7 +13,7 @@ export class UserMessageComponent extends Container {
         this.contentBox = new Box(1, 1, (content) => theme.bg("userMessageBg", content));
         this.contentBox.addChild(new Markdown(text, 0, 0, markdownTheme, {
             color: (content) => theme.fg("userMessageText", content),
-        }));
+        }, { preserveOrderedListMarkers: true }));
         this.addChild(this.contentBox);
     }
     render(width) {

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/interactive-mode.js

@@ -3995,12 +3995,12 @@ export class InteractiveMode {
                             }
                         });
                     }
-                    else if (providerId === "github-copilot") {
-                        // GitHub Copilot polls after onAuth
-                        dialog.showWaiting("Waiting for browser authentication...");
-                    }
                     // For Anthropic: onPrompt is called immediately after
                 },
+                onDeviceCode: (info) => {
+                    dialog.showDeviceCode(info);
+                    dialog.showWaiting("Waiting for authentication...");
+                },
                 onPrompt: async (prompt) => {
                     return dialog.showPrompt(prompt.message, prompt.placeholder);
                 },

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/theme/theme.js

@@ -328,47 +328,56 @@ function getBuiltinThemes() {
     return BUILTIN_THEMES;
 }
 export function getAvailableThemes() {
-    const themes = new Set(Object.keys(getBuiltinThemes()));
-    const customThemesDir = getCustomThemesDir();
-    if (fs.existsSync(customThemesDir)) {
-        const files = fs.readdirSync(customThemesDir);
-        for (const file of files) {
-            if (file.endsWith(".json")) {
-                themes.add(file.slice(0, -5));
-            }
-        }
-    }
-    for (const name of registeredThemes.keys()) {
-        themes.add(name);
-    }
-    return Array.from(themes).sort();
+    return getAvailableThemesWithPaths().map(({ name }) => name);
 }
 export function getAvailableThemesWithPaths() {
     const themesDir = getThemesDir();
-    const customThemesDir = getCustomThemesDir();
     const result = [];
+    const seen = new Set();
+    const addTheme = (themeInfo) => {
+        if (seen.has(themeInfo.name)) {
+            return;
+        }
+        seen.add(themeInfo.name);
+        result.push(themeInfo);
+    };
     // Built-in themes
     for (const name of Object.keys(getBuiltinThemes())) {
-        result.push({ name, path: path.join(themesDir, `${name}.json`) });
+        addTheme({ name, path: path.join(themesDir, `${name}.json`) });
     }
     // Custom themes
-    if (fs.existsSync(customThemesDir)) {
-        for (const file of fs.readdirSync(customThemesDir)) {
-            if (file.endsWith(".json")) {
-                const name = file.slice(0, -5);
-                if (!result.some((t) => t.name === name)) {
-                    result.push({ name, path: path.join(customThemesDir, file) });
-                }
-            }
-        }
+    for (const themeInfo of getCustomThemeInfos()) {
+        addTheme(themeInfo);
     }
     for (const [name, theme] of registeredThemes.entries()) {
-        if (!result.some((t) => t.name === name)) {
-            result.push({ name, path: theme.sourcePath });
-        }
+        addTheme({ name, path: theme.sourcePath });
     }
     return result.sort((a, b) => a.name.localeCompare(b.name));
 }
+function getCustomThemeInfos() {
+    const customThemesDir = getCustomThemesDir();
+    const result = [];
+    if (!fs.existsSync(customThemesDir)) {
+        return result;
+    }
+    for (const file of fs.readdirSync(customThemesDir)) {
+        if (!file.endsWith(".json")) {
+            continue;
+        }
+        const themePath = path.join(customThemesDir, file);
+        try {
+            const customTheme = loadThemeFromPath(themePath);
+            if (customTheme.name) {
+                result.push({ name: customTheme.name, path: themePath });
+            }
+        }
+        catch {
+            // Invalid themes are ignored here; the resource loader reports them
+            // during normal startup/reload.
+        }
+    }
+    return result;
+}
 function parseThemeJson(label, json) {
     if (!validateThemeJson.Check(json)) {
         const errors = Array.from(validateThemeJson.Errors(json));

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

@@ -15,6 +15,7 @@ export class RpcClient {
     pendingRequests = new Map();
     requestId = 0;
     stderr = "";
+    exitError = null;
     options;
     constructor(options = {}) {
         this.options = options;
@@ -26,6 +27,7 @@ export class RpcClient {
         if (this.process) {
             throw new Error("Client already started");
         }
+        this.exitError = null;
         const cliPath = this.options.cliPath ?? "dist/cli.js";
         const args = ["--mode", "rpc"];
         if (this.options.provider) {
@@ -37,24 +39,48 @@ export class RpcClient {
         if (this.options.args) {
             args.push(...this.options.args);
         }
-        this.process = spawn("node", [cliPath, ...args], {
+        const childProcess = spawn("node", [cliPath, ...args], {
             cwd: this.options.cwd,
             env: { ...process.env, ...this.options.env },
             stdio: ["pipe", "pipe", "pipe"],
         });
+        this.process = childProcess;
         // Collect stderr for debugging
-        this.process.stderr?.on("data", (data) => {
+        childProcess.stderr?.on("data", (data) => {
             this.stderr += data.toString();
             process.stderr.write(data);
         });
+        childProcess.once("exit", (code, signal) => {
+            if (this.process !== childProcess)
+                return;
+            const error = this.createProcessExitError(code, signal);
+            this.exitError = error;
+            this.rejectPendingRequests(error);
+        });
+        childProcess.once("error", (error) => {
+            if (this.process !== childProcess)
+                return;
+            const processError = new Error(`Agent process error: ${error.message}. Stderr: ${this.stderr}`);
+            this.exitError = processError;
+            this.rejectPendingRequests(processError);
+        });
+        childProcess.stdin?.on("error", (error) => {
+            if (this.process !== childProcess)
+                return;
+            const stdinError = this.exitError ?? new Error(`Agent process stdin error: ${error.message}. Stderr: ${this.stderr}`);
+            this.exitError = stdinError;
+            this.rejectPendingRequests(stdinError);
+        });
         // Set up strict JSONL reader for stdout.
-        this.stopReadingStdout = attachJsonlLineReader(this.process.stdout, (line) => {
+        this.stopReadingStdout = attachJsonlLineReader(childProcess.stdout, (line) => {
             this.handleLine(line);
         });
         // Wait a moment for process to initialize
         await new Promise((resolve) => setTimeout(resolve, 100));
         if (this.process.exitCode !== null) {
-            throw new Error(`Agent process exited immediately with code ${this.process.exitCode}. Stderr: ${this.stderr}`);
+            const error = this.exitError ?? this.createProcessExitError(this.process.exitCode, this.process.signalCode);
+            this.exitError = error;
+            throw error;
         }
     }
     /**
@@ -371,14 +397,37 @@ export class RpcClient {
             // Ignore non-JSON lines
         }
     }
+    createProcessExitError(code, signal) {
+        return new Error(`Agent process exited (code=${code} signal=${signal}). Stderr: ${this.stderr}`);
+    }
+    rejectPendingRequests(error) {
+        for (const pending of this.pendingRequests.values()) {
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
     async send(command) {
-        if (!this.process?.stdin) {
+        const childProcess = this.process;
+        const stdin = childProcess?.stdin;
+        if (!childProcess || !stdin) {
             throw new Error("Client not started");
         }
+        if (this.exitError) {
+            throw this.exitError;
+        }
+        if (childProcess.exitCode !== null) {
+            const error = this.createProcessExitError(childProcess.exitCode, childProcess.signalCode);
+            this.exitError = error;
+            throw error;
+        }
+        if (stdin.destroyed || !stdin.writable) {
+            const error = new Error(`Agent process stdin is not writable. Stderr: ${this.stderr}`);
+            this.exitError = error;
+            throw error;
+        }
         const id = `req_${++this.requestId}`;
         const fullCommand = { ...command, id };
         return new Promise((resolve, reject) => {
-            this.pendingRequests.set(id, { resolve, reject });
             const timeout = setTimeout(() => {
                 this.pendingRequests.delete(id);
                 reject(new Error(`Timeout waiting for response to ${command.type}. Stderr: ${this.stderr}`));
@@ -393,7 +442,15 @@ export class RpcClient {
                     reject(error);
                 },
             });
-            this.process.stdin.write(serializeJsonLine(fullCommand));
+            try {
+                stdin.write(serializeJsonLine(fullCommand));
+            }
+            catch (error) {
+                const writeError = error instanceof Error ? error : new Error(String(error));
+                const pending = this.pendingRequests.get(id);
+                this.pendingRequests.delete(id);
+                pending?.reject(writeError);
+            }
         });
     }
     getData(response) {

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

@@ -11,7 +11,7 @@
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
 import * as crypto from "node:crypto";
-import { takeOverStdout, writeRawStdout } from "../../core/output-guard.js";
+import { flushRawStdout, takeOverStdout, waitForRawStdoutBackpressure, writeRawStdout, } from "../../core/output-guard.js";
 import { killTrackedDetachedChildren } from "../../utils/shell.js";
 import { theme } from "../interactive/theme/theme.js";
 import { attachJsonlLineReader, serializeJsonLine } from "./jsonl.js";
@@ -23,6 +23,7 @@ export async function runRpcMode(runtimeHost) {
     takeOverStdout();
     let session = runtimeHost.session;
     let unsubscribe;
+    let unsubscribeBackpressure;
     const output = (obj) => {
         writeRawStdout(serializeJsonLine(obj));
     };
@@ -258,9 +259,13 @@ export async function runRpcMode(runtimeHost) {
             },
         });
         unsubscribe?.();
+        unsubscribeBackpressure?.();
         unsubscribe = session.subscribe((event) => {
             output(event);
         });
+        unsubscribeBackpressure = session.agent.subscribe(async () => {
+            await waitForRawStdoutBackpressure();
+        });
     };
     const registerSignalHandlers = () => {
         const signals = ["SIGTERM"];
@@ -270,7 +275,7 @@ export async function runRpcMode(runtimeHost) {
         for (const signal of signals) {
             const handler = () => {
                 killTrackedDetachedChildren();
-                void shutdown(signal === "SIGHUP" ? 129 : 143);
+                void shutdown(signal === "SIGHUP" ? 129 : 143, signal);
             };
             process.on(signal, handler);
             signalCleanupHandlers.push(() => process.off(signal, handler));
@@ -529,7 +534,7 @@ export async function runRpcMode(runtimeHost) {
      * Called after handling each command when waiting for the next command.
      */
     let detachInput = () => { };
-    async function shutdown(exitCode = 0) {
+    async function shutdown(exitCode = 0, signal) {
         if (shuttingDown) {
             process.exit(exitCode);
         }
@@ -538,9 +543,13 @@ export async function runRpcMode(runtimeHost) {
             cleanup();
         }
         unsubscribe?.();
+        unsubscribeBackpressure?.();
         await runtimeHost.dispose();
         detachInput();
         process.stdin.pause();
+        if (signal !== "SIGTERM") {
+            await flushRawStdout();
+        }
         process.exit(exitCode);
     }
     async function checkShutdownRequested() {
@@ -555,6 +564,7 @@ export async function runRpcMode(runtimeHost) {
         }
         catch (parseError) {
             output(error(undefined, "parse", `Failed to parse command: ${parseError instanceof Error ? parseError.message : String(parseError)}`));
+            await waitForRawStdoutBackpressure();
             return;
         }
         // Handle extension UI responses
@@ -575,11 +585,13 @@ export async function runRpcMode(runtimeHost) {
             const response = await handleCommand(command);
             if (response) {
                 output(response);
+                await waitForRawStdoutBackpressure();
             }
             await checkShutdownRequested();
         }
         catch (commandError) {
             output(error(command.id, command.type, commandError instanceof Error ? commandError.message : String(commandError)));
+            await waitForRawStdoutBackpressure();
         }
     };
     const onInputEnd = () => {

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

@@ -1,14 +1,20 @@
 import { createRequire } from "module";
-const require = createRequire(import.meta.url);
-let clipboard = null;
+import { dirname, join } from "path";
+import { pathToFileURL } from "url";
+const moduleRequire = createRequire(import.meta.url);
+const executableDirRequire = createRequire(pathToFileURL(join(dirname(process.execPath), "package.json")).href);
 const hasDisplay = process.platform !== "linux" || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
-if (!process.env.TERMUX_VERSION && hasDisplay) {
-    try {
-        clipboard = require("@mariozechner/clipboard");
-    }
-    catch {
-        clipboard = null;
+export function loadClipboardNative(requires = [moduleRequire, executableDirRequire]) {
+    for (const requireClipboard of requires) {
+        try {
+            return requireClipboard("@mariozechner/clipboard");
+        }
+        catch {
+            // Try the next resolution root.
+        }
     }
+    return null;
 }
+const clipboard = !process.env.TERMUX_VERSION && hasDisplay ? loadClipboardNative() : null;
 export { clipboard };
 //# sourceMappingURL=clipboard-native.js.map

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

@@ -0,0 +1,124 @@
+import { applyExifOrientation } from "./exif-orientation.js";
+import { loadPhoton } from "./photon.js";
+// 4.5MB of base64 payload. Provides headroom below Anthropic's 5MB limit.
+const DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024;
+const DEFAULT_OPTIONS = {
+    maxWidth: 2000,
+    maxHeight: 2000,
+    maxBytes: DEFAULT_MAX_BYTES,
+    jpegQuality: 80,
+};
+function encodeCandidate(buffer, mimeType) {
+    const data = Buffer.from(buffer).toString("base64");
+    return {
+        data,
+        encodedSize: Buffer.byteLength(data, "utf-8"),
+        mimeType,
+    };
+}
+/**
+ * Resize an image to fit within the specified max dimensions and encoded file size.
+ * Returns null if the image cannot be resized below maxBytes.
+ *
+ * Uses Photon (Rust/WASM) for image processing. If Photon is not available,
+ * returns null.
+ *
+ * Strategy for staying under maxBytes:
+ * 1. First resize to maxWidth/maxHeight
+ * 2. Try both PNG and JPEG formats, pick the smaller one
+ * 3. If still too large, try JPEG with decreasing quality
+ * 4. If still too large, progressively reduce dimensions until 1x1
+ */
+export async function resizeImageInProcess(inputBytes, mimeType, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const inputBase64Size = Math.ceil(inputBytes.byteLength / 3) * 4;
+    const photon = await loadPhoton();
+    if (!photon) {
+        return null;
+    }
+    let image;
+    try {
+        const rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
+        image = applyExifOrientation(photon, rawImage, inputBytes);
+        if (image !== rawImage)
+            rawImage.free();
+        const originalWidth = image.get_width();
+        const originalHeight = image.get_height();
+        const format = mimeType.split("/")[1] ?? "png";
+        // Check if already within all limits (dimensions AND encoded size)
+        if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < opts.maxBytes) {
+            return {
+                data: Buffer.from(inputBytes).toString("base64"),
+                mimeType: mimeType || `image/${format}`,
+                originalWidth,
+                originalHeight,
+                width: originalWidth,
+                height: originalHeight,
+                wasResized: false,
+            };
+        }
+        // Calculate initial dimensions respecting max limits
+        let targetWidth = originalWidth;
+        let targetHeight = originalHeight;
+        if (targetWidth > opts.maxWidth) {
+            targetHeight = Math.round((targetHeight * opts.maxWidth) / targetWidth);
+            targetWidth = opts.maxWidth;
+        }
+        if (targetHeight > opts.maxHeight) {
+            targetWidth = Math.round((targetWidth * opts.maxHeight) / targetHeight);
+            targetHeight = opts.maxHeight;
+        }
+        function tryEncodings(width, height, jpegQualities) {
+            const resized = photon.resize(image, width, height, photon.SamplingFilter.Lanczos3);
+            try {
+                const candidates = [encodeCandidate(resized.get_bytes(), "image/png")];
+                for (const quality of jpegQualities) {
+                    candidates.push(encodeCandidate(resized.get_bytes_jpeg(quality), "image/jpeg"));
+                }
+                return candidates;
+            }
+            finally {
+                resized.free();
+            }
+        }
+        const qualitySteps = Array.from(new Set([opts.jpegQuality, 85, 70, 55, 40]));
+        let currentWidth = targetWidth;
+        let currentHeight = targetHeight;
+        while (true) {
+            const candidates = tryEncodings(currentWidth, currentHeight, qualitySteps);
+            for (const candidate of candidates) {
+                if (candidate.encodedSize < opts.maxBytes) {
+                    return {
+                        data: candidate.data,
+                        mimeType: candidate.mimeType,
+                        originalWidth,
+                        originalHeight,
+                        width: currentWidth,
+                        height: currentHeight,
+                        wasResized: true,
+                    };
+                }
+            }
+            if (currentWidth === 1 && currentHeight === 1) {
+                break;
+            }
+            const nextWidth = currentWidth === 1 ? 1 : Math.max(1, Math.floor(currentWidth * 0.75));
+            const nextHeight = currentHeight === 1 ? 1 : Math.max(1, Math.floor(currentHeight * 0.75));
+            if (nextWidth === currentWidth && nextHeight === currentHeight) {
+                break;
+            }
+            currentWidth = nextWidth;
+            currentHeight = nextHeight;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (image) {
+            image.free();
+        }
+    }
+}
+//# sourceMappingURL=image-resize-core.js.map

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

@@ -0,0 +1,31 @@
+import { parentPort } from "node:worker_threads";
+import { resizeImageInProcess } from "./image-resize-core.js";
+function isResizeImageWorkerRequest(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return record.inputBytes instanceof Uint8Array && typeof record.mimeType === "string";
+}
+const port = parentPort;
+if (!port) {
+    throw new Error("image resize worker requires parentPort");
+}
+port.once("message", (message) => {
+    void (async () => {
+        try {
+            if (!isResizeImageWorkerRequest(message)) {
+                throw new Error("Invalid image resize worker request");
+            }
+            const result = await resizeImageInProcess(message.inputBytes, message.mimeType, message.options);
+            const response = { result };
+            port.postMessage(response);
+        }
+        catch (error) {
+            const response = {
+                error: error instanceof Error ? error.message : String(error),
+            };
+            port.postMessage(response);
+        }
+    })();
+});
+//# sourceMappingURL=image-resize-worker.js.map