@zereight/mcp-gitlab 2.1.68 → 2.1.69

package/README.ko.md

@@ -111,7 +111,7 @@ command = lib.getExe inputs.gitlab-mcp.packages.${system}.default;
 
 예시는 기존 `mcp-gitlab`보다 충돌 가능성이 낮은 `zereight-mcp-gitlab` 별칭을 사용합니다. MCP 클라이언트가 찾지 못하면 `which zereight-mcp-gitlab`의 절대 경로를 사용하세요.
 
-전역 설치를 쓰지 않으려면 `npx -y @zereight/mcp-gitlab@2.1.67`처럼 직전 안정 버전(문서가 권장하는 버전)으로 고정하세요. 항상 최신 버전을 원하면 `npx -y @zereight/mcp-gitlab@latest`를 사용하세요. 새 버전이 나오면 서버가 시작 시 stderr로 알려줍니다(`GITLAB_DISABLE_VERSION_CHECK=true`로 비활성화 가능).
+전역 설치를 쓰지 않으려면 `npx -y @zereight/mcp-gitlab@2.1.68`처럼 직전 안정 버전(문서가 권장하는 버전)으로 고정하세요. 항상 최신 버전을 원하면 `npx -y @zereight/mcp-gitlab@latest`를 사용하세요. 새 버전이 나오면 서버가 시작 시 stderr로 알려줍니다(`GITLAB_DISABLE_VERSION_CHECK=true`로 비활성화 가능).
 
 #### CLI 인자 사용하기(환경 변수 문제가 있는 클라이언트용)
 
@@ -139,11 +139,15 @@ command = lib.getExe inputs.gitlab-mcp.packages.${system}.default;
 - `--use-milestone=true` - 마일스톤 API 활성화 (`USE_MILESTONE` 대체, 레거시 — `GITLAB_TOOLSETS=milestones` 권장)
 - `--use-pipeline=true` - 파이프라인 API 활성화 (`USE_PIPELINE` 대체, 레거시 — `GITLAB_TOOLSETS=pipelines` 권장)
 - `--disable-version-check=true` - 시작 시 신규 버전 알림 비활성화 (`GITLAB_DISABLE_VERSION_CHECK` 대체)
+- `--compact-results=true` - 큰 MCP 도구 응답을 미리보기와 CLI 명령으로 바꿈 (`GITLAB_MCP_COMPACT_RESULTS` 대체, 기본 꺼짐)
+- `--compact-result-chars` - compact 임계값 문자 수 (`GITLAB_MCP_COMPACT_RESULT_CHARS` 대체, 기본 `4000`)
 
 CLI 인자는 환경 변수보다 우선합니다.
 
 `zereight-mcp-gitlab auth`는 MCP 서버 플래그가 아니라 서브커맨드입니다. GitLab device flow를 실행한 뒤 종료합니다. [CLI 인자](./docs/getting-started/cli-arguments.md#auth)를 참고하세요.
 
+같은 바이너리는 `gh` 스타일 GitLab CLI이기도 합니다 (`tool <name>` 또는 `mr list` 같은 curated 명령). 전체 페이로드는 터미널에서 이 CLI로 읽습니다. MCP 응답은 대화에 남습니다. `GITLAB_MCP_COMPACT_RESULTS=true`(또는 `--compact-results`)를 켜면 큰 도구 응답이 미리보기와 CLI 명령으로 바뀝니다. Human CLI 자체는 compact 되지 않습니다. permission mode, toolsets, denied-tools regex, tool-policy는 MCP와 같습니다. destructive 도구와 `GITLAB_TOOL_POLICY_APPROVE` 도구는 `--yes`가 필요합니다. [Human CLI](./docs/getting-started/cli-arguments.md#human-cli)를 참고하세요.
+
 > **세밀한 도구 필터링:** `GITLAB_PERMISSION_MODE=modify`로 생성/수정은 허용하고 모든 삭제 도구와
 > 파괴적인 중단(teardown) 도구(`cancel_pipeline`, `cancel_pipeline_job`, `stop_environment`,
 > `stop_stale_environments`, `unprotect_branch`)를 차단하거나(`execute_graphql`을 통한 파괴적

package/README.md

@@ -116,7 +116,7 @@ The store path is pinned by your lock file; update it with `nix flake update git
 
 The examples use `zereight-mcp-gitlab`, a less collision-prone alias for the legacy `mcp-gitlab` binary. If your MCP client cannot find it, use the absolute path from `which zereight-mcp-gitlab`.
 
-No global install? Pin `npx` to the previous stable release (the version these docs recommend), for example `npx -y @zereight/mcp-gitlab@2.1.67`. If you always want the newest release, use `npx -y @zereight/mcp-gitlab@latest` instead. The server prints a notice to stderr on startup when a newer version is available (disable with `GITLAB_DISABLE_VERSION_CHECK=true`).
+No global install? Pin `npx` to the previous stable release (the version these docs recommend), for example `npx -y @zereight/mcp-gitlab@2.1.68`. If you always want the newest release, use `npx -y @zereight/mcp-gitlab@latest` instead. The server prints a notice to stderr on startup when a newer version is available (disable with `GITLAB_DISABLE_VERSION_CHECK=true`).
 
 #### Using CLI Arguments (for clients with env var issues)
 
@@ -148,11 +148,15 @@ Some MCP clients (like GitHub Copilot CLI) have issues with environment variable
 - `--masking-config` - Path to a masking configuration file (replaces `GITLAB_MASKING_CONFIG`)
 - `--masking-policy-file` - Path to a protected managed-policy file (replaces `GITLAB_MASKING_POLICY_FILE`)
 - `--masking-workspace-dir` - Directory used to resolve masking files (replaces `GITLAB_MASKING_WORKSPACE_DIR`)
+- `--compact-results=true` - Truncate oversized MCP tool replies and attach a CLI command for the full payload (replaces `GITLAB_MCP_COMPACT_RESULTS`; default off)
+- `--compact-result-chars` - Character threshold for compacting (replaces `GITLAB_MCP_COMPACT_RESULT_CHARS`; default `4000`)
 
 CLI arguments take precedence over environment variables.
 
 `zereight-mcp-gitlab auth` is a subcommand (not an MCP server flag). It runs GitLab device flow and exits. See [CLI Arguments](./docs/getting-started/cli-arguments.md#auth).
 
+The same binary is also a `gh`-style GitLab CLI (`tool <name>` or curated forms such as `mr list`). Use it for the full payload in a terminal. MCP replies stay in the chat unless you set `GITLAB_MCP_COMPACT_RESULTS=true` (or `--compact-results`), which replaces oversized tool replies with a preview and a CLI command. Human CLI is never compacted. Same permission mode, toolsets, denied-tools regex, and tool-policy filters. Destructive tools and `GITLAB_TOOL_POLICY_APPROVE` tools need `--yes`. See [Human CLI](./docs/getting-started/cli-arguments.md#human-cli).
+
 > **Fine-grained tool filtering:** use `GITLAB_PERMISSION_MODE=modify` to allow create/update while
 > blocking every delete tool and the destructive teardown tools (`cancel_pipeline`,
 > `cancel_pipeline_job`, `stop_environment`, `stop_stale_environments`, `unprotect_branch`) —

package/README.pt-BR.md

@@ -111,7 +111,7 @@ O caminho no store é fixado pelo seu lock file; atualize-o com `nix flake updat
 
 Os exemplos usam `zereight-mcp-gitlab`, um alias com menor chance de conflito que o binário legado `mcp-gitlab`. Se o seu cliente MCP não o encontrar, use o caminho absoluto retornado por `which zereight-mcp-gitlab`.
 
-Não quer instalar globalmente? Fixe o `npx` na versão estável anterior (a versão recomendada por esta documentação), por exemplo `npx -y @zereight/mcp-gitlab@2.1.67`. Se quiser sempre a versão mais recente, use `npx -y @zereight/mcp-gitlab@latest`. O servidor exibe um aviso no stderr durante a inicialização quando existe uma versão mais nova disponível (desative com `GITLAB_DISABLE_VERSION_CHECK=true`).
+Não quer instalar globalmente? Fixe o `npx` na versão estável anterior (a versão recomendada por esta documentação), por exemplo `npx -y @zereight/mcp-gitlab@2.1.68`. Se quiser sempre a versão mais recente, use `npx -y @zereight/mcp-gitlab@latest`. O servidor exibe um aviso no stderr durante a inicialização quando existe uma versão mais nova disponível (desative com `GITLAB_DISABLE_VERSION_CHECK=true`).
 
 #### Usando argumentos de CLI (para clientes com problemas com variáveis de ambiente)
 
@@ -143,11 +143,15 @@ Alguns clientes MCP, como o GitHub Copilot CLI, têm problemas com variáveis de
 - `--masking-config` - caminho para um arquivo de configuração de mascaramento (substitui `GITLAB_MASKING_CONFIG`)
 - `--masking-policy-file` - caminho para um arquivo protegido de política gerenciada (substitui `GITLAB_MASKING_POLICY_FILE`)
 - `--masking-workspace-dir` - diretório usado para resolver arquivos de mascaramento (substitui `GITLAB_MASKING_WORKSPACE_DIR`)
+- `--compact-results=true` - trunca respostas muito grandes de ferramentas MCP e anexa um comando CLI para a carga completa (substitui `GITLAB_MCP_COMPACT_RESULTS`; desativado por padrão)
+- `--compact-result-chars` - limite de caracteres para compactação (substitui `GITLAB_MCP_COMPACT_RESULT_CHARS`; padrão `4000`)
 
 Os argumentos de CLI têm precedência sobre as variáveis de ambiente.
 
 `zereight-mcp-gitlab auth` é um subcomando, não uma flag do servidor MCP. Ele executa o device flow do GitLab e encerra. Veja [Argumentos de CLI](./docs/getting-started/cli-arguments.md#auth).
 
+O mesmo binário também é uma CLI do GitLab no estilo `gh` (`tool <name>` ou formas curadas como `mr list`). Use-o para ver a carga completa no terminal. As respostas do MCP permanecem no chat, a menos que você defina `GITLAB_MCP_COMPACT_RESULTS=true` (ou `--compact-results`), o que substitui respostas grandes de ferramentas por uma prévia e um comando CLI. A CLI humana nunca é compactada. Os mesmos filtros de permission mode, toolsets, denied-tools regex e tool-policy se aplicam. Ferramentas destrutivas e ferramentas com `GITLAB_TOOL_POLICY_APPROVE` exigem `--yes`. Consulte [CLI Humana](./docs/getting-started/cli-arguments.md#human-cli).
+
 > **Filtragem granular de ferramentas:** use `GITLAB_PERMISSION_MODE=modify` para permitir criação/atualização enquanto
 > bloqueia todas as ferramentas de exclusão e as ferramentas destrutivas de teardown (`cancel_pipeline`,
 > `cancel_pipeline_job`, `stop_environment`, `stop_stale_environments`, `unprotect_branch`) —
@@ -519,7 +523,7 @@ Não é necessário definir `headers`. O Claude.ai obtém o token via OAuth.
 | `STREAMABLE_HTTP`                           | sim         | Deve ser `true` (SSE não é suportado)                                                                                                                                                                                                            |
 | `GITLAB_OAUTH_SCOPES`                       | não         | Scopes do GitLab a solicitar, separados por vírgula. O padrão é `api`, ou `read_api` quando `GITLAB_READ_ONLY_MODE=true`. O aplicativo previamente registrado deve ter pelo menos esses scopes configurados.                                     |
 | `OAUTH_REGISTER_RATE_LIMIT_PER_HOUR`        | não         | Limite rolling de Dynamic Client Registration (`POST /register`) por IP do cliente. Padrão `20`/hora, intervalo `1`–`1000`. Aumente se múltiplas janelas de IDE estiverem atingindo o limite. Não está relacionado aos limites da API do GitLab. |
-| `MCP_DANGEROUSLY_ALLOW_INSECURE_ISSUER_URL` | não         | Apenas para desenvolvimento local via HTTP |
+| `MCP_DANGEROUSLY_ALLOW_INSECURE_ISSUER_URL` | não         | Apenas para desenvolvimento local via HTTP                                                                                                                                                                                                       |
 
 **Observações importantes:**
 

package/README.zh-CN.md

@@ -111,7 +111,7 @@ command = lib.getExe inputs.gitlab-mcp.packages.${system}.default;
 
 示例使用 `zereight-mcp-gitlab`，这是比旧的 `mcp-gitlab` 更不容易冲突的别名。如果 MCP 客户端找不到它，请使用 `which zereight-mcp-gitlab` 输出的绝对路径。
 
-如果不想全局安装，请将 `npx` 固定到上一个稳定版本（即文档推荐的版本），例如 `npx -y @zereight/mcp-gitlab@2.1.67`。如果始终想使用最新版本，请改用 `npx -y @zereight/mcp-gitlab@latest`。有新版本发布时，服务器会在启动时通过 stderr 提示（可用 `GITLAB_DISABLE_VERSION_CHECK=true` 关闭）。
+如果不想全局安装，请将 `npx` 固定到上一个稳定版本（即文档推荐的版本），例如 `npx -y @zereight/mcp-gitlab@2.1.68`。如果始终想使用最新版本，请改用 `npx -y @zereight/mcp-gitlab@latest`。有新版本发布时，服务器会在启动时通过 stderr 提示（可用 `GITLAB_DISABLE_VERSION_CHECK=true` 关闭）。
 
 #### 使用 CLI 参数（适用于环境变量有问题的客户端）
 
@@ -143,11 +143,15 @@ command = lib.getExe inputs.gitlab-mcp.packages.${system}.default;
 - `--masking-config` - 掩码配置文件路径（替代 `GITLAB_MASKING_CONFIG`）
 - `--masking-policy-file` - 受保护的托管策略文件路径（替代 `GITLAB_MASKING_POLICY_FILE`）
 - `--masking-workspace-dir` - 用于解析掩码文件的目录（替代 `GITLAB_MASKING_WORKSPACE_DIR`）
+- `--compact-results=true` - 将过大的 MCP 工具回复截断为预览并附带 CLI 命令（替代 `GITLAB_MCP_COMPACT_RESULTS`，默认关闭）
+- `--compact-result-chars` - compact 字符阈值（替代 `GITLAB_MCP_COMPACT_RESULT_CHARS`，默认 `4000`）
 
 CLI 参数优先于环境变量。
 
 `zereight-mcp-gitlab auth` 是子命令，不是 MCP 服务器参数。它运行 GitLab device flow 后退出。参见 [CLI 参数](./docs/getting-started/cli-arguments.md#auth)。
 
+同一二进制也是 `gh` 风格的 GitLab CLI（`tool <name>`，或 `mr list` 这类 curated 命令）。完整结果在终端用 CLI 查看。MCP 回复仍进入对话。设置 `GITLAB_MCP_COMPACT_RESULTS=true`（或 `--compact-results`）后，过大的工具回复会变成预览加上 CLI 命令。Human CLI 本身不会被 compact。permission mode、toolsets、denied-tools regex 和 tool-policy 与 MCP 相同。破坏性工具以及 `GITLAB_TOOL_POLICY_APPROVE` 工具需要 `--yes`。参见 [Human CLI](./docs/getting-started/cli-arguments.md#human-cli)。
+
 > **细粒度工具过滤：**使用 `GITLAB_PERMISSION_MODE=modify` 允许创建/更新，同时阻止所有删除工具以及
 > 破坏性的拆除（teardown）工具（`cancel_pipeline`、`cancel_pipeline_job`、`stop_environment`、
 > `stop_stale_environments`、`unprotect_branch`）（包括通过 `execute_graphql` 的破坏性 mutation

package/build/cli/args.js

@@ -0,0 +1,298 @@
+import { BOOLEAN_CLI_FLAG_NAMES, isBooleanFlagLiteral } from "../cli-boolean-flags.js";
+export class CliUsageError extends Error {
+    exitCode = 2;
+    constructor(message) {
+        super(message);
+        this.name = "CliUsageError";
+    }
+}
+const SCRIPT_PATH_PATTERN = /\.(cjs|mjs|js|cts|mts|ts)$/;
+const FLAGS_WITHOUT_VALUE = new Set(["help", "yes", ...BOOLEAN_CLI_FLAG_NAMES]);
+const GLOBAL_FLAG_NAMES = new Set([
+    "help",
+    "yes",
+    "output",
+    "args-json",
+    "client-id",
+    "token-path",
+    "token",
+    "job-token",
+    "cookie-path",
+    "use-oauth",
+    "is-old",
+    "read-only",
+    "masking-enabled",
+    "masking-config",
+    "masking-policy-file",
+    "masking-workspace-dir",
+    "permission-mode",
+    "use-wiki",
+    "use-milestone",
+    "use-pipeline",
+    "disable-version-check",
+    "toolsets",
+    "tools",
+    "tool-policy-approve",
+    "tool-policy-hidden",
+    "sse",
+    "streamable-http",
+    "remote-auth",
+    "mcp-oauth",
+    "allow-unauthenticated-tool-discovery",
+    "mcp-trust-proxy",
+    "mcp-server-url",
+    "oauth-app-id",
+    "oauth-scopes",
+    "oauth-callback-proxy",
+    "allowed-groups",
+    "oauth-allowed-groups",
+    "enable-dynamic-api-url",
+    "enable-dynamic-project-scope",
+    "enable-strict-project-scope",
+    "oauth-stateless-mode",
+    "oauth-stateless-client-ttl",
+    "oauth-stateless-pending-ttl",
+    "oauth-stateless-stored-ttl",
+    "session-timeout",
+    "oauth-stateless-session-ttl",
+    "host",
+    "port",
+    "http-proxy",
+    "https-proxy",
+    "no-proxy",
+    "tls-reject-unauthorized",
+    "ca-cert-path",
+    "pool-max-size",
+    "api-url",
+    "denied-tools-regex",
+    "compact-results",
+    "compact-result-chars",
+]);
+export function kebabToSnake(value) {
+    return value.replace(/-/g, "_");
+}
+export function snakeToKebab(value) {
+    return value.replace(/_/g, "-");
+}
+export function argvHasHelp(argv) {
+    return argv.includes("--help") || argv.includes("-h");
+}
+export function parseArgv(argv) {
+    const userArgs = userArgv(argv);
+    const positionals = [];
+    const toolFlags = {};
+    let help = false;
+    let yes = false;
+    let output;
+    let argsJson;
+    for (let i = 0; i < userArgs.length; i += 1) {
+        const current = userArgs[i];
+        const flag = readFlag(current);
+        if (flag === undefined) {
+            if (current.startsWith("-")) {
+                throw new CliUsageError(`Unknown flag: ${current}`);
+            }
+            positionals.push(current);
+            continue;
+        }
+        if (flag.name === "help") {
+            help = true;
+            continue;
+        }
+        if (flag.name === "yes") {
+            if (flag.inline !== undefined) {
+                throw new CliUsageError("--yes does not accept a value");
+            }
+            yes = true;
+            continue;
+        }
+        if (BOOLEAN_CLI_FLAG_NAMES.has(flag.name) && flag.inline === undefined) {
+            if (isBooleanFlagLiteral(userArgs[i + 1])) {
+                i += 1;
+            }
+            continue;
+        }
+        const value = flag.inline ?? takeFlagValue(userArgs, i, flag.name);
+        if (flag.inline === undefined && !FLAGS_WITHOUT_VALUE.has(flag.name)) {
+            i += 1;
+        }
+        if (flag.name === "output") {
+            output = parseOutputMode(value);
+            continue;
+        }
+        if (flag.name === "args-json") {
+            argsJson = parseArgsJson(value);
+            continue;
+        }
+        if (GLOBAL_FLAG_NAMES.has(flag.name)) {
+            continue;
+        }
+        toolFlags[kebabToSnake(flag.name)] = value;
+    }
+    return { positionals, toolFlags, help, yes, output, argsJson };
+}
+export function applyFlagAliases(flags, aliases) {
+    if (aliases === undefined) {
+        return { ...flags };
+    }
+    const mapped = {};
+    for (const [key, value] of Object.entries(flags)) {
+        const target = aliases[key] ?? key;
+        mapped[target] = value;
+    }
+    return mapped;
+}
+export function parseToolArgs(input) {
+    const schema = readObjectSchema(input.schema);
+    const propertyNames = schema.properties === undefined ? new Set() : new Set(Object.keys(schema.properties));
+    const unknownFlags = Object.keys(input.flags).filter(name => !propertyNames.has(name));
+    if (unknownFlags.length > 0) {
+        throw new CliUsageError(`Unknown flag: --${snakeToKebab(unknownFlags[0] ?? "")}`);
+    }
+    const args = {};
+    assignOwn(args, input.argsJson);
+    for (const [key, value] of Object.entries(input.flags)) {
+        args[key] = coerceFlagValue(key, value, schema.properties?.[key]);
+    }
+    assignOwn(args, input.extraArgs);
+    const required = schema.required ?? [];
+    const missing = required.filter(name => args[name] === undefined);
+    if (missing.length === 1) {
+        throw new CliUsageError(`Missing required flag: --${snakeToKebab(missing[0] ?? "")}`);
+    }
+    if (missing.length > 1) {
+        throw new CliUsageError(`Missing required flags: ${missing.map(name => `--${snakeToKebab(name)}`).join(", ")}`);
+    }
+    return args;
+}
+function scalarFlagType(property) {
+    const rawTypes = Array.isArray(property?.type) ? property.type : [property?.type];
+    const types = rawTypes.filter(type => type !== "null");
+    if (types.length !== 1) {
+        return undefined;
+    }
+    const [type] = types;
+    if (type === "number" || type === "integer" || type === "boolean") {
+        return type;
+    }
+    return undefined;
+}
+function coerceFlagValue(name, value, property) {
+    const type = scalarFlagType(property);
+    if (type === undefined) {
+        return value;
+    }
+    const flag = `--${snakeToKebab(name)}`;
+    if (type === "boolean") {
+        const normalized = value.toLowerCase();
+        if (normalized === "true" || normalized === "1") {
+            return true;
+        }
+        if (normalized === "false" || normalized === "0") {
+            return false;
+        }
+        throw new CliUsageError(`${flag} must be true or false`);
+    }
+    const parsed = value.trim() === "" ? Number.NaN : Number(value);
+    if (!Number.isFinite(parsed)) {
+        throw new CliUsageError(`${flag} must be a number`);
+    }
+    if (type === "integer" && !Number.isInteger(parsed)) {
+        throw new CliUsageError(`${flag} must be an integer`);
+    }
+    return parsed;
+}
+export function readObjectSchema(schema) {
+    if (!isObject(schema)) {
+        return {};
+    }
+    const propertiesValue = schema.properties;
+    const requiredValue = schema.required;
+    const properties = isObject(propertiesValue)
+        ? Object.fromEntries(Object.entries(propertiesValue).flatMap(([key, value]) => isObject(value) ? [[key, value]] : []))
+        : undefined;
+    const required = Array.isArray(requiredValue)
+        ? requiredValue.filter((item) => typeof item === "string")
+        : undefined;
+    return {
+        type: schema.type,
+        properties,
+        required,
+        description: schema.description,
+    };
+}
+export function isCliOutputMode(value) {
+    return value === "json" || value === "table";
+}
+function userArgv(argv) {
+    const args = argv.slice(2);
+    const start = args.findIndex(arg => !arg.startsWith("-") && SCRIPT_PATH_PATTERN.test(arg));
+    if (start >= 0) {
+        return args.slice(start + 1);
+    }
+    return args;
+}
+function readFlag(arg) {
+    if (arg === "-h") {
+        return { name: "help", inline: undefined };
+    }
+    if (!arg.startsWith("--") || arg === "--") {
+        return undefined;
+    }
+    const body = arg.slice(2);
+    const separator = body.indexOf("=");
+    if (separator === -1) {
+        return { name: body, inline: undefined };
+    }
+    return {
+        name: body.slice(0, separator),
+        inline: body.slice(separator + 1),
+    };
+}
+function takeFlagValue(args, index, flagName) {
+    if (FLAGS_WITHOUT_VALUE.has(flagName)) {
+        return "true";
+    }
+    const next = args[index + 1];
+    if (next === undefined || next.startsWith("-")) {
+        throw new CliUsageError(`Missing value for --${flagName}`);
+    }
+    return next;
+}
+function parseOutputMode(value) {
+    if (isCliOutputMode(value)) {
+        return value;
+    }
+    throw new CliUsageError("--output must be table or json");
+}
+function parseArgsJson(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isObject(parsed)) {
+            throw new CliUsageError("--args-json must be a JSON object");
+        }
+        const copy = {};
+        assignOwn(copy, parsed);
+        return copy;
+    }
+    catch (error) {
+        if (error instanceof CliUsageError) {
+            throw error;
+        }
+        throw new CliUsageError("Invalid --args-json");
+    }
+}
+function assignOwn(target, source) {
+    if (source === undefined) {
+        return;
+    }
+    for (const key of Object.keys(source)) {
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+            continue;
+        }
+        target[key] = Reflect.get(source, key);
+    }
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/build/cli/compact-mcp-result.js

@@ -0,0 +1,87 @@
+import { buildToolReplayCommand } from "./replay-command.js";
+const PREVIEW_ARRAY_ITEMS = 5;
+const PREVIEW_TEXT_CHARS = 1500;
+const PREVIEW_JSON_CHARS = 2000;
+export function readOwnRecord(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const copy = {};
+    for (const key of Object.keys(value)) {
+        copy[key] = Reflect.get(value, key);
+    }
+    return copy;
+}
+export function compactMcpToolResult(input) {
+    if (!input.enabled || input.toolName === "discover_tools") {
+        return toolResultRecord(input.result);
+    }
+    if (!isToolResult(input.result) || input.result.isError === true) {
+        return toolResultRecord(input.result);
+    }
+    const text = unwrapToolText(input.result);
+    if (text.length <= input.maxChars) {
+        return toolResultRecord(input.result);
+    }
+    const compact = {
+        compact: true,
+        tool: input.toolName,
+        original_chars: text.length,
+        ...buildPreview(text),
+        cli: buildToolReplayCommand(input.toolName, input.args),
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(compact) }],
+        isError: false,
+    };
+}
+function toolResultRecord(value) {
+    if (isRecord(value)) {
+        return value;
+    }
+    return { content: [{ type: "text", text: stringifyUnknown(value) }] };
+}
+function buildPreview(text) {
+    const parsed = parseJsonValue(text);
+    if (parsed === undefined) {
+        return { preview: text.slice(0, PREVIEW_TEXT_CHARS) };
+    }
+    if (Array.isArray(parsed)) {
+        return { preview: parsed.slice(0, PREVIEW_ARRAY_ITEMS), items_total: parsed.length };
+    }
+    if (typeof parsed === "string") {
+        return { preview: parsed.slice(0, PREVIEW_TEXT_CHARS) };
+    }
+    const encoded = JSON.stringify(parsed);
+    if (encoded.length <= PREVIEW_JSON_CHARS) {
+        return { preview: parsed };
+    }
+    return { preview: encoded.slice(0, PREVIEW_JSON_CHARS) };
+}
+function unwrapToolText(result) {
+    const textBlock = result.content.find(item => isRecord(item) && typeof item.text === "string");
+    if (!isRecord(textBlock) || typeof textBlock.text !== "string") {
+        return stringifyUnknown(result);
+    }
+    return textBlock.text;
+}
+function isToolResult(value) {
+    return isRecord(value) && Array.isArray(value.content);
+}
+function parseJsonValue(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function stringifyUnknown(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}