@promptbook/cli 0.103.0-1 → 0.103.0-100

package/apps/agents-server/src/tools/$provideCdnForServer.ts

@@ -0,0 +1,24 @@
+import { VercelBlobStorage } from '../utils/cdn/classes/VercelBlobStorage';
+import { IIFilesStorageWithCdn } from '../utils/cdn/interfaces/IFilesStorage';
+
+/**
+ * Cache of CDN instance
+ *
+ * @private internal cache for `$provideCdnForServer`
+ */
+let cdn: IIFilesStorageWithCdn | null = null;
+
+/**
+ * [🐱‍🚀]
+ */
+export function $provideCdnForServer(): IIFilesStorageWithCdn {
+    if (!cdn) {
+        cdn = new VercelBlobStorage({
+            token: process.env.BLOB_READ_WRITE_TOKEN!,
+            pathPrefix: process.env.NEXT_PUBLIC_CDN_PATH_PREFIX!,
+            cdnPublicUrl: new URL(process.env.NEXT_PUBLIC_CDN_PUBLIC_URL!),
+        });
+    }
+
+    return cdn;
+}

package/apps/agents-server/src/tools/$provideExecutionToolsForServer.ts

@@ -0,0 +1,117 @@
+'use server';
+
+import {
+    cacheLlmTools,
+    _AnthropicClaudeMetadataRegistration,
+    _AzureOpenAiMetadataRegistration,
+    _BoilerplateScraperMetadataRegistration,
+    _DeepseekMetadataRegistration,
+    _DocumentScraperMetadataRegistration,
+    _GoogleMetadataRegistration,
+    _LegacyDocumentScraperMetadataRegistration,
+    _MarkdownScraperMetadataRegistration,
+    _MarkitdownScraperMetadataRegistration,
+    _OllamaMetadataRegistration,
+    _OpenAiAssistantMetadataRegistration,
+    _OpenAiCompatibleMetadataRegistration,
+    _OpenAiMetadataRegistration,
+    _PdfScraperMetadataRegistration,
+    _WebsiteScraperMetadataRegistration,
+} from '@promptbook-local/core';
+import { _GoogleRegistration } from '@promptbook-local/google';
+import { _OpenAiRegistration } from '@promptbook-local/openai';
+import { ExecutionTools, TODO_any } from '@promptbook-local/types';
+import { $provideLlmToolsForCli } from '../../../../src/cli/common/$provideLlmToolsForCli';
+import { $provideExecutablesForNode } from '../../../../src/executables/$provideExecutablesForNode';
+import { $provideFilesystemForNode } from '../../../../src/scrapers/_common/register/$provideFilesystemForNode';
+import { $provideScrapersForNode } from '../../../../src/scrapers/_common/register/$provideScrapersForNode';
+import { $provideScriptingForNode } from '../../../../src/scrapers/_common/register/$provideScriptingForNode';
+import { $sideEffect } from '../../../../src/utils/organization/$sideEffect';
+import { SupabaseCacheStorage } from '../utils/cache/SupabaseCacheStorage';
+
+$sideEffect(
+    _AnthropicClaudeMetadataRegistration,
+    _AzureOpenAiMetadataRegistration,
+    _DeepseekMetadataRegistration,
+    _GoogleMetadataRegistration,
+    _OllamaMetadataRegistration,
+    _OpenAiMetadataRegistration,
+    _OpenAiAssistantMetadataRegistration,
+    _OpenAiCompatibleMetadataRegistration,
+    _BoilerplateScraperMetadataRegistration,
+    _LegacyDocumentScraperMetadataRegistration,
+    _DocumentScraperMetadataRegistration,
+    _MarkdownScraperMetadataRegistration,
+    _MarkitdownScraperMetadataRegistration,
+    _PdfScraperMetadataRegistration,
+    _WebsiteScraperMetadataRegistration,
+    // <- TODO: [🐱‍🚀] Export all registrations from one variabile in `@promptbook/core`
+);
+$sideEffect(/* [㊗] */ _OpenAiRegistration);
+$sideEffect(/* [㊗] */ _GoogleRegistration);
+// <- TODO: [🐱‍🚀] Allow to dynamically install required metadata
+
+/**
+ * Cache of provided execution tools
+ *
+ * @private internal cache for `$provideExecutionToolsForServer`
+ */
+let executionTools: null | ExecutionTools = null;
+
+/*
+TODO: [▶️]
+type ProvideExecutionToolsForServerOptions = {
+ isLlmProvided
+}
+*/
+
+/**
+ * [🐱‍🚀]
+ */
+export async function $provideExecutionToolsForServer(): Promise<ExecutionTools> {
+    // TODO: [🐱‍🚀] [🌕] DRY
+
+    // const path = '../../agents'; // <- TODO: [🐱‍🚀] Pass
+    const isVerbose = true; // <- TODO: [🐱‍🚀] Pass
+    const isCacheReloaded = false; // <- TODO: [🐱‍🚀] Pass
+    const cliOptions = {
+        provider: 'BRING_YOUR_OWN_KEYS',
+    } as TODO_any; // <- TODO: [🐱‍🚀] Pass
+
+    if (executionTools !== null) {
+        console.log('[🐱‍🚀] Returning cached execution tools');
+        return executionTools;
+        // TODO: [🐱‍🚀] Be aware of options changes
+    }
+
+    console.log('[🐱‍🚀] Creating NEW execution tools');
+
+    // TODO: DRY [◽]
+    const prepareAndScrapeOptions = {
+        isVerbose,
+        isCacheReloaded,
+    }; /* <- TODO: ` satisfies PrepareAndScrapeOptions` */
+    const fs = await $provideFilesystemForNode(prepareAndScrapeOptions);
+    const { /* [0] strategy,*/ llm: llmUncached } = await $provideLlmToolsForCli({
+        cliOptions,
+        ...prepareAndScrapeOptions,
+    });
+
+    const llm = cacheLlmTools(llmUncached, {
+        storage: new SupabaseCacheStorage(),
+        isVerbose,
+        isCacheReloaded,
+    });
+
+    const executables = await $provideExecutablesForNode(prepareAndScrapeOptions);
+
+    executionTools = {
+        llm,
+        fs,
+        executables,
+        scrapers: await $provideScrapersForNode({ fs, llm, executables }, prepareAndScrapeOptions),
+        script: await $provideScriptingForNode(prepareAndScrapeOptions),
+    };
+
+    return executionTools;
+}

package/apps/agents-server/src/tools/$provideOpenAiAssistantExecutionToolsForServer.ts

@@ -0,0 +1,35 @@
+'use server';
+
+import { OpenAiAssistantExecutionTools } from '@promptbook-local/openai';
+
+/**
+ * Cache of provided OpenAiAssistantExecutionTools
+ *
+ * @private internal cache for `$provideOpenAiAssistantExecutionToolsForServer`
+ */
+let executionTools: null | OpenAiAssistantExecutionTools = null;
+
+/**
+ * [🐱‍🚀]
+ */
+export async function $provideOpenAiAssistantExecutionToolsForServer(): Promise<OpenAiAssistantExecutionTools> {
+    // TODO: [🐱‍🚀] [🌕] DRY
+    const isVerbose = true; // <- TODO: [🐱‍🚀] Pass
+
+    if (executionTools !== null) {
+        console.log('[🐱‍🚀] Returning cached OpenAiAssistantExecutionTools');
+        return executionTools;
+        // TODO: [🐱‍🚀] Be aware of options changes
+    }
+
+    console.log('[🐱‍🚀] Creating NEW OpenAiAssistantExecutionTools');
+
+    executionTools = new OpenAiAssistantExecutionTools({
+        apiKey: process.env.OPENAI_API_KEY,
+        assistantId: 'abstract_assistant', // <- TODO: [🐱‍🚀] In `OpenAiAssistantExecutionTools` Allow to create abstract assistants with `isCreatingNewAssistantsAllowed`
+        isCreatingNewAssistantsAllowed: true,
+        isVerbose,
+    });
+
+    return executionTools;
+}

package/apps/agents-server/src/tools/$provideServer.ts

@@ -0,0 +1,39 @@
+import { NEXT_PUBLIC_SITE_URL, SERVERS, SUPABASE_TABLE_PREFIX } from '@/config';
+import { normalizeTo_PascalCase } from '@promptbook-local/utils';
+import { headers } from 'next/headers';
+
+export async function $provideServer() {
+    if (!SERVERS) {
+        return {
+            publicUrl: NEXT_PUBLIC_SITE_URL || new URL(`https://${(await headers()).get('host') || 'localhost:4440'}`),
+            tablePrefix: SUPABASE_TABLE_PREFIX,
+        };
+    }
+
+    const headersList = await headers();
+    let host = headersList.get('host');
+    const xPromptbookServer = headersList.get('x-promptbook-server');
+
+    if (host === null) {
+        throw new Error('Host header is missing');
+    }
+
+    // If host is not in known servers, check if we have a context header from middleware
+    if (!SERVERS.some((server) => server === host)) {
+        if (xPromptbookServer && SERVERS.some((server) => server === xPromptbookServer)) {
+            host = xPromptbookServer;
+        } else {
+            throw new Error(`Server with host "${host}" is not configured in SERVERS`);
+        }
+    }
+
+    let serverName = host;
+
+    serverName = serverName.replace(/\.ptbk\.io$/, '');
+    serverName = normalizeTo_PascalCase(serverName);
+
+    return {
+        publicUrl: new URL(`https://${host}`),
+        tablePrefix: `server_${serverName}_`,
+    };
+}

package/apps/agents-server/src/utils/auth.ts

@@ -0,0 +1,33 @@
+import { randomBytes, scrypt, timingSafeEqual } from 'crypto';
+import { promisify } from 'util';
+
+const scryptAsync = promisify(scrypt);
+
+/**
+ * Hashes a password using scrypt
+ * 
+ * @param password The plain text password
+ * @returns The salt and hash formatted as "salt:hash"
+ */
+export async function hashPassword(password: string): Promise<string> {
+    const salt = randomBytes(16).toString('hex');
+    const derivedKey = (await scryptAsync(password, salt, 64)) as Buffer;
+    return `${salt}:${derivedKey.toString('hex')}`;
+}
+
+/**
+ * Verifies a password against a stored hash
+ * 
+ * @param password The plain text password
+ * @param storedHash The stored hash in format "salt:hash"
+ * @returns True if the password matches
+ */
+export async function verifyPassword(password: string, storedHash: string): Promise<boolean> {
+    const [salt, key] = storedHash.split(':');
+    if (!salt || !key) return false;
+    
+    const derivedKey = (await scryptAsync(password, salt, 64)) as Buffer;
+    const keyBuffer = Buffer.from(key, 'hex');
+    
+    return timingSafeEqual(derivedKey, keyBuffer);
+}

package/apps/agents-server/src/utils/authenticateUser.ts

@@ -0,0 +1,42 @@
+import { $getTableName } from '../database/$getTableName';
+import { $provideSupabaseForServer } from '../database/$provideSupabaseForServer';
+import { AgentsServerDatabase } from '../database/schema';
+import { verifyPassword } from './auth';
+
+export type AuthenticatedUser = {
+    username: string;
+    isAdmin: boolean;
+};
+
+export async function authenticateUser(username: string, password: string): Promise<AuthenticatedUser | null> {
+    // 1. Check if it's the environment admin
+    if (username === 'admin' && process.env.ADMIN_PASSWORD && password === process.env.ADMIN_PASSWORD) {
+        return { username: 'admin', isAdmin: true };
+    }
+
+    // 2. Check DB users
+    try {
+        const supabase = $provideSupabaseForServer();
+        const { data: user, error } = await supabase
+            .from(await $getTableName('User'))
+            .select('*')
+            .eq('username', username)
+            .single();
+
+        if (error || !user) {
+            return null;
+        }
+
+        const userRow = user as AgentsServerDatabase['public']['Tables']['User']['Row'];
+        const isValid = await verifyPassword(password, userRow.passwordHash);
+
+        if (!isValid) {
+            return null;
+        }
+
+        return { username: userRow.username, isAdmin: userRow.isAdmin };
+    } catch (error) {
+        console.error('Authentication error:', error);
+        return null;
+    }
+}

package/apps/agents-server/src/utils/cache/SupabaseCacheStorage.ts

@@ -0,0 +1,55 @@
+import { TODO_any } from '@promptbook-local/types';
+import { $getTableName } from '../../database/$getTableName';
+import { $provideSupabaseForServer } from '../../database/$provideSupabaseForServer';
+import { Json } from '../../database/schema';
+
+/**
+ * Storage for LLM cache using Supabase
+ */
+export class SupabaseCacheStorage {
+    // implements PromptbookStorage<TODO_any>
+
+    /**
+     * Returns the current value associated with the given key, or null if the given key does not exist in the list associated with the object.
+     */
+    public async getItem(key: string): Promise<TODO_any | null> {
+        const supabase = $provideSupabaseForServer();
+        const tableName = await $getTableName('LlmCache');
+
+        const { data } = await supabase.from(tableName).select('value').eq('hash', key).maybeSingle();
+
+        if (!data) {
+            return null;
+        }
+
+        return data.value;
+    }
+
+    /**
+     * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
+     */
+    public async setItem(key: string, value: TODO_any): Promise<void> {
+        const supabase = $provideSupabaseForServer();
+        const tableName = await $getTableName('LlmCache');
+
+        await supabase.from(tableName).upsert(
+            {
+                hash: key,
+                value: value as Json,
+            },
+            {
+                onConflict: 'hash',
+            },
+        );
+    }
+
+    /**
+     * Removes the key/value pair with the given key from the list associated with the object, if a key/value pair with the given key exists
+     */
+    public async removeItem(key: string): Promise<void> {
+        const supabase = $provideSupabaseForServer();
+        const tableName = await $getTableName('LlmCache');
+
+        await supabase.from(tableName).delete().eq('hash', key);
+    }
+}

package/apps/agents-server/src/utils/cdn/classes/VercelBlobStorage.ts

@@ -0,0 +1,63 @@
+import { del, put } from '@vercel/blob';
+import { validateMimeType } from '../../validators/validateMimeType';
+import type { IFile, IIFilesStorageWithCdn } from '../interfaces/IFilesStorage';
+
+type IVercelBlobStorageConfig = {
+    readonly token: string;
+    readonly cdnPublicUrl: URL;
+    readonly pathPrefix?: string;
+    // Note: Vercel Blob automatically handles compression/serving
+};
+
+export class VercelBlobStorage implements IIFilesStorageWithCdn {
+    public get cdnPublicUrl() {
+        return this.config.cdnPublicUrl;
+    }
+
+    public constructor(private readonly config: IVercelBlobStorageConfig) {}
+
+    public getItemUrl(key: string): URL {
+        const path = this.config.pathPrefix ? `${this.config.pathPrefix}/${key}` : key;
+        return new URL(path, this.cdnPublicUrl);
+    }
+
+    public async getItem(key: string): Promise<IFile | null> {
+        const url = this.getItemUrl(key);
+
+        const response = await fetch(url);
+
+        if (response.status === 404) {
+            return null;
+        }
+
+        if (!response.ok) {
+            throw new Error(`Failed to fetch blob from ${url}: ${response.statusText}`);
+        }
+
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        const contentType = response.headers.get('content-type') || 'application/octet-stream';
+
+        return {
+            type: validateMimeType(contentType),
+            data: buffer,
+        };
+    }
+
+    public async removeItem(key: string): Promise<void> {
+        const url = this.getItemUrl(key).toString();
+        await del(url, { token: this.config.token });
+    }
+
+    public async setItem(key: string, file: IFile): Promise<void> {
+        const path = this.config.pathPrefix ? `${this.config.pathPrefix}/${key}` : key;
+        
+        await put(path, file.data, {
+            access: 'public',
+            addRandomSuffix: false,
+            contentType: file.type,
+            token: this.config.token,
+            // Note: We rely on Vercel Blob for compression
+        });
+    }
+}

package/apps/agents-server/src/utils/cdn/interfaces/IFilesStorage.ts

@@ -0,0 +1,32 @@
+import type { string_mime_type } from '../../../../../../src/types/typeAliases';
+import type { IStorage } from './IStorage';
+
+export type IFile = {
+    // Maybe TODO name: string_name;
+    type: string_mime_type;
+    data: Buffer;
+};
+
+/**
+ * Represents storage that will store each keypair in a separate file.
+ */
+export type IFilesStorage = Omit<IStorage<IFile>, 'length' | 'clear' | 'key'>;
+
+/**
+ * Represents storage that can give public deterministic  URL for each file
+ */
+export type IIFilesStorageWithCdn = IFilesStorage & {
+    readonly cdnPublicUrl: URL;
+    getItemUrl(key: string): URL;
+};
+
+/**
+ * TODO: Probably not deterministic and async getItemUrl
+ * TODO: Probably just createUrlMaker
+ * TODO: List method
+ * TODO: Glob method
+ * TODO: Subfolder (similar to PrefixStorage) method
+ * TODO: Subscribe, list, sub(folder) should be part of LIB everstorage
+ * TODO: Probably implement observe through RxJS
+ * TODO: [☹️] Unite with `PromptbookStorage` and move to `/src/...`
+ */

package/apps/agents-server/src/utils/cdn/interfaces/IStorage.ts

@@ -0,0 +1,14 @@
+// Note: This is a simplified version of the IStorage interface based on the usage in the project.
+export type IStorage<T> = {
+    readonly length: Promise<number>;
+    clear(): Promise<void>;
+    getItem(key: string): Promise<T | null>;
+    key(index: number): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+    setItem(key: string, value: T): Promise<void>;
+};
+
+
+/**
+ * TODO: [☹️] Unite with `PromptbookStorage` and move to `/src/...`
+ */

package/apps/agents-server/src/utils/cdn/utils/getUserFileCdnKey.ts

@@ -0,0 +1,28 @@
+import hexEncoder from 'crypto-js/enc-hex';
+import sha256 from 'crypto-js/sha256';
+import type { string_uri } from '../../../../../../src/types/typeAliases';
+import { titleToName } from '../../../../../../src/utils/normalization/titleToName';
+import { nameToSubfolderPath } from './nameToSubfolderPath';
+
+/**
+ * Generates a path for the user content
+ */
+export function getUserFileCdnKey(file: Buffer, originalFilename: string): string_uri {
+    const hash = sha256(hexEncoder.parse(file.toString('hex'))).toString(/* hex */);
+    //    <- TODO: [🥬] Encapsulate sha256 to some private utility function
+
+    const originalFilenameParts = originalFilename.split('.');
+    const extension = originalFilenameParts.pop();
+    const name = titleToName(originalFilenameParts.join('.'));
+
+    const filename = name + '.' + extension;
+    // <- Note: [⛳️] Preserving original file name
+
+    return `user/files/${nameToSubfolderPath(hash).join('/')}/${filename}`;
+}
+
+/**
+ * TODO: [🌍] Unite this logic in one place
+ * TODO: Way to garbage unused uploaded files
+ * TODO: Probably separate util countBufferHash
+ */

package/apps/agents-server/src/utils/cdn/utils/nameToSubfolderPath.ts

@@ -0,0 +1,9 @@
+import type { string_name } from '../../../../../../src/types/typeAliases';
+
+export function nameToSubfolderPath(name: string_name): Array<string> {
+    return [name.substr(0, 2).toLowerCase(), name.substr(2, 5).toLowerCase()];
+}
+
+/**
+ * TODO: [🐱‍🚀] Use `nameToSubfolderPath` from src
+ */

package/apps/agents-server/src/utils/cdn/utils/nextRequestToNodeRequest.ts

@@ -0,0 +1,27 @@
+import { TODO_any } from '@promptbook-local/types';
+import { NextRequest } from 'next/server';
+import { Readable } from 'node:stream';
+
+export async function nextRequestToNodeRequest(nextRequest: NextRequest): Promise<Readable> {
+    const reader = nextRequest.body?.getReader();
+
+    if (!reader) {
+        throw new Error(`Can not get nextRequest.body.getReader()`);
+    }
+
+    const nodeStream = new Readable({
+        async read() {
+            const { done, value } = await reader.read();
+            if (done) this.push(null);
+            else this.push(Buffer.from(value));
+        },
+    });
+
+    // Fake IncomingMessage with headers
+    (nodeStream as TODO_any).headers = Object.fromEntries(nextRequest.headers.entries());
+    (nodeStream as TODO_any).method = nextRequest.method;
+    (nodeStream as TODO_any).url = nextRequest.url;
+    (nodeStream as TODO_any).socket = {}; // required by formidable
+
+    return nodeStream;
+}

package/apps/agents-server/src/utils/chatFeedbackAdmin.ts

@@ -0,0 +1,96 @@
+import type { AgentsServerDatabase } from '../database/schema';
+
+export type ChatFeedbackRow = AgentsServerDatabase['public']['Tables']['ChatFeedback']['Row'];
+export type ChatFeedbackSortField = 'createdAt' | 'agentName' | 'id';
+export type ChatFeedbackSortOrder = 'asc' | 'desc';
+
+export type ChatFeedbackListResponse = {
+    items: ChatFeedbackRow[];
+    total: number;
+    page: number;
+    pageSize: number;
+    sortBy: ChatFeedbackSortField;
+    sortOrder: ChatFeedbackSortOrder;
+};
+
+export type ChatFeedbackListParams = {
+    page?: number;
+    pageSize?: number;
+    agentName?: string;
+    search?: string;
+    sortBy?: ChatFeedbackSortField;
+    sortOrder?: ChatFeedbackSortOrder;
+};
+
+/**
+ * Build query string for chat feedback listing.
+ *
+ * Kept in a dedicated helper so it can be shared between the
+ * admin feedback page and other admin UIs (per-agent tools, etc.).
+ */
+function buildQuery(params: ChatFeedbackListParams): string {
+    const searchParams = new URLSearchParams();
+
+    if (params.page && params.page > 0) searchParams.set('page', String(params.page));
+    if (params.pageSize && params.pageSize > 0) searchParams.set('pageSize', String(params.pageSize));
+    if (params.agentName) searchParams.set('agentName', params.agentName);
+    if (params.search) searchParams.set('search', params.search);
+    if (params.sortBy) searchParams.set('sortBy', params.sortBy);
+    if (params.sortOrder) searchParams.set('sortOrder', params.sortOrder);
+
+    const qs = searchParams.toString();
+    return qs ? `?${qs}` : '';
+}
+
+/**
+ * Fetch chat feedback from the admin API.
+ */
+export async function $fetchChatFeedback(params: ChatFeedbackListParams = {}): Promise<ChatFeedbackListResponse> {
+    const qs = buildQuery(params);
+    const response = await fetch(`/api/chat-feedback${qs}`, {
+        method: 'GET',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to load chat feedback');
+    }
+
+    return (await response.json()) as ChatFeedbackListResponse;
+}
+
+/**
+ * Clear chat feedback for a specific agent.
+ */
+export async function $clearAgentChatFeedback(agentName: string): Promise<void> {
+    if (!agentName) {
+        throw new Error('agentName is required to clear chat feedback');
+    }
+
+    const response = await fetch(`/api/chat-feedback?agentName=${encodeURIComponent(agentName)}`, {
+        method: 'DELETE',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to clear chat feedback');
+    }
+}
+
+/**
+ * Delete a single chat feedback row by ID.
+ */
+export async function $deleteChatFeedbackRow(id: number): Promise<void> {
+    if (!id || id <= 0) {
+        throw new Error('Valid id is required to delete chat feedback row');
+    }
+
+    const response = await fetch(`/api/chat-feedback/${encodeURIComponent(String(id))}`, {
+        method: 'DELETE',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to delete chat feedback row');
+    }
+}