weaver-work-cli 0.1.0

package/dist/internal/e10/context.js

@@ -0,0 +1,20 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+import { E10AuthSession } from './auth/session.js';
+import { E10ApiClient } from './client.js';
+export async function getE10Session(ctx) {
+    return E10AuthSession.fromOptions(ctx.getGlobalOptions(), ctx.cwd);
+}
+export async function requireE10Session(ctx) {
+    const session = await getE10Session(ctx);
+    if (!session) {
+        throw new CliError('E10 auth not found. Ask the user for the E10 login domain (base URL), then run: weaver-work-cli auth login --base-url <url>.', ExitCode.AuthError);
+    }
+    return session;
+}
+export async function getE10Client(ctx) {
+    const session = await getE10Session(ctx);
+    return session ? new E10ApiClient(session) : null;
+}
+export async function requireE10Client(ctx) {
+    return new E10ApiClient(await requireE10Session(ctx));
+}

package/dist/internal/e10/index.js

@@ -0,0 +1,2 @@
+export { E10ApiClient } from './client.js';
+export { getE10Client, getE10Session, requireE10Client, requireE10Session } from './context.js';

package/dist/internal/e10/types.js

@@ -0,0 +1 @@
+export {};

package/dist/internal/skills/install.js

@@ -0,0 +1,99 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, statSync } 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';
+export function defaultCodexSkillsRoot(env = process.env) {
+    const codexHome = env.CODEX_HOME || resolve(homedir(), '.codex');
+    return resolve(codexHome, 'skills');
+}
+export function normalizePackagedSkillName(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === 'all')
+        return trimmed;
+    if (trimmed.includes('/') || trimmed.includes('\\') || trimmed === '.' || trimmed === '..') {
+        throw new Error(`invalid skill name: ${value}`);
+    }
+    if (!/^[A-Za-z0-9._-]+$/u.test(trimmed)) {
+        throw new Error(`invalid skill name: ${value}`);
+    }
+    return trimmed.startsWith(SKILL_PREFIX) ? trimmed : `${SKILL_PREFIX}${trimmed}`;
+}
+export function resolvePackagedSkillNames(sourceRoot, requested = 'all') {
+    const available = readdirSync(sourceRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && existsSync(resolve(sourceRoot, entry.name, 'SKILL.md')))
+        .map((entry) => entry.name)
+        .sort();
+    const normalized = normalizePackagedSkillName(requested);
+    if (!normalized || normalized === 'all')
+        return available;
+    if (!available.includes(normalized)) {
+        throw new Error(`unknown packaged skill: ${normalized}`);
+    }
+    const names = [];
+    if (normalized !== SHARED_SKILL_NAME && available.includes(SHARED_SKILL_NAME)) {
+        names.push(SHARED_SKILL_NAME);
+    }
+    names.push(normalized);
+    return names;
+}
+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 source = resolveInside(resolvedSourceRoot, name);
+        const target = resolve(resolvedTargetRoot, basename(name));
+        statSync(resolve(source, 'SKILL.md'));
+        cpSync(source, target, {
+            recursive: true,
+            force: true,
+            filter: (entry) => shouldCopy(entry, source),
+        });
+        return {
+            name,
+            source,
+            target,
+            files: countFiles(target),
+        };
+    });
+    return {
+        sourceRoot: resolvedSourceRoot,
+        targetRoot: resolvedTargetRoot,
+        skillNames,
+        installed,
+    };
+}
+function shouldCopy(entry, sourceRoot) {
+    const relativePath = relative(sourceRoot, entry);
+    const name = basename(entry);
+    if (!relativePath)
+        return true;
+    if (name === '.DS_Store' || name.startsWith('.'))
+        return false;
+    const parts = relativePath.split(sep);
+    return !parts.includes('node_modules') && !parts.includes('scripts') && !parts.includes('assets');
+}
+function countFiles(root) {
+    let count = 0;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const child = resolve(root, entry.name);
+        if (entry.isDirectory())
+            count += countFiles(child);
+        if (entry.isFile())
+            count += 1;
+    }
+    return count;
+}
+function resolveInside(base, subpath = '') {
+    if (subpath.startsWith('/') || subpath.split(/[\\/]/u).includes('..')) {
+        throw new Error(`invalid skill path: ${subpath}`);
+    }
+    const target = resolve(base, subpath || '.');
+    const rel = relative(base, target);
+    if (rel === '..' || rel.startsWith(`..${sep}`)) {
+        throw new Error(`invalid skill path: ${subpath}`);
+    }
+    return target;
+}

package/dist/internal/skills/reader.js

@@ -0,0 +1,119 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { relative, resolve, sep } from 'node:path';
+export class SkillReader {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    list() {
+        return readdirSync(this.root, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => this.skillInfo(entry.name))
+            .filter((entry) => Boolean(entry))
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
+    listPath(target) {
+        const { name, subpath } = splitTarget(target);
+        const skillRoot = this.ensureSkill(name);
+        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 entries = readdirSync(dir, { withFileTypes: true })
+            .map((entry) => ({
+            path: cleanOutputPath(listed, entry.name),
+            isDir: entry.isDirectory(),
+        }))
+            .sort((a, b) => a.path.localeCompare(b.path));
+        return { path: listed, entries };
+    }
+    read(target, pathArg = '') {
+        const split = splitTarget(target);
+        const name = split.name;
+        const subpath = pathArg || split.subpath || 'SKILL.md';
+        const skillRoot = this.ensureSkill(name);
+        const file = this.resolveInside(skillRoot, subpath);
+        const info = statSync(file);
+        if (info.isDirectory()) {
+            throw new Error(`path is a directory, not a file: ${cleanOutputPath(name, subpath)}`);
+        }
+        return {
+            skill: name,
+            path: cleanOutputPath(subpath),
+            content: readFileSync(file, 'utf-8'),
+        };
+    }
+    skillInfo(name) {
+        try {
+            const skillRoot = this.ensureSkill(name);
+            const content = readFileSync(resolve(skillRoot, 'SKILL.md'), 'utf-8');
+            const frontmatter = parseFrontmatter(content);
+            return {
+                name,
+                title: frontmatter.name,
+                description: frontmatter.description,
+                version: frontmatter.version,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    ensureSkill(name) {
+        if (!name || name.includes('/') || name.includes('\\') || name === '.' || name === '..') {
+            throw new Error(`unknown skill: ${name}`);
+        }
+        const skillRoot = this.resolveInside(this.root, name);
+        const info = statSync(skillRoot);
+        if (!info.isDirectory())
+            throw new Error(`unknown skill: ${name}`);
+        statSync(resolve(skillRoot, 'SKILL.md'));
+        return skillRoot;
+    }
+    resolveInside(base, subpath = '') {
+        const cleaned = subpath.replace(/\\/g, '/');
+        if (cleaned.startsWith('/') || cleaned.split('/').includes('..')) {
+            throw new Error(`invalid skill path: ${subpath}`);
+        }
+        const target = resolve(base, cleaned || '.');
+        const rel = relative(base, target);
+        if (rel === '..' || rel.startsWith(`..${sep}`) || resolve(base) === target && cleaned === '..') {
+            throw new Error(`invalid skill path: ${subpath}`);
+        }
+        return target;
+    }
+}
+export function splitTarget(target) {
+    const index = target.indexOf('/');
+    if (index === -1)
+        return { name: target, subpath: '' };
+    return {
+        name: target.slice(0, index),
+        subpath: target.slice(index + 1),
+    };
+}
+function cleanOutputPath(...parts) {
+    return parts
+        .filter(Boolean)
+        .join('/')
+        .replace(/\/+/g, '/')
+        .replace(/^\.\//, '');
+}
+function parseFrontmatter(content) {
+    const lines = content.split(/\r?\n/u);
+    if (lines[0] !== '---')
+        return {};
+    const result = {};
+    for (let index = 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line === '---')
+            return result;
+        const match = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/u);
+        if (!match)
+            continue;
+        result[match[1]] = match[2].replace(/^['"]|['"]$/g, '');
+    }
+    return {};
+}

package/dist/services/command-runner.js

@@ -0,0 +1,44 @@
+import { spawn } from 'node:child_process';
+export class CommandRunner {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async run(command, args = [], options = {}) {
+        const runContext = {
+            cwd: options.cwd || this.ctx.cwd,
+            command,
+            args,
+            env: options.env || this.ctx.env,
+            shell: options.shell,
+        };
+        await this.ctx.hooks.beforeRun(runContext);
+        const result = await new Promise((resolve) => {
+            const child = spawn(command, args, {
+                cwd: runContext.cwd,
+                env: runContext.env,
+                shell: runContext.shell,
+                stdio: options.stdio === 'inherit' ? 'inherit' : 'pipe',
+            });
+            const stdout = [];
+            const stderr = [];
+            if (child.stdout)
+                child.stdout.on('data', (chunk) => stdout.push(chunk));
+            if (child.stderr)
+                child.stderr.on('data', (chunk) => stderr.push(chunk));
+            child.on('close', (code, signal) => {
+                resolve({
+                    command,
+                    args,
+                    cwd: runContext.cwd,
+                    code,
+                    signal,
+                    stdout: Buffer.concat(stdout).toString('utf-8'),
+                    stderr: Buffer.concat(stderr).toString('utf-8'),
+                });
+            });
+        });
+        await this.ctx.hooks.afterRun(runContext, result);
+        return result;
+    }
+}

package/dist/shortcuts/index.js

@@ -0,0 +1,4 @@
+import { invoiceShortcut } from './invoice/index.js';
+export const builtinShortcuts = [
+    invoiceShortcut,
+];

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

package/dist/shortcuts/invoice/errors.js

@@ -0,0 +1,59 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+export class InvoiceCliError extends CliError {
+    type;
+    subtype;
+    code;
+    retryable;
+    stage;
+    details;
+    partialData;
+    constructor(type, subtype, message, options = {}) {
+        super(message, options.exitCode ?? ExitCode.InternalError);
+        this.name = 'InvoiceCliError';
+        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 invoiceValidationError(subtype, message, details) {
+    return new InvoiceCliError('validation', subtype, message, {
+        details,
+        exitCode: ExitCode.UsageError,
+    });
+}
+export function invoiceAuthError(subtype, message, details) {
+    return new InvoiceCliError('authentication', subtype, message, {
+        details,
+        exitCode: ExitCode.AuthError,
+    });
+}
+export function invoiceNetworkError(subtype, message, options = {}) {
+    return new InvoiceCliError('network', subtype, message, {
+        ...options,
+        retryable: options.retryable ?? true,
+        exitCode: ExitCode.NetworkError,
+    });
+}
+export function invoiceConfirmationError(action, details) {
+    return new InvoiceCliError('confirmation', 'required', '该操作需要明确确认', {
+        details: { action, ...details },
+        exitCode: ExitCode.ConfirmationRequired,
+    });
+}
+export function invoicePartialError(message, partialData, details) {
+    return new InvoiceCliError('partial', 'write_uncertain', message, {
+        details,
+        partialData,
+        exitCode: ExitCode.Partial,
+    });
+}
+export function isInvoiceNetworkError(error) {
+    return Boolean(error
+        && typeof error === 'object'
+        && 'type' in error
+        && error.type === 'network');
+}