@psnext/slingcli 2.4.20260526-1 → 2.4.20260527-2

package/node_modules/@earendil-works/pi-ai/dist/providers/openai-codex-responses.js

@@ -29,9 +29,10 @@ import { buildBaseOptions } from "./simple-options.js";
 // ============================================================================
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const JWT_CLAIM_PATH = "https://api.openai.com/auth";
-const MAX_RETRIES = 3;
+const DEFAULT_MAX_RETRIES = 0;
 const BASE_DELAY_MS = 1000;
-const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode", "slingshot"]);
+const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
+const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const CODEX_RESPONSE_STATUSES = new Set([
     "completed",
@@ -44,12 +45,44 @@ const CODEX_RESPONSE_STATUSES = new Set([
 // ============================================================================
 // Retry Helpers
 // ============================================================================
+function isTerminalRateLimitError(errorText) {
+    return /GoUsageLimitError|FreeUsageLimitError|Monthly usage limit reached|available balance|insufficient_quota|out of budget|quota exceeded|billing/i.test(errorText);
+}
 function isRetryableError(status, errorText) {
+    if (status === 429 && isTerminalRateLimitError(errorText)) {
+        return false;
+    }
     if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504) {
         return true;
     }
     return /rate.?limit|overloaded|service.?unavailable|upstream.?connect|connection.?refused/i.test(errorText);
 }
+function getRetryAfterDelayMs(headers) {
+    const retryAfterMs = headers.get("retry-after-ms");
+    if (retryAfterMs !== null) {
+        const millis = Number(retryAfterMs);
+        if (Number.isFinite(millis)) {
+            return Math.max(0, millis);
+        }
+    }
+    const retryAfter = headers.get("retry-after");
+    if (!retryAfter) {
+        return undefined;
+    }
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const date = Date.parse(retryAfter);
+    if (!Number.isNaN(date)) {
+        return Math.max(0, date - Date.now());
+    }
+    return undefined;
+}
+function capRetryDelayMs(delayMs, options) {
+    const maxRetryDelayMs = options?.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+    return maxRetryDelayMs > 0 ? Math.min(delayMs, maxRetryDelayMs) : delayMs;
+}
 function sleep(ms, signal) {
     return new Promise((resolve, reject) => {
         if (signal?.aborted) {
@@ -91,7 +124,7 @@ export const streamOpenAICodexResponses = (model, context, options) => {
             if (!apiKey) {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
-            const accountId = extractAccountId(apiKey) || "";
+            const accountId = extractAccountId(apiKey);
             let body = buildRequestBody(model, context, options);
             const nextBody = await options?.onPayload?.(body, model);
             if (nextBody !== undefined) {
@@ -145,7 +178,8 @@ export const streamOpenAICodexResponses = (model, context, options) => {
             // Fetch with retry logic for rate limits and transient errors
             let response;
             let lastError;
-            for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
                 if (options?.signal?.aborted) {
                     throw new Error("Request was aborted");
                 }
@@ -161,30 +195,13 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                         break;
                     }
                     const errorText = await response.text();
-                    if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {
-                        let delayMs = BASE_DELAY_MS * 2 ** attempt;
-                        const retryAfterMs = response.headers.get("retry-after-ms");
-                        if (retryAfterMs !== null) {
-                            const millis = Number(retryAfterMs);
-                            if (Number.isFinite(millis)) {
-                                delayMs = Math.max(0, millis);
-                            }
-                        }
-                        else {
-                            const retryAfter = response.headers.get("retry-after");
-                            if (retryAfter) {
-                                const seconds = Number(retryAfter);
-                                if (Number.isFinite(seconds)) {
-                                    delayMs = Math.max(0, seconds * 1000);
-                                }
-                                else {
-                                    const date = Date.parse(retryAfter);
-                                    if (!Number.isNaN(date)) {
-                                        delayMs = Math.max(0, date - Date.now());
-                                    }
-                                }
-                            }
-                        }
+                    if (attempt < maxRetries && isRetryableError(response.status, errorText)) {
+                        const retryAfterDelayMs = getRetryAfterDelayMs(response.headers);
+                        const delayMs = retryAfterDelayMs === undefined
+                            ? BASE_DELAY_MS * 2 ** attempt
+                            : response.status === 429
+                                ? capRetryDelayMs(retryAfterDelayMs, options)
+                                : retryAfterDelayMs;
                         await sleep(delayMs, options?.signal);
                         continue;
                     }
@@ -204,7 +221,7 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                     }
                     lastError = error instanceof Error ? error : new Error(String(error));
                     // Network errors are retryable
-                    if (attempt < MAX_RETRIES && !lastError.message.includes("usage limit")) {
+                    if (attempt < maxRetries && !lastError.message.includes("usage limit")) {
                         const delayMs = BASE_DELAY_MS * 2 ** attempt;
                         await sleep(delayMs, options?.signal);
                         continue;
@@ -265,7 +282,7 @@ function buildRequestBody(model, context, options) {
         stream: true,
         instructions: context.systemPrompt || "You are a helpful assistant.",
         input: messages,
-        text: { verbosity: options?.textVerbosity || "medium" },
+        text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],
         prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
         tool_choice: "auto",
@@ -322,7 +339,11 @@ function resolveCodexServiceTier(responseServiceTier, requestServiceTier) {
 function resolveCodexUrl(baseUrl) {
     const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE_URL;
     const normalized = raw.replace(/\/+$/, "");
-    return `${normalized}/responses`;
+    if (normalized.endsWith("/codex/responses"))
+        return normalized;
+    if (normalized.endsWith("/codex"))
+        return `${normalized}/responses`;
+    return `${normalized}/codex/responses`;
 }
 function resolveCodexWebSocketUrl(baseUrl) {
     const url = new URL(resolveCodexUrl(baseUrl));
@@ -1031,13 +1052,15 @@ function extractAccountId(token) {
     try {
         const parts = token.split(".");
         if (parts.length !== 3)
-            return null;
+            throw new Error("Invalid token");
         const payload = JSON.parse(atob(parts[1]));
         const accountId = payload?.[JWT_CLAIM_PATH]?.chatgpt_account_id;
-        return accountId || null;
+        if (!accountId)
+            throw new Error("No account ID in token");
+        return accountId;
     }
     catch {
-        return null;
+        throw new Error("Failed to extract accountId from token");
     }
 }
 function createCodexRequestId() {
@@ -1052,10 +1075,7 @@ function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token)
         headers.set(key, value);
     }
     headers.set("Authorization", `Bearer ${token}`);
-    // Only set chatgpt-account-id if we have one (OpenAI-specific)
-    if (accountId) {
-        headers.set("chatgpt-account-id", accountId);
-    }
+    headers.set("chatgpt-account-id", accountId);
     headers.set("originator", "pi");
     const userAgent = _os ? `pi (${_os.platform()} ${_os.release()}; ${_os.arch()})` : "pi (browser)";
     headers.set("User-Agent", userAgent);
@@ -1067,7 +1087,7 @@ function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessi
     headers.set("accept", "text/event-stream");
     headers.set("content-type", "application/json");
     if (sessionId) {
-        headers.set("session_id", sessionId);
+        headers.set("session-id", sessionId);
         headers.set("x-client-request-id", sessionId);
     }
     return headers;
@@ -1080,7 +1100,7 @@ function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token,
     headers.delete("openai-beta");
     headers.set("OpenAI-Beta", OPENAI_BETA_RESPONSES_WEBSOCKETS);
     headers.set("x-client-request-id", requestId);
-    headers.set("session_id", requestId);
+    headers.set("session-id", requestId);
     return headers;
 }
 //# sourceMappingURL=openai-codex-responses.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/openai-completions.js

@@ -83,7 +83,7 @@ export const streamOpenAICompletions = (model, context, options) => {
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                ...(options?.maxRetries !== undefined ? { maxRetries: options.maxRetries } : {}),
+                maxRetries: options?.maxRetries ?? 0,
             };
             const { data: openaiStream, response } = await client.chat.completions
                 .create(params, requestOptions)

package/node_modules/@earendil-works/pi-ai/dist/providers/openai-responses.js

@@ -85,7 +85,7 @@ export const streamOpenAIResponses = (model, context, options) => {
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                ...(options?.maxRetries !== undefined ? { maxRetries: options.maxRetries } : {}),
+                maxRetries: options?.maxRetries ?? 0,
             };
             const { data: openaiStream, response } = await client.responses.create(params, requestOptions).withResponse();
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);

package/node_modules/@earendil-works/pi-ai/dist/utils/oauth/device-code.js

@@ -0,0 +1,55 @@
+const CANCEL_MESSAGE = "Login cancelled";
+const TIMEOUT_MESSAGE = "Device flow timed out";
+const SLOW_DOWN_TIMEOUT_MESSAGE = "Device flow timed out after one or more slow_down responses. This is often caused by clock drift in WSL or VM environments. Please sync or restart the VM clock and try again.";
+const MINIMUM_INTERVAL_MS = 1000;
+// RFC 8628 section 3.2: if the authorization server omits `interval`, the client must use 5 seconds.
+const DEFAULT_POLL_INTERVAL_SECONDS = 5;
+// RFC 8628 section 3.5: `slow_down` means the polling interval must increase by 5 seconds.
+const SLOW_DOWN_INTERVAL_INCREMENT_MS = 5000;
+function abortableSleep(ms, signal, cancelMessage) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error(cancelMessage));
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timeout);
+            reject(new Error(cancelMessage));
+        };
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+export async function pollOAuthDeviceCodeFlow(options) {
+    const deadline = typeof options.expiresInSeconds === "number"
+        ? Date.now() + options.expiresInSeconds * 1000
+        : Number.POSITIVE_INFINITY;
+    let intervalMs = Math.max(MINIMUM_INTERVAL_MS, Math.floor((options.intervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS) * 1000));
+    let slowDownResponses = 0;
+    while (Date.now() < deadline) {
+        if (options.signal?.aborted) {
+            throw new Error(CANCEL_MESSAGE);
+        }
+        const remainingMs = deadline - Date.now();
+        await abortableSleep(Math.min(intervalMs, remainingMs), options.signal, CANCEL_MESSAGE);
+        const result = await options.poll();
+        if (result.status === "complete") {
+            return result.accessToken;
+        }
+        if (result.status === "pending") {
+            continue;
+        }
+        if (result.status === "slow_down") {
+            slowDownResponses += 1;
+            // RFC 8628 section 3.5: apply this increase to this and all subsequent requests.
+            intervalMs = Math.max(MINIMUM_INTERVAL_MS, intervalMs + SLOW_DOWN_INTERVAL_INCREMENT_MS);
+            continue;
+        }
+        throw new Error(result.message);
+    }
+    throw new Error(slowDownResponses > 0 ? SLOW_DOWN_TIMEOUT_MESSAGE : TIMEOUT_MESSAGE);
+}
+//# sourceMappingURL=device-code.js.map

package/node_modules/@earendil-works/pi-ai/dist/utils/oauth/github-copilot.js

@@ -2,6 +2,7 @@
  * GitHub Copilot OAuth flow
  */
 import { getModels } from "../../models.js";
+import { pollOAuthDeviceCodeFlow } from "./device-code.js";
 const decode = (s) => atob(s);
 const CLIENT_ID = decode("SXYxLmI1MDdhMDhjODdlY2ZlOTg=");
 const COPILOT_HEADERS = {
@@ -10,8 +11,6 @@ const COPILOT_HEADERS = {
     "Editor-Plugin-Version": "copilot-chat/0.35.0",
     "Copilot-Integration-Id": "vscode-chat",
 };
-const INITIAL_POLL_INTERVAL_MULTIPLIER = 1.2;
-const SLOW_DOWN_POLL_INTERVAL_MULTIPLIER = 1.4;
 export function normalizeDomain(input) {
     const trimmed = input.trim();
     if (!trimmed)
@@ -90,7 +89,7 @@ async function startDeviceFlow(domain) {
     if (typeof deviceCode !== "string" ||
         typeof userCode !== "string" ||
         typeof verificationUri !== "string" ||
-        typeof interval !== "number" ||
+        (interval !== undefined && typeof interval !== "number") ||
         typeof expiresIn !== "number") {
         throw new Error("Invalid device code response fields");
     }
@@ -102,71 +101,43 @@ async function startDeviceFlow(domain) {
         expires_in: expiresIn,
     };
 }
-/**
- * Sleep that can be interrupted by an AbortSignal
- */
-function abortableSleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            reject(new Error("Login cancelled"));
-            return;
-        }
-        const timeout = setTimeout(resolve, ms);
-        signal?.addEventListener("abort", () => {
-            clearTimeout(timeout);
-            reject(new Error("Login cancelled"));
-        }, { once: true });
-    });
-}
-async function pollForGitHubAccessToken(domain, deviceCode, intervalSeconds, expiresIn, signal) {
+async function pollForGitHubAccessToken(domain, device, signal) {
     const urls = getUrls(domain);
-    const deadline = Date.now() + expiresIn * 1000;
-    let intervalMs = Math.max(1000, Math.floor(intervalSeconds * 1000));
-    let intervalMultiplier = INITIAL_POLL_INTERVAL_MULTIPLIER;
-    let slowDownResponses = 0;
-    while (Date.now() < deadline) {
-        if (signal?.aborted) {
-            throw new Error("Login cancelled");
-        }
-        const remainingMs = deadline - Date.now();
-        const waitMs = Math.min(Math.ceil(intervalMs * intervalMultiplier), remainingMs);
-        await abortableSleep(waitMs, signal);
-        const raw = await fetchJson(urls.accessTokenUrl, {
-            method: "POST",
-            headers: {
-                Accept: "application/json",
-                "Content-Type": "application/x-www-form-urlencoded",
-                "User-Agent": "GitHubCopilotChat/0.35.0",
-            },
-            body: new URLSearchParams({
-                client_id: CLIENT_ID,
-                device_code: deviceCode,
-                grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-            }),
-        });
-        if (raw && typeof raw === "object" && typeof raw.access_token === "string") {
-            return raw.access_token;
-        }
-        if (raw && typeof raw === "object" && typeof raw.error === "string") {
-            const { error, error_description: description, interval } = raw;
-            if (error === "authorization_pending") {
-                continue;
+    return pollOAuthDeviceCodeFlow({
+        intervalSeconds: device.interval,
+        expiresInSeconds: device.expires_in,
+        signal,
+        poll: async () => {
+            const raw = await fetchJson(urls.accessTokenUrl, {
+                method: "POST",
+                headers: {
+                    Accept: "application/json",
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "User-Agent": "GitHubCopilotChat/0.35.0",
+                },
+                body: new URLSearchParams({
+                    client_id: CLIENT_ID,
+                    device_code: device.device_code,
+                    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                }),
+            });
+            if (raw && typeof raw === "object" && typeof raw.access_token === "string") {
+                return { status: "complete", accessToken: raw.access_token };
             }
-            if (error === "slow_down") {
-                slowDownResponses += 1;
-                intervalMs =
-                    typeof interval === "number" && interval > 0 ? interval * 1000 : Math.max(1000, intervalMs + 5000);
-                intervalMultiplier = SLOW_DOWN_POLL_INTERVAL_MULTIPLIER;
-                continue;
+            if (raw && typeof raw === "object" && typeof raw.error === "string") {
+                const { error, error_description: description } = raw;
+                if (error === "authorization_pending") {
+                    return { status: "pending" };
+                }
+                if (error === "slow_down") {
+                    return { status: "slow_down" };
+                }
+                const descriptionSuffix = description ? `: ${description}` : "";
+                return { status: "failed", message: `Device flow failed: ${error}${descriptionSuffix}` };
             }
-            const descriptionSuffix = description ? `: ${description}` : "";
-            throw new Error(`Device flow failed: ${error}${descriptionSuffix}`);
-        }
-    }
-    if (slowDownResponses > 0) {
-        throw new Error("Device flow timed out after one or more slow_down responses. This is often caused by clock drift in WSL or VM environments. Please sync or restart the VM clock and try again.");
-    }
-    throw new Error("Device flow timed out");
+            return { status: "failed", message: "Invalid device token response" };
+        },
+    });
 }
 /**
  * Refresh GitHub Copilot token
@@ -235,7 +206,7 @@ async function enableAllGitHubCopilotModels(token, enterpriseDomain, onProgress)
 /**
  * Login with GitHub Copilot OAuth (device code flow)
  *
- * @param options.onAuth - Callback with URL and optional instructions (user code)
+ * @param options.onDeviceCode - Callback with URL and user code
  * @param options.onPrompt - Callback to prompt user for input
  * @param options.onProgress - Optional progress callback
  * @param options.signal - Optional AbortSignal for cancellation
@@ -256,8 +227,13 @@ export async function loginGitHubCopilot(options) {
     }
     const domain = enterpriseDomain || "github.com";
     const device = await startDeviceFlow(domain);
-    options.onAuth(device.verification_uri, `Enter code: ${device.user_code}`);
-    const githubAccessToken = await pollForGitHubAccessToken(domain, device.device_code, device.interval, device.expires_in, options.signal);
+    options.onDeviceCode({
+        userCode: device.user_code,
+        verificationUri: device.verification_uri,
+        intervalSeconds: device.interval,
+        expiresInSeconds: device.expires_in,
+    });
+    const githubAccessToken = await pollForGitHubAccessToken(domain, device, options.signal);
     const credentials = await refreshGitHubCopilotToken(githubAccessToken, enterpriseDomain ?? undefined);
     // Enable all models after successful login
     options.onProgress?.("Enabling models...");
@@ -269,7 +245,7 @@ export const githubCopilotOAuthProvider = {
     name: "GitHub Copilot",
     async login(callbacks) {
         return loginGitHubCopilot({
-            onAuth: (url, instructions) => callbacks.onAuth({ url, instructions }),
+            onDeviceCode: callbacks.onDeviceCode,
             onPrompt: callbacks.onPrompt,
             onProgress: callbacks.onProgress,
             signal: callbacks.signal,

package/node_modules/@earendil-works/pi-ai/dist/utils/oauth/index.js

@@ -8,6 +8,7 @@
  */
 // Anthropic
 export { anthropicOAuthProvider, loginAnthropic, refreshAnthropicToken } from "./anthropic.js";
+export * from "./device-code.js";
 // GitHub Copilot
 export { getGitHubCopilotBaseUrl, githubCopilotOAuthProvider, loginGitHubCopilot, normalizeDomain, refreshGitHubCopilotToken, } from "./github-copilot.js";
 // OpenAI Codex (ChatGPT OAuth)

package/node_modules/@earendil-works/pi-ai/dist/utils/overflow.js

@@ -14,6 +14,7 @@
  * - xAI: "This model's maximum prompt length is 131072 but the request contains 537812 tokens"
  * - Groq: "Please reduce the length of the messages or completion"
  * - OpenRouter: "This endpoint's maximum context length is X tokens. However, you requested about Y tokens"
+ * - OpenRouter/Poolside: "Input length X exceeds the maximum allowed input length of Y tokens."
  * - Together AI: "The input (X tokens) is longer than the model's context length (Y tokens)."
  * - llama.cpp: "the request exceeds the available context size, try increasing it"
  * - LM Studio: "tokens to keep from the initial prompt is greater than the context length"
@@ -37,7 +38,8 @@ const OVERFLOW_PATTERNS = [
     /input token count.*exceeds the maximum/i, // Google (Gemini)
     /maximum prompt length is \d+/i, // xAI (Grok)
     /reduce the length of the messages/i, // Groq
-    /maximum context length is \d+ tokens/i, // OpenRouter (all backends)
+    /maximum context length is \d+ tokens/i, // OpenRouter (most backends)
+    /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i, // OpenRouter/Poolside
     /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i, // Together AI
     /exceeds the limit of \d+/i, // GitHub Copilot
     /exceeds the available context size/i, // llama.cpp server
@@ -85,7 +87,8 @@ const NON_OVERFLOW_PATTERNS = [
  * - Groq: "reduce the length of the messages"
  * - Cerebras: 400/413 status code (no body)
  * - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
- * - OpenRouter (all backends): "maximum context length is X tokens"
+ * - OpenRouter (most backends): "maximum context length is X tokens"
+ * - OpenRouter/Poolside: "Input length X exceeds the maximum allowed input length of Y tokens."
  * - Together AI: "The input (X tokens) is longer than the model's context length (Y tokens)."
  * - llama.cpp: "exceeds the available context size"
  * - LM Studio: "greater than the context length"

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

@@ -1,6 +1,6 @@
 {
 	"name": "@earendil-works/pi-ai",
-	"version": "0.75.4",
+	"version": "0.75.5",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -60,8 +60,8 @@
 	],
 	"scripts": {
 		"clean": "shx rm -rf dist",
-		"generate-models": "tsx scripts/generate-models.ts",
-		"generate-image-models": "tsx scripts/generate-image-models.ts",
+		"generate-models": "node scripts/generate-models.ts",
+		"generate-image-models": "node scripts/generate-image-models.ts",
 		"build": "npm run generate-models && npm run generate-image-models && tsgo -p tsconfig.build.json",
 		"test": "vitest --run",
 		"prepublishOnly": "npm run clean && npm run build"
@@ -69,6 +69,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "0.91.1",
 		"@aws-sdk/client-bedrock-runtime": "3.1048.0",
+		"@smithy/node-http-handler": "4.7.3",
 		"@google/genai": "1.52.0",
 		"@mistralai/mistralai": "2.2.1",
 		"http-proxy-agent": "7.0.2",

package/node_modules/@earendil-works/pi-coding-agent/dist/cli/file-processor.js

@@ -33,11 +33,10 @@ export async function processFileArguments(fileArgs, options) {
         if (mimeType) {
             // Handle image file
             const content = await readFile(absolutePath);
-            const base64Content = content.toString("base64");
             let attachment;
             let dimensionNote;
             if (autoResizeImages) {
-                const resized = await resizeImage({ type: "image", data: base64Content, mimeType });
+                const resized = await resizeImage(content, mimeType);
                 if (!resized) {
                     text += `<file name="${absolutePath}">[Image omitted: could not be resized below the inline image size limit.]</file>\n`;
                     continue;
@@ -53,7 +52,7 @@ export async function processFileArguments(fileArgs, options) {
                 attachment = {
                     type: "image",
                     mimeType,
-                    data: base64Content,
+                    data: content.toString("base64"),
                 };
             }
             images.push(attachment);

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

@@ -3,6 +3,7 @@ import { homedir } from "os";
 import { basename, dirname, join, resolve, sep, win32 } from "path";
 import { fileURLToPath } from "url";
 import { spawnProcessSync } from "./utils/child-process.js";
+import { normalizePath } from "./utils/paths.js";
 // =============================================================================
 // Package Detection
 // =============================================================================
@@ -76,7 +77,13 @@ function getSelfUpdateCommandForMethod(method, installedPackageName, updatePacka
         case "bun-binary":
             return undefined;
         case "pnpm":
-            return makeSelfUpdateCommand(makeSelfUpdateCommandStep("pnpm", ["install", "-g", "--ignore-scripts", updatePackageName]), updatePackageName === installedPackageName
+            return makeSelfUpdateCommand(makeSelfUpdateCommandStep("pnpm", [
+                "install",
+                "-g",
+                "--ignore-scripts",
+                "--config.minimumReleaseAge=0",
+                updatePackageName,
+            ]), updatePackageName === installedPackageName
                 ? undefined
                 : makeSelfUpdateCommandStep("pnpm", ["remove", "-g", installedPackageName]));
         case "yarn":
@@ -84,7 +91,13 @@ function getSelfUpdateCommandForMethod(method, installedPackageName, updatePacka
                 ? undefined
                 : makeSelfUpdateCommandStep("yarn", ["global", "remove", installedPackageName]));
         case "bun":
-            return makeSelfUpdateCommand(makeSelfUpdateCommandStep("bun", ["install", "-g", "--ignore-scripts", updatePackageName]), updatePackageName === installedPackageName
+            return makeSelfUpdateCommand(makeSelfUpdateCommandStep("bun", [
+                "install",
+                "-g",
+                "--ignore-scripts",
+                "--minimum-release-age=0",
+                updatePackageName,
+            ]), updatePackageName === installedPackageName
                 ? undefined
                 : makeSelfUpdateCommandStep("bun", ["uninstall", "-g", installedPackageName]));
         case "npm": {
@@ -96,6 +109,7 @@ function getSelfUpdateCommandForMethod(method, installedPackageName, updatePacka
                 "install",
                 "-g",
                 "--ignore-scripts",
+                "--min-release-age=0",
                 updatePackageName,
             ]);
             const uninstallStep = updatePackageName === installedPackageName
@@ -261,11 +275,7 @@ export function getPackageDir() {
     // Allow override via environment variable (useful for Nix/Guix where store paths tokenize poorly)
     const envDir = process.env.PI_PACKAGE_DIR;
     if (envDir) {
-        if (envDir === "~")
-            return homedir();
-        if (envDir.startsWith("~/"))
-            return homedir() + envDir.slice(1);
-        return envDir;
+        return normalizePath(envDir);
     }
     if (isBunBinary) {
         // Bun binary: process.execPath points to the compiled executable
@@ -360,11 +370,7 @@ export const VERSION = pkg.version || "0.0.0";
 export const ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
 export const ENV_SESSION_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_SESSION_DIR`;
 export function expandTildePath(path) {
-    if (path === "~")
-        return homedir();
-    if (path.startsWith("~/"))
-        return homedir() + path.slice(1);
-    return path;
+    return normalizePath(path);
 }
 const DEFAULT_SHARE_VIEWER_URL = "https://pi.dev/session/";
 /** Get the share viewer URL for a gist ID */

package/node_modules/@earendil-works/pi-coding-agent/dist/core/agent-session-runtime.js

@@ -1,5 +1,6 @@
 import { copyFileSync, existsSync, mkdirSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
+import { resolvePath } from "../utils/paths.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { assertSessionCwdExists } from "./session-cwd.js";
 import { SessionManager } from "./session-manager.js";
@@ -246,7 +247,7 @@ export class AgentSessionRuntime {
      * @throws {MissingSessionCwdError} When the imported session cwd cannot be resolved and no override is provided.
      */
     async importFromJsonl(inputPath, cwdOverride) {
-        const resolvedPath = resolve(inputPath);
+        const resolvedPath = resolvePath(inputPath);
         if (!existsSync(resolvedPath)) {
             throw new SessionImportFileNotFoundError(resolvedPath);
         }

package/node_modules/@earendil-works/pi-coding-agent/dist/core/agent-session-services.js

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 import { getAgentDir } from "../config.js";
+import { resolvePath } from "../utils/paths.js";
 import { AuthStorage } from "./auth-storage.js";
 import { ModelRegistry } from "./model-registry.js";
 import { DefaultResourceLoader } from "./resource-loader.js";
@@ -51,8 +52,8 @@ function applyExtensionFlagValues(resourceLoader, extensionFlagValues) {
  * Returns services plus diagnostics. It does not create an AgentSession.
  */
 export async function createAgentSessionServices(options) {
-    const cwd = options.cwd;
-    const agentDir = options.agentDir ?? getAgentDir();
+    const cwd = resolvePath(options.cwd);
+    const agentDir = options.agentDir ? resolvePath(options.agentDir) : getAgentDir();
     const authStorage = options.authStorage ?? AuthStorage.create(join(agentDir, "auth.json"));
     const settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir);
     const modelRegistry = options.modelRegistry ?? ModelRegistry.create(authStorage, join(agentDir, "models.json"));