weaver-work-cli 0.1.2 → 0.1.5

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

@@ -0,0 +1,345 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_BIG_INT_STRINGS = true;
+const RESERVED_HEADERS = [
+    'authorization',
+    'cookie',
+    'eteamsid',
+    'token',
+];
+export class E10ApiError extends CliError {
+    type;
+    subtype;
+    code;
+    retryable;
+    details;
+    constructor(type, subtype, message, options = {}) {
+        super(message, options.exitCode ?? ExitCode.GeneralError);
+        this.name = 'E10ApiError';
+        this.type = type;
+        this.subtype = subtype;
+        this.code = options.code;
+        this.retryable = options.retryable ?? false;
+        this.details = options.details;
+    }
+}
+export class E10RequestRuntime {
+    ctx;
+    session;
+    interceptors;
+    fetchFn;
+    constructor(ctx, session, dependencies = {}) {
+        this.ctx = ctx;
+        this.session = session;
+        this.fetchFn = dependencies.fetch || globalThis.fetch;
+        this.interceptors = [
+            ...(this.ctx.hooks?.getE10RequestInterceptors?.() || []),
+            ...(dependencies.interceptors || []),
+        ];
+    }
+    async requestJson(request) {
+        return this.request({ ...request, responseType: 'json' });
+    }
+    async requestBinary(request) {
+        return this.request({ ...request, responseType: 'binary' });
+    }
+    async request(request) {
+        const mutable = this.prepareRequest(request);
+        const sessionContext = this.sessionContext();
+        try {
+            await this.runBeforeRequest(mutable, sessionContext);
+            this.assertPath(mutable.path);
+            if (mutable.path !== request.path) {
+                throw new E10ApiError('policy', 'path_rewrite_denied', 'E10 API 拦截器不能修改请求路径', {
+                    exitCode: ExitCode.PolicyError,
+                    details: { from: request.path, to: mutable.path },
+                });
+            }
+            stripReservedHeaders(mutable.headers);
+            const url = withQuery(this.session.getBaseUrl(), mutable.path, mutable.query);
+            const headers = this.composeHeaders(mutable, request.trustedHeaders);
+            const init = this.buildFetchInit(mutable, headers);
+            const response = await this.fetchWithTimeout(url, init, mutable.timeoutMs);
+            const parsed = await this.readResponse(response, mutable.responseType, mutable.bigIntStrings);
+            await this.runAfterResponse(mutable, sessionContext, parsed);
+            return parsed;
+        }
+        catch (error) {
+            await this.runOnError(mutable, sessionContext, error);
+            throw error;
+        }
+    }
+    prepareRequest(request) {
+        return {
+            module: request.module,
+            operation: request.operation,
+            method: (request.method || 'POST').toUpperCase(),
+            path: request.path,
+            query: { ...(request.query || {}) },
+            headers: sanitizePublicHeaders(request.headers || {}),
+            body: request.body,
+            form: request.form,
+            formData: request.formData,
+            timeoutMs: request.timeoutMs || DEFAULT_TIMEOUT_MS,
+            responseType: request.responseType || 'json',
+            bigIntStrings: request.bigIntStrings ?? DEFAULT_BIG_INT_STRINGS,
+        };
+    }
+    sessionContext() {
+        return {
+            baseUrl: this.session.getBaseUrl(),
+            userId: this.session.userId,
+            agentType: this.session.agentType,
+        };
+    }
+    async runBeforeRequest(request, session) {
+        for (const interceptor of this.interceptors) {
+            await interceptor.beforeRequest?.({ request, session });
+        }
+    }
+    async runAfterResponse(request, session, response) {
+        for (const interceptor of this.interceptors) {
+            await interceptor.afterResponse?.({
+                request: requestForHook(request),
+                session,
+                response: responseForHook(response),
+            });
+        }
+    }
+    async runOnError(request, session, error) {
+        for (const interceptor of this.interceptors) {
+            await interceptor.onError?.({ request, session, error });
+        }
+    }
+    assertPath(requestPath) {
+        if (typeof requestPath !== 'string' || !requestPath.startsWith('/') || requestPath.startsWith('//')) {
+            throw new E10ApiError('validation', 'path_invalid', '请求路径必须是相对绝对路径', {
+                exitCode: ExitCode.UsageError,
+            });
+        }
+        if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes('/../')) {
+            throw new E10ApiError('validation', 'path_invalid', '请求路径不允许跨域或路径逃逸', {
+                exitCode: ExitCode.UsageError,
+            });
+        }
+        if (!requestPath.startsWith('/api/')) {
+            throw new E10ApiError('validation', 'path_not_allowed', 'E10 API 只能调用 /api/ 路径', {
+                exitCode: ExitCode.UsageError,
+            });
+        }
+    }
+    composeHeaders(request, trustedHeaders = {}) {
+        return {
+            Accept: 'application/json, text/plain, */*',
+            ...request.headers,
+            Cookie: this.session.cookieHeader(),
+            eteamsid: this.session.eteamsId,
+            'User-Agent': this.session.uaHeader(),
+            Origin: this.session.getBaseUrl(),
+            'X-Weaver-Cli-Source': 'weaver-work-cli',
+            'X-Weaver-Cli-Version': this.ctx.packageInfo?.version || 'unknown',
+            ...(request.module ? { 'X-Weaver-Cli-Module': request.module } : {}),
+            ...(request.operation ? { 'X-Weaver-Cli-Operation': request.operation } : {}),
+            ...trustedHeaders,
+        };
+    }
+    buildFetchInit(request, headers) {
+        const init = {
+            method: request.method,
+            headers,
+            redirect: 'manual',
+        };
+        if (request.formData) {
+            init.body = request.formData;
+        }
+        else if (request.form !== undefined) {
+            headers['Content-Type'] = 'application/x-www-form-urlencoded;charset=UTF-8';
+            init.body = String(request.form);
+        }
+        else if (request.body !== undefined) {
+            headers['Content-Type'] = 'application/json;charset=UTF-8';
+            init.body = JSON.stringify(request.body);
+        }
+        return init;
+    }
+    async fetchWithTimeout(url, init, timeoutMs) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            return await this.fetchFn(url, { ...init, signal: controller.signal });
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new E10ApiError('network', 'timeout', `请求超时（${timeoutMs}ms）`, {
+                    retryable: false,
+                    exitCode: ExitCode.NetworkError,
+                });
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            throw new E10ApiError('network', 'transport', `请求失败：${message}`, {
+                retryable: true,
+                exitCode: ExitCode.NetworkError,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async readResponse(response, responseType, bigIntStrings = DEFAULT_BIG_INT_STRINGS) {
+        if (responseType === 'binary') {
+            return {
+                status: response.status,
+                headers: response.headers,
+                content: Buffer.from(await response.arrayBuffer()),
+                contentType: response.headers.get('content-type') || 'application/octet-stream',
+            };
+        }
+        const text = await response.text();
+        let value = {};
+        let parseError;
+        try {
+            value = text ? (bigIntStrings ? parseJsonPreservingBigInts(text) : JSON.parse(text)) : {};
+        }
+        catch (error) {
+            parseError = error instanceof Error ? error : new Error(String(error));
+        }
+        return {
+            status: response.status,
+            headers: response.headers,
+            text,
+            value,
+            ...(parseError ? { parseError } : {}),
+        };
+    }
+}
+export function parseJsonPreservingBigInts(text) {
+    return JSON.parse(quoteLargeJsonIntegers(text));
+}
+function quoteLargeJsonIntegers(text) {
+    let output = '';
+    let i = 0;
+    let inString = false;
+    let escaped = false;
+    while (i < text.length) {
+        const char = text[i];
+        if (inString) {
+            output += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            i += 1;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            output += char;
+            i += 1;
+            continue;
+        }
+        if (char === '-' || (char >= '0' && char <= '9')) {
+            const start = i;
+            if (char === '-')
+                i += 1;
+            const digitStart = i;
+            while (i < text.length && text[i] >= '0' && text[i] <= '9')
+                i += 1;
+            if (digitStart === i) {
+                output += text.slice(start, i);
+                continue;
+            }
+            if (text[i] === '.' || text[i] === 'e' || text[i] === 'E') {
+                if (text[i] === '.') {
+                    i += 1;
+                    while (i < text.length && text[i] >= '0' && text[i] <= '9')
+                        i += 1;
+                }
+                if (text[i] === 'e' || text[i] === 'E') {
+                    i += 1;
+                    if (text[i] === '+' || text[i] === '-')
+                        i += 1;
+                    while (i < text.length && text[i] >= '0' && text[i] <= '9')
+                        i += 1;
+                }
+                output += text.slice(start, i);
+                continue;
+            }
+            const rawNumber = text.slice(start, i);
+            const digitCount = rawNumber.startsWith('-') ? rawNumber.length - 1 : rawNumber.length;
+            output += digitCount >= 16 ? `"${rawNumber}"` : rawNumber;
+            continue;
+        }
+        output += char;
+        i += 1;
+    }
+    return output;
+}
+export function createE10RequestRuntime(ctx, session, dependencies = {}) {
+    return new E10RequestRuntime(ctx, session, dependencies);
+}
+function withQuery(baseUrl, requestPath, query = {}) {
+    const url = new URL(`${baseUrl}${requestPath}`);
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                url.searchParams.append(key, String(item));
+        }
+        else {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    return url;
+}
+function sanitizePublicHeaders(headers) {
+    const next = { ...headers };
+    stripReservedHeaders(next);
+    return next;
+}
+function stripReservedHeaders(headers) {
+    for (const key of Object.keys(headers)) {
+        if (RESERVED_HEADERS.includes(key.toLowerCase())) {
+            delete headers[key];
+        }
+    }
+}
+function responseForHook(response) {
+    if ('content' in response) {
+        return {
+            status: response.status,
+            headers: new Headers(response.headers),
+            contentType: response.contentType,
+            contentLength: response.content.length,
+        };
+    }
+    return {
+        status: response.status,
+        headers: new Headers(response.headers),
+        value: cloneForHook(response.value),
+        text: response.text,
+    };
+}
+function requestForHook(request) {
+    return {
+        ...request,
+        query: { ...request.query },
+        headers: { ...request.headers },
+        body: cloneForHook(request.body),
+    };
+}
+function cloneForHook(value) {
+    if (value === undefined || value === null)
+        return value;
+    try {
+        return structuredClone(value);
+    }
+    catch {
+        return value;
+    }
+}

package/dist/internal/skills/install.js

@@ -1,8 +1,10 @@
-import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, relative, resolve, sep } from 'node:path';
-const SKILL_PREFIX = 'weaver-work-cli-';
-const SHARED_SKILL_NAME = 'weaver-work-cli-shared';
+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');
@@ -17,6 +19,9 @@ export function normalizePackagedSkillName(value) {
     if (!/^[A-Za-z0-9._-]+$/u.test(trimmed)) {
         throw new Error(`invalid skill name: ${value}`);
     }
+    if (trimmed.startsWith(LEGACY_SKILL_PREFIX)) {
+        return `${SKILL_PREFIX}${trimmed.slice(LEGACY_SKILL_PREFIX.length)}`;
+    }
     return trimmed.startsWith(SKILL_PREFIX) ? trimmed : `${SKILL_PREFIX}${trimmed}`;
 }
 export function resolvePackagedSkillNames(sourceRoot, requested = 'all') {
@@ -28,7 +33,13 @@ export function resolvePackagedSkillNames(sourceRoot, requested = 'all') {
     if (!normalized || normalized === 'all')
         return available;
     if (!available.includes(normalized)) {
-        throw new Error(`unknown packaged skill: ${normalized}`);
+        const shortName = normalized.slice(SKILL_PREFIX.length);
+        const suggestions = available.filter((name) => editDistance(shortName, name.replace(/^weaver-e10-/u, '')) <= 2);
+        throw new Error([
+            `unknown packaged skill: ${requested}`,
+            ...(suggestions.length ? [`Did you mean: ${suggestions.join(', ')}?`] : []),
+            'Run "weaver-work-cli skills list" to see available skills.',
+        ].join('\n'));
     }
     const names = [];
     if (normalized !== SHARED_SKILL_NAME && available.includes(SHARED_SKILL_NAME)) {
@@ -37,12 +48,23 @@ export function resolvePackagedSkillNames(sourceRoot, requested = 'all') {
     names.push(normalized);
     return names;
 }
+function editDistance(left, right) {
+    let row = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let i = 0; i < left.length; i += 1) {
+        const next = [i + 1];
+        for (let j = 0; j < right.length; j += 1) {
+            next.push(Math.min(next[j] + 1, row[j + 1] + 1, row[j] + (left[i] === right[j] ? 0 : 1)));
+        }
+        row = next;
+    }
+    return row[right.length];
+}
 export function installPackagedSkills(sourceRoot, targetRoot, requested = 'all') {
     const resolvedSourceRoot = resolve(sourceRoot);
     const resolvedTargetRoot = resolve(targetRoot);
     const skillNames = resolvePackagedSkillNames(resolvedSourceRoot, requested);
     mkdirSync(resolvedTargetRoot, { recursive: true, mode: 0o700 });
-    const installed = skillNames.map((name) => {
+    const installed = skillNames.flatMap((name) => {
         const source = resolveInside(resolvedSourceRoot, name);
         const target = resolve(resolvedTargetRoot, basename(name));
         statSync(resolve(source, 'SKILL.md'));
@@ -51,12 +73,28 @@ export function installPackagedSkills(sourceRoot, targetRoot, requested = 'all')
             force: true,
             filter: (entry) => shouldCopy(entry, source),
         });
-        return {
+        const current = {
             name,
             source,
             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),
+        });
+        rewriteSkillName(resolve(legacyTarget, 'SKILL.md'), LEGACY_SHARED_SKILL_NAME);
+        return [current, {
+                name: LEGACY_SHARED_SKILL_NAME,
+                source,
+                target: legacyTarget,
+                files: countFiles(legacyTarget),
+            }];
     });
     return {
         sourceRoot: resolvedSourceRoot,
@@ -65,6 +103,10 @@ 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 shouldCopy(entry, sourceRoot) {
     const relativePath = relative(sourceRoot, entry);
     const name = basename(entry);

package/dist/internal/skills/reader.js

@@ -1,5 +1,7 @@
 import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { relative, resolve, sep } from 'node:path';
+const SKILL_PREFIX = 'weaver-e10-';
+const LEGACY_SKILL_PREFIX = 'weaver-work-cli-';
 export class SkillReader {
     root;
     constructor(root) {
@@ -66,6 +68,14 @@ export class SkillReader {
             throw new Error(`unknown skill: ${name}`);
         }
         const skillRoot = this.resolveInside(this.root, name);
+        if (!existsDirectoryWithSkill(skillRoot)) {
+            const normalized = normalizeLegacySkillName(name);
+            if (normalized !== name) {
+                const normalizedRoot = this.resolveInside(this.root, normalized);
+                if (existsDirectoryWithSkill(normalizedRoot))
+                    return normalizedRoot;
+            }
+        }
         const info = statSync(skillRoot);
         if (!info.isDirectory())
             throw new Error(`unknown skill: ${name}`);
@@ -85,6 +95,23 @@ export class SkillReader {
         return target;
     }
 }
+function normalizeLegacySkillName(name) {
+    return name.startsWith(LEGACY_SKILL_PREFIX)
+        ? `${SKILL_PREFIX}${name.slice(LEGACY_SKILL_PREFIX.length)}`
+        : name;
+}
+function existsDirectoryWithSkill(skillRoot) {
+    try {
+        const info = statSync(skillRoot);
+        if (!info.isDirectory())
+            return false;
+        statSync(resolve(skillRoot, 'SKILL.md'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function splitTarget(target) {
     const index = target.indexOf('/');
     if (index === -1)

package/dist/shortcuts/archive/continuation.js

@@ -0,0 +1,70 @@
+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 { archiveValidationError } 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, 'archive-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');
+}
+export function createArchiveContinuationSigner(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 archiveValidationError('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 archiveValidationError('continuation_invalid', 'continuation 签名校验失败');
+            let value;
+            try {
+                value = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+            }
+            catch {
+                throw archiveValidationError('continuation_invalid', 'continuation 内容无法解析');
+            }
+            if (value.operation !== expectedOperation) {
+                throw archiveValidationError('continuation_mismatch', 'continuation 不属于当前操作');
+            }
+            if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+                throw archiveValidationError('continuation_expired', 'continuation 已过期');
+            }
+            return value;
+        },
+    };
+}

package/dist/shortcuts/archive/errors.js

@@ -0,0 +1,53 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+export class ArchiveCliError extends CliError {
+    type;
+    subtype;
+    code;
+    retryable;
+    stage;
+    details;
+    partialData;
+    constructor(type, subtype, message, options = {}) {
+        super(message, options.exitCode ?? ExitCode.InternalError);
+        this.name = 'ArchiveCliError';
+        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 archiveValidationError(subtype, message, details) {
+    return new ArchiveCliError('validation', subtype, message, {
+        details,
+        exitCode: ExitCode.UsageError,
+    });
+}
+export function archiveAuthError(subtype, message, details) {
+    return new ArchiveCliError('authentication', subtype, message, {
+        details,
+        exitCode: ExitCode.AuthError,
+    });
+}
+export function archiveNetworkError(subtype, message, options = {}) {
+    return new ArchiveCliError('network', subtype, message, {
+        ...options,
+        retryable: options.retryable ?? true,
+        exitCode: ExitCode.NetworkError,
+    });
+}
+export function archiveConfirmationError(action, details) {
+    return new ArchiveCliError('confirmation', 'required', '该操作需要明确确认', {
+        details: { action, ...details },
+        exitCode: ExitCode.ConfirmationRequired,
+    });
+}
+export function archivePartialError(message, partialData, details) {
+    return new ArchiveCliError('partial', 'write_uncertain', message, {
+        details,
+        partialData,
+        exitCode: ExitCode.Partial,
+    });
+}