@psnext/slingcli 2.4.20260601-1 → 2.5.20260602-2

package/node_modules/@earendil-works/pi-coding-agent/dist/core/footer-data-provider.js

@@ -70,6 +70,15 @@ function resolveBranchWithGitAsync(repoDir) {
         });
     });
 }
+function isWslEnvironment() {
+    return process.platform === "linux" && !!(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
+}
+function isWindowsMountedRepoPath(repoDir) {
+    return /^\/mnt\/[a-z](?:\/|$)/i.test(repoDir);
+}
+function shouldPollGitHead(repoDir) {
+    return isWslEnvironment() && isWindowsMountedRepoPath(repoDir);
+}
 /**
  * Provides git branch and extension statuses - data not otherwise accessible to extensions.
  * Token stats, model info available via ctx.sessionManager and ctx.model.
@@ -81,6 +90,8 @@ export class FooterDataProvider {
     cachedBranch = undefined;
     gitPaths = undefined;
     headWatcher = null;
+    headWatchFilePath = null;
+    headWatchFileListener = null;
     reftableWatcher = null;
     reftableTablesListWatcher = null;
     reftableTablesListPath = null;
@@ -236,6 +247,11 @@ export class FooterDataProvider {
     clearGitWatchers() {
         closeWatcher(this.headWatcher);
         this.headWatcher = null;
+        if (this.headWatchFilePath && this.headWatchFileListener) {
+            unwatchFile(this.headWatchFilePath, this.headWatchFileListener);
+            this.headWatchFilePath = null;
+            this.headWatchFileListener = null;
+        }
         closeWatcher(this.reftableWatcher);
         this.reftableWatcher = null;
         closeWatcher(this.reftableTablesListWatcher);
@@ -266,6 +282,7 @@ export class FooterDataProvider {
         this.clearGitWatchers();
         if (!this.gitPaths)
             return;
+        const pollGitHead = shouldPollGitHead(this.gitPaths.repoDir);
         // Watch the directory containing HEAD, not HEAD itself.
         // Git uses atomic writes (write temp, rename over HEAD), which changes the inode.
         // fs.watch on a file stops working after the inode changes.
@@ -274,7 +291,18 @@ export class FooterDataProvider {
                 this.scheduleRefresh();
             }
         }, () => this.handleGitWatcherError());
-        if (!this.headWatcher) {
+        if (pollGitHead) {
+            this.headWatchFilePath = this.gitPaths.headPath;
+            this.headWatchFileListener = (current, previous) => {
+                if (current.mtimeMs !== previous.mtimeMs ||
+                    current.ctimeMs !== previous.ctimeMs ||
+                    current.size !== previous.size) {
+                    this.scheduleRefresh();
+                }
+            };
+            watchFile(this.headWatchFilePath, { interval: 1000 }, this.headWatchFileListener);
+        }
+        if (!this.headWatcher && !pollGitHead) {
             return;
         }
         // In reftable repos, branch switches update files in the reftable directory

package/node_modules/@earendil-works/pi-coding-agent/dist/core/model-registry.js

@@ -8,9 +8,11 @@ import { join } from "path";
 import { Type } from "typebox";
 import { Compile } from "typebox/compile";
 import { getAgentDir } from "../config.js";
+import { warnDeprecation } from "../utils/deprecation.js";
+import { stripJsonComments } from "../utils/json.js";
 import { normalizePath } from "../utils/paths.js";
 import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "./provider-display-names.js";
-import { clearConfigValueCache, resolveConfigValueOrThrow, resolveConfigValueUncached, resolveHeadersOrThrow, } from "./resolve-config-value.js";
+import { clearConfigValueCache, getConfigValueEnvVarNames, isCommandConfigValue, isConfigValueConfigured, isLegacyEnvVarNameConfigValue, resolveConfigValueOrThrow, resolveConfigValueUncached, resolveHeadersOrThrow, } from "./resolve-config-value.js";
 // Schema for OpenRouter routing preferences
 const PercentileCutoffsSchema = Type.Object({
     p50: Type.Optional(Type.Number()),
@@ -166,11 +168,56 @@ function formatValidationPath(error) {
     const path = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
     return path || "root";
 }
-/** Strip `//` line comments and trailing commas from JSON, leaving string literals untouched. */
-function stripJsonComments(input) {
-    return input
-        .replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*/g, (m) => (m[0] === '"' ? m : ""))
-        .replace(/"(?:\\.|[^"\\])*"|,(\s*[}\]])/g, (m, tail) => tail ?? (m[0] === '"' ? m : ""));
+function migrateLegacyRegisterProviderConfigValue(providerName, field, value) {
+    if (!isLegacyEnvVarNameConfigValue(value))
+        return value;
+    warnDeprecation(`registerProvider("${providerName}") ${field} value "${value}" is treated as a legacy environment variable reference. This will no longer be detected as an environment variable reference in a future release. Pass "$${value}" instead.`);
+    return `$${value}`;
+}
+function migrateLegacyRegisterProviderHeaders(providerName, field, headers) {
+    if (!headers)
+        return undefined;
+    let migratedHeaders;
+    for (const [key, value] of Object.entries(headers)) {
+        const migratedValue = migrateLegacyRegisterProviderConfigValue(providerName, `${field} header "${key}"`, value);
+        if (migratedValue === value)
+            continue;
+        migratedHeaders ??= { ...headers };
+        migratedHeaders[key] = migratedValue;
+    }
+    return migratedHeaders ?? headers;
+}
+function migrateLegacyRegisterProviderConfigValues(providerName, config) {
+    let migratedConfig;
+    const setMigratedConfigValue = (key, value) => {
+        migratedConfig ??= { ...config };
+        migratedConfig[key] = value;
+    };
+    if (config.apiKey) {
+        const apiKey = migrateLegacyRegisterProviderConfigValue(providerName, "apiKey", config.apiKey);
+        if (apiKey !== config.apiKey) {
+            setMigratedConfigValue("apiKey", apiKey);
+        }
+    }
+    const headers = migrateLegacyRegisterProviderHeaders(providerName, "headers", config.headers);
+    if (headers !== config.headers) {
+        setMigratedConfigValue("headers", headers);
+    }
+    if (config.models) {
+        let models;
+        for (let index = 0; index < config.models.length; index++) {
+            const model = config.models[index];
+            const modelHeaders = migrateLegacyRegisterProviderHeaders(providerName, `model "${model.id}" headers`, model.headers);
+            if (modelHeaders === model.headers)
+                continue;
+            models ??= [...config.models];
+            models[index] = { ...model, headers: modelHeaders };
+        }
+        if (models) {
+            setMigratedConfigValue("models", models);
+        }
+    }
+    return migratedConfig ?? config;
 }
 function emptyCustomModelsResult(error) {
     return { models: [], overrides: new Map(), modelOverrides: new Map(), error };
@@ -491,8 +538,9 @@ export class ModelRegistry {
      * Get API key for a model.
      */
     hasConfiguredAuth(model) {
+        const providerApiKey = this.providerRequestConfigs.get(model.provider)?.apiKey;
         return (this.authStorage.hasAuth(model.provider) ||
-            this.providerRequestConfigs.get(model.provider)?.apiKey !== undefined);
+            (providerApiKey !== undefined && isConfigValueConfigured(providerApiKey)));
     }
     getModelRequestKey(provider, modelId) {
         return `${provider}:${modelId}`;
@@ -563,11 +611,14 @@ export class ModelRegistry {
         if (!providerApiKey) {
             return authStatus;
         }
-        if (providerApiKey.startsWith("!")) {
+        if (isCommandConfigValue(providerApiKey)) {
             return { configured: true, source: "models_json_command" };
         }
-        if (process.env[providerApiKey]) {
-            return { configured: true, source: "environment", label: providerApiKey };
+        const envVarNames = getConfigValueEnvVarNames(providerApiKey);
+        if (envVarNames.length > 0) {
+            return isConfigValueConfigured(providerApiKey)
+                ? { configured: true, source: "environment", label: envVarNames.join(", ") }
+                : { configured: false };
         }
         return { configured: true, source: "models_json_key" };
     }
@@ -609,9 +660,10 @@ export class ModelRegistry {
      * If provider has oauth: registers OAuth provider for /login support.
      */
     registerProvider(providerName, config) {
-        this.validateProviderConfig(providerName, config);
-        this.applyProviderConfig(providerName, config);
-        this.upsertRegisteredProvider(providerName, config);
+        const migratedConfig = migrateLegacyRegisterProviderConfigValues(providerName, config);
+        this.validateProviderConfig(providerName, migratedConfig);
+        this.applyProviderConfig(providerName, migratedConfig);
+        this.upsertRegisteredProvider(providerName, migratedConfig);
     }
     /**
      * Unregister a previously registered provider.

package/node_modules/@earendil-works/pi-coding-agent/dist/core/model-resolver.js

@@ -9,7 +9,7 @@ import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 /** Default model IDs for each known provider */
 export const defaultModelPerProvider = {
     "amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
-    anthropic: "claude-opus-4-7",
+    anthropic: "claude-opus-4-8",
     openai: "gpt-5.4",
     "azure-openai-responses": "gpt-5.4",
     "openai-codex": "gpt-5.5",

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

@@ -6,17 +6,130 @@ import { execSync, spawnSync } from "child_process";
 import { getShellConfig } from "../utils/shell.js";
 // Cache for shell command results (persists for process lifetime)
 const commandResultCache = new Map();
+const ENV_VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const ENV_VAR_NAME_PREFIX_RE = /^[A-Za-z_][A-Za-z0-9_]*/;
+const LEGACY_ENV_VAR_NAME_RE = /^[A-Z_][A-Z0-9_]*$/;
+function appendLiteral(parts, value) {
+    if (!value)
+        return;
+    const previousPart = parts[parts.length - 1];
+    if (previousPart?.type === "literal") {
+        previousPart.value += value;
+        return;
+    }
+    parts.push({ type: "literal", value });
+}
+function parseConfigValueTemplate(config) {
+    const parts = [];
+    let index = 0;
+    while (index < config.length) {
+        const dollarIndex = config.indexOf("$", index);
+        if (dollarIndex < 0) {
+            appendLiteral(parts, config.slice(index));
+            break;
+        }
+        appendLiteral(parts, config.slice(index, dollarIndex));
+        const nextChar = config[dollarIndex + 1];
+        if (nextChar === "$" || nextChar === "!") {
+            appendLiteral(parts, nextChar);
+            index = dollarIndex + 2;
+            continue;
+        }
+        if (nextChar === "{") {
+            const endIndex = config.indexOf("}", dollarIndex + 2);
+            if (endIndex < 0) {
+                appendLiteral(parts, "$");
+                index = dollarIndex + 1;
+                continue;
+            }
+            const name = config.slice(dollarIndex + 2, endIndex);
+            if (ENV_VAR_NAME_RE.test(name)) {
+                parts.push({ type: "env", name });
+            }
+            else {
+                appendLiteral(parts, config.slice(dollarIndex, endIndex + 1));
+            }
+            index = endIndex + 1;
+            continue;
+        }
+        const match = config.slice(dollarIndex + 1).match(ENV_VAR_NAME_PREFIX_RE);
+        if (match) {
+            parts.push({ type: "env", name: match[0] });
+            index = dollarIndex + 1 + match[0].length;
+            continue;
+        }
+        appendLiteral(parts, "$");
+        index = dollarIndex + 1;
+    }
+    return parts;
+}
+function parseConfigValueReference(config) {
+    if (config.startsWith("!")) {
+        return { type: "command", config };
+    }
+    return { type: "template", parts: parseConfigValueTemplate(config) };
+}
+function resolveEnvConfigValue(name) {
+    return process.env[name] || undefined;
+}
+function getTemplateEnvVarNames(parts) {
+    const names = [];
+    for (const part of parts) {
+        if (part.type !== "env" || names.includes(part.name))
+            continue;
+        names.push(part.name);
+    }
+    return names;
+}
+function resolveTemplate(parts) {
+    let resolved = "";
+    for (const part of parts) {
+        if (part.type === "literal") {
+            resolved += part.value;
+            continue;
+        }
+        const envValue = resolveEnvConfigValue(part.name);
+        if (envValue === undefined)
+            return undefined;
+        resolved += envValue;
+    }
+    return resolved;
+}
+export function getConfigValueEnvVarName(config) {
+    const reference = parseConfigValueReference(config);
+    if (reference.type !== "template")
+        return undefined;
+    return reference.parts.length === 1 && reference.parts[0]?.type === "env" ? reference.parts[0].name : undefined;
+}
+export function getConfigValueEnvVarNames(config) {
+    const reference = parseConfigValueReference(config);
+    return reference.type === "template" ? getTemplateEnvVarNames(reference.parts) : [];
+}
+export function getMissingConfigValueEnvVarNames(config) {
+    return getConfigValueEnvVarNames(config).filter((name) => resolveEnvConfigValue(name) === undefined);
+}
+export function isCommandConfigValue(config) {
+    return parseConfigValueReference(config).type === "command";
+}
+export function isConfigValueConfigured(config) {
+    return getMissingConfigValueEnvVarNames(config).length === 0;
+}
+export function isLegacyEnvVarNameConfigValue(config) {
+    return LEGACY_ENV_VAR_NAME_RE.test(config);
+}
 /**
  * Resolve a config value (API key, header value, etc.) to an actual value.
  * - If starts with "!", executes the rest as a shell command and uses stdout (cached)
- * - Otherwise checks environment variable first, then treats as literal (not cached)
+ * - Interpolates "$ENV_VAR" or "${ENV_VAR}" references with the named environment variable
+ * - In non-command values, "$$" escapes a literal "$" and "$!" escapes a literal "!"
+ * - Otherwise treats the value as a literal
  */
 export function resolveConfigValue(config) {
-    if (config.startsWith("!")) {
-        return executeCommand(config);
+    const reference = parseConfigValueReference(config);
+    if (reference.type === "command") {
+        return executeCommand(reference.config);
     }
-    const envValue = process.env[config];
-    return envValue || config;
+    return resolveTemplate(reference.parts);
 }
 function executeWithConfiguredShell(command) {
     try {
@@ -79,19 +192,29 @@ function executeCommand(commandConfig) {
  * Resolve all header values using the same resolution logic as API keys.
  */
 export function resolveConfigValueUncached(config) {
-    if (config.startsWith("!")) {
-        return executeCommandUncached(config);
+    const reference = parseConfigValueReference(config);
+    if (reference.type === "command") {
+        return executeCommandUncached(reference.config);
     }
-    const envValue = process.env[config];
-    return envValue || config;
+    return resolveTemplate(reference.parts);
 }
 export function resolveConfigValueOrThrow(config, description) {
     const resolvedValue = resolveConfigValueUncached(config);
     if (resolvedValue !== undefined) {
         return resolvedValue;
     }
-    if (config.startsWith("!")) {
-        throw new Error(`Failed to resolve ${description} from shell command: ${config.slice(1)}`);
+    const reference = parseConfigValueReference(config);
+    if (reference.type === "command") {
+        throw new Error(`Failed to resolve ${description} from shell command: ${reference.config.slice(1)}`);
+    }
+    if (reference.type === "template") {
+        const missingEnvVars = getMissingConfigValueEnvVarNames(config);
+        if (missingEnvVars.length === 1) {
+            throw new Error(`Failed to resolve ${description} from environment variable: ${missingEnvVars[0]}`);
+        }
+        if (missingEnvVars.length > 1) {
+            throw new Error(`Failed to resolve ${description} from environment variables: ${missingEnvVars.join(", ")}`);
+        }
     }
     throw new Error(`Failed to resolve ${description}`);
 }

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

@@ -155,11 +155,9 @@ export async function createAgentSession(options = {}) {
     }
     const defaultActiveToolNames = ["read", "bash", "edit", "write"];
     const allowedToolNames = options.tools ?? (options.noTools === "all" ? [] : undefined);
-    const initialActiveToolNames = options.tools
-        ? [...options.tools]
-        : options.noTools
-            ? []
-            : defaultActiveToolNames;
+    const excludedToolNames = options.excludeTools;
+    const excludedToolNameSet = excludedToolNames ? new Set(excludedToolNames) : undefined;
+    const initialActiveToolNames = (options.tools ? [...options.tools] : options.noTools ? [] : defaultActiveToolNames).filter((name) => !excludedToolNameSet?.has(name));
     let agent;
     // Create convertToLlm wrapper that filters images if blockImages is enabled (defense-in-depth)
     const convertToLlmWithBlockImages = (messages) => {
@@ -206,11 +204,18 @@ export async function createAgentSession(options = {}) {
                 throw new Error(auth.error);
             }
             const providerRetrySettings = settingsManager.getProviderRetrySettings();
+            const httpIdleTimeoutMs = settingsManager.getHttpIdleTimeoutMs();
+            // SDKs treat timeout=0 as 0ms (immediate timeout), not "no timeout".
+            // Use max int32 to effectively disable the timeout.
+            const effectiveTimeoutMs = httpIdleTimeoutMs === 0 ? 2147483647 : httpIdleTimeoutMs;
+            const timeoutMs = options?.timeoutMs ?? providerRetrySettings.timeoutMs ?? effectiveTimeoutMs;
+            const websocketConnectTimeoutMs = options?.websocketConnectTimeoutMs ?? settingsManager.getWebSocketConnectTimeoutMs();
             const attributionHeaders = getAttributionHeaders(model, settingsManager, options?.sessionId);
             return streamSimple(model, context, {
                 ...options,
                 apiKey: auth.apiKey,
-                timeoutMs: options?.timeoutMs ?? providerRetrySettings.timeoutMs,
+                timeoutMs,
+                websocketConnectTimeoutMs,
                 maxRetries: options?.maxRetries ?? providerRetrySettings.maxRetries,
                 maxRetryDelayMs: options?.maxRetryDelayMs ?? providerRetrySettings.maxRetryDelayMs,
                 headers: attributionHeaders || auth.headers || options?.headers
@@ -274,6 +279,7 @@ export async function createAgentSession(options = {}) {
         modelRegistry,
         initialActiveToolNames,
         allowedToolNames,
+        excludedToolNames,
         extensionRunnerRef,
         sessionStartEvent: options.sessionStartEvent,
     });