weaver-work-cli 0.1.7 → 0.1.20

package/README.md

@@ -126,7 +126,7 @@ weaver-work-cli auth login --base-url "https://weapp.xxx.cn" --agent_type "<当
 weaver-work-cli invoice schema
 ```
 
-如果要让 Codex/Agent 一键识别发票业务，把随包 Skill 安装到 Codex skills 目录：
+如果要让当前 Agent 一键识别发票业务，把随包 Skill 安装到它的 skills 目录：
 
 ```text
 weaver-work-cli setup invoice --install-skill
@@ -135,11 +135,10 @@ weaver-work-cli skills install yepiaotong
 ```
 
 `skills install yepiaotong` 会同时安装 `weaver-e10-shared` 和
-`weaver-e10-yepiaotong`。默认目标目录优先使用环境变量 `CODEX_HOME` 下的
-`skills` 子目录；未设置 `CODEX_HOME` 时使用用户主目录下的 `.codex/skills`
-（Windows PowerShell 示例：`"$env:USERPROFILE\.codex\skills"`）；需要自定义时可加
-`--target-dir <path>`。默认目标面向 Codex CLI；WorkBuddy 等桌面 Agent 的
-用户级 Skill 目录不是默认目标，需显式指定：
+`weaver-e10-yepiaotong`。CLI 会优先使用 `--target-dir` 或 `WEAVER_SKILLS_ROOT`，
+否则根据当前进程的 Codex/WorkBuddy 环境信号选择当前用户的 skills 目录。
+宿主不明确、候选目录冲突或其它 Agent 未提供路径时，CLI 会停止安装并要求显式指定，
+避免把 Skill 写到当前 Agent 不会读取的位置：
 
 Windows PowerShell：
 
@@ -212,11 +211,12 @@ weaver-work-cli auth login --base-url "https://weapp.xxx.cn"
 weaver-work-cli auth oidc --base-url "https://weapp.xxx.cn"
 ```
 
-在 XiaoE 宿主环境中，`auth login` / `auth oidc` / `auth xiaoe` 会优先读取宿主
-`xiaoeUserData/tokens.py`；脚本不可用（不存在、执行失败，或所用 Python 缺少
-`requests` 等依赖）时，CLI 会改用内置的原生等价实现读取 XiaoE 客户端本地会话
-（`XiaoE/Robots/*/user_settings.json` 或 `XIAOE_USER_TOKEN`）换取 `eteamId`，
-不依赖本机 Python 环境；仍没有可用凭证时，再读取宿主注入的 `XIAOE_*`
+在 XiaoE 宿主环境中，`auth login` / `auth oidc` / `auth xiaoe` 会优先使用平台注入的
+`XIAOE_USER_TOKEN` + `XIAOE_DOMAIN` 换取 ETEAMSID（沙箱环境唯一可用来源）；
+拿不到时再读取宿主 `xiaoeUserData/tokens.py`；脚本不可用（不存在、执行失败，或所用
+Python 缺少 `requests` 等依赖）时，CLI 会改用内置的原生等价实现读取桌面 XiaoE
+客户端本地会话（`XiaoE/Robots/<id>/user_settings.json`）换取 `eteamId`，
+不依赖本机 Python 环境；仍没有可用凭证时，再读取 `WEAVER_XIAOE_*`
 环境变量，匹配当前登录域名对应的统一登录凭证。匹配成功时直接保存登录态，
 并固定使用 `agentType=XiaoE`；凭证只返回 `eteamId` 时，会使用凭证中的
 域名或资料包默认域名 `https://www.e-cology.com.cn`；仍没有可用凭证时才考虑当前

package/dist/cmd/action.js

@@ -1,13 +1,89 @@
 import { ExitCode, isCliError, toErrorEnvelope } from '../core/errors.js';
+import { guardFileInput } from '../core/input.js';
+import { RefError, pruneRefs, resolveRefInput } from '../core/refs.js';
+import { refMaxBytes, refMaxCount } from '../core/output.js';
 function commandFromArgs(args) {
     const last = args[args.length - 1];
     return last && typeof last === 'object' && 'name' in last && 'opts' in last ? last : undefined;
 }
+function optionsHolderFrom(args) {
+    return args.find((arg) => Boolean(arg
+        && typeof arg === 'object'
+        && !Array.isArray(arg)
+        && !('opts' in arg)
+        && ('inputRef' in arg
+            || 'pick' in arg
+            || 'pickAs' in arg
+            || 'allowFileInput' in arg
+            || 'fileInput' in arg)));
+}
+/**
+ * 把 `--input-ref`（+ 可选 `--pick`）翻译成等价的内联 JSON，写回 options 的 inputJson。
+ *
+ * 这样 20 个业务模块各自的 `inputFrom()` 无需任何改动就能消费结果引用：
+ * 它们本来就认 `--input-json`，我们只是在参数进入 handler 之前把 ref 展开成它。
+ */
+function applyRefInput(ctx, args) {
+    const holder = optionsHolderFrom(args);
+    if (!holder)
+        return;
+    const refId = String(holder.inputRef ?? '').trim();
+    if (!refId) {
+        if (holder.pick || holder.pickAs) {
+            throw new RefError('input_ref_required', '--pick 和 --pick-as 必须与 --input-ref 一起使用');
+        }
+        return;
+    }
+    if (holder.inputJson !== undefined || holder.input !== undefined) {
+        throw new RefError('input_conflict', '不能同时传 --input-ref 与 --input/--input-json');
+    }
+    const pick = holder.pick === undefined || holder.pick === null || holder.pick === ''
+        ? undefined
+        : String(holder.pick);
+    const pickAs = holder.pickAs === undefined || holder.pickAs === null || holder.pickAs === ''
+        ? undefined
+        : String(holder.pickAs);
+    holder.inputJson = JSON.stringify(resolveRefInput(ctx, {
+        refId,
+        ...(pick ? { pick } : {}),
+        ...(pickAs ? { pickAs } : {}),
+    }));
+    delete holder.inputRef;
+    delete holder.pick;
+    delete holder.pickAs;
+}
+function cleanupRefs(ctx) {
+    try {
+        pruneRefs(ctx, { maxCount: refMaxCount(ctx), maxBytes: refMaxBytes(ctx) });
+    }
+    catch {
+        process.stderr.write('[weaver-work-cli] 暂存结果清理失败；本次命令继续执行。\n');
+    }
+}
+function isRefsShow(command) {
+    const names = [];
+    let current = command;
+    while (current) {
+        const name = current.name();
+        if (name)
+            names.unshift(name);
+        current = current.parent;
+    }
+    return names.slice(-2).join(' ') === 'refs show';
+}
 export function createAction(ctx) {
     return (handler) => async (...args) => {
         const commandCtx = ctx.forCommand(commandFromArgs(args));
         try {
             await commandCtx.hooks.beforeCommand(commandCtx);
+            applyRefInput(commandCtx, args);
+            const options = commandCtx.activeCommand?.opts();
+            if (options)
+                guardFileInput(commandCtx, options);
+            // Run GC on every command, but after resolving a supplied ref so an
+            // expired handle can still return the specific ref_expired error.
+            if (!isRefsShow(commandCtx.activeCommand))
+                cleanupRefs(commandCtx);
             const result = await handler(commandCtx, ...args);
             await commandCtx.hooks.afterCommand(commandCtx, result);
         }

package/dist/cmd/index.js

@@ -3,6 +3,7 @@ import { configCommand } from './config/index.js';
 import { docsCommand } from './docs/index.js';
 import { doctorCommand } from './doctor/index.js';
 import { e10Command } from './e10/index.js';
+import { refsCommand } from './refs/index.js';
 import { runCommand } from './run/index.js';
 import { setupCommand } from './setup/index.js';
 import { skillsCommand } from './skills/index.js';
@@ -12,6 +13,7 @@ export const builtinCommands = [
     doctorCommand,
     commandsCommand,
     runCommand,
+    refsCommand,
     e10Command,
     setupCommand,
     skillsCommand,

package/dist/cmd/refs/index.js

@@ -0,0 +1,103 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+import { listRefs, pickValue, pruneRefs, readRef } from '../../core/refs.js';
+import { refsDir } from '../../core/state.js';
+import { bytesOf, DEFAULT_RESULT_THRESHOLD_BYTES, refMaxBytes, refMaxCount, resultThresholdBytes, } from '../../core/output.js';
+/** 解析 `7d` / `24h` / `30m` / `90s` / 纯毫秒数。 */
+function parseDuration(value) {
+    const raw = value.trim().toLowerCase();
+    const matched = /^(\d+)\s*([dhms])?$/.exec(raw);
+    if (!matched) {
+        throw new CliError(`无法解析时长：${value}（示例：7d、24h、30m）`, ExitCode.UsageError);
+    }
+    const amount = Number(matched[1]);
+    const unit = matched[2] ?? 'ms';
+    const factor = unit === 'd' ? 86_400_000 : unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : 1;
+    return amount * factor;
+}
+function asOptions(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+export const refsCommand = {
+    name: 'refs',
+    description: 'Inspect and prune persisted large results',
+    category: 'system',
+    register({ program, action }) {
+        const refs = program.command('refs').description('Manage persisted large results');
+        refs.command('path')
+            .description('Print the directory holding persisted results')
+            .action(action((ctx) => {
+            const path = refsDir(ctx);
+            ctx.output.write({ path }, { text: path });
+        }));
+        refs.command('list')
+            .description('List persisted results, newest first')
+            .action(action((ctx) => {
+            const now = Date.now();
+            const items = listRefs(ctx).filter((row) => Date.parse(row.expiresAt) > now).map((row) => ({
+                refId: row.refId,
+                operation: row.operation ?? null,
+                bytes: row.bytes,
+                createdAt: row.createdAt,
+                expiresAt: row.expiresAt,
+            }));
+            ctx.output.write({ count: items.length, items });
+        }));
+        refs.command('show')
+            .description('Print one persisted result in full')
+            .argument('<refId>', 'reference id')
+            .action(action((ctx, refId) => {
+            const id = String(refId ?? '').trim();
+            if (!id)
+                throw new CliError('refId 不能为空', ExitCode.UsageError);
+            const record = readRef(ctx, id);
+            const configuredLimit = resultThresholdBytes(ctx);
+            const displayLimit = configuredLimit > 0 ? configuredLimit : DEFAULT_RESULT_THRESHOLD_BYTES;
+            if (bytesOf(record.envelope) > displayLimit) {
+                throw new CliError(`结果太大，不能安全地一次显示。请用 refs get ${id} <json-path> 读取需要的字段。`, ExitCode.UsageError);
+            }
+            // 用户主动查看完整结果，不再二次落盘。
+            ctx.output.write(record.envelope, { json: true, persist: false });
+        }));
+        refs.command('get')
+            .description('Print one value from a persisted result by JSON path')
+            .argument('<refId>', 'reference id')
+            .argument('<path>', 'JSON path, e.g. data.items[0].fid')
+            .action(action((ctx, refId, path) => {
+            const id = String(refId ?? '').trim();
+            const jsonPath = String(path ?? '').trim();
+            if (!id || !jsonPath)
+                throw new CliError('refId 和 JSON 路径不能为空', ExitCode.UsageError);
+            const record = readRef(ctx, id);
+            ctx.output.write(pickValue(record.envelope, jsonPath));
+        }));
+        refs.command('prune')
+            .description('Prune persisted results')
+            .option('--older-than <duration>', 'remove results created before this age, e.g. 7d')
+            .option('--all', 'remove every persisted result')
+            .action(action((ctx, options) => {
+            const opts = asOptions(options);
+            if (opts.all === true) {
+                const result = pruneRefs(ctx, { maxCount: 0, maxBytes: 0 });
+                ctx.output.write({
+                    removed: result.removed,
+                    kept: result.kept,
+                    bytes: result.bytes,
+                    cleanupIncomplete: result.cleanupIncomplete,
+                });
+                return;
+            }
+            const olderThanMs = opts.olderThan ? parseDuration(String(opts.olderThan)) : undefined;
+            const result = pruneRefs(ctx, {
+                maxCount: refMaxCount(ctx),
+                maxBytes: refMaxBytes(ctx),
+                ...(olderThanMs === undefined ? {} : { olderThanMs }),
+            });
+            ctx.output.write({
+                removed: result.removed,
+                kept: result.kept,
+                bytes: result.bytes,
+                cleanupIncomplete: result.cleanupIncomplete,
+            });
+        }));
+    },
+};

package/dist/cmd/register.js

@@ -1,4 +1,34 @@
 import { createAction } from './action.js';
+const IO_CHANNEL_OPTIONS = [
+    { flags: '--input-ref <ref>', description: 'consume a persisted large result reference' },
+    { flags: '--pick <path>', description: 'pick a sub path from --input-ref, e.g. items[0].fid' },
+    { flags: '--pick-as <field>', description: 'map a scalar picked value to this input field, e.g. fid' },
+    { flags: '--allow-file-input', description: 'allow reading JSON input from --input <path>' },
+    { flags: '--no-file-input', description: 'reject JSON input from --input <path>' },
+];
+/**
+ * 只给叶子命令补上结果引用相关的输入选项。
+ *
+ * 两个坑：
+ * 1. Commander 的子命令不继承父命令 option，只加在 program 上会被解析成 unknown option，
+ *    所以必须递归到每个叶子命令；
+ * 2. **绝不能加在中间命令上**——父命令 parseOptions 时会先把 `--input-ref` 当自己的
+ *    选项吃掉，子命令就再也收不到（实测 `invoice run op --input-ref x` 的 opts() 为空）。
+ */
+function ensureRefInputOptions(command) {
+    if (command.commands.length === 0) {
+        for (const option of IO_CHANNEL_OPTIONS) {
+            const long = option.flags.split(' ')[0];
+            if (!command.options.some((existing) => existing.long === long)) {
+                command.option(option.flags, option.description);
+            }
+        }
+        return;
+    }
+    for (const child of command.commands) {
+        ensureRefInputOptions(child);
+    }
+}
 export async function registerCommands(program, ctx, commands) {
     ctx.commands = commands.map((command) => ({
         name: command.name,
@@ -15,5 +45,6 @@ export async function registerCommands(program, ctx, commands) {
     for (const command of commands) {
         await command.register({ program, ctx, action });
     }
+    ensureRefInputOptions(program);
 }
 export const registerModules = registerCommands;

package/dist/cmd/root.js

@@ -29,6 +29,7 @@ export function createProgram() {
         .option('--config <path>', 'use a custom weaver-work-cli config file')
         .option('--auth <path>', 'use a specific E10 auth file')
         .option('--profile <name>', 'use a specific E10 profile')
+        .option('--is-connector [value]', 'run as the WorkBuddy connector: use the fixed E10 profile managed by the connector')
         .option('--base-url <url>', 'override E10 base URL')
         .option('--passport-url <url>', 'override E10 passport URL');
     program.showHelpAfterError();

package/dist/cmd/setup/index.js

@@ -1,7 +1,8 @@
 import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { CliError, ExitCode } from '../../core/errors.js';
 import { findAuthFile } from '../../internal/e10/auth/session.js';
-import { defaultCodexSkillsRoot, installPackagedSkills, resolvePackagedSkillNames } from '../../internal/skills/install.js';
+import { installPackagedSkills, resolvePackagedSkillNames, resolveSkillsRoot, resolveSkillsTargetPath, unresolvedSkillsRootMessage, } from '../../internal/skills/install.js';
 const SKILLS_DIR = fileURLToPath(new URL('../../../skills/', import.meta.url));
 function versionMajor(version) {
     return Number(version.replace(/^v/, '').split('.')[0] || 0);
@@ -15,8 +16,8 @@ export const setupCommand = {
             .description('One-step setup checks for business shortcuts');
         setup.command('invoice')
             .description('Check invoice CLI readiness and optionally install Agent skills')
-            .option('--install-skill', 'install packaged invoice Agent skill into Codex skills directory')
-            .option('--skill-target-dir <path>', 'override target Codex skills directory')
+            .option('--install-skill', 'install packaged invoice skill into the current Agent skills directory')
+            .option('--skill-target-dir <path>', 'override target Agent skills directory')
             .action(action((ctx, options) => {
             const opts = options && typeof options === 'object'
                 ? options
@@ -45,8 +46,26 @@ export const setupCommand = {
                     detail: authFile || 'not found',
                 },
             ];
-            const skillInstall = opts.installSkill
-                ? installPackagedSkills(SKILLS_DIR, opts.skillTargetDir || defaultCodexSkillsRoot(ctx.env), 'yepiaotong')
+            const specifiedSkillRoot = typeof opts.skillTargetDir === 'string' && opts.skillTargetDir.trim()
+                ? resolveSkillsTargetPath(opts.skillTargetDir)
+                : '';
+            const skillResolution = opts.installSkill
+                ? specifiedSkillRoot
+                    ? { root: specifiedSkillRoot, host: 'explicit', source: 'target-dir' }
+                    : resolveSkillsRoot(ctx.env)
+                : null;
+            if (skillResolution?.requiresExplicitTarget) {
+                throw new CliError(unresolvedSkillsRootMessage(skillResolution, '--skill-target-dir'), ExitCode.UsageError);
+            }
+            const skillInstall = skillResolution
+                ? {
+                    ...installPackagedSkills(SKILLS_DIR, skillResolution.root, 'yepiaotong'),
+                    skillsHost: skillResolution.host,
+                    skillsRootSource: skillResolution.source,
+                    warnings: skillResolution.source === 'filesystem-detected'
+                        ? ['目标目录仅根据本机已有目录推断；如与当前智能体不符，请显式指定。']
+                        : [],
+                }
                 : null;
             const nextActions = [];
             if (!checks.find((check) => check.name === 'e10Auth')?.ok) {
@@ -68,6 +87,7 @@ export const setupCommand = {
                     ok ? 'Invoice setup checks passed.' : 'Invoice setup needs attention.',
                     ...checks.map((check) => `- ${check.name}: ${check.ok ? 'ok' : 'missing'} (${check.detail})`),
                     ...(skillInstall ? skillInstall.installed.map((entry) => `- installed skill: ${entry.name} -> ${entry.target}`) : []),
+                    ...(skillInstall ? skillInstall.warnings.map((warning) => `- warning: ${warning}`) : []),
                     'Next:',
                     ...nextActions.map((actionText) => `- ${actionText}`),
                 ].join('\n'),

package/dist/cmd/skills/index.js

@@ -1,9 +1,9 @@
 import { existsSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { CliError } from '../../core/errors.js';
+import { CliError, ExitCode } from '../../core/errors.js';
 import { resolveDetectorInfo } from '../../internal/skills/detector.js';
-import { defaultCodexSkillsRoot, installPackagedSkills } from '../../internal/skills/install.js';
+import { installPackagedSkills, resolveSkillsRoot, resolveSkillsTargetPath, unresolvedSkillsRootMessage, } from '../../internal/skills/install.js';
 import { SkillReader } from '../../internal/skills/reader.js';
 const SKILLS_DIR = fileURLToPath(new URL('../../../skills/', import.meta.url));
 function reader() {
@@ -18,6 +18,18 @@ function commandOptions(value) {
     const opts = value.opts();
     return opts && typeof opts === 'object' ? opts : {};
 }
+function describeRoot(resolution) {
+    if (resolution.source === 'target-dir')
+        return '由 --target-dir 指定';
+    if (resolution.source === 'explicit-env') {
+        return `由 ${resolution.environmentVariable || '宿主环境变量'} 指定（${resolution.host}）`;
+    }
+    if (resolution.source === 'host-detected')
+        return `自动探测宿主 ${resolution.host}`;
+    if (resolution.source === 'filesystem-detected')
+        return `由本机唯一已存在的宿主目录推断（${resolution.host}）`;
+    return '无法可靠判断宿主';
+}
 function pythonInvocation(opts) {
     if (opts.python)
         return { command: opts.python, args: [] };
@@ -81,17 +93,37 @@ export const skillsCommand = {
             ctx.output.raw(result.content);
         }));
         skills.command('install')
-            .description('Install packaged skills into Codex skills directory')
+            .description('Install packaged skills into the current Agent skills directory')
             .argument('[target]', 'skill name (weaver-e10-* or legacy weaver-work-cli-*), short name such as skill-maker, or all', 'all')
             .option('--target-dir <path>', 'override target skills directory')
             .action(action((ctx, target, options) => {
             const opts = options && typeof options === 'object' ? options : {};
-            const targetRoot = opts.targetDir || defaultCodexSkillsRoot(ctx.env);
+            const specified = typeof opts.targetDir === 'string' && opts.targetDir.trim()
+                ? resolveSkillsTargetPath(opts.targetDir)
+                : '';
+            const resolution = specified
+                ? { root: specified, host: 'explicit', source: 'target-dir' }
+                : resolveSkillsRoot(ctx.env);
+            if (resolution.requiresExplicitTarget) {
+                throw new CliError(unresolvedSkillsRootMessage(resolution), ExitCode.UsageError);
+            }
+            const targetRoot = resolution.root;
             const result = installPackagedSkills(SKILLS_DIR, targetRoot, typeof target === 'string' ? target : 'all');
-            ctx.output.write(result, {
+            const warnings = resolution.source === 'filesystem-detected'
+                ? ['提示：该目录仅根据本机已有目录推断；如与当前智能体不符，请用 --target-dir 或 WEAVER_SKILLS_ROOT 指定。']
+                : [];
+            ctx.output.write({
+                ...result,
+                targetRoot,
+                skillsHost: resolution.host,
+                skillsRootSource: resolution.source,
+                warnings,
+            }, {
                 text: [
+                    `Skills root: ${targetRoot}（${describeRoot(resolution)}）`,
                     'Installed packaged skills:',
                     ...result.installed.map((entry) => `- ${entry.name} -> ${entry.target}`),
+                    ...warnings,
                 ].join('\n'),
             });
         }));

package/dist/core/connector.js

@@ -0,0 +1,54 @@
+/**
+ * 连接器模式下内部固定使用的 E10 profile。
+ *
+ * WorkBuddy 连接器由连接器自己完成安装与登录，业务 Skill 不再显式写 `--profile eteams`，
+ * 改为由模型按「本次任务是否使用连接器能力」传 `--is-connector true`，由 CLI 内部切到该 profile。
+ * 该 profile 的 `config.json` 自带 baseUrl / passportUrl，凭据在 `profiles/<name>/auth`。
+ */
+export const CONNECTOR_PROFILE = 'eteams';
+/**
+ * 判定 `--is-connector` 的值是否表示「启用连接器模式」。
+ *
+ * 支持写法：`--is-connector`（裸写）、`--is-connector true`、`--is-connector=1`、`--is-connector yes`。
+ * 未传、传 `false` / `0` / `no` 一律视为关闭。
+ */
+export function isConnectorEnabled(value) {
+    if (value === undefined || value === null || value === false)
+        return false;
+    if (value === true)
+        return true;
+    const normalized = String(value).trim().toLowerCase();
+    return normalized === '' || normalized === 'true' || normalized === '1' || normalized === 'yes';
+}
+/**
+ * 当前进程是否以「连接器模式」运行。
+ *
+ * 由 `normalizeGlobalOptions` 在每次解析全局参数时刷新。CLI 是一次性进程，
+ * 且全局参数在整个进程生命周期内不变，因此这里不存在跨命令残留的问题。
+ */
+let connectorMode = false;
+/**
+ * 当前进程是否带 `--is-connector` 运行。
+ *
+ * 供深层模块判断「是否需要为连接器让路」，例如写活跃 profile 指针处：
+ * 连接器只应新增自己的认证信息，不得改动用户既有的活跃 profile 选择。
+ */
+export function isConnectorMode() {
+    return connectorMode;
+}
+/**
+ * 把 `--is-connector true` 归一化为「使用固定连接器 profile」，并刷新连接器模式状态。
+ *
+ * 设计取舍：漏传 `--is-connector` 时**保持原行为**（回退当前活跃 profile），
+ * 不做静默仲裁，也不报错——这样非连接器场景的既有用法完全不受影响。
+ * 反过来，带了 `--is-connector` 时除了锁定 profile，还会关闭一切对用户
+ * 既有认证状态的写入（活跃 profile 指针）。
+ */
+export function normalizeGlobalOptions(options) {
+    if (!isConnectorEnabled(options.isConnector)) {
+        connectorMode = false;
+        return options;
+    }
+    connectorMode = true;
+    return { ...options, profile: CONNECTOR_PROFILE };
+}

package/dist/core/context.js

@@ -1,10 +1,11 @@
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
 import { ConfigStore } from './config-store.js';
+import { normalizeGlobalOptions } from './connector.js';
 import { Logger } from './logger.js';
 import { Output } from './output.js';
 export function createCliContext(program, hooks, packageInfo) {
-    const getGlobalOptions = () => program.opts();
+    const getGlobalOptions = () => normalizeGlobalOptions(program.opts());
     const configStore = new ConfigStore(() => {
         const opts = getGlobalOptions();
         const home = process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli');

package/dist/core/input.js

@@ -0,0 +1,48 @@
+import { CliError, ExitCode } from './errors.js';
+export class FileInputPolicyError extends CliError {
+    type = 'policy';
+    subtype = 'file_input_denied';
+    retryable = false;
+    constructor() {
+        super('不允许通过 --input <path> 读取 JSON 文件。请改用 --input-json、--input -，或用 --input-ref 传递上一步的结果。', ExitCode.PolicyError);
+        this.name = 'FileInputPolicyError';
+    }
+}
+function configuredPolicy(ctx) {
+    const io = ctx.config.get('io');
+    if (io && typeof io === 'object' && !Array.isArray(io) && 'fileInput' in io) {
+        return io.fileInput;
+    }
+    return ctx.config.get('io.fileInput');
+}
+/** Policy precedence: explicit flags, environment, config, then warn. */
+export function resolveFileInputPolicy(ctx, options) {
+    const allow = options.allowFileInput === true;
+    const deny = options.fileInput === false;
+    if (allow && deny) {
+        throw new CliError('不能同时传 --allow-file-input 和 --no-file-input', ExitCode.UsageError);
+    }
+    if (allow)
+        return 'allow';
+    if (deny)
+        return 'deny';
+    const fromEnv = (ctx.env.WEAVER_WORK_CLI_FILE_INPUT ?? '').trim().toLowerCase();
+    if (fromEnv === 'allow' || fromEnv === 'warn' || fromEnv === 'deny')
+        return fromEnv;
+    const fromConfig = configuredPolicy(ctx);
+    if (fromConfig === 'allow' || fromConfig === 'warn' || fromConfig === 'deny')
+        return fromConfig;
+    return 'warn';
+}
+/** Warn or reject only JSON file input; stdin and business --file options are separate. */
+export function guardFileInput(ctx, options) {
+    const input = options.input;
+    if (input === undefined || input === null || String(input).trim() === '' || input === '-')
+        return;
+    const policy = resolveFileInputPolicy(ctx, options);
+    if (policy === 'allow')
+        return;
+    if (policy === 'deny')
+        throw new FileInputPolicyError();
+    process.stderr.write('[weaver-work-cli] 使用 --input <path> 读取 JSON 文件；多步传递请优先用 --input-ref，简单数据请用 --input-json。\n');
+}