weaver-e9-assistant-cli 1.0.0

package/dist/client.js

@@ -0,0 +1,199 @@
+import { endpointFor } from './config.js';
+import { AuthTokenSession } from './auth-token.js';
+import { sleep } from './util.js';
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+/**
+ * 响应是否疑似鉴权失效（需重试续期）。
+ * 认：HTTP 401/403；顶层 msg 含「登录信息超时/登录超时/无效认证/认证失败/未授权/E9AIAgent」。
+ * **不扫整个 body**——微博正文可合法含这些关键词（如日报记录本次认证改造就含"E9AIAgent无效认证"），
+ *   整体正则会把 200 成功响应当成鉴权失效误触发重试/弹浏览器。
+ * **不认空 body**——E9 有不少接口正常返回 200+空 body（成功但无内容），误判会多弹浏览器并把成功报成失败。
+ * 不认：业务层 status:false（如「记录不存在」），避免误触发重试。
+ */
+function looksAuthFailed(er) {
+    if (!er)
+        return false; // fetch 抛错（er 为 null）走外层 er-null 分支
+    if (er.status === 401 || er.status === 403)
+        return true;
+    const j = er.json;
+    if (j && typeof j === 'object') {
+        const msg = String(j.msg ?? '');
+        if (/登录信息超时|登录超时|无效认证|认证失败|未授权|E9AIAgent/i.test(msg))
+            return true;
+    }
+    return false;
+}
+/** 把 fetch 响应包成 E9Response。 */
+async function toE9Response(res) {
+    const text = await res.text();
+    let json = null;
+    if (text) {
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            json = null;
+        }
+    }
+    return { status: res.status, ok: res.ok, text, json };
+}
+/** 拼 baseUrl+path+query，query 非空时追加（path 已含 ? 则用 &）。 */
+function buildUrl(baseUrl, path, query) {
+    let url = baseUrl + path;
+    if (query && Object.keys(query).length > 0) {
+        const qs = new URLSearchParams();
+        for (const [k, v] of Object.entries(query))
+            qs.append(k, v);
+        url += (path.includes('?') ? '&' : '?') + qs.toString();
+    }
+    return url;
+}
+/**
+ * 底层裸请求：按显式 opts 构造 header 集合发请求，无鉴权/重试逻辑。
+ * 保留供 dry-run 路径或外部直接调用；E9Api 内部自带鉴权与重试。
+ */
+export async function e9Request(ep, opts) {
+    const url = buildUrl(ep.baseUrl, opts.path, opts.query);
+    const headers = {
+        Referer: ep.baseUrl + '/wui/index.html',
+        'X-Requested-With': 'XMLHttpRequest',
+        'User-Agent': UA,
+        Accept: 'application/json, text/plain, */*',
+        Cookie: ep.cookie,
+    };
+    let bodyStr;
+    if (opts.method === 'POST') {
+        headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8';
+        const form = new URLSearchParams();
+        for (const [k, v] of Object.entries(opts.body ?? {}))
+            form.append(k, v);
+        bodyStr = form.toString();
+    }
+    const timeoutMs = Number(process.env.E9_TIMEOUT_MS ?? '20000');
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let res;
+    try {
+        res = await fetch(url, { method: opts.method, headers, body: bodyStr, signal: controller.signal });
+    }
+    catch (e) {
+        if (controller.signal.aborted) {
+            throw new Error(`请求超时（${timeoutMs}ms）：${opts.method} ${url}。服务器可能故障或网络不通。可用 E9_TIMEOUT_MS 调大。`);
+        }
+        throw new Error(`请求失败：${opts.method} ${url} — ${e.message}。服务器可能不可达或网络不通。`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    return toE9Response(res);
+}
+/**
+ * E9Api：双头鉴权 + 失效重试（对标 e9-cli lib/api.js 的 E9Api）。
+ *   有 token（ensureValid true）→ aiAgentToken 头（不带 cookie/X-Requested-With/Accept:application/json）
+ *   无 token / noToken → cookie 头（http:// 才带 X-Requested-With）
+ */
+export class E9Api {
+    cfg;
+    baseUrl;
+    tokenSession;
+    constructor(cfg, tokenSession) {
+        this.cfg = cfg;
+        this.baseUrl = endpointFor(cfg).baseUrl.replace(/\/+$/, '');
+        this.tokenSession = tokenSession;
+    }
+    /** 取当前 cookie（实时读 config，反映 saveCookieToProfile 的回写）。 */
+    get cookie() {
+        return endpointFor(this.cfg).cookie;
+    }
+    async getHeaders(contentType, { forceCookie = false } = {}) {
+        const h = {
+            Accept: '*/*',
+            'Accept-Language': 'zh-CN,zh;q=0.9',
+            'Content-Type': contentType ?? 'application/x-www-form-urlencoded; charset=utf-8',
+        };
+        if (!forceCookie && this.tokenSession && (await this.tokenSession.ensureValid()) && this.tokenSession.token) {
+            // token 路径：仅 aiAgentToken + Content-Type（不带 cookie/X-Requested-With/Accept:application/json）
+            h['aiAgentToken'] = this.tokenSession.token;
+        }
+        else {
+            // cookie 回退路径：复刻原 e9Request 的头集合（Referer/UA/X-Requested-With），保证 E9 后端识别为 WUI 内部调用
+            const cookie = this.cookie;
+            if (cookie) {
+                h['Cookie'] = cookie;
+                h['Referer'] = this.baseUrl + '/wui/index.html';
+                h['User-Agent'] = UA;
+                h['Accept'] = 'application/json, text/plain, */*';
+                if (this.baseUrl.startsWith('http://'))
+                    h['X-Requested-With'] = 'XMLHttpRequest';
+            }
+        }
+        return h;
+    }
+    /** 单次请求（带 getHeaders），返回 E9Response 或 null（fetch 抛错）。opts.forceCookie=true 强制走 cookie 头（不调 ensureValid）。 */
+    async fetchOnce(method, url, bodyStr, timeoutMs = 15000, opts = {}) {
+        const headers = await this.getHeaders(undefined, opts);
+        const init = { method, headers, signal: AbortSignal.timeout(timeoutMs) };
+        if (bodyStr !== undefined)
+            init.body = bodyStr;
+        const res = await fetch(url, init).catch(() => null);
+        return res ? await toE9Response(res) : null;
+    }
+    /**
+     * 带失效重试的单次请求（get/post 共享）：
+     *   瞬时 401/登录超时 → 同 token 重试 3 次（500ms 间隔，应对服务器抖动，不弹浏览器）；
+     *   ★#14 仍失败 → 先 cookie-only 重发一次（token 可能被服务端吊销但 cookie 还能用，避免直接弹浏览器）；
+     *   还失败且未设 E9_NO_REAUTH 且 token 可续期且未在退避窗口 → acquireToken（reactive 重登）再试一次；
+     *   最终仍失败 → 抛鉴权失效错。
+     */
+    async requestWithRetry(method, url, bodyStr, timeoutMs = 15000) {
+        let er = await this.fetchOnce(method, url, bodyStr, timeoutMs);
+        if (looksAuthFailed(er)) {
+            for (let i = 0; i < 3 && looksAuthFailed(er); i++) {
+                await sleep(500);
+                er = await this.fetchOnce(method, url, bodyStr, timeoutMs);
+            }
+            // ★ #14 先 cookie-only 重发一次（forceCookie 跳过 ensureValid，直接走 cookie 头）
+            if (looksAuthFailed(er) && this.cookie) {
+                await sleep(300);
+                er = await this.fetchOnce(method, url, bodyStr, timeoutMs, { forceCookie: true });
+            }
+            // ★ reactive 续期：尊重 #13 退避窗口（acquireFailedAt 10min 内不反复弹浏览器）
+            const backoff = this.tokenSession?.data?.acquireFailedAt && Date.now() - this.tokenSession.data.acquireFailedAt < 10 * 60 * 1000;
+            if (looksAuthFailed(er) && !process.env.E9_NO_REAUTH && this.tokenSession && this.tokenSession.data?.token && !this.tokenSession.data?.noToken && !backoff) {
+                try {
+                    await this.tokenSession.acquireToken();
+                }
+                catch { /* browser/network 失败 → 下面回退 cookie */ }
+                er = await this.fetchOnce(method, url, bodyStr, timeoutMs);
+            }
+            if (!er || looksAuthFailed(er)) {
+                throw new Error('鉴权失效，请运行 e9 auth token-login 或确认 .e9/config.json 的 cookie');
+            }
+        }
+        if (!er)
+            throw new Error(`请求失败：${method} ${url}。服务器可能不可达或网络不通。`);
+        return er;
+    }
+    /** GET。URL+query 拼好后委托 requestWithRetry。 */
+    async get(path, query) {
+        return this.requestWithRetry('GET', buildUrl(this.baseUrl, path, query));
+    }
+    /** POST。body 用 URLSearchParams（与原 e9Request 编码一致），委托 requestWithRetry。 */
+    async post(path, body) {
+        const form = new URLSearchParams();
+        for (const [k, v] of Object.entries(body ?? {}))
+            form.append(k, v);
+        return this.requestWithRetry('POST', buildUrl(this.baseUrl, path), form.toString(), 30000);
+    }
+}
+/**
+ * 建当前环境的 E9Api（单一端点）。baseUrl 空或 http://localhost:8080 → tokenSession=null（纯 cookie）。
+ */
+export async function createApiFromProfile(cfg) {
+    const endpoint = endpointFor(cfg);
+    let tokenSession = null;
+    if (endpoint.baseUrl && endpoint.baseUrl.replace(/\/+$/, '') !== 'http://localhost:8080') {
+        tokenSession = AuthTokenSession.fromProfile(cfg);
+    }
+    return new E9Api(cfg, tokenSession);
+}

package/dist/config.js

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+/** 取当前环境的唯一端点（不再按模块拆分——所有功能访问同一个 baseUrl）。 */
+export function endpointFor(cfg) {
+    return { baseUrl: cfg.baseUrl.replace(/\/+$/, ''), cookie: cfg.cookie ?? '' };
+}
+export const DEFAULT_MENU_IDS = '1,13';
+/** 待办三分类的标准默认 tab（取自 references/todo.md 实跑确认的 viewcondition）。config 未配 tabs 时兜底，避免 todo list 报"找不到 tab: (空)"。 */
+export const DEFAULT_TABS = {
+    todo: { viewcondition: '5', name: '待处理' },
+    done: { viewcondition: '10', name: '已办' },
+    mine: { viewcondition: '16', name: '我发起的' },
+};
+export function resolveConfigPath(explicit) {
+    const candidates = [];
+    if (explicit)
+        candidates.push(explicit);
+    if (process.env.E9_CONFIG)
+        candidates.push(process.env.E9_CONFIG);
+    candidates.push(path.join(process.cwd(), 'e9config', 'config.json'));
+    candidates.push(path.join(os.homedir(), '.e9', 'config.json'));
+    for (const c of candidates) {
+        try {
+            if (fs.existsSync(c))
+                return c;
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
+export function defaultConfigPath() {
+    const local = path.join(process.cwd(), 'e9config', 'config.json');
+    if (fs.existsSync(local))
+        return local;
+    return path.join(os.homedir(), '.e9', 'config.json');
+}
+export function loadConfig(explicit) {
+    const p = resolveConfigPath(explicit);
+    if (!p)
+        throw new Error('找不到 E9 配置文件');
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch (e) {
+        throw new Error('配置文件 ' + p + ' 不是合法 JSON：' + e.message);
+    }
+    if (typeof raw.baseUrl !== 'string' || !raw.baseUrl)
+        throw new Error('配置文件 ' + p + ' 缺少 baseUrl');
+    return {
+        baseUrl: raw.baseUrl.replace(/\/+$/, ''),
+        cookie: typeof raw.cookie === 'string' ? raw.cookie : undefined,
+        username: raw.username,
+        encPassword: raw.encPassword,
+        menuIds: raw.menuIds ?? DEFAULT_MENU_IDS,
+        menuPathIds: raw.menuPathIds ?? raw.menuIds ?? DEFAULT_MENU_IDS,
+        emailMenuIds: raw.emailMenuIds,
+        defaultTab: raw.defaultTab ?? 'todo',
+        tabs: raw.tabs ?? DEFAULT_TABS,
+        llmConsent: raw.llmConsent === true || String(raw.llmConsent).toLowerCase() === 'true',
+        _configPath: p,
+    };
+}
+export function resolveViewcondition(cfg, tab) {
+    const tabs = cfg.tabs ?? {};
+    const key = tab ?? cfg.defaultTab ?? Object.keys(tabs)[0];
+    if (!key || !tabs[key])
+        throw new Error('找不到 tab: ' + (key ?? '(空)'));
+    const t = tabs[key];
+    return { key, viewcondition: String(t.viewcondition), name: t.name };
+}
+export function saveConfig(cfg) {
+    const p = cfg._configPath ?? defaultConfigPath();
+    const raw = {
+        baseUrl: cfg.baseUrl.replace(/\/+$/, ''),
+        cookie: cfg.cookie ?? '',
+        menuIds: cfg.menuIds,
+        menuPathIds: cfg.menuPathIds,
+        defaultTab: cfg.defaultTab ?? 'todo',
+        tabs: cfg.tabs ?? DEFAULT_TABS,
+    };
+    if (cfg.llmConsent !== undefined)
+        raw.llmConsent = cfg.llmConsent === true || String(cfg.llmConsent).toLowerCase() === 'true';
+    if (cfg.username !== undefined)
+        raw.username = cfg.username;
+    if (cfg.encPassword !== undefined)
+        raw.encPassword = cfg.encPassword;
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(raw, null, 2) + '\n', 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'EPERM' || e.code === 'EACCES') {
+            throw new Error('无法写入配置文件 ' + p + '，请检查文件权限或沙箱设置（可尝试 danger-full-access）');
+        }
+        console.error('[saveConfig] write failed:', e.message);
+    }
+}
+export function setConfigField(field, value, explicit) {
+    const p = explicit ?? resolveConfigPath(explicit) ?? defaultConfigPath();
+    let raw = {};
+    try {
+        raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch { /* new */ }
+    if (field === 'baseUrl')
+        raw.baseUrl = value.replace(/\/+$/, '');
+    else
+        raw[field] = value;
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(raw, null, 2) + '\n', 'utf8');
+    console.log('已设置 ' + field + ' (写入 ' + p + ')');
+}
+export function profileNameFromBaseUrl(baseUrl) {
+    try {
+        const u = new URL(baseUrl);
+        const host = (u.hostname || '').replace(/[^a-zA-Z0-9]/g, '_');
+        return host + (u.port ? '_' + u.port : '') || 'override';
+    }
+    catch {
+        return 'override';
+    }
+}

package/dist/createcontext.js

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+function contextDir() {
+    return path.resolve(process.cwd(), 'state', 'create_contexts');
+}
+function contextPath(id) {
+    if (!/^[a-zA-Z0-9-]+$/.test(String(id)))
+        throw new Error('context_id 格式无效。');
+    return path.join(contextDir(), `${id}.json`);
+}
+function write(ctx) {
+    fs.mkdirSync(contextDir(), { recursive: true });
+    fs.writeFileSync(contextPath(ctx.id), JSON.stringify(ctx, null, 2), 'utf8');
+    return ctx;
+}
+
+export function createContext({ workflowId, workflowName }) {
+    return write({
+        id: randomUUID(),
+        workflowId: String(workflowId),
+        workflowName: String(workflowName ?? ''),
+        values: {},
+        requestName: '',
+        details: [],
+        files: [],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    });
+}
+export function loadContext(id) {
+    const p = contextPath(id);
+    if (!fs.existsSync(p))
+        throw new Error(`未找到发起上下文“${id}”。请先运行 create form。`);
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+export function updateContext(id, patch) {
+    const old = loadContext(id);
+    return write({ ...old, ...patch, updatedAt: new Date().toISOString() });
+}

package/dist/crypto.js

@@ -0,0 +1,139 @@
+/**
+ * AES-256-GCM 加解密（对标 e9-cli lib/crypto.js）。
+ *
+ * 用途：加密存 aiAgentToken 文件、profile.encPassword 的解密。
+ *
+ * 密钥管理（v2，修复 v1 硬编码静态种子的安全缺陷）：
+ *   - 主密钥：首次运行生成 32 字节随机数，写入 ~/.e9/master.key（chmod 0o600，Windows 忽略）。
+ *     每台机器/每个安装一把独立钥匙，源码泄露不再能解密他人 token。
+ *   - 旧密钥（LEGACY_KEY）：v1 用静态 SEED SHA256，所有安装共享。decrypt 读不到主密钥时
+ *     回退旧密钥，保证存量 token/encPassword 仍可读；save() 用新密钥重写即自动迁移。
+ *
+ * 存储信封统一：JSON.stringify({ enc: true, v: 1, data: <base64> }) + "\n"。
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const LEGACY_SEED = 'e9_cli_auth_v1_7b2e9d4f1a8c';
+const LEGACY_KEY = crypto.createHash('sha256').update(LEGACY_SEED).digest(); // 32 字节
+let masterKeyCache = null;
+/** 主密钥文件路径（支持 E9_MASTER_KEY_PATH 覆盖，便于测试）。 */
+function masterKeyPath() {
+    return process.env.E9_MASTER_KEY_PATH ?? path.join(os.homedir(), '.e9', 'master.key');
+}
+/**
+ * 取主密钥：有 master.key 用之；没有则生成并写盘（0o600）。
+ * 写盘失败（权限等）落回 LEGACY_KEY，保证存量文件仍可读，不阻断首次使用。
+ * 进程内缓存，避免反复读盘。
+ */
+function getMasterKey() {
+    if (masterKeyCache)
+        return masterKeyCache;
+    try {
+        const p = masterKeyPath();
+        if (fs.existsSync(p)) {
+            const raw = fs.readFileSync(p, 'utf8').trim();
+            const buf = Buffer.from(raw, 'base64');
+            if (buf.length === 32) {
+                masterKeyCache = buf;
+                return buf;
+            }
+        }
+    }
+    catch {
+        /* 读失败下面尝试生成 */
+    }
+    // 生成新主密钥并写盘
+    const newKey = crypto.randomBytes(32);
+    try {
+        const p = masterKeyPath();
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, newKey.toString('base64') + '\n', {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+        try {
+            fs.chmodSync(p, 0o600);
+        }
+        catch { /* Windows 忽略 */ }
+        masterKeyCache = newKey;
+        return newKey;
+    }
+    catch {
+        /* 写盘失败：落回旧密钥（降级，存量仍可读，但新写的也用旧密钥） */
+        masterKeyCache = LEGACY_KEY;
+        return LEGACY_KEY;
+    }
+}
+/**
+ * 加密明文字符串（用主密钥）。
+ * 输出布局：IV(12) + 密文 + tag(16)，整体 base64。IV 每次随机，故同明文密文不同。
+ */
+export function encrypt(plaintext) {
+    const key = getMasterKey();
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    const enc = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag(); // 16 字节
+    return Buffer.concat([iv, enc, tag]).toString('base64');
+}
+/**
+ * 解密 encrypt() 输出的 base64。
+ * 先用主密钥；tag 不匹配（v1 旧密文）回退 LEGACY_KEY，保证存量文件透明迁移。
+ */
+export function decrypt(b64) {
+    const buf = Buffer.from(b64, 'base64');
+    if (buf.length < 12 + 16)
+        throw new Error('密文过短');
+    const iv = buf.subarray(0, 12);
+    const tag = buf.subarray(buf.length - 16);
+    const enc = buf.subarray(12, buf.length - 16);
+    // 先主密钥
+    try {
+        const decipher = crypto.createDecipheriv('aes-256-gcm', getMasterKey(), iv);
+        decipher.setAuthTag(tag);
+        return Buffer.concat([decipher.update(enc), decipher.final()]).toString('utf8');
+    }
+    catch {
+        /* 主密钥解不开，尝试旧密钥（v1 存量迁移） */
+    }
+    const decipher = crypto.createDecipheriv('aes-256-gcm', LEGACY_KEY, iv);
+    decipher.setAuthTag(tag);
+    const dec = Buffer.concat([decipher.update(enc), decipher.final()]);
+    return dec.toString('utf8');
+}
+/** 把明文写成加密信封 JSON 字符串（带尾换行）。 */
+export function wrapEncrypted(plaintext) {
+    return JSON.stringify({ enc: true, v: 1, data: encrypt(plaintext) }, null, 2) + '\n';
+}
+/**
+ * 解析加密信封；兼容明文 { token } / 裸字符串。
+ * 返回 null 表示文件不存在或不可解析。
+ */
+export function unwrapEncrypted(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const j = JSON.parse(trimmed);
+        if (j && j.enc === true && typeof j.data === 'string') {
+            try {
+                return decrypt(j.data);
+            }
+            catch {
+                /* 密文损坏，落回其他形态 */
+            }
+        }
+        if (j && typeof j.token === 'string')
+            return trimmed; // 明文信封，原样返回由上层再 JSON.parse
+    }
+    catch {
+        /* 非 JSON */
+    }
+    return trimmed; // 裸字符串
+}
+// 仅测试用：重置主密钥缓存（避免用例间互相污染）
+export function __resetMasterKeyCacheForTests() {
+    masterKeyCache = null;
+}