bdip-office-assistant-cli 0.0.0-stage → 1.0.0

package/dist/session.js

@@ -0,0 +1,280 @@
+import fs from 'node:fs';
+import { updateConfigCookie } from './config.js';
+
+const managers = new Map();
+const warned = new Set();
+const UA = 'Mozilla/5.0 BDIP-Office-Assistant';
+export const HEARTBEAT_PATH = '/api/bdip/assistant/session/heartbeat';
+
+function bounded(value, fallback, min, max) {
+    const n = Number(value);
+    return Number.isFinite(n) && n >= min && n <= max ? n : fallback;
+}
+export function sessionOptions(cfg) {
+    return {
+        enabled: cfg.session?.enabled !== false && cfg.session?.enabled !== 'false',
+        intervalMs: bounded(cfg.session?.heartbeatSeconds, 120, 15, 600) * 1000,
+        timeoutMs: bounded(cfg.session?.timeoutMs, 8000, 1000, 30000),
+    };
+}
+export function sessionKey(cfg) {
+    return `${cfg.baseUrl.replace(/\/+$/, '')}\n${cfg._configPath ?? ''}`;
+}
+/** Reload just the Cookie. A worker never writes an old profile over an account switch. */
+export function refreshCookie(cfg) {
+    if (!cfg._configPath) return;
+    const raw = JSON.parse(fs.readFileSync(cfg._configPath, 'utf8'));
+    if (String(raw.baseUrl).replace(/\/+$/, '') !== cfg.baseUrl.replace(/\/+$/, '')) {
+        const error = new Error('平台地址已变更，请停止保活并重新启动');
+        error.code = 'PROFILE_CHANGED';
+        throw error;
+    }
+    cfg.cookie = typeof raw.cookie === 'string' ? raw.cookie : '';
+}
+
+/** Apply only cookies valid for the configured OA, with compare-before-write persistence. */
+export function mergeResponseCookies(cfg, headers, sentCookie) {
+    const lines = typeof headers.getSetCookie === 'function' ? headers.getSetCookie() :
+        (headers.get('set-cookie') ?? '').split(/,(?=\s*[^;,\s]+=)/).filter(Boolean);
+    if (!lines.length) return;
+    const base = new URL(cfg.baseUrl + '/wui/index.html');
+    const values = new Map(String(sentCookie ?? '').split(';').map(s => s.trim()).filter(Boolean).map(s => {
+        const i = s.indexOf('='); return [s.slice(0, i), s.slice(i + 1)];
+    }));
+    let changed = false;
+    for (const line of lines) {
+        if (/[\r\n]/.test(line)) continue;
+        const [pair, ...attributes] = line.split(';').map(s => s.trim());
+        const i = pair.indexOf('=');
+        if (i <= 0) continue;
+        const name = pair.slice(0, i), value = pair.slice(i + 1);
+        if (!/^[!#$%&'*+.^_`|~\w-]+$/.test(name)) continue;
+        const attrs = Object.fromEntries(attributes.map(s => {
+            const eq = s.indexOf('='); return eq < 0 ? [s.toLowerCase(), true] : [s.slice(0, eq).toLowerCase(), s.slice(eq + 1)];
+        }));
+        const domain = typeof attrs.domain === 'string' ? attrs.domain.replace(/^\./, '').toLowerCase() : base.hostname;
+        if (base.hostname !== domain && !base.hostname.endsWith('.' + domain)) continue;
+        if (attrs.secure && base.protocol !== 'https:') continue;
+        if (attrs.path && !(base.pathname === attrs.path || base.pathname.startsWith(String(attrs.path).replace(/\/$/, '') + '/'))) continue;
+        const remove = (attrs['max-age'] !== undefined && Number(attrs['max-age']) <= 0) ||
+            (attrs['max-age'] === undefined && attrs.expires && Date.parse(attrs.expires) <= Date.now());
+        if (remove) changed = values.delete(name) || changed;
+        else if (values.get(name) !== value) { values.set(name, value); changed = true; }
+    }
+    if (changed) updateConfigCookie(cfg, [...values].map(([k, v]) => `${k}=${v}`).join('; '), sentCookie);
+}
+
+export function authFailureCode(status, json) {
+    const code = String(json?.errorCode ?? json?.code ?? '');
+    if (code === '003' || code === '004' || code === 'FORCED_OFFLINE') return 'FORCED_OFFLINE';
+    if (status === 401 || code === '002' || code === 'SESSION_EXPIRED' || code === 'NOT_AUTHENTICATED') return 'SESSION_EXPIRED';
+    return null;
+}
+function identity(data) {
+    const id = String(data?.userId ?? '');
+    const loginId = typeof data?.loginId === 'string' ? data.loginId.trim() : '';
+    return /^[1-9]\d*$/.test(id) && loginId ? { userId: id, loginId } : null;
+}
+function result(authenticated, mode, fields = {}) {
+    return { authenticated, mode, checkedAt: Date.now(), ...fields };
+}
+async function cookieFetch(cfg, path, method, options) {
+    options.signal?.throwIfAborted();
+    const sentCookie = cfg.cookie ?? '';
+    const url = new URL(cfg.baseUrl.replace(/\/+$/, '') + path);
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) throw new Error('平台地址格式无效');
+    // Combine cancellation and the per-request timeout without AbortSignal.any (Node 18).
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    options.signal?.addEventListener('abort', abort, { once: true });
+    const timeout = setTimeout(abort, options.timeoutMs);
+    timeout.unref?.();
+    try {
+        options.signal?.throwIfAborted();
+        options.onCredential?.(sentCookie);
+        const res = await (options.fetchImpl ?? fetch)(url, {
+            method, redirect: 'manual', signal: controller.signal,
+            headers: { Cookie: sentCookie, 'User-Agent': UA, Accept: 'application/json',
+                'X-Requested-With': 'XMLHttpRequest', Referer: cfg.baseUrl + '/wui/index.html',
+                ...(method === 'POST' ? { 'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8' } : {}) },
+            ...(method === 'POST' ? { body: '' } : {}),
+        });
+        controller.signal.throwIfAborted();
+        // Fetch never follows an authenticated request into another origin or a login page.
+        if (res.status >= 300 && res.status < 400) return { status: res.status, json: null, redirected: true };
+        const text = await res.text();
+        controller.signal.throwIfAborted();
+        let json;
+        try { json = JSON.parse(text); } catch { json = null; }
+        return { status: res.status, json, commitCookies: () => {
+            options.signal?.throwIfAborted();
+            mergeResponseCookies(cfg, res.headers, sentCookie);
+        } };
+    }
+    finally {
+        clearTimeout(timeout);
+        options.signal?.removeEventListener('abort', abort);
+    }
+}
+
+/** Prove current identity. Native heartbeat's status:1 alone is deliberately insufficient. */
+export async function probeCookieSession(cfg, options = {}) {
+    const opts = { ...sessionOptions(cfg), ...options };
+    try {
+        opts.signal?.throwIfAborted();
+        if (options.refresh !== false) refreshCookie(cfg);
+        if (!cfg.cookie) return result(false, 'none', { code: 'NO_COOKIE', message: '未保存 Cookie' });
+        const response = await cookieFetch(cfg, HEARTBEAT_PATH, 'POST', opts);
+        const failure = authFailureCode(response.status, response.json);
+        if (failure) return result(false, 'extension', { code: failure, message: failure === 'FORCED_OFFLINE' ? '当前会话已被强制下线' : 'Cookie 登录已失效' });
+        const user = response.json?.success === true ? identity(response.json.data) : null;
+        if (response.status === 200 && user) {
+            response.commitCookies();
+            return result(true, 'extension', { ...user,
+                idleTimeoutSeconds: Number(response.json.data.idleTimeoutSeconds),
+                serverTime: response.json.data.serverTime });
+        }
+        if (response.status === 403) return result(false, 'extension', { code: 'FORBIDDEN', message: '心跳被服务器拒绝' });
+        // An unavailable extension may fall back to an independently proven native Cookie identity.
+        if (response.status >= 500 && response.status !== 501) return result(false, 'extension', { code: 'SERVER_ERROR', message: '会话扩展暂时不可用' });
+        const native = await cookieFetch(cfg, '/api/hrm/login/getAccountList', 'GET', opts);
+        const nativeFailure = authFailureCode(native.status, native.json);
+        if (nativeFailure) return result(false, 'native', { code: nativeFailure, message: 'Cookie 登录已失效' });
+        const rows = native.json?.data?.accountlist;
+        const current = Array.isArray(rows) ? rows.filter(row => String(row.iscurrent) === '1') : [];
+        const id = String(current[0]?.userid ?? '');
+        if (native.status !== 200 || native.json?.status === false || current.length !== 1 || !/^[1-9]\d*$/.test(id)) {
+            return result(false, 'native', { code: 'IDENTITY_UNVERIFIED', message: '未取得唯一当前用户，无法确认 Cookie 登录有效' });
+        }
+        native.commitCookies();
+        // getAccountList itself has already touched the authenticated HttpSession.
+        return result(true, 'native', { userId: id, loginId: current[0].loginid ?? null,
+            idleTimeoutSeconds: null, message: '已验证当前用户；需部署扩展才能延长空闲超时和生成免登录链接' });
+    }
+    catch (e) {
+        if (opts.signal?.aborted) return result(false, 'unknown', { code: 'CANCELLED', message: '会话检查已停止' });
+        return result(false, 'unknown', { code: e.code === 'PROFILE_CHANGED' ? e.code : 'NETWORK_ERROR',
+            message: e.code === 'PROFILE_CHANGED' ? e.message : '会话检查失败，请检查网络或服务器' });
+    }
+}
+
+export class SessionHeartbeat {
+    constructor(cfg, options = {}) {
+        this.cfg = cfg;
+        this.options = { ...sessionOptions(cfg), ...options };
+        this.state = null;
+        this.checkedCookie = null;
+        this.timer = null;
+        this.inflight = null;
+        this.controller = null;
+        this.stopped = false;
+    }
+    async tick() {
+        if (this.inflight) return this.inflight;
+        if (this.stopped) return this.state;
+        const controller = new AbortController();
+        this.controller = controller;
+        const externalAbort = () => this.stop();
+        this.options.signal?.addEventListener('abort', externalAbort, { once: true });
+        if (this.options.signal?.aborted) this.stop();
+        // Replaced by the actual request credential after refreshCookie. Never bind
+        // a response identity to cfg.cookie after a concurrent update or rotation.
+        this.checkedCookie = this.cfg.cookie;
+        this.inflight = probeCookieSession(this.cfg, { ...this.options, signal: controller.signal,
+            onCredential: cookie => {
+                this.checkedCookie = cookie;
+                this.options.onCredential?.(cookie);
+            },
+        }).then(state => {
+            if (this.stopped || controller.signal.aborted) return this.state;
+            this.state = state;
+            this.options.onState?.(state);
+            if (['FORCED_OFFLINE', 'SESSION_EXPIRED', 'PROFILE_CHANGED', 'NO_COOKIE'].includes(state.code)) this.stop();
+            return state;
+        }).finally(() => {
+            this.options.signal?.removeEventListener('abort', externalAbort);
+            if (this.controller === controller) this.controller = null;
+            this.inflight = null;
+        });
+        return this.inflight;
+    }
+    async start() {
+        await this.tick();
+        if (!this.stopped && !this.timer) {
+            this.timer = setInterval(() => { void this.tick(); }, this.options.intervalMs);
+            // An ordinary CLI command must exit promptly when its actual work finishes.
+            if (this.options.unref !== false) this.timer.unref();
+        }
+        return this;
+    }
+    stop() {
+        this.stopped = true;
+        this.controller?.abort();
+        if (this.timer) clearInterval(this.timer);
+        this.timer = null;
+    }
+}
+
+/** Bind a forced-offline observation to the credential actually checked. */
+export function latchForcedOffline(cfg, state, checkedCookie = cfg.cookie) {
+    const key = sessionKey(cfg);
+    let manager = managers.get(key);
+    if (!manager) {
+        manager = new SessionHeartbeat(cfg);
+        managers.set(key, manager);
+    }
+    manager.stop();
+    manager.state = result(false, state?.mode ?? 'unknown', {
+        code: 'FORCED_OFFLINE', message: state?.message ?? '当前 Cookie 会话已被强制下线',
+        checkedAt: state?.checkedAt ?? Date.now(),
+    });
+    manager.checkedCookie = checkedCookie;
+    manager.forcedCookie = checkedCookie;
+    return manager;
+}
+
+export function currentSessionState(cfg) {
+    const manager = managers.get(sessionKey(cfg));
+    return manager?.checkedCookie === cfg.cookie ? manager.state : null;
+}
+export function assertSessionNotForcedOffline(cfg) {
+    const manager = managers.get(sessionKey(cfg));
+    if (manager?.state?.code === 'FORCED_OFFLINE' && cfg.cookie === manager.forcedCookie) {
+        const error = new Error('当前 Cookie 会话已被强制下线；请核实后重新登录，未自动重登或继续业务操作。');
+        error.code = 'FORCED_OFFLINE';
+        throw error;
+    }
+}
+export async function ensureSessionHeartbeat(cfg) {
+    if (!sessionOptions(cfg).enabled) return null;
+    refreshCookie(cfg);
+    const key = sessionKey(cfg);
+    let manager = managers.get(key);
+    if (manager?.inflight) await manager.inflight;
+    if (manager?.state?.code === 'FORCED_OFFLINE' && cfg.cookie === manager.forcedCookie) return manager;
+    if (manager?.stopped && cfg.cookie === manager.checkedCookie) return manager;
+    if (!manager || manager.stopped) {
+        manager = new SessionHeartbeat(cfg, { onState: state => {
+            if (state.code === 'FORCED_OFFLINE') manager.forcedCookie = manager.checkedCookie;
+            const warning = `${key}:${state.code ?? state.mode}`;
+            if (warned.has(warning)) return;
+            if (state.mode === 'native' && state.authenticated) {
+                console.error('[登录] 已按当前 Cookie 用户保活；部署办公助手扩展后可延长空闲登录时间。');
+                warned.add(warning);
+            } else if (state.code === 'FORCED_OFFLINE' || state.code === 'SESSION_EXPIRED') {
+                console.error('[登录] 当前 Cookie 会话已失效，保活已停止；请重新登录后再继续需要 Cookie 的操作。');
+                warned.add(warning);
+            }
+        } });
+        managers.set(key, manager);
+        await manager.start();
+    } else if (manager.checkedCookie !== cfg.cookie) {
+        await manager.tick();
+    }
+    return manager;
+}
+export function stopSessionHeartbeats() {
+    for (const manager of managers.values()) manager.stop();
+    managers.clear();
+}
+process.once('exit', stopSessionHeartbeats);

package/dist/submissionplan.js

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const MAX_AGE_MS = 24 * 60 * 60 * 1000;
+
+function planDir() {
+    return path.resolve(process.cwd(), 'state', 'create_plans');
+}
+function planPath(id) {
+    if (!/^[a-zA-Z0-9-]+$/.test(String(id)))
+        throw new Error('plan_id 格式无效。');
+    return path.join(planDir(), `${id}.json`);
+}
+
+/** 保存用户已确认的业务字段；短期 token 和签名绝不落盘。 */
+export function saveSubmissionPlan(prepared) {
+    const plan = {
+        id: randomUUID(),
+        workflowId: String(prepared.workflowId),
+        workflowName: String(prepared.workflowName ?? ''),
+        requestName: String(prepared.requestName),
+        values: prepared.values,
+        details: prepared.details,
+        browserNames: prepared.browserNames,
+        files: prepared.files ?? [],
+        accountId: prepared.accountId, baseUrl: prepared.baseUrl,
+        prepared: prepared.prepared ? {...prepared.prepared, body:Object.fromEntries(Object.entries(prepared.prepared.body).filter(([k])=>!/token|signature|UUID/i.test(k)))} : undefined,
+        createdAt: new Date().toISOString(),
+    };
+    fs.mkdirSync(planDir(), { recursive: true });
+    fs.writeFileSync(planPath(plan.id), JSON.stringify(plan, null, 2), 'utf8');
+    return plan;
+}
+export function loadSubmissionPlan(id, workflowId) {
+    const file = planPath(id);
+    if (!fs.existsSync(file))
+        throw new Error('未找到确认计划。请先重新预览，确认后再提交。');
+    const plan = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (String(plan.workflowId) !== String(workflowId))
+        throw new Error('确认计划与当前流程不一致。请重新预览。');
+    if (Date.now() - Date.parse(plan.createdAt) > MAX_AGE_MS)
+        throw new Error('确认计划已超过 24 小时。请重新预览，避免提交过期内容。');
+    return plan;
+}

package/dist/submissionstate.js

@@ -0,0 +1,81 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const ACTIVE_STATUSES = new Set(['submitting', 'uncertain', 'created']);
+const DUPLICATE_WINDOW_MS = 10 * 60 * 1000;
+
+function stateDir() {
+    return path.resolve(process.cwd(), 'state', 'create_submissions');
+}
+function statePath(id) {
+    if (!/^[a-zA-Z0-9-]+$/.test(String(id)))
+        throw new Error('submission_id 格式无效。');
+    return path.join(stateDir(), `${id}.json`);
+}
+function write(record) {
+    fs.mkdirSync(stateDir(), { recursive: true });
+    fs.writeFileSync(statePath(record.id), JSON.stringify(record, null, 2), 'utf8');
+    return record;
+}
+function fingerprint(workflowId, requestName, values) {
+    return crypto.createHash('sha256')
+        .update(JSON.stringify({ workflowId: String(workflowId), requestName: String(requestName ?? ''), values: values ?? {} }))
+        .digest('hex');
+}
+function readRecent() {
+    try {
+        return fs.readdirSync(stateDir())
+            .filter((name) => name.endsWith('.json'))
+            .map((name) => JSON.parse(fs.readFileSync(path.join(stateDir(), name), 'utf8')))
+            .filter((record) => record && record.id);
+    }
+    catch {
+        return [];
+    }
+}
+
+/**
+ * 为一次真实发起建立本地操作记录。相同内容在十分钟内处于进行/不确定/成功状态时不再次提交。
+ * 只存指纹而不存字段原文，避免把敏感表单值重复落盘。
+ */
+export function beginSubmission({ workflowId, workflowName = '', requestName = '', values = {} }) {
+    const now = Date.now();
+    const key = fingerprint(workflowId, requestName, values);
+    const duplicate = readRecent().find((record) => record.fingerprint === key
+        && ACTIVE_STATUSES.has(record.status)
+        && now - Date.parse(record.updatedAt ?? record.createdAt ?? 0) < DUPLICATE_WINDOW_MS);
+    if (duplicate)
+        return { record: duplicate, duplicate: true };
+    const record = {
+        id: crypto.randomUUID(),
+        workflowId: String(workflowId),
+        workflowName: String(workflowName),
+        requestName: String(requestName),
+        fingerprint: key,
+        status: 'submitting',
+        requestId: '',
+        createdAt: new Date(now).toISOString(),
+        updatedAt: new Date(now).toISOString(),
+    };
+    return { record: write(record), duplicate: false };
+}
+export function loadSubmission(id) {
+    const p = statePath(id);
+    if (!fs.existsSync(p))
+        throw new Error(`未找到发起记录“${id}”。`);
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+export function updateSubmission(id, patch) {
+    const old = loadSubmission(id);
+    return write({ ...old, ...patch, updatedAt: new Date().toISOString() });
+}
+export function extractCreatedRequestId(response) {
+    const body = response?.json ?? {};
+    const type = body?.data?.type ?? body?.type ?? '';
+    const requestId = body?.requestid ?? body?.data?.requestid ?? body?.data?.resultInfo?.requestid ?? body?.data?.requestId;
+    // A success type without an addressable request id cannot be presented as a
+    // completed creation: the caller must verify it instead of retrying.
+    const accepted = !!requestId && (type === 'SUCCESS' || type === 'ASYNC_SUBMIT');
+    return { accepted, requestId: requestId ? String(requestId) : '', type: String(type) };
+}