weaver-work-cli 0.1.8 → 0.1.20

package/dist/internal/e10/auth/xiaoe.js

@@ -6,7 +6,14 @@ import { CliError, ExitCode } from '../../../core/errors.js';
 import { buildE10CookieHeader, E10AuthSession, profileNameFromUrl, readTeamsCheckUserInfo, saveAuthFile, saveProfileConfig, setActiveProfile, } from './session.js';
 export const DEFAULT_E10_BASE_URL = 'https://www.e-cology.com.cn';
 export const XIAOE_AGENT_TYPE = 'XiaoE';
+// `XIAOE_` 是宿主/平台保留前缀（XIAOE_DOMAIN、XIAOE_USER_TOKEN、XIAOE_SKILL_* 等）。
+// 本 CLI 自定义的宿主集成变量一律使用自有前缀 `WEAVER_XIAOE_*`；历史 `XIAOE_*`
+// 名称仅作兼容别名排在后面，读取优先级低于新名称。
 const XIAOE_UNIFIED_LOGIN_MAP_ENV_KEYS = [
+    'WEAVER_XIAOE_AUTH_MAP',
+    'WEAVER_XIAOE_E10_AUTH_MAP',
+    'WEAVER_XIAOE_DOMAIN_ETEAMSID_MAP',
+    'WEAVER_XIAOE_UNIFIED_LOGIN_MAP',
     'XIAOE_E10_AUTH_MAP',
     'XIAOE_E10_DOMAIN_ETEAMSID_MAP',
     'XIAOE_DOMAIN_ETEAMSID_MAP',
@@ -14,25 +21,30 @@ const XIAOE_UNIFIED_LOGIN_MAP_ENV_KEYS = [
 ];
 const XIAOE_SINGLE_DOMAIN_ENV_KEYS = [
     'XIAOE_DOMAIN',
+    'WEAVER_XIAOE_E10_DOMAIN',
+    'WEAVER_XIAOE_BASE_URL',
+    'WEAVER_XIAOE_E10_BASE_URL',
     'XIAOE_E10_DOMAIN',
     'XIAOE_BASE_URL',
     'XIAOE_E10_BASE_URL',
 ];
 const XIAOE_DEFAULT_DOMAIN_ENV_KEYS = [
+    'WEAVER_XIAOE_DEFAULT_DOMAIN',
+    'WEAVER_XIAOE_DEFAULT_BASE_URL',
+    'WEAVER_XIAOE_E10_DEFAULT_DOMAIN',
+    'WEAVER_XIAOE_E10_DEFAULT_BASE_URL',
     'XIAOE_DEFAULT_DOMAIN',
     'XIAOE_DEFAULT_BASE_URL',
     'XIAOE_E10_DEFAULT_DOMAIN',
     'XIAOE_E10_DEFAULT_BASE_URL',
 ];
-const XIAOE_SINGLE_ETEAMSID_ENV_KEYS = [
-    'XIAOE_ETEAMSID',
-    'XIAOE_ETEAM_ID',
-    'XIAOE_ETEAMID',
-    'XIAOE_E10_ETEAMSID',
-    'XIAOE_E10_ETEAM_ID',
-];
-const XIAOE_TOKEN_SCRIPT_ENV_KEY = 'XIAOE_TOKEN_SCRIPT_PATH';
-const XIAOE_TOKEN_SCRIPT_PYTHON_ENV_KEY = 'XIAOE_TOKEN_SCRIPT_PYTHON';
+// The XiaoE host only injects domain variables (XIAOE_DOMAIN etc.) together
+// with XIAOE_USER_TOKEN; it never injects an ETEAMSID environment variable, so
+// no `XIAOE_*ETEAMSID*` credential channel exists here on purpose.
+const XIAOE_TOKEN_SCRIPT_ENV_KEY = 'WEAVER_XIAOE_TOKEN_SCRIPT_PATH';
+const XIAOE_TOKEN_SCRIPT_PYTHON_ENV_KEY = 'WEAVER_XIAOE_TOKEN_SCRIPT_PYTHON';
+const XIAOE_TOKEN_SCRIPT_LEGACY_ENV_KEY = 'XIAOE_TOKEN_SCRIPT_PATH';
+const XIAOE_TOKEN_SCRIPT_PYTHON_LEGACY_ENV_KEY = 'XIAOE_TOKEN_SCRIPT_PYTHON';
 const XIAOE_TOKEN_SCRIPT_TIMEOUT_MS = 15_000;
 const XIAOE_CLIENT_TOKEN_TIMEOUT_MS = 15_000;
 export const XIAOE_SKILL_ETEAMID_API_PATH = '/spec-apps/api/app/rpachat/skill/extend/eteamId';
@@ -50,29 +62,38 @@ function hasEnvPrefix(env, prefix) {
     return Object.keys(env).some((key) => key === prefix || key.startsWith(`${prefix}_`));
 }
 export function hasXiaoEEnv(env = process.env) {
-    return hasEnvPrefix(env, 'XIAOE');
+    // `XIAOE_*` are the platform-injected variables; `WEAVER_XIAOE_*` are this
+    // CLI's own host-integration variables. Either one marks a XiaoE host.
+    return hasEnvPrefix(env, 'XIAOE') || hasEnvPrefix(env, 'WEAVER_XIAOE');
 }
 export function describeXiaoECredentialSource(source) {
-    if (source === 'xiaoeUserData/tokens.py') {
+    // Step 1 is the platform-injected credential (XIAOE_USER_TOKEN + XIAOE_DOMAIN):
+    // it is available in every sandbox run and needs no local desktop client.
+    if (source === XIAOE_USER_TOKEN_SOURCE) {
         return {
             credentialSourceStep: 1,
+            credentialSourceType: 'xiaoe_platform',
+            credentialSourceLabel: 'XiaoE platform user token',
+        };
+    }
+    if (source === 'xiaoeUserData/tokens.py') {
+        return {
+            credentialSourceStep: 2,
             credentialSourceType: 'token_script',
             credentialSourceLabel: 'xiaoeUserData/tokens.py',
         };
     }
-    if (source === XIAOE_CLIENT_SETTINGS_SOURCE || source === XIAOE_USER_TOKEN_SOURCE) {
+    if (source === XIAOE_CLIENT_SETTINGS_SOURCE) {
         return {
-            credentialSourceStep: 2,
+            credentialSourceStep: 3,
             credentialSourceType: 'xiaoe_client',
-            credentialSourceLabel: source === XIAOE_USER_TOKEN_SOURCE
-                ? 'XiaoE client user token'
-                : 'XiaoE client settings',
+            credentialSourceLabel: 'XiaoE client settings',
         };
     }
     return {
-        credentialSourceStep: 3,
+        credentialSourceStep: 4,
         credentialSourceType: 'xiaoe_env',
-        credentialSourceLabel: 'XIAOE_* environment variables',
+        credentialSourceLabel: 'WEAVER_XIAOE_* environment variables',
     };
 }
 function normalizeUrl(value) {
@@ -223,25 +244,27 @@ function listXiaoEUnifiedLoginCredentials(env = process.env) {
         if (raw)
             candidates.push(...parseXiaoEUnifiedLoginMap(raw, key));
     }
-    const singleDomain = envString(env, ...XIAOE_SINGLE_DOMAIN_ENV_KEYS);
-    const singleEteamsId = envString(env, ...XIAOE_SINGLE_ETEAMSID_ENV_KEYS);
-    if (singleDomain && singleEteamsId) {
-        candidates.push({
-            baseUrl: normalizeUrl(singleDomain),
-            eteamsId: singleEteamsId,
-            source: `${XIAOE_SINGLE_DOMAIN_ENV_KEYS[0]}+${XIAOE_SINGLE_ETEAMSID_ENV_KEYS[0]}`,
-        });
-    }
     return candidates;
 }
 export function resolveXiaoEUnifiedLoginCredential(baseUrl, env = process.env) {
     const candidates = listXiaoEUnifiedLoginCredentials(env);
     return candidates.find((candidate) => domainMatches(baseUrl, candidate.baseUrl)) || null;
 }
+function normalizeBaseUrlValue(value) {
+    const raw = normalizeUrl(value.trim());
+    if (!raw)
+        return '';
+    return /^https?:\/\//i.test(raw) ? raw : `https://${raw}`;
+}
 export function resolveXiaoEDefaultBaseUrl(env = process.env) {
     const explicitDefault = envString(env, ...XIAOE_DEFAULT_DOMAIN_ENV_KEYS);
     if (explicitDefault)
-        return normalizeUrl(explicitDefault);
+        return normalizeBaseUrlValue(explicitDefault);
+    // The injected XIAOE_DOMAIN (XIAOE_USER_TOKEN's target domain) is a fact
+    // about the current host and must win over the CLI's built-in fallback.
+    const singleDomain = envString(env, ...XIAOE_SINGLE_DOMAIN_ENV_KEYS);
+    if (singleDomain)
+        return normalizeBaseUrlValue(singleDomain);
     const firstCredential = listXiaoEUnifiedLoginCredentials(env)[0];
     if (firstCredential?.baseUrl)
         return normalizeUrl(firstCredential.baseUrl);
@@ -259,7 +282,7 @@ function uniqueStrings(values) {
     return result;
 }
 function xiaoETokenScriptCandidatePaths(env = process.env) {
-    const explicit = envString(env, XIAOE_TOKEN_SCRIPT_ENV_KEY);
+    const explicit = envString(env, XIAOE_TOKEN_SCRIPT_ENV_KEY, XIAOE_TOKEN_SCRIPT_LEGACY_ENV_KEY);
     if (explicit)
         return [explicit];
     if (process.platform === 'win32') {
@@ -281,14 +304,14 @@ function xiaoETokenScriptPath(env = process.env) {
     return xiaoETokenScriptCandidatePaths(env).find((path) => existsSync(path)) || '';
 }
 export function hasXiaoETokenScript(env = process.env) {
-    const explicit = envString(env, XIAOE_TOKEN_SCRIPT_ENV_KEY);
+    const explicit = envString(env, XIAOE_TOKEN_SCRIPT_ENV_KEY, XIAOE_TOKEN_SCRIPT_LEGACY_ENV_KEY);
     if (explicit)
         return existsSync(explicit);
     const scriptPath = xiaoETokenScriptPath(env);
     return Boolean(scriptPath && existsSync(scriptPath));
 }
 function xiaoETokenScriptPythonCandidates(env = process.env) {
-    const explicit = envString(env, XIAOE_TOKEN_SCRIPT_PYTHON_ENV_KEY);
+    const explicit = envString(env, XIAOE_TOKEN_SCRIPT_PYTHON_ENV_KEY, XIAOE_TOKEN_SCRIPT_PYTHON_LEGACY_ENV_KEY);
     if (explicit)
         return [explicit];
     return uniqueStrings(process.platform === 'win32'
@@ -418,14 +441,31 @@ export function findXiaoEClientSettingsFile(env = process.env) {
  * Mirror of the host `xiaoeUserData/tokens.py` credential chain, implemented in
  * Node so the CLI does not depend on a Python runtime that has `requests`.
  */
-export function readXiaoEClientCredential(env = process.env) {
+/**
+ * Platform-injected credential: XIAOE_USER_TOKEN (+ the XiaoE service address).
+ * This is the only source that works in a Linux sandbox with no desktop client
+ * and no Python runtime, so it is tried first.
+ */
+export function readXiaoEPlatformCredential(env = process.env) {
     const envToken = envString(env, 'XIAOE_USER_TOKEN');
-    if (envToken) {
-        const erpaUrl = normalizeUrl(envString(env, 'XIAOE_ERP', 'XIAOE_ERPA', 'XIAOE_ERP_URL', 'XIAOE_DOMAIN'));
-        if (/^https?:\/\//i.test(erpaUrl)) {
-            return { authToken: envToken, erpaUrl, source: XIAOE_USER_TOKEN_SOURCE };
-        }
-    }
+    if (!envToken)
+        return null;
+    const rawErpa = envString(env, 'WEAVER_XIAOE_ERP', 'WEAVER_XIAOE_ERPA', 'WEAVER_XIAOE_ERP_URL', 'XIAOE_ERP', 'XIAOE_ERPA', 'XIAOE_ERP_URL', 'XIAOE_DOMAIN');
+    // Hosts may inject the domain without a scheme (e.g. "weapp.example.cn");
+    // default to https instead of rejecting the credential outright.
+    const erpaUrl = normalizeBaseUrlValue(rawErpa);
+    if (!erpaUrl)
+        return null;
+    return { authToken: envToken, erpaUrl, source: XIAOE_USER_TOKEN_SOURCE };
+}
+export function hasXiaoEPlatformCredential(env = process.env) {
+    return Boolean(readXiaoEPlatformCredential(env));
+}
+/**
+ * Desktop XiaoE client session: the newest XiaoE/Robots/<id>/user_settings.json.
+ * Kept for local desktop hosts only; sandboxes must rely on the platform credential.
+ */
+export function readXiaoEClientCredential(env = process.env) {
     const settingsFile = findXiaoEClientSettingsFile(env);
     if (!settingsFile)
         return null;
@@ -442,7 +482,7 @@ export function readXiaoEClientCredential(env = process.env) {
     }
 }
 export function hasXiaoEClientCredential(env = process.env) {
-    return Boolean(envString(env, 'XIAOE_USER_TOKEN')) || Boolean(findXiaoEClientSettingsFile(env));
+    return Boolean(findXiaoEClientSettingsFile(env));
 }
 async function fetchXiaoEClientEteamId(credential, domain) {
     const controller = new AbortController();
@@ -468,13 +508,22 @@ async function fetchXiaoEClientEteamId(credential, domain) {
         clearTimeout(timer);
     }
 }
+async function resolveXiaoETokenCredential(credential, baseUrl) {
+    const targetBaseUrl = baseUrl || DEFAULT_E10_BASE_URL;
+    const payload = await fetchXiaoEClientEteamId(credential, targetBaseUrl);
+    return readXiaoECredentialRecord(payload, credential.source, targetBaseUrl);
+}
+async function resolveXiaoEPlatformCredential(baseUrl, env = process.env) {
+    const credential = readXiaoEPlatformCredential(env);
+    if (!credential)
+        return null;
+    return resolveXiaoETokenCredential(credential, baseUrl);
+}
 async function resolveXiaoEClientCredential(baseUrl, env = process.env) {
     const clientCredential = readXiaoEClientCredential(env);
     if (!clientCredential)
         return null;
-    const targetBaseUrl = baseUrl || DEFAULT_E10_BASE_URL;
-    const payload = await fetchXiaoEClientEteamId(clientCredential, targetBaseUrl);
-    return readXiaoECredentialRecord(payload, clientCredential.source, targetBaseUrl);
+    return resolveXiaoETokenCredential(clientCredential, baseUrl);
 }
 export function resolveXiaoEPreferredBaseUrl(options) {
     const env = options.env || process.env;
@@ -563,37 +612,53 @@ export async function tryXiaoEUnifiedLogin(options = {}) {
     if (!baseUrl && !mayUseTokenScript)
         return null;
     let credential = null;
-    if (mayUseTokenScript) {
+    // Step 1 — platform-injected credential (XIAOE_USER_TOKEN + XIAOE_DOMAIN).
+    // Works in sandboxes: no desktop client, no Python, no developer-machine paths.
+    if (hasXiaoEPlatformCredential(env)) {
+        options.logger?.info('Trying XiaoE platform credential from XIAOE_USER_TOKEN...');
+        try {
+            credential = await resolveXiaoEPlatformCredential(baseUrl || DEFAULT_E10_BASE_URL, env);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            options.logger?.warn('XiaoE platform credential failed. ' + message);
+        }
+        if (!credential) {
+            options.logger?.warn('XiaoE platform credential did not return usable ETEAMSID; will try xiaoeUserData/tokens.py next.');
+        }
+    }
+    // Step 2 — host tokens.py (desktop host only; Linux sandboxes have no such path).
+    if (!credential && mayUseTokenScript) {
         const tokenScriptPath = xiaoETokenScriptPath(env);
         if (!tokenScriptPath) {
-            options.logger?.warn('XiaoE token script not found. Expected xiaoeUserData/tokens.py; will try the built-in XiaoE client credential next.');
+            options.logger?.warn('XiaoE token script not found. Expected xiaoeUserData/tokens.py; will try the local XiaoE client session next.');
         }
         else {
             options.logger?.info('Trying XiaoE token script credential...');
             try {
-                credential = await resolveXiaoETokenScriptCredential(explicitBaseUrl || DEFAULT_E10_BASE_URL, env);
+                credential = await resolveXiaoETokenScriptCredential(baseUrl || DEFAULT_E10_BASE_URL, env);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 options.logger?.warn('XiaoE token script failed. ' + message);
             }
             if (!credential) {
-                options.logger?.warn('XiaoE token script did not return usable ETEAMSID; will try the built-in XiaoE client credential next.');
+                options.logger?.warn('XiaoE token script did not return usable ETEAMSID; will try the local XiaoE client session next.');
             }
         }
-        // Built-in Node equivalent of tokens.py: reads the local XiaoE client
-        // session and exchanges it for an eteamId, so a Python runtime without
-        // `requests` no longer blocks unified login.
+        // Step 3 — built-in Node equivalent of tokens.py: reads the local XiaoE
+        // client session and exchanges it for an eteamId, so a Python runtime
+        // without `requests` no longer blocks unified login.
         if (!credential && hasXiaoEClientCredential(env)) {
             try {
-                credential = await resolveXiaoEClientCredential(explicitBaseUrl || DEFAULT_E10_BASE_URL, env);
+                credential = await resolveXiaoEClientCredential(baseUrl || DEFAULT_E10_BASE_URL, env);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 options.logger?.warn('Built-in XiaoE client credential failed. ' + message);
             }
             if (!credential) {
-                options.logger?.warn('Built-in XiaoE client credential did not return usable ETEAMSID; will try XIAOE_* credentials next.');
+                options.logger?.warn('Built-in XiaoE client credential did not return usable ETEAMSID; will try WEAVER_XIAOE_* credentials next.');
             }
         }
     }

package/dist/internal/e10/request-runtime.js

@@ -131,6 +131,11 @@ export class E10RequestRuntime {
     composeHeaders(request, trustedHeaders = {}) {
         return {
             Accept: 'application/json, text/plain, */*',
+            // E10 各端（含 eBuilder 表单运行态）依赖这两个头；缺失时 EB formdata 接口会直接返回
+            // 业务失败（CLI 侧表现为 business_error「泛微接口返回业务失败」，且响应无可读 message，
+            // 极易被误判为「EB 未配置/环境不对」）。standalone skill 的脚本一直带这两个头。
+            langType: 'zh_CN',
+            timeZoneOffset: String(new Date().getTimezoneOffset()),
             ...request.headers,
             Cookie: this.session.cookieHeader(),
             eteamsid: this.session.eteamsId,

package/dist/internal/skills/install.js

@@ -1,13 +1,153 @@
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { basename, relative, resolve, sep } from 'node:path';
+import { basename, posix, relative, resolve, sep, win32 } from 'node:path';
 const SKILL_PREFIX = 'weaver-e10-';
 const LEGACY_SKILL_PREFIX = 'weaver-work-cli-';
 const SHARED_SKILL_NAME = 'weaver-e10-shared';
-const LEGACY_SHARED_SKILL_NAME = 'weaver-work-cli-shared';
-export function defaultCodexSkillsRoot(env = process.env) {
-    const codexHome = env.CODEX_HOME || resolve(homedir(), '.codex');
-    return resolve(codexHome, 'skills');
+function envValue(env, name) {
+    const direct = env[name];
+    if (typeof direct === 'string' && direct.trim())
+        return direct.trim();
+    const expected = name.toUpperCase();
+    for (const [key, value] of Object.entries(env)) {
+        if (key.toUpperCase() === expected && typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return '';
+}
+function hasEnvFamily(env, prefix, ignoredNames = []) {
+    const expected = `${prefix.toUpperCase()}_`;
+    const ignored = new Set(ignoredNames.map((name) => name.toUpperCase()));
+    return Object.entries(env).some(([key, value]) => (key.toUpperCase().startsWith(expected)
+        && !ignored.has(key.toUpperCase())
+        && typeof value === 'string'
+        && Boolean(value.trim())));
+}
+function normalizedAgentType(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'codex-cli')
+        return 'codex';
+    if (normalized === 'work-buddy')
+        return 'workbuddy';
+    return normalized || 'unknown';
+}
+function isKnownSkillsHost(host) {
+    return host === 'codex' || host === 'workbuddy';
+}
+export function resolveSkillsTargetPath(value, options = {}) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error('skills target path must not be empty');
+    const platform = options.platform ?? process.platform;
+    const pathApi = platform === 'win32' ? win32 : posix;
+    const userHome = options.homeDir ?? homedir();
+    if (trimmed === '~')
+        return pathApi.resolve(userHome);
+    if (/^~[\\/]/u.test(trimmed)) {
+        const segments = trimmed.slice(2).split(/[\\/]+/u).filter(Boolean);
+        return pathApi.resolve(userHome, ...segments);
+    }
+    return pathApi.resolve(trimmed);
+}
+function hostSkillsRoot(host, env, options) {
+    const platform = options.platform ?? process.platform;
+    const pathApi = platform === 'win32' ? win32 : posix;
+    const userHome = options.homeDir ?? homedir();
+    const envName = host === 'codex' ? 'CODEX_HOME' : 'WORKBUDDY_HOME';
+    const configuredHome = envValue(env, envName);
+    const hostHome = configuredHome
+        ? resolveSkillsTargetPath(configuredHome, options)
+        : pathApi.resolve(userHome, host === 'codex' ? '.codex' : '.workbuddy');
+    return pathApi.resolve(hostHome, 'skills');
+}
+/**
+ * 根据当前进程的环境信号探测宿主。目录存在只代表曾安装过某个宿主，
+ * 不能证明当前命令由该宿主调用，因此不在这里参与判定。
+ *
+ * WEAVER_AGENT_TYPE 是跨宿主的显式信号；没有它时，当前进程的运行时变量优先于
+ * 可能被用户长期配置的 *_HOME。两个宿主仍然同时有信号时保持 unknown。
+ */
+export function detectSkillsHost(env = process.env) {
+    const explicitAgent = envValue(env, 'WEAVER_AGENT_TYPE');
+    if (explicitAgent)
+        return normalizedAgentType(explicitAgent);
+    const hasCodexRuntime = hasEnvFamily(env, 'CODEX', ['CODEX_HOME']);
+    const hasWorkBuddyRuntime = hasEnvFamily(env, 'WORKBUDDY', ['WORKBUDDY_HOME']);
+    if (hasCodexRuntime !== hasWorkBuddyRuntime)
+        return hasCodexRuntime ? 'codex' : 'workbuddy';
+    const hasCodexHome = Boolean(envValue(env, 'CODEX_HOME'));
+    const hasWorkBuddyHome = Boolean(envValue(env, 'WORKBUDDY_HOME'));
+    if (hasCodexHome !== hasWorkBuddyHome)
+        return hasCodexHome ? 'codex' : 'workbuddy';
+    return 'unknown';
+}
+export function resolveSkillsRoot(env = process.env, options = {}) {
+    const configuredRoot = envValue(env, 'WEAVER_SKILLS_ROOT');
+    if (configuredRoot) {
+        const explicitAgent = envValue(env, 'WEAVER_AGENT_TYPE');
+        const detectedHost = explicitAgent ? normalizedAgentType(explicitAgent) : detectSkillsHost(env);
+        return {
+            root: resolveSkillsTargetPath(configuredRoot, options),
+            host: detectedHost === 'unknown' ? 'explicit' : detectedHost,
+            source: 'explicit-env',
+            environmentVariable: 'WEAVER_SKILLS_ROOT',
+        };
+    }
+    const host = detectSkillsHost(env);
+    if (isKnownSkillsHost(host)) {
+        const environmentVariable = envValue(env, host === 'codex' ? 'CODEX_HOME' : 'WORKBUDDY_HOME')
+            ? (host === 'codex' ? 'CODEX_HOME' : 'WORKBUDDY_HOME')
+            : undefined;
+        return {
+            root: hostSkillsRoot(host, env, options),
+            host,
+            source: environmentVariable ? 'explicit-env' : 'host-detected',
+            ...(environmentVariable ? { environmentVariable } : {}),
+        };
+    }
+    const codexRoot = hostSkillsRoot('codex', env, options);
+    const workBuddyRoot = hostSkillsRoot('workbuddy', env, options);
+    const pathExists = options.pathExists ?? existsSync;
+    if (host === 'unknown') {
+        const existing = [
+            { root: codexRoot, host: 'codex' },
+            { root: workBuddyRoot, host: 'workbuddy' },
+        ].filter((candidate) => pathExists(candidate.root));
+        if (existing.length === 1) {
+            return { ...existing[0], source: 'filesystem-detected' };
+        }
+        return {
+            root: codexRoot,
+            host,
+            source: 'fallback',
+            requiresExplicitTarget: true,
+            reason: existing.length > 1 ? 'ambiguous-host' : 'unknown-host',
+            candidates: [codexRoot, workBuddyRoot],
+        };
+    }
+    return {
+        root: codexRoot,
+        host,
+        source: 'fallback',
+        requiresExplicitTarget: true,
+        reason: 'unsupported-host',
+        candidates: [codexRoot, workBuddyRoot],
+    };
+}
+export function defaultCodexSkillsRoot(env = process.env, options = {}) {
+    return hostSkillsRoot('codex', env, options);
+}
+export function unresolvedSkillsRootMessage(resolution, targetOption = '--target-dir') {
+    const reason = resolution.reason === 'ambiguous-host'
+        ? '检测到多个可能的宿主目录'
+        : resolution.reason === 'unsupported-host'
+            ? `检测到当前智能体 ${resolution.host}，但不知道它的 skills 目录`
+            : '未检测到当前智能体及其 skills 目录';
+    return [
+        `${reason}，为避免装错位置，本次未执行安装。`,
+        `请使用 ${targetOption} <当前智能体的 skills 根目录>，或设置 WEAVER_SKILLS_ROOT 后重试。`,
+        ...(resolution.candidates?.length ? [`已知候选目录：${resolution.candidates.join('，')}`] : []),
+    ].join('\n');
 }
 export function normalizePackagedSkillName(value) {
     const trimmed = value.trim();
@@ -65,7 +205,7 @@ export function installPackagedSkills(sourceRoot, targetRoot, requested = 'all')
     const skillNames = resolvePackagedSkillNames(resolvedSourceRoot, requested);
     const productContent = productMetadataContent(resolvedSourceRoot);
     mkdirSync(resolvedTargetRoot, { recursive: true, mode: 0o700 });
-    const installed = skillNames.flatMap((name) => {
+    const installed = skillNames.map((name) => {
         const source = resolveInside(resolvedSourceRoot, name);
         const target = resolve(resolvedTargetRoot, basename(name));
         statSync(resolve(source, 'SKILL.md'));
@@ -81,23 +221,7 @@ export function installPackagedSkills(sourceRoot, targetRoot, requested = 'all')
             target,
             files: countFiles(target),
         };
-        if (name !== SHARED_SKILL_NAME)
-            return [current];
-        const legacyTarget = resolve(resolvedTargetRoot, LEGACY_SHARED_SKILL_NAME);
-        rmSync(legacyTarget, { recursive: true, force: true });
-        cpSync(source, legacyTarget, {
-            recursive: true,
-            force: true,
-            filter: (entry) => shouldCopy(entry, source, Boolean(productContent)),
-        });
-        rewriteSkillName(resolve(legacyTarget, 'SKILL.md'), LEGACY_SHARED_SKILL_NAME);
-        writeProductMetadata(legacyTarget, productContent);
-        return [current, {
-                name: LEGACY_SHARED_SKILL_NAME,
-                source,
-                target: legacyTarget,
-                files: countFiles(legacyTarget),
-            }];
+        return current;
     });
     return {
         sourceRoot: resolvedSourceRoot,
@@ -106,10 +230,6 @@ export function installPackagedSkills(sourceRoot, targetRoot, requested = 'all')
         installed,
     };
 }
-function rewriteSkillName(skillPath, name) {
-    const content = readFileSync(skillPath, 'utf8');
-    writeFileSync(skillPath, content.replace(/^name:\s*weaver-e10-shared\s*$/mu, `name: ${name}`), 'utf8');
-}
 function productMetadataContent(sourceRoot) {
     const productPath = productMetadataPath(sourceRoot);
     if (!existsSync(productPath))

package/dist/internal/skills/reader.js

@@ -16,13 +16,14 @@ export class SkillReader {
     }
     listPath(target) {
         const { name, subpath } = splitTarget(target);
-        const skillRoot = this.ensureSkill(name);
+        const skill = this.resolveSkill(name);
+        const skillRoot = skill.root;
         const dir = this.resolveInside(skillRoot, subpath);
         const info = statSync(dir);
         if (!info.isDirectory()) {
             throw new Error(`path is a file, not a directory: ${target}`);
         }
-        const listed = cleanOutputPath(name, subpath);
+        const listed = cleanOutputPath(skill.name, subpath);
         const entries = readdirSync(dir, { withFileTypes: true })
             .map((entry) => ({
             path: cleanOutputPath(listed, entry.name),
@@ -33,16 +34,15 @@ export class SkillReader {
     }
     read(target, pathArg = '') {
         const split = splitTarget(target);
-        const name = split.name;
+        const skill = this.resolveSkill(split.name);
         const subpath = pathArg || split.subpath || 'SKILL.md';
-        const skillRoot = this.ensureSkill(name);
-        const file = this.resolveInside(skillRoot, subpath);
+        const file = this.resolveInside(skill.root, subpath);
         const info = statSync(file);
         if (info.isDirectory()) {
-            throw new Error(`path is a directory, not a file: ${cleanOutputPath(name, subpath)}`);
+            throw new Error(`path is a directory, not a file: ${cleanOutputPath(skill.name, subpath)}`);
         }
         return {
-            skill: name,
+            skill: skill.name,
             path: cleanOutputPath(subpath),
             content: readFileSync(file, 'utf-8'),
         };
@@ -64,6 +64,9 @@ export class SkillReader {
         }
     }
     ensureSkill(name) {
+        return this.resolveSkill(name).root;
+    }
+    resolveSkill(name) {
         if (!name || name.includes('/') || name.includes('\\') || name === '.' || name === '..') {
             throw new Error(`unknown skill: ${name}`);
         }
@@ -73,14 +76,14 @@ export class SkillReader {
             if (normalized !== name) {
                 const normalizedRoot = this.resolveInside(this.root, normalized);
                 if (existsDirectoryWithSkill(normalizedRoot))
-                    return normalizedRoot;
+                    return { name: normalized, root: normalizedRoot };
             }
         }
         const info = statSync(skillRoot);
         if (!info.isDirectory())
             throw new Error(`unknown skill: ${name}`);
         statSync(resolve(skillRoot, 'SKILL.md'));
-        return skillRoot;
+        return { name, root: skillRoot };
     }
     resolveInside(base, subpath = '') {
         const cleaned = subpath.replace(/\\/g, '/');

package/dist/shortcuts/blog/continuation.js

@@ -0,0 +1,74 @@
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { blogValidationError } from './errors.js';
+function stateRoot(ctx) {
+    const configured = ctx?.config?.path();
+    if (configured)
+        return resolve(configured, '..');
+    return process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli');
+}
+async function loadKey(ctx) {
+    const keysDir = resolve(stateRoot(ctx), 'keys');
+    const filename = resolve(keysDir, 'blog-continuation.key');
+    await mkdir(keysDir, { recursive: true, mode: 0o700 });
+    if (existsSync(filename))
+        return readFile(filename);
+    const key = randomBytes(32);
+    try {
+        await writeFile(filename, key, { flag: 'wx', mode: 0o600 });
+        if (process.platform !== 'win32')
+            await chmod(filename, 0o600).catch(() => undefined);
+        return key;
+    }
+    catch {
+        return readFile(filename);
+    }
+}
+function encode(value) {
+    return Buffer.from(JSON.stringify(value)).toString('base64url');
+}
+function signature(payload, key) {
+    return createHmac('sha256', key).update(payload).digest('base64url');
+}
+/**
+ * prepare -> apply 确认链的 signed continuation（HMAC-SHA256，默认 10 分钟有效）。
+ * 密钥持久化在 `<stateRoot>/keys/blog-continuation.key`，保证多次 CLI 进程调用可校验。
+ */
+export function createBlogContinuationSigner(ctx) {
+    return {
+        async issue(payload, ttlMs = 10 * 60_000) {
+            const issuedAt = Date.now();
+            const body = encode({ ...payload, issuedAt, expiresAt: issuedAt + ttlMs });
+            const sig = signature(body, await loadKey(ctx));
+            return `${body}.${sig}`;
+        },
+        async verify(token, expectedOperation) {
+            if (typeof token !== 'string' || !token.includes('.')) {
+                throw blogValidationError('continuation_invalid', 'continuation 无效');
+            }
+            const [body, provided] = token.split('.');
+            const expected = signature(body, await loadKey(ctx));
+            const valid = provided.length === expected.length
+                && timingSafeEqual(Buffer.from(provided), Buffer.from(expected));
+            if (!valid)
+                throw blogValidationError('continuation_invalid', 'continuation 签名校验失败');
+            let value;
+            try {
+                value = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+            }
+            catch {
+                throw blogValidationError('continuation_invalid', 'continuation 内容无法解析');
+            }
+            if (value.operation !== expectedOperation) {
+                throw blogValidationError('continuation_mismatch', 'continuation 不属于当前操作');
+            }
+            if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+                throw blogValidationError('continuation_expired', 'continuation 已过期');
+            }
+            return value;
+        },
+    };
+}