@wrongstack/cli 0.310.0 → 0.313.0

package/dist/{acp-EA57GUFB.js → acp-LQMSMV32.js}

@@ -3,7 +3,7 @@ import {
   loadCachedAcpRegistry,
   refreshAcpRegistry,
   setupProvider
-} from "./chunk-CHZZEEIP.js";
+} from "./chunk-CNQZ4HG4.js";
 import "./chunk-QYIIOMLE.js";
 import "./chunk-BXFYBQKR.js";
 import "./chunk-7OCVIDC7.js";
@@ -913,4 +913,4 @@ ${renderAcpBenchText(result)}
 export {
   acpCmd
 };
-//# sourceMappingURL=acp-EA57GUFB.js.map
+//# sourceMappingURL=acp-LQMSMV32.js.map

package/dist/chunk-4JRIWVJ4.js

@@ -0,0 +1,13 @@
+
+// src/wiring/wrongtrace-gate.ts
+import {
+  getWrongTrace,
+  preflightFileEdit,
+  resetWrongTraceGate,
+  withFileLock
+} from "@wrongstack/wrongtrace";
+
+export {
+  getWrongTrace
+};
+//# sourceMappingURL=chunk-4JRIWVJ4.js.map

package/dist/{chunk-63GFD62R.js → chunk-4S52MIIM.js}

@@ -166,7 +166,7 @@ Update failed: ${msg}
 var updateCmd = async (args, deps) => runUpdateCommand(args, deps);
 function writeUpdateUsage(renderer) {
   renderer.write(
-    "Usage: wrongstack update [--check-only] [--pm npm|pnpm|yarn|bun] [--allow-scripts]\n"
+    "Usage: wstack update [--check-only] [--pm <manager>] [--allow-scripts (alias: --lifecycle-scripts)]\n"
   );
 }
 function mergeUpdateArgs(args, flags) {
@@ -383,4 +383,4 @@ export {
   detectUpdatePackageManager,
   detectUpdatePackageName
 };
-//# sourceMappingURL=chunk-63GFD62R.js.map
+//# sourceMappingURL=chunk-4S52MIIM.js.map

package/dist/chunk-7CECQDNH.js

@@ -0,0 +1,24 @@
+
+// src/wiring/wrongtrace-gate-counters.ts
+import {
+  createWrongTraceGateCounter,
+  countersFilePath,
+  formatGateCounterReport,
+  loadWrongTraceGateCounters,
+  persistWrongTraceGateCounters,
+  recordGateDecision,
+  resetGateDecisions,
+  snapshotGateDecisions
+} from "@wrongstack/wrongtrace";
+
+export {
+  createWrongTraceGateCounter,
+  countersFilePath,
+  formatGateCounterReport,
+  loadWrongTraceGateCounters,
+  persistWrongTraceGateCounters,
+  recordGateDecision,
+  resetGateDecisions,
+  snapshotGateDecisions
+};
+//# sourceMappingURL=chunk-7CECQDNH.js.map

package/dist/chunk-AOAIPYFB.js

@@ -0,0 +1,58 @@
+import {
+  startProxyProbe
+} from "./chunk-GWVLRUVH.js";
+
+// src/wiring/proxy-wiring.ts
+import {
+  applyProxyConfig
+} from "@wrongstack/core/wiring/proxy-rewrite";
+var probeRunner;
+function applyWrongProxyPrefs(payload) {
+  const patch = {};
+  if (typeof payload["wrongProxyEnabled"] === "boolean") {
+    patch.enabled = payload["wrongProxyEnabled"];
+  }
+  if (typeof payload["wrongProxyUrl"] === "string") {
+    patch.url = payload["wrongProxyUrl"];
+  }
+  if (Object.keys(patch).length === 0) return;
+  applyProxyConfig(patch);
+  if (!probeRunner) {
+    probeRunner = startProxyProbe();
+  } else {
+    void probeRunner.poke();
+  }
+}
+async function awaitFirstWrongProxyProbe() {
+  if (!probeRunner) return;
+  await probeRunner.poke();
+}
+function bootstrapWrongProxy(snapshot) {
+  if (!snapshot) {
+    applyWrongProxyPrefs({});
+    return;
+  }
+  const enabled = snapshot.enabled;
+  const url = snapshot.url;
+  if (typeof enabled === "boolean" || typeof url === "string") {
+    const payload = {};
+    if (typeof enabled === "boolean") payload["wrongProxyEnabled"] = enabled;
+    if (typeof url === "string") payload["wrongProxyUrl"] = url;
+    applyWrongProxyPrefs(payload);
+    return;
+  }
+  applyWrongProxyPrefs(snapshot);
+}
+function shutdownWrongProxy() {
+  if (probeRunner) probeRunner.stop();
+  probeRunner = void 0;
+  applyProxyConfig({ enabled: false, url: "", active: false });
+}
+
+export {
+  applyWrongProxyPrefs,
+  awaitFirstWrongProxyProbe,
+  bootstrapWrongProxy,
+  shutdownWrongProxy
+};
+//# sourceMappingURL=chunk-AOAIPYFB.js.map

package/dist/{chunk-CHZZEEIP.js → chunk-CNQZ4HG4.js}

@@ -42,6 +42,37 @@ async function refreshAcpRegistry(paths, opts) {
   return { count: result.agents.length, location, fetchedAt: result.fetchedAt };
 }
 
+// src/wiring/provider-runtime.ts
+import { makeProviderFromConfig } from "@wrongstack/providers";
+import { getProxyConfig, rewriteBaseUrl, shouldRewriteFor } from "@wrongstack/core/wiring/proxy-rewrite";
+function resolveProviderCfg(config, providerId) {
+  const savedCfg = config.providers?.[providerId];
+  const rawBaseUrl = savedCfg?.baseUrl ?? config.baseUrl;
+  const baseUrl = rawBaseUrl && shouldRewriteFor(providerId) ? rewriteBaseUrl(rawBaseUrl, currentProxyBaseUrl()) : rawBaseUrl;
+  const cfg = {
+    ...savedCfg,
+    apiKey: savedCfg?.apiKey ?? config.apiKey,
+    baseUrl,
+    type: providerId
+  };
+  const factoryType = savedCfg?.type ?? providerId;
+  return { cfg, factoryType };
+}
+function currentProxyBaseUrl() {
+  return getProxyConfig().url;
+}
+function resolveProviderCfgWithProxy(config, providerId) {
+  return resolveProviderCfg(config, providerId);
+}
+function buildProviderForId(args, providerId) {
+  const { cfg, factoryType } = resolveProviderCfg(args.config, providerId);
+  const useRegistry = !!args.config.features.modelsRegistry && args.providerRegistry.has(factoryType);
+  return useRegistry ? args.providerRegistry.create(cfg, factoryType) : makeProviderFromConfig(
+    providerId,
+    factoryType === "ai-gateway" ? { ...cfg, type: factoryType } : cfg
+  );
+}
+
 // src/shutdown-cleanup.ts
 function createGracefulShutdown(cleanup) {
   const exitCode = cleanup.exitCode ?? 0;
@@ -92,7 +123,7 @@ import {
   buildProviderFactoriesFromRegistry,
   createAiGatewayProviderFactory,
   installCatalogModelOutputLimits,
-  makeProviderFromConfig,
+  makeProviderFromConfig as makeProviderFromConfig2,
   withCatalogCapabilities
 } from "@wrongstack/providers";
 async function setupProvider(params) {
@@ -174,19 +205,17 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
       });
     }
   }
-  const providerConfig = config.providers?.[config.provider] ?? {
-    type: config.provider,
-    apiKey: config.apiKey,
-    baseUrl: config.baseUrl
-  };
+  const { cfg: providerConfig, factoryType } = resolveProviderCfgWithProxy(
+    config,
+    config.provider
+  );
   let provider;
   try {
-    const factoryType = providerConfig.type ?? config.provider;
     const cfgWithType = { ...providerConfig, type: config.provider };
     if (providerRegistry.has(factoryType)) {
       provider = providerRegistry.create(cfgWithType, factoryType);
     } else {
-      provider = makeProviderFromConfig(config.provider, { ...cfgWithType, type: factoryType });
+      provider = makeProviderFromConfig2(config.provider, { ...cfgWithType, type: factoryType });
     }
   } catch (err) {
     throw new ConfigError({
@@ -211,7 +240,9 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
 export {
   loadCachedAcpRegistry,
   refreshAcpRegistry,
+  resolveProviderCfg,
+  buildProviderForId,
   setupProvider,
   createGracefulShutdown
 };
-//# sourceMappingURL=chunk-CHZZEEIP.js.map
+//# sourceMappingURL=chunk-CNQZ4HG4.js.map

package/dist/{chunk-KQNYSZG2.js → chunk-E3X4KM7T.js}

@@ -959,7 +959,10 @@ function lanIPv4Addresses() {
 function truncateHqSummary(value, maxLength) {
   if (typeof value !== "string" || value.length === 0) return void 0;
   if (value.length <= maxLength) return value;
-  return `${value.slice(0, maxLength)}\u2026[truncated:${value.length - maxLength}]`;
+  const suffix = `\u2026[truncated:${value.length - maxLength}]`;
+  if (maxLength <= suffix.length) return "\u2026";
+  const prefixLen = maxLength - suffix.length;
+  return `${value.slice(0, prefixLen)}${suffix}`;
 }
 function hqMachineKey(hostname, machineId) {
   const hn = hostname?.trim();
@@ -2841,7 +2844,7 @@ async function handleApiAgentMessages(req, res, match, agentMessages) {
 async function handleApiSystemUpdate(res) {
   const [{ checkForUpdate }, { detectUpdatePackageName }] = await Promise.all([
     import("./update-check-WARHSVZA.js"),
-    import("./update-RATFF63M.js")
+    import("./update-ZXNC6I6G.js")
   ]);
   const packageName = detectUpdatePackageName();
   const info = await checkForUpdate({ packageName });
@@ -4916,4 +4919,4 @@ export {
   startHqServer,
   HqInsecureExposureError2 as HqInsecureExposureError
 };
-//# sourceMappingURL=chunk-KQNYSZG2.js.map
+//# sourceMappingURL=chunk-E3X4KM7T.js.map

package/dist/chunk-GWVLRUVH.js

@@ -0,0 +1,120 @@
+
+// src/wiring/proxy-probe.ts
+import { applyProxyConfig, getProxyConfig } from "@wrongstack/core/wiring/proxy-rewrite";
+var DEFAULT_INTERVAL_MS = 3e4;
+var DEFAULT_TIMEOUT_MS = 2e3;
+var HEALTH_PATH = "/api/health";
+var DEFAULT_DEACTIVATE_AFTER_FAILURES = 2;
+var activeRunner;
+function startProxyProbe(opts = {}) {
+  if (activeRunner) {
+    scheduleImmediateProbe(activeRunner);
+    return activeRunner;
+  }
+  const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const setIntervalImpl = opts.setIntervalImpl ?? setInterval;
+  const clearIntervalImpl = opts.clearIntervalImpl ?? clearInterval;
+  const deactivateAfterFailures = typeof opts.deactivateAfterFailures === "number" && Number.isFinite(opts.deactivateAfterFailures) ? Math.max(1, Math.trunc(opts.deactivateAfterFailures)) : DEFAULT_DEACTIVATE_AFTER_FAILURES;
+  const state = {
+    currentAbort: void 0,
+    timer: void 0,
+    // Consecutive failed probes. Reset on every success; `active` flips to
+    // false only once this reaches `deactivateAfterFailures`. A single
+    // transient failure is a soft signal and must not disable rewrites.
+    consecutiveFailures: 0
+  };
+  const runOnce = async () => {
+    const cfg = getProxyConfig();
+    if (!cfg.enabled || !cfg.url) {
+      state.consecutiveFailures = 0;
+      if (state.currentAbort) state.currentAbort.abort();
+      state.currentAbort = void 0;
+      applyProxyConfig({ active: false });
+      return false;
+    }
+    if (state.currentAbort) state.currentAbort.abort();
+    const abort = new AbortController();
+    state.currentAbort = abort;
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      abort.abort();
+    }, timeoutMs);
+    if (typeof timeout.unref === "function") {
+      timeout.unref();
+    }
+    try {
+      const healthUrl = buildHealthUrl(cfg.url);
+      const res = await fetchImpl(healthUrl, {
+        method: "GET",
+        signal: abort.signal,
+        headers: { accept: "application/json" }
+      });
+      const ok = res.ok && res.status >= 200 && res.status < 300;
+      const live = getProxyConfig();
+      const stillRelevant = live.enabled && live.url === cfg.url;
+      if (stillRelevant) {
+        if (ok) {
+          state.consecutiveFailures = 0;
+          applyProxyConfig({ active: true });
+        } else {
+          state.consecutiveFailures += 1;
+          if (state.consecutiveFailures >= deactivateAfterFailures) {
+            applyProxyConfig({ active: false });
+          }
+        }
+      }
+      return ok;
+    } catch {
+      const live = getProxyConfig();
+      const stillRelevant = live.enabled && live.url === cfg.url;
+      if (stillRelevant && (timedOut || !abort.signal.aborted)) {
+        state.consecutiveFailures += 1;
+        if (state.consecutiveFailures >= deactivateAfterFailures) {
+          applyProxyConfig({ active: false });
+        }
+      }
+      return false;
+    } finally {
+      clearTimeout(timeout);
+      if (state.currentAbort === abort) state.currentAbort = void 0;
+    }
+  };
+  const runner = {
+    stop() {
+      if (state.timer !== void 0) {
+        clearIntervalImpl(state.timer);
+        state.timer = void 0;
+      }
+      if (state.currentAbort) {
+        state.currentAbort.abort();
+        state.currentAbort = void 0;
+      }
+      activeRunner = void 0;
+    },
+    poke: runOnce
+  };
+  scheduleImmediateProbe(runner);
+  state.timer = setIntervalImpl(() => {
+    void runOnce();
+  }, intervalMs);
+  if (state.timer && typeof state.timer.unref === "function") {
+    state.timer.unref();
+  }
+  activeRunner = runner;
+  return runner;
+}
+function scheduleImmediateProbe(runner) {
+  void runner.poke();
+}
+function buildHealthUrl(rawBase) {
+  const trimmed = rawBase.trim().replace(/\/+$/, "");
+  return `${trimmed}${HEALTH_PATH}`;
+}
+
+export {
+  startProxyProbe
+};
+//# sourceMappingURL=chunk-GWVLRUVH.js.map