@optima-chat/dev-skills 0.16.8 → 0.16.10

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.8",
+  "version": "0.16.10",
   "description": "Claude Code Skills for Optima development team - cross-environment collaboration tools",
   "main": "index.js",
   "bin": {