@optima-chat/dev-skills 0.16.9 → 0.16.10

package/bin/helpers/billing-http.ts

@@ -1,4 +1,4 @@
-import { execFileSync } from 'child_process';
+import { runCurl, scrub } from './safe-exec';
 import { fetchInfisicalSecret } from './infisical-secrets';
 import { getInfisicalConfig, getInfisicalToken, getCnInfisicalToken, getCnSecrets, resolveUserId } from './db-utils';
 
@@ -152,25 +152,22 @@ export function getServiceToken(env: string, scope?: string): string {
   // execFileSync + 参数数组（不经 shell）：Windows cmd.exe 不认单引号，shell 拼出的
   // `-d '${body}'` 会被拆碎、curl 收到垃圾参数直接退出（#92）。数组传参绕开 shell、
   // 跨平台一致；函数保持同步。
-  const response = execFileSync(
-    'curl',
-    [
-      '-s', '-X', 'POST',
-      `${authUrl}/api/v1/oauth/token`,
-      '-H', 'Content-Type: application/x-www-form-urlencoded',
-      '-d', body,
-    ],
-    { encoding: 'utf-8' },
-  );
+  // runCurl：失败时的报错不回显命令参数（请求体含凭据）。
+  const response = runCurl([
+    '-X', 'POST',
+    `${authUrl}/api/v1/oauth/token`,
+    '-H', 'Content-Type: application/x-www-form-urlencoded',
+    '-d', body,
+  ]);
 
   let parsed: { access_token?: string; error?: string };
   try {
     parsed = JSON.parse(response);
   } catch {
-    throw new Error(`user-auth token endpoint returned non-JSON (${env}): ${response.slice(0, 200)}`);
+    throw new Error(`user-auth token endpoint returned non-JSON (${env}): ${scrub(response).slice(0, 200)}`);
   }
   if (!parsed.access_token) {
-    throw new Error(`user-auth token mint failed (${env}): ${response.slice(0, 200)}`);
+    throw new Error(`user-auth token mint failed (${env}): ${scrub(response).slice(0, 200)}`);
   }
   tokenCache[cacheKey] = parsed.access_token;
   return parsed.access_token;

package/bin/helpers/db-utils.ts

@@ -1,4 +1,5 @@
-import { execSync, execFileSync, spawn } from 'child_process';
+import { execSync, spawn } from 'child_process';
+import { runCurl, scrub } from './safe-exec';
 import * as fs from 'fs';
 import * as os from 'os';
 
@@ -92,10 +93,11 @@ export function getInfisicalToken(config: InfisicalConfig): string {
 }
 
 export function getInfisicalSecrets(config: InfisicalConfig, token: string, environment: string, secretPath: string): Record<string, string> {
-  const response = execSync(
-    `curl -s "${config.url}/api/v3/secrets/raw?workspaceId=${config.projectId}&environment=${environment}&secretPath=${secretPath}" -H "Authorization: Bearer ${token}"`,
-    { encoding: 'utf-8' }
-  );
+  // runCurl：参数数组直传（不经 shell），失败时的报错不回显命令参数。
+  const response = runCurl([
+    `${config.url}/api/v3/secrets/raw?workspaceId=${config.projectId}&environment=${environment}&secretPath=${secretPath}`,
+    '-H', `Authorization: Bearer ${token}`,
+  ]);
   const data = JSON.parse(response);
   const secrets: Record<string, string> = {};
   for (const secret of data.secrets || []) {
@@ -105,11 +107,15 @@ export function getInfisicalSecrets(config: InfisicalConfig, token: string, envi
 }
 
 // ─── cn Infisical（独立实例，admin email/password 认证）──────────────────────
-/** curl → JSON，用 execFileSync 传参（避免 shell 引号坑，跨平台安全）。 */
+/**
+ * curl → JSON。参数数组直传（避免 shell 引号坑，跨平台安全）。
+ * 走 runCurl：curl 失败时抛的错误只带退出码 / 主机名 / 清洗过的 stderr，不回显命令参数
+ * （参数里有请求体与认证头）。
+ */
 function curlJson(args: string[]): any {
-  const out = execFileSync('curl', ['-s', ...args], { encoding: 'utf-8' });
+  const out = runCurl(args);
   try { return JSON.parse(out || '{}'); }
-  catch { throw new Error(`cn Infisical: non-JSON response: ${String(out).slice(0, 200)}`); }
+  catch { throw new Error(`cn Infisical: non-JSON response: ${scrub(String(out)).slice(0, 200)}`); }
 }
 
 /** 明文密码文件权限比 600 宽（组/其他用户可读）时往 stderr 警告一行。Windows 无此语义，跳过。 */
@@ -187,14 +193,14 @@ export function getCnInfisicalToken(): string {
     '-H', 'Content-Type: application/json',
     '-d', JSON.stringify({ email, password }),
   ]);
-  if (!login.accessToken) throw new Error(`cn Infisical login 失败: ${JSON.stringify(login).slice(0, 200)}`);
+  if (!login.accessToken) throw new Error(`cn Infisical login 失败: ${scrub(JSON.stringify(login)).slice(0, 200)}`);
   const org = curlJson([
     '-X', 'POST', `${CN_INFISICAL_URL}/api/v3/auth/select-organization`,
     '-H', 'Content-Type: application/json',
     '-H', `Authorization: Bearer ${login.accessToken}`,
     '-d', JSON.stringify({ organizationId: CN_INFISICAL_ORG }),
   ]);
-  if (!org.token) throw new Error(`cn Infisical select-organization 失败: ${JSON.stringify(org).slice(0, 200)}`);
+  if (!org.token) throw new Error(`cn Infisical select-organization 失败: ${scrub(JSON.stringify(org)).slice(0, 200)}`);
   return org.token;
 }
 

package/bin/helpers/infisical-secrets.ts

@@ -1,4 +1,4 @@
-import { execSync } from 'child_process';
+import { runCurl, scrub } from './safe-exec';
 import { getInfisicalConfig, getInfisicalToken, InfisicalConfig } from './db-utils';
 
 /**
@@ -23,19 +23,20 @@ export function fetchInfisicalSecret(
   const encodedPath = encodeURIComponent(secretPath);
   const encodedName = encodeURIComponent(secretName);
 
-  const response = execSync(
-    `curl -s "${cfg.url}/api/v3/secrets/raw/${encodedName}?workspaceId=${cfg.projectId}&environment=${envSlug}&secretPath=${encodedPath}" -H "Authorization: Bearer ${tok}"`,
-    { encoding: 'utf-8' },
-  );
+  // runCurl：参数数组直传（不经 shell），失败时的报错不回显命令参数。
+  const response = runCurl([
+    `${cfg.url}/api/v3/secrets/raw/${encodedName}?workspaceId=${cfg.projectId}&environment=${envSlug}&secretPath=${encodedPath}`,
+    '-H', `Authorization: Bearer ${tok}`,
+  ]);
 
   let parsed: { secret?: { secretValue?: string }; message?: string };
   try {
     parsed = JSON.parse(response);
   } catch {
-    throw new Error(`Infisical raw secret fetch returned non-JSON for ${secretPath}/${secretName} (${envSlug}): ${response.slice(0, 200)}`);
+    throw new Error(`Infisical raw secret fetch returned non-JSON for ${secretPath}/${secretName} (${envSlug}): ${scrub(response).slice(0, 200)}`);
   }
   if (!parsed.secret?.secretValue) {
-    throw new Error(`Infisical secret not found: env=${envSlug} path=${secretPath} name=${secretName} (response: ${response.slice(0, 200)})`);
+    throw new Error(`Infisical secret not found: env=${envSlug} path=${secretPath} name=${secretName} (response: ${scrub(response).slice(0, 200)})`);
   }
   return parsed.secret.secretValue;
 }

package/bin/helpers/query-db.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { execSync } from 'child_process';
+import { sanitizeExecError } from './safe-exec';
 import * as fs from 'fs';
 import { ensureTunnel, getGitHubVariable, getInfisicalConfig, getInfisicalToken, getInfisicalSecrets, parseDatabaseUrl, isCnEnv, connectCnDB, connectCnDBFromUrl } from './db-utils';
 
@@ -305,10 +306,16 @@ async function main() {
 
     const { container, user, database } = serviceConfig as any;
 
-    const result = execSync(
-      `sshpass -p "${ciPassword}" ssh -o StrictHostKeyChecking=no ${ciUser}@${ciHost} "docker exec ${container} psql -U ${user} -d ${database} -c \\"${sql}\\""`,
-      { encoding: 'utf-8' }
-    );
+    // 密码经 SSHPASS 环境变量给 `sshpass -e`：不进命令行（ps 不可见），失败时的报错也不会带出它。
+    let result: string;
+    try {
+      result = execSync(
+        `sshpass -e ssh -o StrictHostKeyChecking=no ${ciUser}@${ciHost} "docker exec ${container} psql -U ${user} -d ${database} -c \\"${sql}\\""`,
+        { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, SSHPASS: ciPassword } }
+      );
+    } catch (raw) {
+      throw sanitizeExecError('ssh (CI database)', raw, [ciPassword], `host=${ciHost}`);
+    }
 
     console.log('\n' + result);
   } else {

package/bin/helpers/safe-exec.ts

@@ -0,0 +1,252 @@
+import { execFileSync } from 'child_process';
+
+/**
+ * 子进程调用的「报错不回显命令参数」封装。
+ *
+ * 背景：Node 的 execSync/execFileSync 失败时，错误对象的 message 是 `Command failed: <完整命令行>`，
+ * 且带 `cmd` / `spawnargs` / `stderr` 等字段。命令行里若有请求体、认证头、`-u user:pass`、URL 里的
+ * 凭据参数，调用方一句 `console.error(err.message)` 或把报错原文落盘，就把它们带了出去。
+ *
+ * 做法：失败时**不复用**原始 error——抛一个全新的 Error，只含排错需要的东西（退出码/信号/errno、
+ * 目标主机名、子进程 stderr），且 stderr 先过 `scrub`（按字面值 + 常见凭据形态双重清洗）。
+ */
+
+const MASK = '[REDACTED]';
+
+/** 值整体敏感的 curl 选项（下一个 argv 元素或 `--opt=value` 的 value 整体打码）。 */
+const VALUE_IS_SECRET = new Set([
+  '-d', '--data', '--data-raw', '--data-binary', '--data-urlencode', '--data-ascii', '--json',
+  '-u', '--user', '-U', '--proxy-user', '--oauth2-bearer',
+  '-x', '--proxy', '--preproxy', // 代理 URL 常带 user:pass@，且可能无 scheme
+  '-F', '--form', '--form-string', '-b', '--cookie', '--pass', '--key',
+  '--tlspassword', '--proxy-tlspassword', '--proxy-pass', '--proxy-key',
+  '-E', '--cert', '--proxy-cert', // `<file>:<passphrase>`
+  '--variable', '--aws-sigv4',
+]);
+/** 带值的短选项字母：解析 `-sSu user:pass` / `-XPOST` 这类合写簇时，遇到它簇就结束（其后是值）。 */
+const SHORT_WITH_VALUE = new Set('dubFHxeAXoKEUmTrCQYyzwPtcDh'.split('').filter((c) => c !== 'h'));
+const HEADER_OPTS = new Set(['-H', '--header', '--proxy-header']);
+/** 头值白名单：只有这些无害头保留原值，其余一律整值打码（黑名单永远列不全）。 */
+const SAFE_HEADER_RE = /^(content-type|content-length|content-encoding|accept|accept-encoding|accept-language|user-agent|cache-control|connection|host|origin)$/i;
+/** 参数/字段名像凭据 ⇒ 值打码。`secret` 单独判：`secretPath` / `expandSecretReferences` 这类是路径与开关，不是凭据。 */
+const SECRET_NAME_RE = /(pass(?:word|wd)?|pwd|token|jwt|hmac|assertion|api[-_]?key|access[-_]?key|private[-_]?key|signature|credential|session|(?:^|[-_])(?:sig|sign|auth|code|key|otp|pw|ticket)$)/i;
+const SECRET_WORD_RE = /secret/i;
+/**
+ * 「名字像凭据、其实不是」的排除——**必须锚定**：无锚点的子串排除会把 `provider_secret`（prov-id-er）、
+ * `model_secret`（mode-l）这类真凭据放过去。只认两种形态：
+ *  - 整名是已知的路径/开关参数；
+ *  - 以「凭据词 + 明确的非凭据后缀」结尾（`secret_id` / `token_type` / `max_tokens` …）。
+ */
+const KNOWN_NON_SECRET = new Set(['secretpath', 'expandsecretreferences', 'sshpass', 'tokenizer', 'passthrough', 'bypass']);
+const NON_SECRET_SUFFIX_RE = /(?:secret|token|key)s?[-_]?(?:path|references?|names?|ids?|version|types?|mode|enabled|count|limit|length|ttl|expiry|expires(?:[-_]?(?:at|in))?)$|(?:^|[-_])(?:max|min|num|total|input|output|prompt|completion)[-_]?tokens$/i;
+export function isSecretName(name: string): boolean {
+  const n = name.trim();
+  if (KNOWN_NON_SECRET.has(n.toLowerCase()) || NON_SECRET_SUFFIX_RE.test(n)) return false;
+  return SECRET_NAME_RE.test(n) || SECRET_WORD_RE.test(n);
+}
+
+function redactUrl(raw: string): string {
+  let u: URL;
+  try { u = new URL(raw); } catch { return raw; }
+  if (!/^https?:$/.test(u.protocol)) return raw;
+  if (u.username || u.password) { u.username = MASK; u.password = ''; }
+  for (const key of [...u.searchParams.keys()]) {
+    if (isSecretName(key)) u.searchParams.set(key, MASK);
+  }
+  if (u.hash.length > 1) u.hash = MASK; // fragment 常见 `#access_token=…`，对排错无用，整段打码
+  return u.toString().replace(/%5BREDACTED%5D/g, MASK);
+}
+
+function redactHeader(h: string): string {
+  const i = h.indexOf(':');
+  if (i <= 0) return h;
+  const name = h.slice(0, i).trim();
+  return SAFE_HEADER_RE.test(name) ? h : `${name}: ${MASK}`;
+}
+
+/**
+ * 返回脱敏后的 argv 副本（仅用于展示/排错；绝不改传给子进程的真参数）。
+ * 不覆盖：藏在 URL **路径段**里的凭据（webhook 型 URL）与 User-Agent 里夹带的值——这类请走请求头/请求体。
+ */
+export function redactArgv(args: readonly string[]): string[] {
+  const out: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    // --opt=value
+    const eq = a.startsWith('--') ? a.indexOf('=') : -1;
+    if (eq > 0) {
+      const opt = a.slice(0, eq);
+      if (opt === '--url') { out.push(`${opt}=${redactUrl(a.slice(eq + 1))}`); continue; }
+      if (VALUE_IS_SECRET.has(opt)) { out.push(`${opt}=${MASK}`); continue; }
+      if (HEADER_OPTS.has(opt)) { out.push(`${opt}=${redactHeader(a.slice(eq + 1))}`); continue; }
+    }
+    // 选项与值分开
+    if (VALUE_IS_SECRET.has(a)) { out.push(a); if (i + 1 < args.length) { out.push(MASK); i++; } continue; }
+    if (HEADER_OPTS.has(a)) { out.push(a); if (i + 1 < args.length) { out.push(redactHeader(args[i + 1])); i++; } continue; }
+    // 短选项簇：-Hfoo / -dbody / -uuser:pass / -sSu user:pass / -XPOST
+    if (/^-[^-]/.test(a) && a.length > 2) {
+      let j = 1;
+      while (j < a.length && !SHORT_WITH_VALUE.has(a[j])) j++;   // 跳过不带值的开关字母
+      if (j < a.length) {
+        const opt = `-${a[j]}`, head = a.slice(0, j + 1), rest = a.slice(j + 1);
+        const sticky = rest.length > 0;                           // 值粘在簇里，否则是下一个 argv
+        const value = sticky ? rest : args[i + 1];
+        if (VALUE_IS_SECRET.has(opt) || HEADER_OPTS.has(opt)) {
+          const masked = value === undefined ? undefined : (HEADER_OPTS.has(opt) ? redactHeader(value) : MASK);
+          if (sticky) out.push(`${head}${masked}`); else { out.push(head); if (masked !== undefined) { out.push(masked); i++; } }
+          continue;
+        }
+      }
+    }
+    if (/^https?:\/\//i.test(a)) { out.push(redactUrl(a)); continue; }
+    // 无 scheme 的 `user:pass@host…`（curl 接受）
+    out.push(a.replace(/^[^\s/@:]+:[^\s/@]+@/, `${MASK}@`));
+  }
+  return out;
+}
+
+/** 从 argv 里收集「字面值就是秘密」的串，供 scrub 在任意文本里逐字清除。 */
+function secretLiterals(args: readonly string[]): string[] {
+  const red = redactArgv(args);
+  const lits: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    if (!red[i].includes(MASK)) continue; // 按「是否真的打了码」判，不按字符串是否相等（URL 规范化也会让它不等）
+    const a = args[i].replace(/^--url=/, '');
+    // 子进程 stderr 可能只回显参数的一段，所以除整串外还要收内部片段——但**只收名字像凭据的值**：
+    // 把 URL 里所有 k=v 都当秘密，会让 `prod` / `true` 这类普通词把报错原文洗得没法读。
+    if (/^https?:\/\//i.test(a)) {
+      try {
+        const u = new URL(a);
+        if (u.password) lits.push(u.password, decodeURIComponent(u.password));
+        if (u.username && u.password) lits.push(`${u.username}:${u.password}`);
+        for (const [k, v] of u.searchParams) if (isSecretName(k)) lits.push(v);
+        if (u.hash.length > 1) {                                  // fragment：`#access_token=…`
+          lits.push(u.hash.slice(1));
+          for (const [, v] of new URLSearchParams(u.hash.slice(1))) if (v) lits.push(v);
+        }
+      } catch { /* 非法 URL：redactUrl 也不会动它，走不到这里 */ }
+      continue;
+    }
+    lits.push(a); // 非 URL 的敏感参数（请求体 / -u / 认证头 / 代理）：整串即秘密
+    for (const m of a.matchAll(/"([^"]*)"\s*:\s*"([^"]+)"/g)) if (isSecretName(m[1])) lits.push(m[2]); // JSON 字段
+    for (const m of a.matchAll(/(?:^|&)([^=&\s]+)=([^&\s]+)/g)) {                                       // form k=v
+      if (isSecretName(m[1])) { lits.push(m[2]); try { lits.push(decodeURIComponent(m[2])); } catch { /* 裸 % */ } }
+    }
+    const header = /^[A-Za-z0-9-]+:\s*(.+)$/.exec(a);
+    if (header) {                                                                                         // Header: value
+      lits.push(header[1].trim());
+      const scheme = /^(?:Bearer|Basic|Token)\s+(\S+)/i.exec(header[1].trim());
+      if (scheme) lits.push(scheme[1]);
+    } else {
+      const up = /^[^\s/@:]*:([^\s@]+)(?:@|$)/.exec(a);                                                  // user:pass[@host]
+      if (up) lits.push(up[1]);
+    }
+  }
+  // 长的先替换，避免短片段把长串切碎后漏网；太短的不收（误伤普通文本）
+  return [...new Set(lits.filter((s) => s && s.length >= 4))].sort((x, y) => y.length - x.length);
+}
+
+/** 清洗任意文本：先按字面值，再按常见凭据形态（认证头、Bearer/Basic、URL 凭据、k=v、JSON 字段）。 */
+export function scrub(text: string, literals: readonly string[] = []): string {
+  let out = String(text ?? '');
+  for (const lit of [...literals].filter((s) => s && s.length >= 4).sort((a, b) => b.length - a.length)) {
+    out = out.split(lit).join(MASK);
+    const enc = encodeURIComponent(lit);
+    if (enc !== lit) out = out.split(enc).join(MASK);
+  }
+  return out
+    .replace(/((?:proxy-)?authorization\s*[:=]\s*)(?:(?:bearer|basic|token)\s+)?[^\s"'\\]+/gi, `$1${MASK}`)
+    .replace(/\b(bearer|basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, `$1 ${MASK}`)
+    .replace(/(\b[a-z][a-z0-9+.-]*:\/\/)[^\s/:]+:[^\s/]*@/gi, `$1${MASK}@`) // 贪婪到最后一个 @：密码本身可含 @
+    // 三条「名字 → 值」规则统一用 isSecretName 判（与 argv 脱敏同一口径）
+    // 值类必须排除 `?`：否则非凭据键（`url=http://h/cb?token=X`）会把后面的凭据对整段吞进自己的值里原样返回。
+    .replace(/(^|[?&;,(\s"'])(-{0,2}[A-Za-z_][\w.-]*)(\s*=\s*)(?:"[^"]*"|'[^']*'|[^&?;,)\s"']+)/g,
+      (m, pre: string, key: string, eq: string) => (isSecretName(key.replace(/^-+/, '')) ? `${pre}${key}${eq}${MASK}` : m))
+    .replace(/"([A-Za-z_][\w-]*)"(\s*:\s*)"[^"]*"/g,
+      (m, key: string, sep: string) => (isSecretName(key) ? `"${key}"${sep}"${MASK}"` : m))
+    .replace(/\b((?:cookie|set-cookie|x-[a-z0-9-]*(?:key|token|secret|auth|session)[a-z0-9-]*|[a-z0-9-]*api-?key)\s*:\s*)[^\r\n"']+/gi, `$1${MASK}`)
+    // `name: value`（yaml / 单引号 dict）。值须像一个 token（≥6 且含数字或符号），否则 `password: must be …`
+    // 这类普通报错句子会被误洗。
+    .replace(/(^|[\s{,])(["']?)([A-Za-z_][\w-]*)\2(\s*:\s*)('[^']*'|[^\s,}"']+)/g,
+      (m, pre: string, q: string, key: string, sep: string, val: string) => {
+        const bare = val.replace(/^'|'$/g, '');
+        const tokenish = bare.length >= 6 && /[\d_\-+/=.]/.test(bare);
+        return isSecretName(key) && tokenish ? `${pre}${q}${key}${q}${sep}${MASK}` : m;
+      })
+    .replace(/(\bsshpass\s+-p\s*)("[^"]*"|'[^']*'|\S+)/g, `$1${MASK}`);
+}
+
+/** 值是 URL 但不是请求目标的选项（代理 / referer）。 */
+const URL_VALUED_OPTS = new Set(['-x', '--proxy', '--preproxy', '-e', '--referer']);
+function hostOf(args: readonly string[]): string {
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i].replace(/^--url=/, '');
+    if (!/^https?:\/\//i.test(a) || (i > 0 && URL_VALUED_OPTS.has(args[i - 1]))) continue;
+    try { return new URL(a).host; } catch { /* 不是合法 URL：继续找 */ }
+  }
+  return 'unknown';
+}
+
+/** 会让 curl 把请求头/响应头/响应体细节写进输出的选项：响应头里的凭据（Set-Cookie 等）没法按字面值清洗，直接不许用。 */
+function findVerboseOpt(args: readonly string[]): string | undefined {
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith('--')) {
+      const name = a.split('=')[0];
+      // curl 接受长选项的唯一前缀（`--verbos`），所以按前缀判
+      if (/^--(verb|trace|incl|dump-h)/.test(name)) return name;
+      if (!a.includes('=') && (VALUE_IS_SECRET.has(name) || HEADER_OPTS.has(name) || URL_VALUED_OPTS.has(name))) i++; // 跳过它的值
+      continue;
+    }
+    if (!/^-[^-]/.test(a)) continue;
+    let j = 1;
+    for (; j < a.length; j++) {
+      if ('viD'.includes(a[j])) return `-${a[j]}`;
+      if (SHORT_WITH_VALUE.has(a[j])) break;
+    }
+    if (j < a.length && j === a.length - 1) i++; // 簇以带值选项结尾：下一个 argv 是值，跳过
+  }
+  return undefined;
+}
+
+/**
+ * 把 child_process 抛的 error 换成一个干净的新 Error。
+ * 只取 status/signal/code 与（清洗后的）stderr；**不复制** message/cmd/spawnargs/stdout/output。
+ */
+export function sanitizeExecError(label: string, raw: unknown, literals: readonly string[] = [], context = ''): Error {
+  const e = (raw ?? {}) as { status?: number | null; signal?: string | null; code?: string | number; stderr?: unknown };
+  const parts: string[] = [];
+  if (typeof e.status === 'number') parts.push(`exit=${e.status}`);
+  if (e.signal) parts.push(`signal=${e.signal}`);
+  if (typeof e.code === 'string') parts.push(`code=${e.code}`); // ENOENT / ETIMEDOUT / ENOBUFS…
+  if (context) parts.push(context);
+  const stderr = scrub(e.stderr == null ? '' : String(e.stderr), literals).trim().slice(0, 2000);
+  return new Error(`${label} failed (${parts.join(' ') || 'unknown error'})${stderr ? `: ${stderr}` : ''}`);
+}
+
+export interface RunCurlOptions {
+  /** 仅测试用：替换可执行文件。 */
+  bin?: string;
+  /** 毫秒；不传 = 不限（保持原行为）。 */
+  timeoutMs?: number;
+}
+
+/**
+ * 同步跑 curl，返回 stdout。参数数组直传（不经 shell）。
+ * 失败时抛的 Error 不含 argv：只有退出码/信号/errno、目标主机名、清洗过的 curl stderr。
+ * `-sS`：静默进度条但保留 curl 自己的错误行（`curl: (7) Failed to connect…`），否则失败时两眼一抹黑。
+ */
+export function runCurl(args: readonly string[], opts: RunCurlOptions = {}): string {
+  const verbose = findVerboseOpt(args);
+  if (verbose) throw new Error(`runCurl: option ${verbose} is not allowed (it writes header/body details to the output)`);
+  try {
+    return execFileSync(opts.bin ?? 'curl', ['-sS', ...args], {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'pipe'], // stderr 收进 error 对象（由我们清洗后再露出），不直通父进程
+      maxBuffer: 64 * 1024 * 1024,
+      ...(opts.timeoutMs ? { timeout: opts.timeoutMs } : {}),
+    });
+  } catch (raw) {
+    throw sanitizeExecError('curl', raw, secretLiterals(args), `host=${hostOf(args)}`);
+  }
+}

package/bin/helpers/show-env.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { execSync } from 'child_process';
+import { runCurl } from './safe-exec';
 import { getInfisicalConfig, getInfisicalToken, InfisicalConfig, isCnEnv, cnInfisicalEnv, getCnInfisicalToken, getCnSecrets } from './db-utils';
 
 // 支持的服务列表（Infisical 路径为 /services/<service-name>）
@@ -46,10 +46,11 @@ function isSupportedEnv(env: string): boolean {
 // NOTE: getInfisicalSecrets is kept local because it encodes secretPath (encodeURIComponent),
 // unlike db-utils' raw-path variant; getGitHubVariable/getInfisicalConfig/getInfisicalToken are shared from db-utils.
 function getInfisicalSecrets(config: InfisicalConfig, token: string, environment: string, secretPath: string): Record<string, string> {
-  const response = execSync(
-    `curl -s "${config.url}/api/v3/secrets/raw?workspaceId=${config.projectId}&environment=${environment}&secretPath=${encodeURIComponent(secretPath)}" -H "Authorization: Bearer ${token}"`,
-    { encoding: 'utf-8' }
-  );
+  // runCurl：参数数组直传（不经 shell），失败时的报错不回显命令参数。
+  const response = runCurl([
+    `${config.url}/api/v3/secrets/raw?workspaceId=${config.projectId}&environment=${environment}&secretPath=${encodeURIComponent(secretPath)}`,
+    '-H', `Authorization: Bearer ${token}`,
+  ]);
   const data = JSON.parse(response);
   const secrets: Record<string, string> = {};
   for (const secret of data.secrets || []) {

package/dist/bin/helpers/billing-http.js

@@ -10,7 +10,7 @@ exports.callUserAuthAsAdmin = callUserAuthAsAdmin;
 exports.resolveUserIdByEmail = resolveUserIdByEmail;
 exports.resolveUserIdByPhone = resolveUserIdByPhone;
 exports.getUserById = getUserById;
-const child_process_1 = require("child_process");
+const safe_exec_1 = require("./safe-exec");
 const infisical_secrets_1 = require("./infisical-secrets");
 const db_utils_1 = require("./db-utils");
 const USER_AUTH_URLS = {
@@ -159,21 +159,22 @@ function getServiceToken(env, scope) {
     // execFileSync + 参数数组（不经 shell）：Windows cmd.exe 不认单引号，shell 拼出的
     // `-d '${body}'` 会被拆碎、curl 收到垃圾参数直接退出（#92）。数组传参绕开 shell、
     // 跨平台一致；函数保持同步。
-    const response = (0, child_process_1.execFileSync)('curl', [
-        '-s', '-X', 'POST',
+    // runCurl：失败时的报错不回显命令参数（请求体含凭据）。
+    const response = (0, safe_exec_1.runCurl)([
+        '-X', 'POST',
         `${authUrl}/api/v1/oauth/token`,
         '-H', 'Content-Type: application/x-www-form-urlencoded',
         '-d', body,
-    ], { encoding: 'utf-8' });
+    ]);
     let parsed;
     try {
         parsed = JSON.parse(response);
     }
     catch {
-        throw new Error(`user-auth token endpoint returned non-JSON (${env}): ${response.slice(0, 200)}`);
+        throw new Error(`user-auth token endpoint returned non-JSON (${env}): ${(0, safe_exec_1.scrub)(response).slice(0, 200)}`);
     }
     if (!parsed.access_token) {
-        throw new Error(`user-auth token mint failed (${env}): ${response.slice(0, 200)}`);
+        throw new Error(`user-auth token mint failed (${env}): ${(0, safe_exec_1.scrub)(response).slice(0, 200)}`);
     }
     tokenCache[cacheKey] = parsed.access_token;
     return parsed.access_token;

package/dist/bin/helpers/db-utils.js

@@ -57,6 +57,7 @@ exports.connectAuthDB = connectAuthDB;
 exports.connectBillingDB = connectBillingDB;
 exports.resolveUserId = resolveUserId;
 const child_process_1 = require("child_process");
+const safe_exec_1 = require("./safe-exec");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 // ─── Constants ──────────────────────────────────────────────────────────────
@@ -127,7 +128,11 @@ function getInfisicalToken(config) {
     ]).accessToken;
 }
 function getInfisicalSecrets(config, token, environment, secretPath) {
-    const response = (0, child_process_1.execSync)(`curl -s "${config.url}/api/v3/secrets/raw?workspaceId=${config.projectId}&environment=${environment}&secretPath=${secretPath}" -H "Authorization: Bearer ${token}"`, { encoding: 'utf-8' });
+    // runCurl：参数数组直传（不经 shell），失败时的报错不回显命令参数。
+    const response = (0, safe_exec_1.runCurl)([
+        `${config.url}/api/v3/secrets/raw?workspaceId=${config.projectId}&environment=${environment}&secretPath=${secretPath}`,
+        '-H', `Authorization: Bearer ${token}`,
+    ]);
     const data = JSON.parse(response);
     const secrets = {};
     for (const secret of data.secrets || []) {
@@ -136,14 +141,18 @@ function getInfisicalSecrets(config, token, environment, secretPath) {
     return secrets;
 }
 // ─── cn Infisical（独立实例，admin email/password 认证）──────────────────────
-/** curl → JSON，用 execFileSync 传参（避免 shell 引号坑，跨平台安全）。 */
+/**
+ * curl → JSON。参数数组直传（避免 shell 引号坑，跨平台安全）。
+ * 走 runCurl：curl 失败时抛的错误只带退出码 / 主机名 / 清洗过的 stderr，不回显命令参数
+ * （参数里有请求体与认证头）。
+ */
 function curlJson(args) {
-    const out = (0, child_process_1.execFileSync)('curl', ['-s', ...args], { encoding: 'utf-8' });
+    const out = (0, safe_exec_1.runCurl)(args);
     try {
         return JSON.parse(out || '{}');
     }
     catch {
-        throw new Error(`cn Infisical: non-JSON response: ${String(out).slice(0, 200)}`);
+        throw new Error(`cn Infisical: non-JSON response: ${(0, safe_exec_1.scrub)(String(out)).slice(0, 200)}`);
     }
 }
 /** 明文密码文件权限比 600 宽（组/其他用户可读）时往 stderr 警告一行。Windows 无此语义，跳过。 */
@@ -234,7 +243,7 @@ function getCnInfisicalToken() {
         '-d', JSON.stringify({ email, password }),
     ]);
     if (!login.accessToken)
-        throw new Error(`cn Infisical login 失败: ${JSON.stringify(login).slice(0, 200)}`);
+        throw new Error(`cn Infisical login 失败: ${(0, safe_exec_1.scrub)(JSON.stringify(login)).slice(0, 200)}`);
     const org = curlJson([
         '-X', 'POST', `${CN_INFISICAL_URL}/api/v3/auth/select-organization`,
         '-H', 'Content-Type: application/json',
@@ -242,7 +251,7 @@ function getCnInfisicalToken() {
         '-d', JSON.stringify({ organizationId: CN_INFISICAL_ORG }),
     ]);
     if (!org.token)
-        throw new Error(`cn Infisical select-organization 失败: ${JSON.stringify(org).slice(0, 200)}`);
+        throw new Error(`cn Infisical select-organization 失败: ${(0, safe_exec_1.scrub)(JSON.stringify(org)).slice(0, 200)}`);
     return org.token;
 }
 /**

package/dist/bin/helpers/infisical-secrets.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchInfisicalSecret = fetchInfisicalSecret;
-const child_process_1 = require("child_process");
+const safe_exec_1 = require("./safe-exec");
 const db_utils_1 = require("./db-utils");
 /**
  * Fetch a single secret value from Infisical given env + path + name.
@@ -18,16 +18,20 @@ function fetchInfisicalSecret(env, secretPath, secretName, config, token) {
     const envSlug = env === 'stage' ? 'staging' : env;
     const encodedPath = encodeURIComponent(secretPath);
     const encodedName = encodeURIComponent(secretName);
-    const response = (0, child_process_1.execSync)(`curl -s "${cfg.url}/api/v3/secrets/raw/${encodedName}?workspaceId=${cfg.projectId}&environment=${envSlug}&secretPath=${encodedPath}" -H "Authorization: Bearer ${tok}"`, { encoding: 'utf-8' });
+    // runCurl：参数数组直传（不经 shell），失败时的报错不回显命令参数。
+    const response = (0, safe_exec_1.runCurl)([
+        `${cfg.url}/api/v3/secrets/raw/${encodedName}?workspaceId=${cfg.projectId}&environment=${envSlug}&secretPath=${encodedPath}`,
+        '-H', `Authorization: Bearer ${tok}`,
+    ]);
     let parsed;
     try {
         parsed = JSON.parse(response);
     }
     catch {
-        throw new Error(`Infisical raw secret fetch returned non-JSON for ${secretPath}/${secretName} (${envSlug}): ${response.slice(0, 200)}`);
+        throw new Error(`Infisical raw secret fetch returned non-JSON for ${secretPath}/${secretName} (${envSlug}): ${(0, safe_exec_1.scrub)(response).slice(0, 200)}`);
     }
     if (!parsed.secret?.secretValue) {
-        throw new Error(`Infisical secret not found: env=${envSlug} path=${secretPath} name=${secretName} (response: ${response.slice(0, 200)})`);
+        throw new Error(`Infisical secret not found: env=${envSlug} path=${secretPath} name=${secretName} (response: ${(0, safe_exec_1.scrub)(response).slice(0, 200)})`);
     }
     return parsed.secret.secretValue;
 }

package/dist/bin/helpers/query-db.js

@@ -37,6 +37,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryDbUsageError = void 0;
 exports.parseQueryDbArgs = parseQueryDbArgs;
 const child_process_1 = require("child_process");
+const safe_exec_1 = require("./safe-exec");
 const fs = __importStar(require("fs"));
 const db_utils_1 = require("./db-utils");
 const SERVICE_DB_MAP = {
@@ -299,7 +300,14 @@ async function main() {
         const ciHost = (0, db_utils_1.getGitHubVariable)('CI_SSH_HOST');
         const ciPassword = (0, db_utils_1.getGitHubVariable)('CI_SSH_PASSWORD');
         const { container, user, database } = serviceConfig;
-        const result = (0, child_process_1.execSync)(`sshpass -p "${ciPassword}" ssh -o StrictHostKeyChecking=no ${ciUser}@${ciHost} "docker exec ${container} psql -U ${user} -d ${database} -c \\"${sql}\\""`, { encoding: 'utf-8' });
+        // 密码经 SSHPASS 环境变量给 `sshpass -e`：不进命令行（ps 不可见），失败时的报错也不会带出它。
+        let result;
+        try {
+            result = (0, child_process_1.execSync)(`sshpass -e ssh -o StrictHostKeyChecking=no ${ciUser}@${ciHost} "docker exec ${container} psql -U ${user} -d ${database} -c \\"${sql}\\""`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, SSHPASS: ciPassword } });
+        }
+        catch (raw) {
+            throw (0, safe_exec_1.sanitizeExecError)('ssh (CI database)', raw, [ciPassword], `host=${ciHost}`);
+        }
         console.log('\n' + result);
     }
     else {

package/dist/bin/helpers/safe-exec.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSecretName = isSecretName;
+exports.redactArgv = redactArgv;
+exports.scrub = scrub;
+exports.sanitizeExecError = sanitizeExecError;
+exports.runCurl = runCurl;
+const child_process_1 = require("child_process");
+/**
+ * 子进程调用的「报错不回显命令参数」封装。
+ *
+ * 背景：Node 的 execSync/execFileSync 失败时，错误对象的 message 是 `Command failed: <完整命令行>`，
+ * 且带 `cmd` / `spawnargs` / `stderr` 等字段。命令行里若有请求体、认证头、`-u user:pass`、URL 里的
+ * 凭据参数，调用方一句 `console.error(err.message)` 或把报错原文落盘，就把它们带了出去。
+ *
+ * 做法：失败时**不复用**原始 error——抛一个全新的 Error，只含排错需要的东西（退出码/信号/errno、
+ * 目标主机名、子进程 stderr），且 stderr 先过 `scrub`（按字面值 + 常见凭据形态双重清洗）。
+ */
+const MASK = '[REDACTED]';
+/** 值整体敏感的 curl 选项（下一个 argv 元素或 `--opt=value` 的 value 整体打码）。 */
+const VALUE_IS_SECRET = new Set([
+    '-d', '--data', '--data-raw', '--data-binary', '--data-urlencode', '--data-ascii', '--json',
+    '-u', '--user', '-U', '--proxy-user', '--oauth2-bearer',
+    '-x', '--proxy', '--preproxy', // 代理 URL 常带 user:pass@，且可能无 scheme
+    '-F', '--form', '--form-string', '-b', '--cookie', '--pass', '--key',
+    '--tlspassword', '--proxy-tlspassword', '--proxy-pass', '--proxy-key',
+    '-E', '--cert', '--proxy-cert', // `<file>:<passphrase>`
+    '--variable', '--aws-sigv4',
+]);
+/** 带值的短选项字母：解析 `-sSu user:pass` / `-XPOST` 这类合写簇时，遇到它簇就结束（其后是值）。 */
+const SHORT_WITH_VALUE = new Set('dubFHxeAXoKEUmTrCQYyzwPtcDh'.split('').filter((c) => c !== 'h'));
+const HEADER_OPTS = new Set(['-H', '--header', '--proxy-header']);
+/** 头值白名单：只有这些无害头保留原值，其余一律整值打码（黑名单永远列不全）。 */
+const SAFE_HEADER_RE = /^(content-type|content-length|content-encoding|accept|accept-encoding|accept-language|user-agent|cache-control|connection|host|origin)$/i;
+/** 参数/字段名像凭据 ⇒ 值打码。`secret` 单独判：`secretPath` / `expandSecretReferences` 这类是路径与开关，不是凭据。 */
+const SECRET_NAME_RE = /(pass(?:word|wd)?|pwd|token|jwt|hmac|assertion|api[-_]?key|access[-_]?key|private[-_]?key|signature|credential|session|(?:^|[-_])(?:sig|sign|auth|code|key|otp|pw|ticket)$)/i;
+const SECRET_WORD_RE = /secret/i;
+/**
+ * 「名字像凭据、其实不是」的排除——**必须锚定**：无锚点的子串排除会把 `provider_secret`（prov-id-er）、
+ * `model_secret`（mode-l）这类真凭据放过去。只认两种形态：
+ *  - 整名是已知的路径/开关参数；
+ *  - 以「凭据词 + 明确的非凭据后缀」结尾（`secret_id` / `token_type` / `max_tokens` …）。
+ */
+const KNOWN_NON_SECRET = new Set(['secretpath', 'expandsecretreferences', 'sshpass', 'tokenizer', 'passthrough', 'bypass']);
+const NON_SECRET_SUFFIX_RE = /(?:secret|token|key)s?[-_]?(?:path|references?|names?|ids?|version|types?|mode|enabled|count|limit|length|ttl|expiry|expires(?:[-_]?(?:at|in))?)$|(?:^|[-_])(?:max|min|num|total|input|output|prompt|completion)[-_]?tokens$/i;
+function isSecretName(name) {
+    const n = name.trim();
+    if (KNOWN_NON_SECRET.has(n.toLowerCase()) || NON_SECRET_SUFFIX_RE.test(n))
+        return false;
+    return SECRET_NAME_RE.test(n) || SECRET_WORD_RE.test(n);
+}
+function redactUrl(raw) {
+    let u;
+    try {
+        u = new URL(raw);
+    }
+    catch {
+        return raw;
+    }
+    if (!/^https?:$/.test(u.protocol))
+        return raw;
+    if (u.username || u.password) {
+        u.username = MASK;
+        u.password = '';
+    }
+    for (const key of [...u.searchParams.keys()]) {
+        if (isSecretName(key))
+            u.searchParams.set(key, MASK);
+    }
+    if (u.hash.length > 1)
+        u.hash = MASK; // fragment 常见 `#access_token=…`，对排错无用，整段打码
+    return u.toString().replace(/%5BREDACTED%5D/g, MASK);
+}
+function redactHeader(h) {
+    const i = h.indexOf(':');
+    if (i <= 0)
+        return h;
+    const name = h.slice(0, i).trim();
+    return SAFE_HEADER_RE.test(name) ? h : `${name}: ${MASK}`;
+}
+/**
+ * 返回脱敏后的 argv 副本（仅用于展示/排错；绝不改传给子进程的真参数）。
+ * 不覆盖：藏在 URL **路径段**里的凭据（webhook 型 URL）与 User-Agent 里夹带的值——这类请走请求头/请求体。
+ */
+function redactArgv(args) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        // --opt=value
+        const eq = a.startsWith('--') ? a.indexOf('=') : -1;
+        if (eq > 0) {
+            const opt = a.slice(0, eq);
+            if (opt === '--url') {
+                out.push(`${opt}=${redactUrl(a.slice(eq + 1))}`);
+                continue;
+            }
+            if (VALUE_IS_SECRET.has(opt)) {
+                out.push(`${opt}=${MASK}`);
+                continue;
+            }
+            if (HEADER_OPTS.has(opt)) {
+                out.push(`${opt}=${redactHeader(a.slice(eq + 1))}`);
+                continue;
+            }
+        }
+        // 选项与值分开
+        if (VALUE_IS_SECRET.has(a)) {
+            out.push(a);
+            if (i + 1 < args.length) {
+                out.push(MASK);
+                i++;
+            }
+            continue;
+        }
+        if (HEADER_OPTS.has(a)) {
+            out.push(a);
+            if (i + 1 < args.length) {
+                out.push(redactHeader(args[i + 1]));
+                i++;
+            }
+            continue;
+        }
+        // 短选项簇：-Hfoo / -dbody / -uuser:pass / -sSu user:pass / -XPOST
+        if (/^-[^-]/.test(a) && a.length > 2) {
+            let j = 1;
+            while (j < a.length && !SHORT_WITH_VALUE.has(a[j]))
+                j++; // 跳过不带值的开关字母
+            if (j < a.length) {
+                const opt = `-${a[j]}`, head = a.slice(0, j + 1), rest = a.slice(j + 1);
+                const sticky = rest.length > 0; // 值粘在簇里，否则是下一个 argv
+                const value = sticky ? rest : args[i + 1];
+                if (VALUE_IS_SECRET.has(opt) || HEADER_OPTS.has(opt)) {
+                    const masked = value === undefined ? undefined : (HEADER_OPTS.has(opt) ? redactHeader(value) : MASK);
+                    if (sticky)
+                        out.push(`${head}${masked}`);
+                    else {
+                        out.push(head);
+                        if (masked !== undefined) {
+                            out.push(masked);
+                            i++;
+                        }
+                    }
+                    continue;
+                }
+            }
+        }
+        if (/^https?:\/\//i.test(a)) {
+            out.push(redactUrl(a));
+            continue;
+        }
+        // 无 scheme 的 `user:pass@host…`（curl 接受）
+        out.push(a.replace(/^[^\s/@:]+:[^\s/@]+@/, `${MASK}@`));
+    }
+    return out;
+}
+/** 从 argv 里收集「字面值就是秘密」的串，供 scrub 在任意文本里逐字清除。 */
+function secretLiterals(args) {
+    const red = redactArgv(args);
+    const lits = [];
+    for (let i = 0; i < args.length; i++) {
+        if (!red[i].includes(MASK))
+            continue; // 按「是否真的打了码」判，不按字符串是否相等（URL 规范化也会让它不等）
+        const a = args[i].replace(/^--url=/, '');
+        // 子进程 stderr 可能只回显参数的一段，所以除整串外还要收内部片段——但**只收名字像凭据的值**：
+        // 把 URL 里所有 k=v 都当秘密，会让 `prod` / `true` 这类普通词把报错原文洗得没法读。
+        if (/^https?:\/\//i.test(a)) {
+            try {
+                const u = new URL(a);
+                if (u.password)
+                    lits.push(u.password, decodeURIComponent(u.password));
+                if (u.username && u.password)
+                    lits.push(`${u.username}:${u.password}`);
+                for (const [k, v] of u.searchParams)
+                    if (isSecretName(k))
+                        lits.push(v);
+                if (u.hash.length > 1) { // fragment：`#access_token=…`
+                    lits.push(u.hash.slice(1));
+                    for (const [, v] of new URLSearchParams(u.hash.slice(1)))
+                        if (v)
+                            lits.push(v);
+                }
+            }
+            catch { /* 非法 URL：redactUrl 也不会动它，走不到这里 */ }
+            continue;
+        }
+        lits.push(a); // 非 URL 的敏感参数（请求体 / -u / 认证头 / 代理）：整串即秘密
+        for (const m of a.matchAll(/"([^"]*)"\s*:\s*"([^"]+)"/g))
+            if (isSecretName(m[1]))
+                lits.push(m[2]); // JSON 字段
+        for (const m of a.matchAll(/(?:^|&)([^=&\s]+)=([^&\s]+)/g)) { // form k=v
+            if (isSecretName(m[1])) {
+                lits.push(m[2]);
+                try {
+                    lits.push(decodeURIComponent(m[2]));
+                }
+                catch { /* 裸 % */ }
+            }
+        }
+        const header = /^[A-Za-z0-9-]+:\s*(.+)$/.exec(a);
+        if (header) { // Header: value
+            lits.push(header[1].trim());
+            const scheme = /^(?:Bearer|Basic|Token)\s+(\S+)/i.exec(header[1].trim());
+            if (scheme)
+                lits.push(scheme[1]);
+        }
+        else {
+            const up = /^[^\s/@:]*:([^\s@]+)(?:@|$)/.exec(a); // user:pass[@host]
+            if (up)
+                lits.push(up[1]);
+        }
+    }
+    // 长的先替换，避免短片段把长串切碎后漏网；太短的不收（误伤普通文本）
+    return [...new Set(lits.filter((s) => s && s.length >= 4))].sort((x, y) => y.length - x.length);
+}
+/** 清洗任意文本：先按字面值，再按常见凭据形态（认证头、Bearer/Basic、URL 凭据、k=v、JSON 字段）。 */
+function scrub(text, literals = []) {
+    let out = String(text ?? '');
+    for (const lit of [...literals].filter((s) => s && s.length >= 4).sort((a, b) => b.length - a.length)) {
+        out = out.split(lit).join(MASK);
+        const enc = encodeURIComponent(lit);
+        if (enc !== lit)
+            out = out.split(enc).join(MASK);
+    }
+    return out
+        .replace(/((?:proxy-)?authorization\s*[:=]\s*)(?:(?:bearer|basic|token)\s+)?[^\s"'\\]+/gi, `$1${MASK}`)
+        .replace(/\b(bearer|basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, `$1 ${MASK}`)
+        .replace(/(\b[a-z][a-z0-9+.-]*:\/\/)[^\s/:]+:[^\s/]*@/gi, `$1${MASK}@`) // 贪婪到最后一个 @：密码本身可含 @
+        // 三条「名字 → 值」规则统一用 isSecretName 判（与 argv 脱敏同一口径）
+        // 值类必须排除 `?`：否则非凭据键（`url=http://h/cb?token=X`）会把后面的凭据对整段吞进自己的值里原样返回。
+        .replace(/(^|[?&;,(\s"'])(-{0,2}[A-Za-z_][\w.-]*)(\s*=\s*)(?:"[^"]*"|'[^']*'|[^&?;,)\s"']+)/g, (m, pre, key, eq) => (isSecretName(key.replace(/^-+/, '')) ? `${pre}${key}${eq}${MASK}` : m))
+        .replace(/"([A-Za-z_][\w-]*)"(\s*:\s*)"[^"]*"/g, (m, key, sep) => (isSecretName(key) ? `"${key}"${sep}"${MASK}"` : m))
+        .replace(/\b((?:cookie|set-cookie|x-[a-z0-9-]*(?:key|token|secret|auth|session)[a-z0-9-]*|[a-z0-9-]*api-?key)\s*:\s*)[^\r\n"']+/gi, `$1${MASK}`)
+        // `name: value`（yaml / 单引号 dict）。值须像一个 token（≥6 且含数字或符号），否则 `password: must be …`
+        // 这类普通报错句子会被误洗。
+        .replace(/(^|[\s{,])(["']?)([A-Za-z_][\w-]*)\2(\s*:\s*)('[^']*'|[^\s,}"']+)/g, (m, pre, q, key, sep, val) => {
+        const bare = val.replace(/^'|'$/g, '');
+        const tokenish = bare.length >= 6 && /[\d_\-+/=.]/.test(bare);
+        return isSecretName(key) && tokenish ? `${pre}${q}${key}${q}${sep}${MASK}` : m;
+    })
+        .replace(/(\bsshpass\s+-p\s*)("[^"]*"|'[^']*'|\S+)/g, `$1${MASK}`);
+}
+/** 值是 URL 但不是请求目标的选项（代理 / referer）。 */
+const URL_VALUED_OPTS = new Set(['-x', '--proxy', '--preproxy', '-e', '--referer']);
+function hostOf(args) {
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i].replace(/^--url=/, '');
+        if (!/^https?:\/\//i.test(a) || (i > 0 && URL_VALUED_OPTS.has(args[i - 1])))
+            continue;
+        try {
+            return new URL(a).host;
+        }
+        catch { /* 不是合法 URL：继续找 */ }
+    }
+    return 'unknown';
+}
+/** 会让 curl 把请求头/响应头/响应体细节写进输出的选项：响应头里的凭据（Set-Cookie 等）没法按字面值清洗，直接不许用。 */
+function findVerboseOpt(args) {
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.startsWith('--')) {
+            const name = a.split('=')[0];
+            // curl 接受长选项的唯一前缀（`--verbos`），所以按前缀判
+            if (/^--(verb|trace|incl|dump-h)/.test(name))
+                return name;
+            if (!a.includes('=') && (VALUE_IS_SECRET.has(name) || HEADER_OPTS.has(name) || URL_VALUED_OPTS.has(name)))
+                i++; // 跳过它的值
+            continue;
+        }
+        if (!/^-[^-]/.test(a))
+            continue;
+        let j = 1;
+        for (; j < a.length; j++) {
+            if ('viD'.includes(a[j]))
+                return `-${a[j]}`;
+            if (SHORT_WITH_VALUE.has(a[j]))
+                break;
+        }
+        if (j < a.length && j === a.length - 1)
+            i++; // 簇以带值选项结尾：下一个 argv 是值，跳过
+    }
+    return undefined;
+}
+/**
+ * 把 child_process 抛的 error 换成一个干净的新 Error。
+ * 只取 status/signal/code 与（清洗后的）stderr；**不复制** message/cmd/spawnargs/stdout/output。
+ */
+function sanitizeExecError(label, raw, literals = [], context = '') {
+    const e = (raw ?? {});
+    const parts = [];
+    if (typeof e.status === 'number')
+        parts.push(`exit=${e.status}`);
+    if (e.signal)
+        parts.push(`signal=${e.signal}`);
+    if (typeof e.code === 'string')
+        parts.push(`code=${e.code}`); // ENOENT / ETIMEDOUT / ENOBUFS…
+    if (context)
+        parts.push(context);
+    const stderr = scrub(e.stderr == null ? '' : String(e.stderr), literals).trim().slice(0, 2000);
+    return new Error(`${label} failed (${parts.join(' ') || 'unknown error'})${stderr ? `: ${stderr}` : ''}`);
+}
+/**
+ * 同步跑 curl，返回 stdout。参数数组直传（不经 shell）。
+ * 失败时抛的 Error 不含 argv：只有退出码/信号/errno、目标主机名、清洗过的 curl stderr。
+ * `-sS`：静默进度条但保留 curl 自己的错误行（`curl: (7) Failed to connect…`），否则失败时两眼一抹黑。
+ */
+function runCurl(args, opts = {}) {
+    const verbose = findVerboseOpt(args);
+    if (verbose)
+        throw new Error(`runCurl: option ${verbose} is not allowed (it writes header/body details to the output)`);
+    try {
+        return (0, child_process_1.execFileSync)(opts.bin ?? 'curl', ['-sS', ...args], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'], // stderr 收进 error 对象（由我们清洗后再露出），不直通父进程
+            maxBuffer: 64 * 1024 * 1024,
+            ...(opts.timeoutMs ? { timeout: opts.timeoutMs } : {}),
+        });
+    }
+    catch (raw) {
+        throw sanitizeExecError('curl', raw, secretLiterals(args), `host=${hostOf(args)}`);
+    }
+}

package/dist/bin/helpers/show-env.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
+const safe_exec_1 = require("./safe-exec");
 const db_utils_1 = require("./db-utils");
 // 支持的服务列表（Infisical 路径为 /services/<service-name>）
 const SUPPORTED_SERVICES = [
@@ -43,7 +43,11 @@ function isSupportedEnv(env) {
 // NOTE: getInfisicalSecrets is kept local because it encodes secretPath (encodeURIComponent),
 // unlike db-utils' raw-path variant; getGitHubVariable/getInfisicalConfig/getInfisicalToken are shared from db-utils.
 function getInfisicalSecrets(config, token, environment, secretPath) {
-    const response = (0, child_process_1.execSync)(`curl -s "${config.url}/api/v3/secrets/raw?workspaceId=${config.projectId}&environment=${environment}&secretPath=${encodeURIComponent(secretPath)}" -H "Authorization: Bearer ${token}"`, { encoding: 'utf-8' });
+    // runCurl：参数数组直传（不经 shell），失败时的报错不回显命令参数。
+    const response = (0, safe_exec_1.runCurl)([
+        `${config.url}/api/v3/secrets/raw?workspaceId=${config.projectId}&environment=${environment}&secretPath=${encodeURIComponent(secretPath)}`,
+        '-H', `Authorization: Bearer ${token}`,
+    ]);
     const data = JSON.parse(response);
     const secrets = {};
     for (const secret of data.secrets || []) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optima-chat/dev-skills",
-  "version": "0.16.9",
+  "version": "0.16.10",
   "description": "Claude Code Skills for Optima development team - cross-environment collaboration tools",
   "main": "index.js",
   "bin": {