llm-cli-gateway 2.14.1 → 2.16.0

package/CHANGELOG.md

@@ -4,6 +4,66 @@ All notable changes to the llm-cli-gateway project.
 
 ## [Unreleased]
 
+## [2.16.0] - 2026-07-10
+
+### Added
+
+- **Native outbound display-text compressor, PR-1 (#151).** A built-in,
+  provider-agnostic compressor that shrinks provider display text before it is
+  returned to the caller. It is ANSI- and fence-aware (protects code fences,
+  inline code, OSC sequences, and wide characters from lossy rewriting) and is
+  **off by default**; opt in per the compressor configuration. This is the first
+  slice; response-side wiring and API-provider coverage are named follow-ups.
+- **Site machine-discovery generation (#169).** The machine-readable discovery
+  artifacts under `site/` (`llms.txt`, `.well-known/*`, `tools.md`,
+  `openapi.json`, ...) are now generated from the live MCP tool surface by
+  `scripts/generate-site-discovery.mjs`. Regenerate with `npm run site:generate`;
+  `npm run site:generate:check` + `npm run site:validate` gate them in
+  `npm run check` so the published surface can never silently drift from the
+  tools the server actually exposes.
+
+### Changed
+
+- **Vibe/Mistral no longer defaults to `--agent auto-approve` (#155).** Under the
+  default `legacy` approval strategy, Vibe was spawned in auto-approve ("YOLO"),
+  auto-executing every tool call including shell. It now defaults to
+  `--agent accept-edits` (auto-accept file edits; dangerous ops such as shell stay
+  gated, and Vibe denies rather than blocks on them in programmatic mode), matching
+  the `mcp_managed` posture and the other providers' non-bypass defaults. This
+  shrinks the blast radius of a prompt-injected tool call. `auto-approve` remains
+  reachable deliberately: pass `permissionMode: "auto-approve"` on the request, or
+  set `LLM_GATEWAY_APPROVAL_ALLOW_BYPASS` operator-wide. **Behaviour change:**
+  `legacy` callers that relied on Vibe running shell unattended will now see the
+  gated op denied unless they adopt one of those opt-ins.
+- **Provider contract and target-version refreshes (#157 through #171).**
+  `PROVIDER_TARGET_VERSIONS` is now the single source of truth for provider
+  target versions (#165), and every provider's declared upstream contract was
+  re-probed against the installed CLI and refreshed: codex-cli 0.144.1, claude
+  2.1.206, grok 0.2.93, gemini/agy 1.1.0, mistral vibe 2.19.1 (with
+  `--disabled-tools` acknowledged, #170), cursor-agent 2026.07.09, and the devin
+  ACP target 3000.1.27. Internal metadata only; no request-time behaviour change.
+
+### Security
+
+- **Opt-in isolation of provider child-process environment (#154).** A new
+  `LLM_GATEWAY_ISOLATE_SPAWN_ENV` opt-in scrubs the spawned provider CLI's
+  environment at the single `spawnCliProcess` chokepoint, shrinking the blast
+  radius of a hostile provider attempting to exfiltrate redirected/inherited
+  environment secrets.
+- **Installer Go toolchain bumped 1.26.4 to 1.26.5 (#166).** Clears a Go stdlib
+  vulnerability (GO-2026-4970) in the shipped installer binaries.
+
+## [2.15.0] - 2026-07-03
+
+### Added
+
+- **Updateable local skill packs.** Gateway startup now loads bundled skills,
+  optional `[skills].paths`, `LLM_GATEWAY_SKILLS_PATH`, and
+  `~/.llm-cli-gateway/skills` with deterministic override precedence. Skill
+  pack roots can include a `skill-pack.json` integrity manifest that pins each
+  loaded `SKILL.md` by SHA-256, allowing operators to update workflow skills
+  outside core gateway npm releases without silent network fetches.
+
 ## [2.14.1] - 2026-07-03
 
 ### Added
@@ -21,7 +81,7 @@ All notable changes to the llm-cli-gateway project.
 - **Durable instance-lease orphan recovery (#139).** The blanket
   `markOrphanedOnStartup` sweep in the `AsyncJobManager` constructor rewrote
   every `running` row to `orphaned`, so on a SHARED store (`backend =
-  "postgres"`) a fresh instance (especially an ephemeral stdio spawn)
+"postgres"`) a fresh instance (especially an ephemeral stdio spawn)
   transiently orphaned other live instances' in-flight jobs (a `running` ->
   `orphaned` -> `completed` flap a poller can trip on). The sweep is now a
   per-job fencing lease: each instance registers a lease and advances a

package/README.md

@@ -53,6 +53,40 @@ Or use directly with `npx` from an MCP client:
 
 The repo ships agent-ready workflow skills under [`.agents/skills`](.agents/skills) for async orchestration, session continuity, multi-LLM review, implement-review-fix loops, retrospective evidence walks, and secure approval-gated dispatch. Seven caller-facing skills are bundled in the published npm package: `async-job-orchestration`, `multi-llm-review`, `session-workflow`, `secure-orchestration`, `implement-review-fix`, `retrospective-walk`, and `public-demo-session`. Machine-readable DAG-TOML plans live under [`docs/plans`](docs/plans) and [`setup/install-plan.dag.toml`](setup/install-plan.dag.toml) for workflows that need deterministic sequencing and verification gates.
 
+Skill packs can be updated outside the core npm release by placing skill
+directories in local, operator-controlled paths. The gateway loads bundled
+skills first, then `[skills].paths`, then `LLM_GATEWAY_SKILLS_PATH`, then
+`~/.llm-cli-gateway/skills` when it exists; later roots override earlier skills
+by name. Each skill is a directory containing `SKILL.md`. A root may also carry
+`skill-pack.json` to pin expected `SKILL.md` hashes:
+
+```toml
+[skills]
+paths = ["/opt/llm-cli-gateway/skills"]
+```
+
+```bash
+export LLM_GATEWAY_SKILLS_PATH="/opt/team-skill-pack:/opt/incident-skill-pack"
+```
+
+```json
+{
+  "name": "team-pack",
+  "version": "1.0.0",
+  "skills": [
+    {
+      "name": "incident-retrospective",
+      "sha256": "<sha256 of incident-retrospective/SKILL.md>"
+    }
+  ]
+}
+```
+
+The loader is intentionally local-only: it never fetches remote Markdown at
+startup. To update a pack, install or replace files through your package manager
+or deployment system, then restart the gateway so the advertised `skills://...`
+resources refresh.
+
 The next documentation focus is provider-specific skill and DAG-TOML pairs for each outbound CLI and API-provider family: Claude, Codex, Gemini/Antigravity, Grok, Mistral Vibe, Devin, Cursor Agent, OpenAI-compatible endpoints, Anthropic Messages, and xAI Responses. The implementation plan is tracked in [`docs/plans/provider-workflow-assets.dag.toml`](docs/plans/provider-workflow-assets.dag.toml), with each provider asset expected to cover install/login checks or token-env checks, session behavior, approval modes, cache/telemetry surfaces, failure modes, and a smoke-test gate.
 
 ## Trust & Supply Chain
@@ -1435,6 +1469,7 @@ await callTool("session_delete", {
   LLM_GATEWAY_OAUTH_REQUIRE_CONSENT=1 LLM_GATEWAY_OAUTH_CONSENT_SECRET='choose-a-strong-code' node dist/index.js
   ```
 - `LLM_GATEWAY_CONFIG`: Path to the gateway TOML config (default: `~/.llm-cli-gateway/config.toml`). See **Persistence configuration** above for the `[persistence]` schema.
+- `LLM_GATEWAY_SKILLS_PATH`: Extra local skill-pack roots to load at startup, separated by the host path delimiter (`:` on Linux/macOS, `;` on Windows). These paths are appended after `[skills].paths`; `~/.llm-cli-gateway/skills` still loads last when present.
 - `LLM_GATEWAY_LOGS_DB`: **Deprecated** — overrides `[persistence].path` and selects `backend = "sqlite"` (or `backend = "none"` when set to `none`). Emits a deprecation warning at startup; migrate to `config.toml`.
   ```bash
   # Custom path

package/dist/acp/process-manager.js

@@ -6,6 +6,7 @@ import { AcpError, AcpProcessExitError, ProviderUnavailableError } from "./error
 import { JsonRpcStdioTransport, } from "./json-rpc-stdio.js";
 import { getAcpProviderEntry } from "./provider-registry.js";
 import { envWithExtendedPath, getExtendedPath } from "../executor.js";
+import { applySpawnEnvIsolation } from "../spawn-env-isolation.js";
 import { noopLogger } from "../logger.js";
 const SHUTDOWN_KILL_GRACE_MS = 5000;
 const SHELL_METACHARACTERS = /[\s|&;<>(){}$`"'\\*?[\]~#! ]/;
@@ -15,7 +16,7 @@ function assertSafeExecutable(command, provider) {
     }
 }
 export function buildProviderEnv(provider, providerConfig, baseEnv) {
-    const env = envWithExtendedPath(baseEnv, getExtendedPath());
+    const env = applySpawnEnvIsolation(envWithExtendedPath(baseEnv, getExtendedPath()));
     if (provider === "grok" && providerConfig.isolatedLeaderSocket) {
         const socketDir = tmpdir();
         const socketName = `grok-acp-leader-${process.pid}-${Date.now()}.sock`;

package/dist/acp/provider-registry.js

@@ -1,4 +1,4 @@
-import { getProviderDefinition } from "../provider-definitions.js";
+import { getProviderDefinition, PROVIDER_TARGET_VERSIONS } from "../provider-definitions.js";
 function acpEntrypointFromDefinition(provider) {
     const entry = getProviderDefinition(provider).acp.entrypoint;
     if (!entry) {
@@ -12,7 +12,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "Mistral Vibe",
         status: "native_smoke_passed",
         supportKind: "native",
-        targetVersion: "vibe 2.18.3",
+        targetVersion: PROVIDER_TARGET_VERSIONS.mistral,
         entrypoint: acpEntrypointFromDefinition("mistral"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: true,
@@ -25,7 +25,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "xAI Grok CLI",
         status: "native_smoke_passed",
         supportKind: "native",
-        targetVersion: "grok 0.2.77 (44e77bec3a)",
+        targetVersion: PROVIDER_TARGET_VERSIONS.grok,
         entrypoint: acpEntrypointFromDefinition("grok"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: true,
@@ -38,7 +38,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "OpenAI Codex CLI",
         status: "adapter_mediated_deferred",
         supportKind: "adapter_mediated",
-        targetVersion: "codex-cli 0.142.4",
+        targetVersion: PROVIDER_TARGET_VERSIONS.codex,
         entrypoint: acpEntrypointFromDefinition("codex"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: false,
@@ -51,7 +51,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "Anthropic Claude Code",
         status: "adapter_mediated_deferred",
         supportKind: "adapter_mediated",
-        targetVersion: "claude 2.1.198",
+        targetVersion: PROVIDER_TARGET_VERSIONS.claude,
         entrypoint: acpEntrypointFromDefinition("claude"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: false,
@@ -64,7 +64,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "Google Antigravity",
         status: "absent_watchlist",
         supportKind: "none",
-        targetVersion: "agy 1.0.14",
+        targetVersion: PROVIDER_TARGET_VERSIONS.gemini,
         entrypoint: acpEntrypointFromDefinition("gemini"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: false,
@@ -77,7 +77,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "Cognition Devin CLI",
         status: "native_smoke_passed",
         supportKind: "native",
-        targetVersion: "devin 2026.8.18 (16737566)",
+        targetVersion: PROVIDER_TARGET_VERSIONS.devin,
         entrypoint: acpEntrypointFromDefinition("devin"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: true,
@@ -90,7 +90,7 @@ const ACP_PROVIDER_REGISTRY = Object.freeze({
         displayName: "Cursor Agent CLI",
         status: "native_smoke_passed",
         supportKind: "native",
-        targetVersion: "cursor-agent 2026.06.29-2ad2186",
+        targetVersion: PROVIDER_TARGET_VERSIONS.cursor,
         entrypoint: acpEntrypointFromDefinition("cursor"),
         runtimeEnabledDefault: false,
         shipRuntimePilot: true,

package/dist/async-job-manager.d.ts

@@ -45,6 +45,7 @@ export interface AsyncJobFlightRecorderEntry {
     stablePrefixTokens?: number;
     cacheControlBlocks?: number;
     cacheControlTtlSeconds?: number;
+    optimizationApplied?: boolean;
 }
 export type AsyncJobUsageExtractor = (stdout: string) => {
     inputTokens?: number;
@@ -91,6 +92,7 @@ export interface StartJobOptions {
     writeFlightStart?: boolean;
     flightRecorderEntry?: AsyncJobFlightRecorderEntry;
     extractUsage?: AsyncJobUsageExtractor;
+    compressResponse?: boolean;
 }
 export interface StartJobOutcome {
     snapshot: AsyncJobSnapshot;
@@ -169,7 +171,7 @@ export declare class AsyncJobManager {
     private persistComplete;
     private hydrateFromStore;
     getJobOwner(jobId: string): string | null | undefined;
-    startJob(cli: LlmCli, args: string[], correlationId: string, cwd?: string, idleTimeoutMs?: number, outputFormat?: string, forceRefresh?: boolean, env?: Record<string, string>, onComplete?: () => void, flightRecorderEntry?: AsyncJobFlightRecorderEntry, extractUsage?: AsyncJobUsageExtractor, writeFlightStart?: boolean, stdin?: string): AsyncJobSnapshot;
+    startJob(cli: LlmCli, args: string[], correlationId: string, cwd?: string, idleTimeoutMs?: number, outputFormat?: string, forceRefresh?: boolean, env?: Record<string, string>, onComplete?: () => void, flightRecorderEntry?: AsyncJobFlightRecorderEntry, extractUsage?: AsyncJobUsageExtractor, writeFlightStart?: boolean, stdin?: string, compressResponse?: boolean): AsyncJobSnapshot;
     startJobWithDedup(cli: LlmCli, args: string[], correlationId: string, opts?: StartJobOptions): StartJobOutcome;
     private launchProcessJob;
     private failQueuedJob;
@@ -199,6 +201,7 @@ export declare class AsyncJobManager {
     getLimiterSnapshot(): JobLimiterSnapshot;
     getConfiguredLimits(): JobLimitsConfig;
     getJobOutputFormat(jobId: string): string | undefined;
+    getJobCompressResponse(jobId: string): boolean;
     getJobCli(jobId: string): JobProvider | undefined;
     private snapshot;
     private appendOutput;

package/dist/async-job-manager.js

@@ -657,11 +657,12 @@ export class AsyncJobManager {
             }
         }
     }
-    buildRequestKey(cli, args, env, stdin, cwd, outputFormat) {
+    buildRequestKey(cli, args, env, stdin, cwd, outputFormat, compressResponse) {
         const extraEnv = canonicaliseEnvForKey(env);
         const withStdin = stdin === undefined ? extraEnv : `${extraEnv}|stdin:${stdin}`;
         const withCwd = cwd === undefined ? withStdin : `${withStdin}|cwd:${cwd}`;
-        const extra = cli === "codex" ? `${withCwd}|fmt:${outputFormat ?? "text"}` : withCwd;
+        const withFmt = cli === "codex" ? `${withCwd}|fmt:${outputFormat ?? "text"}` : withCwd;
+        const extra = compressResponse ? `${withFmt}|compress:1` : withFmt;
         const principal = resolveOwnerPrincipal(getRequestContext());
         const scoped = principal === "local" ? extra : `${extra}|principal:${principal}`;
         return computeRequestKey(cli, args, scoped);
@@ -927,7 +928,7 @@ export class AsyncJobManager {
                 durationMs,
                 retryCount: 0,
                 circuitBreakerState: "closed",
-                optimizationApplied: false,
+                optimizationApplied: job.flightRecorderEntry.optimizationApplied ?? false,
                 exitCode,
                 httpStatus: job.transport === "http" ? (job.httpStatus ?? undefined) : undefined,
                 errorMessage,
@@ -1068,6 +1069,7 @@ export class AsyncJobManager {
             exited: row.status !== "running" && row.status !== "queued",
             metricsRecorded: true,
             outputFormat: row.outputFormat ?? undefined,
+            compressResponse: row.compressResponse ?? null,
             ownerPrincipal: row.ownerPrincipal,
             outputDirty: false,
             lastOutputFlushAt: Date.now(),
@@ -1081,7 +1083,7 @@ export class AsyncJobManager {
             job = this.hydrateFromStore(jobId) ?? undefined;
         return job?.ownerPrincipal;
     }
-    startJob(cli, args, correlationId, cwd, idleTimeoutMs, outputFormat, forceRefresh, env, onComplete, flightRecorderEntry, extractUsage, writeFlightStart, stdin) {
+    startJob(cli, args, correlationId, cwd, idleTimeoutMs, outputFormat, forceRefresh, env, onComplete, flightRecorderEntry, extractUsage, writeFlightStart, stdin, compressResponse) {
         return this.startJobWithDedup(cli, args, correlationId, {
             cwd,
             idleTimeoutMs,
@@ -1093,11 +1095,12 @@ export class AsyncJobManager {
             flightRecorderEntry,
             extractUsage,
             writeFlightStart,
+            compressResponse,
         }).snapshot;
     }
     startJobWithDedup(cli, args, correlationId, opts = {}) {
-        const { cwd, idleTimeoutMs, outputFormat, forceRefresh, env: extraEnv, stdin, onComplete, flightRecorderEntry, extractUsage, writeFlightStart, } = opts;
-        const requestKey = this.buildRequestKey(cli, args, extraEnv, stdin, cwd, outputFormat);
+        const { cwd, idleTimeoutMs, outputFormat, forceRefresh, env: extraEnv, stdin, onComplete, flightRecorderEntry, extractUsage, writeFlightStart, compressResponse, } = opts;
+        const requestKey = this.buildRequestKey(cli, args, extraEnv, stdin, cwd, outputFormat, compressResponse);
         if (!forceRefresh) {
             const reused = this.tryReuseDedupedJob(requestKey, correlationId, cli, onComplete);
             if (reused)
@@ -1130,6 +1133,7 @@ export class AsyncJobManager {
             exited: false,
             metricsRecorded: false,
             outputFormat,
+            compressResponse: compressResponse ?? null,
             onComplete,
             onCompleteFired: false,
             outputDirty: false,
@@ -1178,6 +1182,7 @@ export class AsyncJobManager {
             cli,
             args: [...args],
             outputFormat,
+            compressResponse,
             startedAt,
             pid: null,
             ownerPrincipal,
@@ -1222,6 +1227,7 @@ export class AsyncJobManager {
             cwd,
             stdio: stdin === undefined ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
             env: { ...baseEnv, ...(extraEnv ?? {}) },
+            logger: this.logger,
         });
         job.process = child;
         try {
@@ -1531,6 +1537,9 @@ export class AsyncJobManager {
     getJobOutputFormat(jobId) {
         return this.jobs.get(jobId)?.outputFormat;
     }
+    getJobCompressResponse(jobId) {
+        return this.jobs.get(jobId)?.compressResponse === true;
+    }
     getJobCli(jobId) {
         return this.jobs.get(jobId)?.cli;
     }

package/dist/compressor/estimate.d.ts

@@ -0,0 +1,5 @@
+import type { ContentRoute } from "./router.js";
+export type DevTokenizer = (text: string) => number;
+export declare function setDevTokenizer(tokenizer: DevTokenizer | null): void;
+export declare function estimateTokensForRoute(text: string, route: ContentRoute): number;
+export declare function estimateTokensSaved(originalText: string, compressedText: string, route: ContentRoute): number;

package/dist/compressor/estimate.js

@@ -0,0 +1,21 @@
+const DIVISORS = {
+    json: 3.0,
+    log: 3.4,
+    "ansi-text": 3.4,
+    plain: 3.6,
+    identity: 3.6,
+};
+let devTokenizer = null;
+export function setDevTokenizer(tokenizer) {
+    devTokenizer = tokenizer;
+}
+export function estimateTokensForRoute(text, route) {
+    if (devTokenizer)
+        return devTokenizer(text);
+    if (text.length === 0)
+        return 0;
+    return Math.ceil(text.length / DIVISORS[route]);
+}
+export function estimateTokensSaved(originalText, compressedText, route) {
+    return Math.max(0, estimateTokensForRoute(originalText, route) - estimateTokensForRoute(compressedText, route));
+}

package/dist/compressor/index.d.ts

@@ -0,0 +1,23 @@
+import { type ContentRoute } from "./router.js";
+export interface CompressCtx {
+    provider: string;
+    direction: "outbound";
+    outputFormat?: string;
+    outputSchemaDeclared: boolean;
+    lossless: true;
+}
+export interface CompressResult {
+    text: string;
+    originalChars: number;
+    compressedChars: number;
+    route: ContentRoute;
+    transforms: string[];
+    estimatedTokensSaved: number;
+}
+export interface Compressor {
+    compact(text: string, ctx: CompressCtx): CompressResult;
+}
+export declare class NativeCompressor implements Compressor {
+    compact(text: string, ctx: CompressCtx): CompressResult;
+}
+export declare function compressDisplayText(text: string, ctx: CompressCtx): CompressResult;

package/dist/compressor/index.js

@@ -0,0 +1,77 @@
+import { classify } from "./router.js";
+import { minifyJson } from "./transforms/json.js";
+import { dedupAdjacentLines, escapeSentinelLikeLines, noteLine, } from "./transforms/log.js";
+import { stripAnsi } from "./transforms/ansi.js";
+import { normalizeWhitespace } from "./transforms/whitespace.js";
+import { estimateTokensSaved } from "./estimate.js";
+function identityResult(text, route = "identity") {
+    return {
+        text,
+        originalChars: text.length,
+        compressedChars: text.length,
+        route,
+        transforms: [],
+        estimatedTokensSaved: 0,
+    };
+}
+export class NativeCompressor {
+    compact(text, ctx) {
+        if (ctx.outputFormat === "json" || ctx.outputSchemaDeclared) {
+            return identityResult(text);
+        }
+        const route = classify(text);
+        if (route === "identity")
+            return identityResult(text);
+        if (route === "json") {
+            const minified = minifyJson(text.trim());
+            if (minified === null || minified.length >= text.length) {
+                return identityResult(text);
+            }
+            return {
+                text: minified,
+                originalChars: text.length,
+                compressedChars: minified.length,
+                route,
+                transforms: ["json-minify"],
+                estimatedTokensSaved: estimateTokensSaved(text, minified, route),
+            };
+        }
+        const counts = { folded: 0, escaped: 0 };
+        const transforms = [];
+        let current = text;
+        const apply = (name, fn) => {
+            const next = fn(current);
+            if (next !== current)
+                transforms.push(name);
+            current = next;
+        };
+        apply("lit-escape", input => escapeSentinelLikeLines(input, counts));
+        if (route === "ansi-text") {
+            apply("ansi-strip", input => stripAnsi(input, counts));
+            apply("dedup", input => dedupAdjacentLines(input, counts));
+        }
+        if (route === "log") {
+            apply("dedup", input => dedupAdjacentLines(input, counts));
+        }
+        apply("whitespace", normalizeWhitespace);
+        if (counts.folded + counts.escaped > 0) {
+            current = `${noteLine(counts.folded, counts.escaped)}\n${current}`;
+            transforms.push("leading-note");
+        }
+        if (current.length >= text.length) {
+            return identityResult(text, route);
+        }
+        return {
+            text: current,
+            originalChars: text.length,
+            compressedChars: current.length,
+            route,
+            transforms,
+            estimatedTokensSaved: estimateTokensSaved(text, current, route),
+        };
+    }
+}
+const defaultCompressor = new NativeCompressor();
+export function compressDisplayText(text, ctx) {
+    return defaultCompressor.compact(text, ctx);
+}

package/dist/compressor/router.d.ts

@@ -0,0 +1,2 @@
+export type ContentRoute = "json" | "log" | "ansi-text" | "plain" | "identity";
+export declare function classify(text: string): ContentRoute;

package/dist/compressor/router.js

@@ -0,0 +1,57 @@
+import { hasDangerousSequences } from "./transforms/ansi.js";
+import { minifyJson } from "./transforms/json.js";
+import { splitFences } from "./transforms/whitespace.js";
+import { MIN_RUN } from "./transforms/log.js";
+const HAS_ESCAPE = /\x1b/;
+const HAS_INTERNAL_CR = /\r(?!\n|$)/;
+const HAS_FENCE = /^ {0,3}(?:`{3,}|~{3,})/m;
+function hasFence(text) {
+    return HAS_FENCE.test(text);
+}
+function hasRepeatedRuns(text) {
+    for (const segment of splitFences(text)) {
+        if (segment.fenced)
+            continue;
+        const lines = segment.text.split("\n");
+        let run = 1;
+        for (let i = 1; i < lines.length; i += 1) {
+            if (lines[i] === lines[i - 1] && lines[i].trim() !== "") {
+                run += 1;
+                if (run >= MIN_RUN)
+                    return true;
+            }
+            else {
+                run = 1;
+            }
+        }
+    }
+    return false;
+}
+function isStructuralJson(text) {
+    const trimmed = text.trim();
+    if (trimmed.length < 2)
+        return false;
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    const structural = (first === "{" && last === "}") || (first === "[" && last === "]");
+    if (!structural)
+        return false;
+    return minifyJson(trimmed) !== null;
+}
+export function classify(text) {
+    if (text.length === 0)
+        return "identity";
+    const escapes = HAS_ESCAPE.test(text);
+    const internalCr = HAS_INTERNAL_CR.test(text);
+    if (escapes || internalCr) {
+        if (hasDangerousSequences(text))
+            return "identity";
+        if (!hasFence(text))
+            return "ansi-text";
+    }
+    if (isStructuralJson(text))
+        return "json";
+    if (hasRepeatedRuns(text))
+        return "log";
+    return "plain";
+}

package/dist/compressor/transforms/ansi.d.ts

@@ -0,0 +1,3 @@
+import { type MarkerCounts } from "./log.js";
+export declare function hasDangerousSequences(text: string): boolean;
+export declare function stripAnsi(text: string, counts: MarkerCounts): string;

package/dist/compressor/transforms/ansi.js

@@ -0,0 +1,89 @@
+import { mapUnfenced } from "./whitespace.js";
+import { crMarker } from "./log.js";
+const CSI = /\x1b\[([0-9:;<=>?]*)[ -/]*([@-~])/g;
+const OSC = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+const DCS_APC_PM_SOS = /\x1b[PX^_][\s\S]*?\x1b\\/g;
+const ESC_TWO_BYTE = /\x1b[@-Z\\-_]/g;
+const STRAY_C0 = /[\x00-\x07\x0b\x0c\x0e-\x1f]/g;
+const DANGEROUS_CSI_FINALS = new Set([
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "f",
+    "S",
+    "T",
+    "J",
+    "s",
+    "u",
+]);
+export function hasDangerousSequences(text) {
+    if (text.includes("\b"))
+        return true;
+    CSI.lastIndex = 0;
+    let match;
+    while ((match = CSI.exec(text)) !== null) {
+        const params = match[1];
+        const final = match[2];
+        if (DANGEROUS_CSI_FINALS.has(final))
+            return true;
+        if ((final === "h" || final === "l") && params.includes("?")) {
+            return true;
+        }
+    }
+    return false;
+}
+function stripEscapes(text) {
+    return text
+        .replace(OSC, "")
+        .replace(DCS_APC_PM_SOS, "")
+        .replace(CSI, "")
+        .replace(ESC_TWO_BYTE, "")
+        .replace(STRAY_C0, "");
+}
+const ASCII_ONLY = /^[\x09\x0d\x20-\x7e]*$/;
+function overlayFrames(frames) {
+    const cells = [];
+    for (const frame of frames) {
+        for (let i = 0; i < frame.length; i += 1)
+            cells[i] = frame[i];
+    }
+    return cells.join("");
+}
+function collapseLine(line, out, counts) {
+    const crlf = line.endsWith("\r");
+    const body = crlf ? line.slice(0, -1) : line;
+    if (!body.includes("\r")) {
+        out.push(line);
+        return;
+    }
+    if (!ASCII_ONLY.test(body)) {
+        out.push(line);
+        return;
+    }
+    const frames = body.split("\r");
+    const visible = overlayFrames(frames);
+    out.push(crlf ? `${visible}\r` : visible);
+    out.push(crMarker(frames.length - 1));
+    counts.folded += 1;
+}
+export function stripAnsi(text, counts) {
+    if (hasDangerousSequences(text))
+        return text;
+    return mapUnfenced(text, segment => {
+        const stripped = stripEscapes(segment);
+        const out = [];
+        for (const line of stripped.split("\n")) {
+            if (line.includes("`")) {
+                out.push(line);
+                continue;
+            }
+            collapseLine(line, out, counts);
+        }
+        return out.join("\n");
+    });
+}

package/dist/compressor/transforms/json.d.ts

@@ -0,0 +1 @@
+export declare function minifyJson(text: string): string | null;