weaver-work-cli 0.1.8 → 0.1.21

package/dist/internal/e10/context.js

@@ -1,16 +1,19 @@
 import { CliError, ExitCode } from '../../core/errors.js';
-import { E10AuthSession } from './auth/session.js';
-import { hasXiaoEEnv, hasXiaoETokenScript, tryXiaoEUnifiedLogin } from './auth/xiaoe.js';
+import { E10AuthSession, getActiveProfile, readProfileConfig } from './auth/session.js';
+import { createXiaoEUnifiedLoginUnavailableError, hasXiaoEEnv, hasXiaoETokenScript, resolveXiaoEPreferredBaseUrl, shouldUseXiaoEBrowserFallback, tryXiaoEUnifiedLogin, } from './auth/xiaoe.js';
 import { E10ApiClient } from './client.js';
 function shouldPreferXiaoEUnifiedLogin(options, env) {
     return !options.auth && !options.profile && (hasXiaoEEnv(env) || hasXiaoETokenScript(env));
 }
-export async function getE10Session(ctx) {
+export async function getE10Session(ctx, load = {}) {
     const options = ctx.getGlobalOptions();
     if (shouldPreferXiaoEUnifiedLogin(options, ctx.env)) {
+        const profileBaseUrl = readProfileConfig(getActiveProfile()).baseUrl;
         const xiaoELogin = await tryXiaoEUnifiedLogin({
             env: ctx.env,
             baseUrl: options.baseUrl,
+            profileBaseUrl,
+            allowBundledEnvScript: true,
             allowTokenScript: true,
             logger: ctx.logger,
         });
@@ -18,11 +21,20 @@ export async function getE10Session(ctx) {
             return xiaoELogin.session;
         return null;
     }
-    return E10AuthSession.fromOptions(options, ctx.cwd);
+    return E10AuthSession.fromOptions(options, ctx.cwd, load);
 }
-export async function requireE10Session(ctx) {
-    const session = await getE10Session(ctx);
+export async function requireE10Session(ctx, load = {}) {
+    const session = await getE10Session(ctx, load);
     if (!session) {
+        const options = ctx.getGlobalOptions();
+        if ((hasXiaoEEnv(ctx.env) || hasXiaoETokenScript(ctx.env)) && !shouldUseXiaoEBrowserFallback()) {
+            const baseUrl = resolveXiaoEPreferredBaseUrl({
+                explicitBaseUrl: options.baseUrl,
+                profileBaseUrl: readProfileConfig(getActiveProfile()).baseUrl,
+                env: ctx.env,
+            });
+            throw createXiaoEUnifiedLoginUnavailableError(baseUrl);
+        }
         throw new CliError('E10 auth not found. In XiaoE, run weaver-work-cli auth xiaoe first; if unified login is unavailable, ask the user for the E10 login domain (base URL), then run: weaver-work-cli auth login --base-url <url> --agent_type <agent_type>.', ExitCode.AuthError);
     }
     return session;

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

@@ -28,10 +28,12 @@ export class E10RequestRuntime {
     session;
     interceptors;
     fetchFn;
+    attachSessionTicket;
     constructor(ctx, session, dependencies = {}) {
         this.ctx = ctx;
         this.session = session;
         this.fetchFn = dependencies.fetch || globalThis.fetch;
+        this.attachSessionTicket = dependencies.attachSessionTicket === true;
         this.interceptors = [
             ...(this.ctx.hooks?.getE10RequestInterceptors?.() || []),
             ...(dependencies.interceptors || []),
@@ -131,8 +133,13 @@ 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(),
+            Cookie: this.attachSessionTicket ? this.session.cookieHeaderWithSessionTicket() : this.session.cookieHeader(),
             eteamsid: this.session.eteamsId,
             'User-Agent': this.session.uaHeader(),
             Origin: this.session.getBaseUrl(),

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;
+        },
+    };
+}

package/dist/shortcuts/blog/errors.js

@@ -0,0 +1,60 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+/** 日报模块结构化错误：type/subtype 驱动 Agent 决策，exitCode 决定进程退出码。 */
+export class BlogCliError extends CliError {
+    type;
+    subtype;
+    code;
+    retryable;
+    stage;
+    details;
+    partialData;
+    constructor(type, subtype, message, options = {}) {
+        super(message, options.exitCode ?? ExitCode.InternalError);
+        this.name = 'BlogCliError';
+        this.type = type;
+        this.subtype = subtype;
+        this.code = options.code;
+        this.retryable = options.retryable ?? false;
+        this.stage = options.stage;
+        this.details = options.details;
+        this.partialData = options.partialData;
+    }
+}
+export function blogValidationError(subtype, message, details) {
+    return new BlogCliError('validation', subtype, message, {
+        details,
+        exitCode: ExitCode.UsageError,
+    });
+}
+export function blogAuthError(subtype, message, details) {
+    return new BlogCliError('authentication', subtype, message, {
+        details,
+        exitCode: ExitCode.AuthError,
+    });
+}
+export function blogNetworkError(subtype, message, options = {}) {
+    return new BlogCliError('network', subtype, message, {
+        ...options,
+        retryable: options.retryable ?? true,
+        exitCode: ExitCode.NetworkError,
+    });
+}
+export function blogConfirmationError(action, details) {
+    return new BlogCliError('confirmation', 'required', '该操作需要明确确认', {
+        details: { action, ...details },
+        exitCode: ExitCode.ConfirmationRequired,
+    });
+}
+export function blogPartialError(message, partialData, details) {
+    return new BlogCliError('partial', 'write_uncertain', message, {
+        details,
+        partialData,
+        exitCode: ExitCode.Partial,
+    });
+}
+export function isBlogNetworkError(error) {
+    return Boolean(error
+        && typeof error === 'object'
+        && 'type' in error
+        && error.type === 'network');
+}

package/dist/shortcuts/blog/host.js

@@ -0,0 +1,175 @@
+import { ExitCode } from '../../core/errors.js';
+import { requireE10Session } from '../../internal/e10/context.js';
+import { getActiveProfile } from '../../internal/e10/auth/session.js';
+import { createE10RequestRuntime } from '../../internal/e10/request-runtime.js';
+import { BlogCliError, blogAuthError, blogNetworkError, blogValidationError, } from './errors.js';
+const MAX_EXPORT_BYTES = 50 * 1024 * 1024;
+/** E10 登录失效在业务响应体里的 code（实测 -2 既可能是数字也可能是字符串） */
+const SESSION_EXPIRED_CODES = new Set(['-2', -2]);
+function assertPath(requestPath) {
+    if (typeof requestPath !== 'string' || !requestPath.startsWith('/') || requestPath.startsWith('//')) {
+        throw blogValidationError('path_invalid', '请求路径必须是相对绝对路径');
+    }
+    if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes('/../')) {
+        throw blogValidationError('path_invalid', '请求路径不允许跨域或路径逃逸');
+    }
+    if (!requestPath.startsWith('/api/')) {
+        throw blogValidationError('path_not_allowed', '日报模块只能调用 /api/ 路径');
+    }
+}
+/** 业务码位置在三种响应形态间漂移：顶层 code / res_base.ret / data.res_base.ret */
+function responseCode(value) {
+    return value?.code ?? value?.res_base?.ret ?? value?.data?.res_base?.ret;
+}
+function responseMessage(value) {
+    if (typeof value?.msg === 'string')
+        return value.msg;
+    if (typeof value?.message === 'string')
+        return value.message;
+    if (typeof value?.error === 'string')
+        return value.error;
+    return '泛微接口返回业务失败';
+}
+function isSessionExpired(value) {
+    const code = responseCode(value);
+    return code !== undefined && SESSION_EXPIRED_CODES.has(code);
+}
+/** 业务失败判定：fail === true，或 code 存在且不在 {0, 200} 与登录失效码之内 */
+function isBusinessFailure(value) {
+    if (value?.fail === true)
+        return true;
+    const code = responseCode(value);
+    if (code === undefined || code === null)
+        return false;
+    return !SESSION_EXPIRED_CODES.has(code)
+        && code !== 0 && code !== '0' && code !== 200 && code !== '200';
+}
+function inferProfile(ctx) {
+    const options = ctx.getGlobalOptions();
+    return options.profile || getActiveProfile();
+}
+export function createBlogHost(ctx, dependencies = {}) {
+    let e10Session = null;
+    let sessionContext = null;
+    const requireSession = dependencies.requireSession || requireE10Session;
+    async function ensureSession() {
+        if (!e10Session) {
+            e10Session = await requireSession(ctx);
+            sessionContext = {
+                baseUrl: e10Session.getBaseUrl(),
+                profile: inferProfile(ctx),
+                userId: e10Session.userId,
+            };
+        }
+        return e10Session;
+    }
+    async function getSession() {
+        await ensureSession();
+        return sessionContext;
+    }
+    async function runtime() {
+        return createE10RequestRuntime(ctx, await ensureSession(), {
+            interceptors: dependencies.interceptors,
+            fetch: dependencies.fetch,
+        });
+    }
+    function assertSession(value) {
+        if (isSessionExpired(value)) {
+            throw blogAuthError('session_expired', 'E10 登录态已失效，请先向用户确认 E10 登录域名，再运行 weaver-work-cli auth login --base-url <域名> --agent_type <当前智能体名称> 完成登录');
+        }
+    }
+    async function blogRequest(request) {
+        const { method = 'POST', path, query, body, operation, timeoutMs = 30_000 } = request;
+        assertPath(path);
+        const response = await (await runtime()).requestJson({
+            module: 'blog',
+            operation,
+            method,
+            path,
+            query: query,
+            body,
+            timeoutMs,
+        });
+        if (response.status === 401 || response.status === 302) {
+            throw blogAuthError('session_expired', 'E10 登录态已失效，请先向用户确认 E10 登录域名，再运行 weaver-work-cli auth login --base-url <域名> --agent_type <当前智能体名称> 完成登录', { httpStatus: response.status });
+        }
+        if (response.parseError) {
+            if (response.status < 200 || response.status >= 300) {
+                throw new BlogCliError('api', 'http_error', `泛微接口 HTTP ${response.status}`, {
+                    code: response.status,
+                    details: { status: response.status },
+                    exitCode: ExitCode.GeneralError,
+                });
+            }
+            throw blogNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });
+        }
+        if (response.status < 200 || response.status >= 300) {
+            throw new BlogCliError('api', 'http_error', `泛微接口 HTTP ${response.status}`, {
+                code: response.status,
+                details: { status: response.status, message: responseMessage(response.value) },
+                exitCode: ExitCode.GeneralError,
+            });
+        }
+        assertSession(response.value);
+        if (isBusinessFailure(response.value)) {
+            throw new BlogCliError('api', 'business_error', responseMessage(response.value), {
+                code: String(responseCode(response.value)),
+                details: { response: response.value },
+                exitCode: ExitCode.GeneralError,
+            });
+        }
+        return response.value;
+    }
+    async function blogBinaryRequest(request) {
+        const { method = 'POST', path, query, body, operation, timeoutMs = 60_000 } = request;
+        assertPath(path);
+        const response = await (await runtime()).requestBinary({
+            module: 'blog',
+            operation,
+            method,
+            path,
+            query: query,
+            body,
+            timeoutMs,
+            headers: { Accept: 'application/octet-stream, */*' },
+        });
+        if (response.status === 401 || response.status === 302) {
+            throw blogAuthError('session_expired', 'E10 登录态已失效，请先向用户确认 E10 登录域名，再运行 weaver-work-cli auth login --base-url <域名> --agent_type <当前智能体名称> 完成登录', { httpStatus: response.status });
+        }
+        const contentType = response.contentType;
+        const declaredLength = Number(response.headers.get('content-length'));
+        if (Number.isFinite(declaredLength) && declaredLength > MAX_EXPORT_BYTES) {
+            throw blogNetworkError('response_too_large', `导出文件超过 ${MAX_EXPORT_BYTES} 字节限制`, { retryable: false });
+        }
+        const content = response.content;
+        const looksLikeJson = /^[\s\r\n]*[[{]/.test(content.subarray(0, 64).toString('utf8'));
+        // 导出接口出错时返回 JSON（登录失效 / 业务失败），需在落盘前识别
+        if (response.status < 200 || response.status >= 300 || contentType.includes('json') || looksLikeJson) {
+            let value = {};
+            try {
+                value = JSON.parse(content.toString('utf8'));
+            }
+            catch {
+                value = {};
+            }
+            assertSession(value);
+            throw new BlogCliError('api', 'export_failed', responseMessage(value) || `导出失败（HTTP ${response.status}）`, {
+                code: response.status,
+                details: { status: response.status, preview: content.subarray(0, 500).toString('utf8') },
+                exitCode: ExitCode.GeneralError,
+            });
+        }
+        if (!content.length) {
+            throw blogNetworkError('protocol', '导出接口返回空文件', { retryable: false });
+        }
+        if (content.length > MAX_EXPORT_BYTES) {
+            throw blogNetworkError('response_too_large', `导出文件超过 ${MAX_EXPORT_BYTES} 字节限制`, { retryable: false });
+        }
+        return { content, contentType };
+    }
+    return {
+        blogRequest,
+        blogBinaryRequest,
+        getSession,
+    };
+}