@next-open-ai/openbot 0.3.2 → 0.6.6

package/dist/server/saved-items/saved-items.controller.d.ts

@@ -1,11 +1,17 @@
+import type { Response } from 'express';
 import { SavedItemsService } from './saved-items.service.js';
+import { WorkspaceService } from '../workspace/workspace.service.js';
+import { ConfigService } from '../config/config.service.js';
 export declare class SavedItemsController {
     private readonly savedItemsService;
-    constructor(savedItemsService: SavedItemsService);
+    private readonly workspaceService;
+    private readonly configService;
+    constructor(savedItemsService: SavedItemsService, workspaceService: WorkspaceService, configService: ConfigService);
     list(tagId?: string, workspace?: string): Promise<{
         success: boolean;
         data: import("./saved-items.service.js").SavedItem[];
     }>;
+    imageProxy(url: string, res: Response): Promise<void>;
     get(id: string): Promise<{
         success: boolean;
         data: import("./saved-items.service.js").SavedItem;
@@ -23,4 +29,29 @@ export declare class SavedItemsController {
     delete(id: string): Promise<{
         success: boolean;
     }>;
+    /**
+     * Download the saved item URL to workspace .favorite or to a user-chosen directory.
+     * Body: { workspace?: string, targetDir?: string }.
+     * If targetDir (absolute path) is provided, file is written there; otherwise to workspace/.favorite.
+     */
+    downloadToWorkspace(id: string, body: {
+        workspace?: string;
+        targetDir?: string;
+    }): Promise<{
+        success: boolean;
+        data: {
+            absolutePath: string;
+            targetDir: string;
+            relativePath?: undefined;
+            workspace?: undefined;
+        };
+    } | {
+        success: boolean;
+        data: {
+            relativePath: string;
+            workspace: string;
+            absolutePath?: undefined;
+            targetDir?: undefined;
+        };
+    }>;
 }

package/dist/server/saved-items/saved-items.controller.js

@@ -10,17 +10,114 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Controller, Get, Post, Delete, Body, Param, Query, HttpException, HttpStatus, } from '@nestjs/common';
+import { Controller, Get, Post, Delete, Body, Param, Query, Res, HttpException, HttpStatus, } from '@nestjs/common';
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { homedir } from 'os';
+import { existsSync } from 'fs';
 import { SavedItemsService } from './saved-items.service.js';
+import { WorkspaceService } from '../workspace/workspace.service.js';
+import { ConfigService } from '../config/config.service.js';
+import { getOpenbotWorkspaceDir } from '../../core/agent/agent-dir.js';
+const IMAGE_EXT_MIME = {
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    svg: 'image/svg+xml',
+    bmp: 'image/bmp',
+    ico: 'image/x-icon',
+};
+function mimeFromPath(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase() || '';
+    return IMAGE_EXT_MIME[ext] || 'application/octet-stream';
+}
+function safeFilenameFromUrl(url, contentType) {
+    try {
+        const u = new URL(url);
+        const pathname = u.pathname || '';
+        const segment = pathname.split('/').filter(Boolean).pop() || '';
+        const decoded = decodeURIComponent(segment);
+        const base = decoded.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 180);
+        if (base)
+            return base;
+    }
+    catch (_) { }
+    const ct = (contentType || '').split(';')[0].trim().toLowerCase();
+    let ext = 'bin';
+    if (ct.includes('image/'))
+        ext = ct.replace('image/', '').trim() || 'png';
+    else if (ct.includes('text/html'))
+        ext = 'html';
+    else if (ct.includes('text/plain'))
+        ext = 'txt';
+    return `download_${Date.now()}.${ext}`;
+}
 let SavedItemsController = class SavedItemsController {
     savedItemsService;
-    constructor(savedItemsService) {
+    workspaceService;
+    configService;
+    constructor(savedItemsService, workspaceService, configService) {
         this.savedItemsService = savedItemsService;
+        this.workspaceService = workspaceService;
+        this.configService = configService;
     }
     async list(tagId, workspace) {
         const data = await this.savedItemsService.findAll({ tagId, workspace });
         return { success: true, data };
     }
+    async imageProxy(url, res) {
+        if (!url?.trim())
+            throw new HttpException('url is required', HttpStatus.BAD_REQUEST);
+        const decoded = decodeURIComponent(url.trim());
+        if (decoded.startsWith('file://') || decoded.startsWith('file:/')) {
+            try {
+                let pathPart;
+                try {
+                    const u = new URL(decoded);
+                    pathPart = (u.pathname || decoded).replace(/^\/([a-z]:)/i, '$1');
+                }
+                catch {
+                    pathPart = decoded.replace(/^file:\/+/, '').replace(/^\/([a-z]:)/i, '$1');
+                }
+                const absolutePath = resolve(pathPart);
+                const home = homedir();
+                const workspaceRoot = getOpenbotWorkspaceDir();
+                if (!absolutePath.startsWith(resolve(home)) &&
+                    !absolutePath.startsWith(resolve(workspaceRoot))) {
+                    throw new HttpException('Local file path not allowed', HttpStatus.FORBIDDEN);
+                }
+                if (!existsSync(absolutePath)) {
+                    throw new HttpException('File not found', HttpStatus.NOT_FOUND);
+                }
+                const buffer = await readFile(absolutePath);
+                const contentType = mimeFromPath(absolutePath);
+                res.setHeader('Content-Type', contentType);
+                res.send(buffer);
+            }
+            catch (e) {
+                if (e instanceof HttpException)
+                    throw e;
+                throw new HttpException('Local file read failed', HttpStatus.BAD_GATEWAY);
+            }
+            return;
+        }
+        try {
+            const resFetch = await fetch(decoded, { redirect: 'follow' });
+            if (!resFetch.ok)
+                throw new HttpException('Upstream failed', HttpStatus.BAD_GATEWAY);
+            const contentType = resFetch.headers.get('content-type') || 'application/octet-stream';
+            res.setHeader('Content-Type', contentType);
+            const arr = new Uint8Array(await resFetch.arrayBuffer());
+            res.send(Buffer.from(arr));
+        }
+        catch (e) {
+            if (e instanceof HttpException)
+                throw e;
+            throw new HttpException('Proxy failed', HttpStatus.BAD_GATEWAY);
+        }
+    }
     async get(id) {
         const data = await this.savedItemsService.findById(id);
         if (!data)
@@ -41,6 +138,42 @@ let SavedItemsController = class SavedItemsController {
         await this.savedItemsService.delete(id);
         return { success: true };
     }
+    /**
+     * Download the saved item URL to workspace .favorite or to a user-chosen directory.
+     * Body: { workspace?: string, targetDir?: string }.
+     * If targetDir (absolute path) is provided, file is written there; otherwise to workspace/.favorite.
+     */
+    async downloadToWorkspace(id, body) {
+        const item = await this.savedItemsService.findById(id);
+        if (!item)
+            throw new HttpException('Saved item not found', HttpStatus.NOT_FOUND);
+        const workspace = (body?.workspace ?? '').trim() ||
+            this.configService.getDefaultAgentId(await this.configService.getConfig());
+        let buffer;
+        let contentType;
+        try {
+            const res = await fetch(item.url, { redirect: 'follow' });
+            if (!res.ok) {
+                throw new HttpException(`Failed to fetch URL: ${res.status} ${res.statusText}`, HttpStatus.BAD_GATEWAY);
+            }
+            contentType = res.headers.get('content-type') || undefined;
+            const arr = new Uint8Array(await res.arrayBuffer());
+            buffer = Buffer.from(arr);
+        }
+        catch (err) {
+            if (err instanceof HttpException)
+                throw err;
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new HttpException(`Download failed: ${msg}`, HttpStatus.BAD_GATEWAY);
+        }
+        const filename = safeFilenameFromUrl(item.url, contentType);
+        if ((body?.targetDir ?? '').trim()) {
+            const absolutePath = await this.workspaceService.writeFileToDir(body.targetDir.trim(), filename, buffer);
+            return { success: true, data: { absolutePath, targetDir: body.targetDir.trim() } };
+        }
+        const relativePath = await this.workspaceService.writeFileInFavorite(workspace, filename, buffer);
+        return { success: true, data: { relativePath, workspace } };
+    }
 };
 __decorate([
     Get(),
@@ -50,6 +183,14 @@ __decorate([
     __metadata("design:paramtypes", [String, String]),
     __metadata("design:returntype", Promise)
 ], SavedItemsController.prototype, "list", null);
+__decorate([
+    Get('image-proxy'),
+    __param(0, Query('url')),
+    __param(1, Res({ passthrough: false })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], SavedItemsController.prototype, "imageProxy", null);
 __decorate([
     Get(':id'),
     __param(0, Param('id')),
@@ -71,8 +212,18 @@ __decorate([
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
 ], SavedItemsController.prototype, "delete", null);
+__decorate([
+    Post(':id/download-to-workspace'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], SavedItemsController.prototype, "downloadToWorkspace", null);
 SavedItemsController = __decorate([
     Controller('saved-items'),
-    __metadata("design:paramtypes", [SavedItemsService])
+    __metadata("design:paramtypes", [SavedItemsService,
+        WorkspaceService,
+        ConfigService])
 ], SavedItemsController);
 export { SavedItemsController };

package/dist/server/saved-items/saved-items.module.js

@@ -6,6 +6,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Module } from '@nestjs/common';
 import { DatabaseModule } from '../database/database.module.js';
+import { ConfigModule } from '../config/config.module.js';
+import { WorkspaceModule } from '../workspace/workspace.module.js';
 import { TagsService } from './tags.service.js';
 import { TagsController } from './tags.controller.js';
 import { SavedItemsService } from './saved-items.service.js';
@@ -14,7 +16,7 @@ let SavedItemsModule = class SavedItemsModule {
 };
 SavedItemsModule = __decorate([
     Module({
-        imports: [DatabaseModule],
+        imports: [DatabaseModule, ConfigModule, WorkspaceModule],
         controllers: [TagsController, SavedItemsController],
         providers: [TagsService, SavedItemsService],
         exports: [TagsService, SavedItemsService],

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

@@ -22,4 +22,15 @@ export declare class WorkspaceService {
     /** 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

@@ -5,9 +5,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Injectable } from '@nestjs/common';
-import { readdir, stat, rm } from 'fs/promises';
+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) {
@@ -96,6 +97,44 @@ let WorkspaceService = class WorkspaceService {
         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()

package/package.json

@@ -3,7 +3,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.3.2",
+    "version": "0.6.6",
     "description": "CLI and library to run prompts with skill paths (Agent Skills style). Use as npm package or openbot CLI.",
     "type": "module",
     "main": "dist/index.js",
@@ -25,6 +25,7 @@
         "openbot": "./dist/cli/cli.js"
     },
     "dependencies": {
+        "@larksuiteoapi/node-sdk": "^1.59.0",
         "@mariozechner/pi-ai": "^0.51.2",
         "@mariozechner/pi-coding-agent": "^0.51.2",
         "@nestjs/common": "^10.3.0",