vps-work 2.4.1 → 2.5.1

package/dist/packages/vps-work/src/core/v-drive-store.js

@@ -0,0 +1,392 @@
+import { randomUUID } from 'node:crypto';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { VertuError } from './errors.js';
+const EMPTY_DATABASE = { items: [], spaces: [], transfers: [] };
+function cleanName(value, fallback) {
+    const name = String(value ?? '').trim().replaceAll('/', '-').replaceAll('\\', '-');
+    return name.slice(0, 160) || fallback;
+}
+function mimeFromName(name) {
+    const extension = extname(name).toLowerCase();
+    const types = {
+        '.csv': 'text/csv',
+        '.doc': 'application/msword',
+        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.gif': 'image/gif',
+        '.jpeg': 'image/jpeg',
+        '.jpg': 'image/jpeg',
+        '.json': 'application/json',
+        '.md': 'text/markdown',
+        '.mkv': 'video/x-matroska',
+        '.mov': 'video/quicktime',
+        '.mp4': 'video/mp4',
+        '.pdf': 'application/pdf',
+        '.png': 'image/png',
+        '.ppt': 'application/vnd.ms-powerpoint',
+        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        '.txt': 'text/plain',
+        '.webp': 'image/webp',
+        '.webm': 'video/webm',
+        '.avi': 'video/x-msvideo',
+        '.xls': 'application/vnd.ms-excel',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.zip': 'application/zip',
+        '.rar': 'application/vnd.rar',
+        '.7z': 'application/x-7z-compressed',
+        '.tar': 'application/x-tar',
+        '.gz': 'application/gzip',
+        '.bz2': 'application/x-bzip2',
+        '.xz': 'application/x-xz',
+    };
+    return types[extension] ?? 'application/octet-stream';
+}
+export function defaultVDriveRoot() {
+    const override = process.env.VERTU_V_DRIVE_ROOT?.trim();
+    if (override)
+        return resolve(override);
+    if (process.platform === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'vertu-im-desktop', 'v-drive');
+    }
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+        return join(appData, 'vertu-im-desktop', 'v-drive');
+    }
+    const configRoot = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+    return join(configRoot, 'vertu-im-desktop', 'v-drive');
+}
+export class VDriveStore {
+    root;
+    filesDir;
+    databasePath;
+    constructor(root = defaultVDriveRoot()) {
+        this.root = resolve(root);
+        this.filesDir = join(this.root, 'files');
+        this.databasePath = join(this.root, 'index.json');
+    }
+    list(parentId, recursive, query) {
+        const database = this.read();
+        this.assertFolder(database, parentId);
+        const normalizedQuery = query?.trim().toLocaleLowerCase();
+        const descendantIds = recursive && parentId ? this.descendantIds(database, parentId) : null;
+        return database.items
+            .filter((item) => {
+            if (item.deletedAt)
+                return false;
+            const inScope = recursive
+                ? parentId === null || descendantIds?.has(item.id)
+                : item.parentId === parentId;
+            return inScope && (!normalizedQuery || item.name.toLocaleLowerCase().includes(normalizedQuery));
+        })
+            .map((item) => this.publicItem(item));
+    }
+    info(itemId) {
+        return this.publicItem(this.requireItem(this.read(), itemId));
+    }
+    usedBytes() {
+        return this.read().items.reduce((total, item) => total + (item.kind === 'file' ? item.sizeBytes : 0), 0);
+    }
+    trash() {
+        return this.read().items
+            .filter((item) => item.deletedAt && item.trashRootId === item.id)
+            .map((item) => ({
+            ...this.publicItem(item),
+            deletedAt: item.deletedAt,
+        }));
+    }
+    transfers() {
+        return this.read().transfers;
+    }
+    createFolder(parentId, name, actor) {
+        const database = this.read();
+        this.assertFolder(database, parentId);
+        const now = new Date().toISOString();
+        const item = {
+            id: randomUUID(),
+            name: cleanName(name, '新建文件夹'),
+            kind: 'folder',
+            parentId,
+            mimeType: null,
+            sizeBytes: 0,
+            createdAt: now,
+            updatedAt: now,
+            updatedBy: actor,
+            sharedSpaceIds: [],
+            storedName: null,
+        };
+        database.items.push(item);
+        this.write(database);
+        return this.publicItem(item);
+    }
+    createTextFile(parentId, name, content, actor) {
+        const database = this.read();
+        this.assertFolder(database, parentId);
+        const id = randomUUID();
+        const now = new Date().toISOString();
+        const fileName = cleanName(name, '新建文本.txt');
+        const storedName = `${id}${extname(fileName) || '.txt'}`;
+        this.ensureRoot();
+        writeFileSync(join(this.filesDir, storedName), content, 'utf8');
+        const item = {
+            id,
+            name: fileName,
+            kind: 'file',
+            parentId,
+            mimeType: mimeFromName(fileName),
+            sizeBytes: Buffer.byteLength(content),
+            createdAt: now,
+            updatedAt: now,
+            updatedBy: actor,
+            sharedSpaceIds: [],
+            storedName,
+        };
+        database.items.push(item);
+        this.write(database);
+        return this.publicItem(item);
+    }
+    importFiles(parentId, paths, actor) {
+        const database = this.read();
+        this.assertFolder(database, parentId);
+        const sourcePaths = paths.map((rawPath) => {
+            const sourcePath = resolve(rawPath);
+            if (!existsSync(sourcePath) || !statSync(sourcePath).isFile()) {
+                throw new VertuError(`上传源文件不存在或不是普通文件：${rawPath}`);
+            }
+            return sourcePath;
+        });
+        const imported = [];
+        for (const sourcePath of sourcePaths) {
+            const id = randomUUID();
+            const now = new Date().toISOString();
+            const name = cleanName(basename(sourcePath), '未命名文件');
+            const storedName = `${id}${extname(name)}`;
+            this.ensureRoot();
+            copyFileSync(sourcePath, join(this.filesDir, storedName));
+            const sizeBytes = statSync(sourcePath).size;
+            const item = {
+                id,
+                name,
+                kind: 'file',
+                parentId,
+                mimeType: mimeFromName(name),
+                sizeBytes,
+                createdAt: now,
+                updatedAt: now,
+                updatedBy: actor,
+                sharedSpaceIds: [],
+                storedName,
+            };
+            database.items.push(item);
+            imported.push(item);
+            database.transfers.unshift({
+                id: randomUUID(),
+                direction: 'upload',
+                name,
+                sizeBytes,
+                completedAt: now,
+                itemId: id,
+            });
+        }
+        database.transfers = database.transfers.slice(0, 100);
+        this.write(database);
+        return imported.map((item) => this.publicItem(item));
+    }
+    readFile(itemId) {
+        const database = this.read();
+        const item = this.requireFile(database, itemId);
+        return { item: this.publicItem(item), bytes: readFileSync(this.filePathFor(item)) };
+    }
+    writeText(itemId, content, actor) {
+        const database = this.read();
+        const item = this.requireFile(database, itemId);
+        writeFileSync(this.filePathFor(item), content, 'utf8');
+        item.sizeBytes = Buffer.byteLength(content);
+        item.updatedAt = new Date().toISOString();
+        item.updatedBy = actor;
+        this.write(database);
+        return this.publicItem(item);
+    }
+    download(itemId, outputPath, overwrite) {
+        const database = this.read();
+        const item = this.requireFile(database, itemId);
+        const requested = resolve(outputPath);
+        const target = existsSync(requested) && statSync(requested).isDirectory()
+            ? join(requested, item.name)
+            : requested;
+        if (existsSync(target) && !overwrite) {
+            throw new VertuError(`目标文件已存在：${target}；如需覆盖请显式传 --overwrite。`);
+        }
+        mkdirSync(dirname(target), { recursive: true });
+        copyFileSync(this.filePathFor(item), target);
+        database.transfers.unshift({
+            id: randomUUID(),
+            direction: 'download',
+            name: item.name,
+            sizeBytes: item.sizeBytes,
+            completedAt: new Date().toISOString(),
+            filePath: target,
+        });
+        database.transfers = database.transfers.slice(0, 100);
+        this.write(database);
+        return { item: this.publicItem(item), filePath: target };
+    }
+    rename(itemId, name, actor) {
+        const database = this.read();
+        const item = this.requireItem(database, itemId);
+        item.name = cleanName(name, item.name);
+        item.updatedAt = new Date().toISOString();
+        item.updatedBy = actor;
+        this.write(database);
+        return this.publicItem(item);
+    }
+    move(itemId, parentId, actor) {
+        const database = this.read();
+        const item = this.requireItem(database, itemId);
+        this.assertFolder(database, parentId);
+        if (item.id === parentId || this.descendantIds(database, item.id).has(parentId ?? '')) {
+            throw new VertuError('不能将文件夹移动到自身或其子文件夹中。');
+        }
+        item.parentId = parentId;
+        item.updatedAt = new Date().toISOString();
+        item.updatedBy = actor;
+        this.write(database);
+        return this.publicItem(item);
+    }
+    remove(itemId) {
+        const database = this.read();
+        const root = this.requireItem(database, itemId);
+        const removedIds = this.descendantIds(database, itemId);
+        removedIds.add(itemId);
+        const deletedAt = new Date().toISOString();
+        for (const item of database.items) {
+            if (!removedIds.has(item.id))
+                continue;
+            item.deletedAt = deletedAt;
+            item.trashRootId = itemId;
+        }
+        this.write(database);
+        return { ...this.publicItem(root), deletedAt };
+    }
+    restore(itemId) {
+        const database = this.read();
+        const root = database.items.find((item) => item.id === itemId && item.deletedAt && item.trashRootId === item.id);
+        if (!root)
+            throw new VertuError('回收站项目不存在。');
+        const activeParent = root.parentId
+            ? database.items.some((item) => item.id === root.parentId && !item.deletedAt)
+            : true;
+        if (!activeParent)
+            root.parentId = null;
+        for (const item of database.items) {
+            if (item.trashRootId !== itemId)
+                continue;
+            item.deletedAt = null;
+            item.trashRootId = null;
+        }
+        this.write(database);
+        return this.publicItem(root);
+    }
+    purge(itemId) {
+        const database = this.read();
+        const root = database.items.find((item) => item.id === itemId && item.deletedAt && item.trashRootId === item.id);
+        if (!root)
+            throw new VertuError('回收站项目不存在。');
+        const removed = {
+            ...this.publicItem(root),
+            deletedAt: root.deletedAt,
+        };
+        for (const item of database.items) {
+            if (item.trashRootId === itemId && item.storedName) {
+                rmSync(join(this.filesDir, item.storedName), { force: true });
+            }
+        }
+        database.items = database.items.filter((item) => item.trashRootId !== itemId);
+        this.write(database);
+        return removed;
+    }
+    emptyTrash() {
+        const database = this.read();
+        const purgedItems = database.items.filter((item) => item.deletedAt).length;
+        for (const item of database.items) {
+            if (item.deletedAt && item.storedName) {
+                rmSync(join(this.filesDir, item.storedName), { force: true });
+            }
+        }
+        database.items = database.items.filter((item) => !item.deletedAt);
+        this.write(database);
+        return { purgedItems };
+    }
+    ensureRoot() {
+        mkdirSync(this.filesDir, { recursive: true });
+    }
+    read() {
+        this.ensureRoot();
+        if (!existsSync(this.databasePath)) {
+            return { ...EMPTY_DATABASE, items: [], spaces: [], transfers: [] };
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(this.databasePath, 'utf8'));
+            return {
+                items: Array.isArray(parsed.items) ? parsed.items : [],
+                spaces: Array.isArray(parsed.spaces) ? parsed.spaces : [],
+                transfers: Array.isArray(parsed.transfers) ? parsed.transfers : [],
+            };
+        }
+        catch {
+            throw new VertuError(`V盘索引无法解析：${this.databasePath}`);
+        }
+    }
+    write(database) {
+        this.ensureRoot();
+        writeFileSync(this.databasePath, JSON.stringify(database, null, 2), 'utf8');
+    }
+    publicItem(item) {
+        const { storedName: _storedName, deletedAt: _deletedAt, trashRootId: _trashRootId, ...publicItem } = item;
+        return publicItem;
+    }
+    requireItem(database, itemId) {
+        const item = database.items.find((candidate) => candidate.id === itemId && !candidate.deletedAt);
+        if (!item)
+            throw new VertuError('文件或文件夹不存在。');
+        return item;
+    }
+    requireFile(database, itemId) {
+        const item = this.requireItem(database, itemId);
+        if (item.kind !== 'file' || !item.storedName) {
+            throw new VertuError('所选项目不是文件。');
+        }
+        return item;
+    }
+    assertFolder(database, parentId) {
+        if (parentId === null)
+            return;
+        const parent = this.requireItem(database, parentId);
+        if (parent.kind !== 'folder')
+            throw new VertuError('目标位置不是文件夹。');
+    }
+    filePathFor(item) {
+        if (!item.storedName)
+            throw new VertuError('文件内容不存在。');
+        const filePath = join(this.filesDir, item.storedName);
+        if (!existsSync(filePath))
+            throw new VertuError('文件内容不存在。');
+        return filePath;
+    }
+    descendantIds(database, itemId) {
+        const result = new Set();
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const item of database.items) {
+                if (!item.deletedAt
+                    && (item.parentId === itemId || (item.parentId && result.has(item.parentId)))
+                    && !result.has(item.id)) {
+                    result.add(item.id);
+                    changed = true;
+                }
+            }
+        }
+        return result;
+    }
+}

package/dist/packages/vps-work/src/core/vertu-agent-env.js

@@ -0,0 +1,32 @@
+/** Agent 宿主注入的环境变量（人类 login 后由 CLI 签发 app_key，写入宿主配置）。 */
+export const VERTU_APP_ID_ENV = 'VERTU_APP_ID';
+export const VERTU_APP_KEY_ENV = 'VERTU_APP_KEY';
+export const VERTU_USER_LOGIN_ENV = 'VERTU_USER_LOGIN';
+export const VERTU_VPS_SERVICE_URL_ENV = 'VERTU_VPS_SERVICE_URL';
+export const VERTU_ACCESS_TOKEN_ENV = 'VERTU_ACCESS_TOKEN';
+export const VERTU_EXPECTED_USER_ID_ENV = 'VERTU_EXPECTED_USER_ID';
+export const DEFAULT_AGENT_APP_ID = 'cursor';
+/** 服务端 vps_auth_trusted_apps 中登记的智能体宿主（非 vertu-cli 本身）。 */
+export const TRUSTED_AGENT_APP_IDS = ['cursor', 'openclaw', 'hermes'];
+export function readVertuAgentEnvFromProcess() {
+    const trim = (key) => {
+        const v = process.env[key]?.trim();
+        return v || undefined;
+    };
+    return {
+        serviceUrl: trim(VERTU_VPS_SERVICE_URL_ENV),
+        appId: trim(VERTU_APP_ID_ENV),
+        appKey: trim(VERTU_APP_KEY_ENV),
+        login: trim(VERTU_USER_LOGIN_ENV),
+    };
+}
+export function formatAgentEnvExports(serviceUrl, appId, appKey, login) {
+    const lines = [
+        `# Vertu Agent — 注入到 Cursor / OpenClaw 等宿主环境`,
+        `export ${VERTU_VPS_SERVICE_URL_ENV}='${serviceUrl.replace(/'/g, "'\\''")}'`,
+        `export ${VERTU_APP_ID_ENV}='${appId.replace(/'/g, "'\\''")}'`,
+        `export ${VERTU_APP_KEY_ENV}='${appKey.replace(/'/g, "'\\''")}'`,
+        `export ${VERTU_USER_LOGIN_ENV}='${login.replace(/'/g, "'\\''")}'`,
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/packages/vps-work/src/core/vps-auth-scopes.js

@@ -0,0 +1,73 @@
+import { request } from 'undici';
+import { VertuError } from './errors.js';
+import { resolveVpsServiceUrl } from './sales-query-client.js';
+import { vpsServiceAuthHeaders } from './vps-service-http.js';
+export async function fetchVpsUserScopes(serviceBaseUrl, scopeCheck) {
+    const base = resolveVpsServiceUrl(serviceBaseUrl);
+    const headers = vpsServiceAuthHeaders(base);
+    if (!headers.authorization) {
+        throw new VertuError('未认证。Agent/Bot/Hermes 请检查宿主注入的 app_key；仅人工用户可交互执行 `vps-work auth login`。');
+    }
+    const query = scopeCheck?.trim() ? `?scope=${encodeURIComponent(scopeCheck.trim())}` : '';
+    const res = await request(`${base}/v1/auth/scopes${query}`, {
+        method: 'GET',
+        headers: {
+            accept: 'application/json',
+            ...headers,
+        },
+    });
+    const text = await res.body.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new VertuError(`查询 scope 失败：非 JSON（HTTP ${res.statusCode}）`);
+    }
+    if (res.statusCode >= 400) {
+        const errMsg = data && typeof data === 'object' && 'error' in data
+            ? String(data.error)
+            : `HTTP ${res.statusCode}`;
+        throw new VertuError(`查询 scope 失败：${errMsg}`);
+    }
+    if (!data || typeof data !== 'object') {
+        throw new VertuError('查询 scope 失败：响应无效');
+    }
+    return data;
+}
+export function userHasVpsScope(scopes, required) {
+    const scope = required.trim();
+    if (!scope) {
+        return false;
+    }
+    if (scope === 'hr.payslip.dept:read') {
+        return scopes.includes(scope) || scopes.includes('hr.payslip.dept:*');
+    }
+    if (scope === 'sales.performance.all:read') {
+        return scopes.includes(scope) || scopes.includes('sales.performance.all:*');
+    }
+    if (scope === 'sales.pii:read') {
+        return scopes.includes(scope) || scopes.includes('sales.pii:*');
+    }
+    if (scope === 'sales.customer_region.all:read') {
+        return scopes.includes(scope) || scopes.includes('sales.customer_region.all:*');
+    }
+    if (scope === 'product.device_abnormal:read') {
+        return scopes.includes(scope) || scopes.includes('product.device_abnormal:*');
+    }
+    if (scope.startsWith('hr.profile.') || scope.startsWith('corporate.')) {
+        const resource = scope.split(':')[0];
+        return scopes.includes(scope) || scopes.includes(`${resource}:*`);
+    }
+    if (scopes.includes(scope)) {
+        return true;
+    }
+    const [resource] = scope.split(':');
+    if (resource && scopes.includes(`${resource}:*`)) {
+        return true;
+    }
+    if (scopes.includes('admin:*')) {
+        return true;
+    }
+    return false;
+}