@next-open-ai/openbot 0.1.1

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,25 @@
+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;
+}

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

@@ -0,0 +1,103 @@
+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 } from 'fs/promises';
+import { join, resolve, relative } from 'path';
+import { existsSync } from 'fs';
+import { getOpenbotWorkspaceDir } from '../../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('/');
+    }
+};
+WorkspaceService = __decorate([
+    Injectable()
+], WorkspaceService);
+export { WorkspaceService };

package/dist/tools/browser-tool.d.ts

@@ -0,0 +1,10 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+/**
+ * Create browser automation tool
+ * @param workspaceDir Optional workspace directory for downloads
+ */
+export declare function createBrowserTool(workspaceDir?: string): AgentTool<any>;
+/**
+ * Cleanup function to close browser on process exit
+ */
+export declare function closeBrowser(): Promise<void>;