@next-open-ai/openclawx 0.6.6

package/dist/server/users/users.module.d.ts

@@ -0,0 +1,2 @@
+export declare class UsersModule {
+}

package/dist/server/users/users.module.js

@@ -0,0 +1,19 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Module } from '@nestjs/common';
+import { UsersController } from './users.controller.js';
+import { UsersService } from './users.service.js';
+let UsersModule = class UsersModule {
+};
+UsersModule = __decorate([
+    Module({
+        controllers: [UsersController],
+        providers: [UsersService],
+        exports: [UsersService],
+    })
+], UsersModule);
+export { UsersModule };

package/dist/server/users/users.service.d.ts

@@ -0,0 +1,39 @@
+export interface UserItem {
+    id: string;
+    username: string;
+    password: string;
+}
+export declare class UsersService {
+    private usersPath;
+    constructor();
+    private load;
+    private save;
+    list(): Promise<{
+        id: string;
+        username: string;
+    }[]>;
+    create(username: string, password: string): Promise<{
+        id: string;
+        username: string;
+    }>;
+    update(id: string, updates: {
+        username?: string;
+        password?: string;
+    }): Promise<{
+        id: string;
+        username: string;
+    }>;
+    delete(id: string): Promise<void>;
+    validateCredentials(username: string, password: string): Promise<boolean>;
+    /** 根据用户名查找用户（用于登录后返回当前用户信息） */
+    findByUsername(username: string): Promise<{
+        id: string;
+        username: string;
+    } | null>;
+    hasUsers(): Promise<boolean>;
+    /** 确保缺省 admin 用户存在，若不存在则创建并保存。返回该用户的 { id, username } */
+    ensureDefaultAdmin(): Promise<{
+        id: string;
+        username: string;
+    }>;
+}

package/dist/server/users/users.service.js

@@ -0,0 +1,140 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable, ConflictException, NotFoundException } from '@nestjs/common';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { randomUUID } from 'crypto';
+const DEFAULT_ADMIN_USERNAME = 'admin';
+const DEFAULT_ADMIN_PASSWORD = '123456';
+let UsersService = class UsersService {
+    usersPath;
+    constructor() {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        const configDir = join(homeDir, '.openbot', 'desktop');
+        this.usersPath = join(configDir, 'users.json');
+        if (!existsSync(configDir)) {
+            mkdir(configDir, { recursive: true });
+        }
+    }
+    async load() {
+        let users = [];
+        try {
+            if (existsSync(this.usersPath)) {
+                const content = await readFile(this.usersPath, 'utf-8');
+                const data = JSON.parse(content);
+                users = Array.isArray(data.users) ? data.users : [];
+            }
+        }
+        catch (e) {
+            console.error('Load users failed:', e);
+        }
+        if (users.length === 0) {
+            const defaultAdmin = {
+                id: randomUUID(),
+                username: DEFAULT_ADMIN_USERNAME,
+                password: DEFAULT_ADMIN_PASSWORD,
+            };
+            users = [defaultAdmin];
+            await this.save(users);
+        }
+        return users;
+    }
+    async save(users) {
+        await writeFile(this.usersPath, JSON.stringify({ users }, null, 2));
+    }
+    async list() {
+        const users = await this.load();
+        return users.map((u) => ({ id: u.id, username: u.username }));
+    }
+    async create(username, password) {
+        const trimmed = (username ?? '').trim();
+        const pass = (password ?? '').trim();
+        if (!trimmed)
+            throw new ConflictException('Username is required');
+        const users = await this.load();
+        const lower = trimmed.toLowerCase();
+        if (users.some((u) => u.username.toLowerCase() === lower)) {
+            throw new ConflictException('Username already exists');
+        }
+        const id = randomUUID();
+        users.push({ id, username: trimmed, password: pass });
+        await this.save(users);
+        return { id, username: trimmed };
+    }
+    async update(id, updates) {
+        const users = await this.load();
+        const idx = users.findIndex((u) => u.id === id);
+        if (idx < 0)
+            throw new NotFoundException('User not found');
+        if (updates.username !== undefined) {
+            const trimmed = updates.username.trim();
+            if (!trimmed)
+                throw new ConflictException('Username is required');
+            const lower = trimmed.toLowerCase();
+            if (users.some((u, i) => i !== idx && u.username.toLowerCase() === lower)) {
+                throw new ConflictException('Username already exists');
+            }
+            users[idx].username = trimmed;
+        }
+        if (updates.password !== undefined) {
+            users[idx].password = updates.password.trim();
+        }
+        await this.save(users);
+        return { id: users[idx].id, username: users[idx].username };
+    }
+    async delete(id) {
+        const users = await this.load();
+        const filtered = users.filter((u) => u.id !== id);
+        if (filtered.length === users.length)
+            throw new NotFoundException('User not found');
+        await this.save(filtered);
+    }
+    async validateCredentials(username, password) {
+        const users = await this.load();
+        if (users.length === 0)
+            return false;
+        const user = (username ?? '').trim().toLowerCase();
+        const pass = (password ?? '').trim();
+        const found = users.find((u) => u.username.toLowerCase() === user);
+        return found ? found.password === pass : false;
+    }
+    /** 根据用户名查找用户（用于登录后返回当前用户信息） */
+    async findByUsername(username) {
+        const users = await this.load();
+        const lower = (username ?? '').trim().toLowerCase();
+        const found = users.find((u) => u.username.toLowerCase() === lower);
+        return found ? { id: found.id, username: found.username } : null;
+    }
+    async hasUsers() {
+        const users = await this.load();
+        return users.length > 0;
+    }
+    /** 确保缺省 admin 用户存在，若不存在则创建并保存。返回该用户的 { id, username } */
+    async ensureDefaultAdmin() {
+        const users = await this.load();
+        const existing = users.find((u) => u.username.toLowerCase() === DEFAULT_ADMIN_USERNAME.toLowerCase());
+        if (existing)
+            return { id: existing.id, username: existing.username };
+        const defaultAdmin = {
+            id: randomUUID(),
+            username: DEFAULT_ADMIN_USERNAME,
+            password: DEFAULT_ADMIN_PASSWORD,
+        };
+        users.push(defaultAdmin);
+        await this.save(users);
+        return { id: defaultAdmin.id, username: defaultAdmin.username };
+    }
+};
+UsersService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [])
+], UsersService);
+export { UsersService };

package/dist/server/workspace/workspace.controller.d.ts

@@ -0,0 +1,24 @@
+import { Response } from 'express';
+import { WorkspaceService } from './workspace.service.js';
+import { ConfigService } from '../config/config.service.js';
+export declare class WorkspaceController {
+    private readonly workspaceService;
+    private readonly configService;
+    constructor(workspaceService: WorkspaceService, configService: ConfigService);
+    listWorkspaces(): Promise<{
+        success: boolean;
+        data: string[];
+    }>;
+    getCurrentWorkspace(): Promise<{
+        success: boolean;
+        data: string;
+    }>;
+    listDocuments(workspace: string, path?: string): Promise<{
+        success: boolean;
+        data: import("./workspace.service.js").WorkspaceItem[];
+    }>;
+    serveFile(workspace: string, path: string, download: string, res: Response): Promise<void>;
+    deleteDocument(workspace: string, path: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/server/workspace/workspace.controller.js

@@ -0,0 +1,132 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Get, Delete, Query, Res, HttpException, HttpStatus, NotFoundException, } from '@nestjs/common';
+import { createReadStream } from 'fs';
+import { existsSync } from 'fs';
+import { stat } from 'fs/promises';
+import { WorkspaceService } from './workspace.service.js';
+import { ConfigService } from '../config/config.service.js';
+const PREVIEW_TYPES = new Set([
+    'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml',
+    'application/pdf',
+    'text/plain', 'text/html', 'text/markdown', 'application/json',
+]);
+function getMimeType(filename) {
+    const ext = filename.split('.').pop()?.toLowerCase() || '';
+    const map = {
+        jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', gif: 'image/gif',
+        webp: 'image/webp', svg: 'image/svg+xml', pdf: 'application/pdf',
+        txt: 'text/plain', html: 'text/html', htm: 'text/html', md: 'text/markdown',
+        json: 'application/json',
+    };
+    return map[ext] || 'application/octet-stream';
+}
+let WorkspaceController = class WorkspaceController {
+    workspaceService;
+    configService;
+    constructor(workspaceService, configService) {
+        this.workspaceService = workspaceService;
+        this.configService = configService;
+    }
+    async listWorkspaces() {
+        const list = await this.workspaceService.listWorkspaces();
+        return { success: true, data: list };
+    }
+    async getCurrentWorkspace() {
+        const config = await this.configService.getConfig();
+        return { success: true, data: this.configService.getDefaultAgentId(config) };
+    }
+    async listDocuments(workspace, path = '') {
+        const name = workspace || this.configService.getDefaultAgentId(await this.configService.getConfig());
+        const items = await this.workspaceService.listDocuments(name, path);
+        return { success: true, data: items };
+    }
+    async serveFile(workspace, path, download, res) {
+        if (!path) {
+            throw new HttpException('path is required', HttpStatus.BAD_REQUEST);
+        }
+        const name = workspace || this.configService.getDefaultAgentId(await this.configService.getConfig());
+        const { absolutePath, safe } = this.workspaceService.resolveFilePath(name, path);
+        if (!safe || !existsSync(absolutePath)) {
+            throw new NotFoundException('File not found');
+        }
+        const fileStat = await stat(absolutePath);
+        if (!fileStat.isFile()) {
+            throw new HttpException('Not a file', HttpStatus.BAD_REQUEST);
+        }
+        const filename = path.split('/').pop() || path;
+        const mime = getMimeType(filename);
+        const isPreview = !download && PREVIEW_TYPES.has(mime);
+        res.setHeader('Content-Type', mime);
+        if (!isPreview) {
+            res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(filename)}"`);
+        }
+        const stream = createReadStream(absolutePath);
+        stream.pipe(res);
+    }
+    async deleteDocument(workspace, path) {
+        if (!path) {
+            throw new HttpException('path is required', HttpStatus.BAD_REQUEST);
+        }
+        const name = workspace || this.configService.getDefaultAgentId(await this.configService.getConfig());
+        const deleted = await this.workspaceService.deletePath(name, path);
+        if (!deleted) {
+            throw new NotFoundException('File or folder not found');
+        }
+        return { success: true };
+    }
+};
+__decorate([
+    Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WorkspaceController.prototype, "listWorkspaces", null);
+__decorate([
+    Get('current'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WorkspaceController.prototype, "getCurrentWorkspace", null);
+__decorate([
+    Get('documents'),
+    __param(0, Query('workspace')),
+    __param(1, Query('path')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], WorkspaceController.prototype, "listDocuments", null);
+__decorate([
+    Get('files/serve'),
+    __param(0, Query('workspace')),
+    __param(1, Query('path')),
+    __param(2, Query('download')),
+    __param(3, Res({ passthrough: false })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Object]),
+    __metadata("design:returntype", Promise)
+], WorkspaceController.prototype, "serveFile", null);
+__decorate([
+    Delete('files'),
+    __param(0, Query('workspace')),
+    __param(1, Query('path')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], WorkspaceController.prototype, "deleteDocument", null);
+WorkspaceController = __decorate([
+    Controller('workspace'),
+    __metadata("design:paramtypes", [WorkspaceService,
+        ConfigService])
+], WorkspaceController);
+export { WorkspaceController };

package/dist/server/workspace/workspace.module.d.ts

@@ -0,0 +1,2 @@
+export declare class WorkspaceModule {
+}

package/dist/server/workspace/workspace.module.js

@@ -0,0 +1,21 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Module } from '@nestjs/common';
+import { WorkspaceController } from './workspace.controller.js';
+import { WorkspaceService } from './workspace.service.js';
+import { ConfigModule } from '../config/config.module.js';
+let WorkspaceModule = class WorkspaceModule {
+};
+WorkspaceModule = __decorate([
+    Module({
+        imports: [ConfigModule],
+        controllers: [WorkspaceController],
+        providers: [WorkspaceService],
+        exports: [WorkspaceService],
+    })
+], WorkspaceModule);
+export { WorkspaceModule };

package/dist/server/workspace/workspace.service.d.ts

@@ -0,0 +1,36 @@
+export interface WorkspaceItem {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    size?: number;
+    mtime?: number;
+}
+export declare class WorkspaceService {
+    private getWorkspaceRoot;
+    /** List workspace names (directories under OPENBOT_WORKSPACE_DIR, default ~/.openbot/workspace) */
+    listWorkspaces(): Promise<string[]>;
+    /** List files and folders under a path relative to workspace root. Empty path = root. */
+    listDocuments(workspaceName: string, relativePath?: string): Promise<WorkspaceItem[]>;
+    /**
+     * Resolve a relative path and ensure it stays under workspace root.
+     * Returns path suitable for join(workspaceRoot, result).
+     */
+    resolveFilePath(workspaceName: string, relativePath: string): {
+        absolutePath: string;
+        safe: boolean;
+    };
+    /** Delete a file or directory (recursive) under workspace. Returns true if deleted. skills 与 .skills 目录禁止删除。 */
+    deletePath(workspaceName: string, relativePath: string): Promise<boolean>;
+    private safeRelativePath;
+    /** Ensure workspace/.favorite directory exists. */
+    ensureFavoriteDir(workspaceName: string): Promise<string>;
+    /**
+     * Write buffer to workspace/.favorite/{filename}. Returns relative path (e.g. .favorite/xxx).
+     */
+    writeFileInFavorite(workspaceName: string, filename: string, buffer: Buffer): Promise<string>;
+    /**
+     * Write buffer to a user-chosen directory. targetDir must be absolute and under homedir or workspace root.
+     * Returns the full path of the written file.
+     */
+    writeFileToDir(targetDir: string, filename: string, buffer: Buffer): Promise<string>;
+}

package/dist/server/workspace/workspace.service.js

@@ -0,0 +1,142 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from '@nestjs/common';
+import { readdir, stat, rm, mkdir, writeFile } from 'fs/promises';
+import { join, resolve, relative } from 'path';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { getOpenbotWorkspaceDir } from '../../core/agent/agent-dir.js';
+let WorkspaceService = class WorkspaceService {
+    getWorkspaceRoot(name) {
+        return join(getOpenbotWorkspaceDir(), name);
+    }
+    /** List workspace names (directories under OPENBOT_WORKSPACE_DIR, default ~/.openbot/workspace) */
+    async listWorkspaces() {
+        const base = getOpenbotWorkspaceDir();
+        if (!existsSync(base)) {
+            return [];
+        }
+        const entries = await readdir(base, { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    }
+    /** List files and folders under a path relative to workspace root. Empty path = root. */
+    async listDocuments(workspaceName, relativePath = '') {
+        const root = resolve(this.getWorkspaceRoot(workspaceName));
+        if (!existsSync(root)) {
+            return [];
+        }
+        const safePath = this.safeRelativePath(relativePath);
+        const dir = resolve(root, safePath);
+        const dirNormalized = resolve(dir);
+        const rootNormalized = resolve(root);
+        if (!dirNormalized.startsWith(rootNormalized) || !existsSync(dirNormalized)) {
+            return [];
+        }
+        const entries = await readdir(dirNormalized, { withFileTypes: true });
+        const items = [];
+        const hiddenDirNames = new Set(['skills', '.skills']);
+        for (const e of entries) {
+            if (e.isDirectory() && hiddenDirNames.has(e.name))
+                continue;
+            const fullPath = join(dirNormalized, e.name);
+            const rel = relative(rootNormalized, fullPath);
+            let st;
+            try {
+                st = await stat(fullPath);
+            }
+            catch (err) {
+                if (err?.code === 'ENOENT')
+                    continue;
+                throw err;
+            }
+            items.push({
+                name: e.name,
+                path: rel,
+                isDirectory: st.isDirectory(),
+                size: st.isFile() ? st.size : undefined,
+                mtime: st.mtimeMs,
+            });
+        }
+        return items.sort((a, b) => {
+            if (a.isDirectory !== b.isDirectory)
+                return a.isDirectory ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+    }
+    /**
+     * Resolve a relative path and ensure it stays under workspace root.
+     * Returns path suitable for join(workspaceRoot, result).
+     */
+    resolveFilePath(workspaceName, relativePath) {
+        const root = resolve(this.getWorkspaceRoot(workspaceName));
+        const safe = this.safeRelativePath(relativePath);
+        const absolute = resolve(root, safe);
+        const ok = resolve(absolute).startsWith(root) && existsSync(absolute);
+        return { absolutePath: absolute, safe: ok };
+    }
+    /** Delete a file or directory (recursive) under workspace. Returns true if deleted. skills 与 .skills 目录禁止删除。 */
+    async deletePath(workspaceName, relativePath) {
+        const safe = this.safeRelativePath(relativePath);
+        const topDir = safe.split('/')[0];
+        if (topDir === 'skills' || topDir === '.skills')
+            return false;
+        const { absolutePath, safe: resolved } = this.resolveFilePath(workspaceName, relativePath);
+        if (!resolved || !existsSync(absolutePath))
+            return false;
+        await rm(absolutePath, { recursive: true });
+        return true;
+    }
+    safeRelativePath(relativePath) {
+        if (!relativePath || relativePath === '.')
+            return '';
+        const normalized = relativePath.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\/+/, '');
+        const parts = normalized.split('/').filter((p) => p !== '..' && p !== '.');
+        return parts.join('/');
+    }
+    /** Ensure workspace/.favorite directory exists. */
+    async ensureFavoriteDir(workspaceName) {
+        const root = resolve(this.getWorkspaceRoot(workspaceName));
+        const favoriteDir = join(root, '.favorite');
+        if (!existsSync(favoriteDir)) {
+            await mkdir(favoriteDir, { recursive: true });
+        }
+        return favoriteDir;
+    }
+    /**
+     * Write buffer to workspace/.favorite/{filename}. Returns relative path (e.g. .favorite/xxx).
+     */
+    async writeFileInFavorite(workspaceName, filename, buffer) {
+        const dir = await this.ensureFavoriteDir(workspaceName);
+        const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 200) || 'download';
+        const absolutePath = join(dir, safeName);
+        await writeFile(absolutePath, buffer);
+        return `.favorite/${safeName}`;
+    }
+    /**
+     * Write buffer to a user-chosen directory. targetDir must be absolute and under homedir or workspace root.
+     * Returns the full path of the written file.
+     */
+    async writeFileToDir(targetDir, filename, buffer) {
+        const home = homedir();
+        const workspaceRoot = getOpenbotWorkspaceDir();
+        const normalized = resolve(targetDir);
+        if (!normalized.startsWith(resolve(home)) && !normalized.startsWith(resolve(workspaceRoot))) {
+            throw new Error('Target directory must be under user home or workspace root');
+        }
+        if (!existsSync(normalized)) {
+            await mkdir(normalized, { recursive: true });
+        }
+        const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 200) || 'download';
+        const absolutePath = join(normalized, safeName);
+        await writeFile(absolutePath, buffer);
+        return absolutePath;
+    }
+};
+WorkspaceService = __decorate([
+    Injectable()
+], WorkspaceService);
+export { WorkspaceService };

package/package.json

@@ -0,0 +1,90 @@
+{
+    "name": "@next-open-ai/openclawx",
+    "publishConfig": {
+        "access": "public"
+    },
+    "version": "0.6.6",
+    "description": "CLI and library to run prompts with skill paths (Agent Skills style). Use as npm package or openclawx CLI.",
+    "type": "module",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "skills",
+        "README.md",
+        "apps/desktop/renderer/dist"
+    ],
+    "bin": {
+        "openbot": "./dist/cli/cli.js"
+    },
+    "dependencies": {
+        "@mariozechner/pi-ai": "^0.51.2",
+        "@mariozechner/pi-coding-agent": "^0.51.2",
+        "@nestjs/common": "^10.3.0",
+        "@nestjs/core": "^10.3.0",
+        "@nestjs/platform-express": "^10.3.0",
+        "@nestjs/platform-socket.io": "^10.3.0",
+        "@nestjs/websockets": "^10.3.0",
+        "@sinclair/typebox": "^0.34.41",
+        "adm-zip": "^0.5.16",
+        "agent-browser": "^0.8.5",
+        "commander": "^14.0.2",
+        "croner": "^9.1.0",
+        "multer": "^1.4.5-lts.1",
+        "reflect-metadata": "^0.2.1",
+        "rxjs": "^7.8.1",
+        "sql.js": "^1.13.0",
+        "vectra": "^0.12.3",
+        "ws": "^8.19.0"
+    },
+    "devDependencies": {
+        "@nestjs/testing": "^10.3.0",
+        "@types/adm-zip": "^0.5.7",
+        "@types/express": "^4.17.21",
+        "@types/jest": "^29.5.14",
+        "@types/multer": "^2.0.0",
+        "@types/node": "^22.0.0",
+        "@types/sql.js": "^1.4.9",
+        "@types/ws": "^8.18.1",
+        "jest": "^29.7.0",
+        "rimraf": "^5.0.5",
+        "ts-jest": "^29.2.5",
+        "typescript": "^5.7.0"
+    },
+    "scripts": {
+        "clean": "rimraf dist",
+        "build": "npm run clean && tsc",
+        "build:web": "cd apps/desktop && npm run build:renderer",
+        "build:all": "npm run build && npm run build:web",
+        "prepublishOnly": "npm run build && cd apps/desktop && npm run build:renderer",
+        "start": "node dist/cli/cli.js",
+        "run": "node dist/cli/cli.js",
+        "dev": "npm run build && node dist/cli/cli.js",
+        "desktop:dev": "cd apps/desktop && npm run dev",
+        "desktop:build": "cd apps/desktop && npm run build",
+        "desktop:pack": "npm run build && cd apps/desktop && npm run build",
+        "desktop:install": "cd apps/desktop && npm install",
+        "test": "jest --config test/jest.config.cjs",
+        "test:memory": "node test/run-memory.mjs",
+        "test:e2e": "OPENBOT_DB_PATH=:memory: jest --config test/jest.config.cjs --testPathPattern=e2e",
+        "test:gateway-e2e": "npm run build && node test/gateway/server.e2e.mjs"
+    },
+    "engines": {
+        "node": ">=20.0.0"
+    },
+    "keywords": [
+        "skill",
+        "agent",
+        "cli",
+        "llm",
+        "openbot"
+    ],
+    "license": "MIT"
+}