@promptbook/cli 0.112.0-102 → 0.112.0-104

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

@@ -0,0 +1,168 @@
+import { readdir, readFile } from 'fs/promises';
+import { join } from 'path';
+import type { AgentBasicInformation, AgentCollection, string_book } from '@promptbook-local/types';
+import { parseAgentSource } from '../../../../../src/book-2.0/agent-source/parseAgentSource';
+import { DEFAULT_AGENT_VISIBILITY } from '../agentVisibility';
+
+/**
+ * Installation status for one default agent book.
+ *
+ * @private shared utility for Agents Server default-agent installation
+ */
+export type DefaultAgentInstallStatus = 'installed' | 'skipped';
+
+/**
+ * Result for one processed default agent book.
+ *
+ * @private shared utility for Agents Server default-agent installation
+ */
+export type DefaultAgentInstallRecord = {
+    /**
+     * Source book filename.
+     */
+    readonly fileName: string;
+
+    /**
+     * Parsed canonical agent name.
+     */
+    readonly agentName: string;
+
+    /**
+     * Whether the agent was created or skipped because an active agent with the same name already exists.
+     */
+    readonly status: DefaultAgentInstallStatus;
+
+    /**
+     * Permanent id of the newly created agent, if created.
+     */
+    readonly permanentId?: string;
+};
+
+/**
+ * Aggregate default-agent installation result.
+ *
+ * @private shared utility for Agents Server default-agent installation
+ */
+export type DefaultAgentInstallResult = {
+    /**
+     * Number of newly created agents.
+     */
+    readonly installedCount: number;
+
+    /**
+     * Number of already-present agents skipped by name.
+     */
+    readonly skippedCount: number;
+
+    /**
+     * Per-book processing records.
+     */
+    readonly records: ReadonlyArray<DefaultAgentInstallRecord>;
+};
+
+/**
+ * Options for installing default agents from a directory.
+ *
+ * @private shared utility for Agents Server default-agent installation
+ */
+export type InstallDefaultAgentsFromDirectoryOptions = {
+    /**
+     * Agent collection used for persistence.
+     */
+    readonly collection: AgentCollection;
+
+    /**
+     * Directory containing the repository default `*.book` files.
+     */
+    readonly defaultAgentsDirectoryPath: string;
+
+    /**
+     * Optional logger for install-time progress.
+     */
+    readonly logger?: Pick<Console, 'info'>;
+};
+
+/**
+ * Lists repository default book filenames in stable install order.
+ *
+ * @param defaultAgentsDirectoryPath - Directory containing default `*.book` files.
+ * @returns Sorted book filenames.
+ *
+ * @private shared utility for Agents Server default-agent installation
+ */
+export async function listDefaultAgentBookFileNames(defaultAgentsDirectoryPath: string): Promise<ReadonlyArray<string>> {
+    const directoryEntries = await readdir(defaultAgentsDirectoryPath, { withFileTypes: true });
+
+    return directoryEntries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.book'))
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+}
+
+/**
+ * Creates default agents from repository `*.book` files, skipping already-active agents with matching names.
+ *
+ * @param options - Installation options.
+ * @returns Aggregate installation result.
+ *
+ * @private shared utility for Agents Server default-agent installation
+ */
+export async function installDefaultAgentsFromDirectory(
+    options: InstallDefaultAgentsFromDirectoryOptions,
+): Promise<DefaultAgentInstallResult> {
+    const fileNames = await listDefaultAgentBookFileNames(options.defaultAgentsDirectoryPath);
+    const existingAgentNames = new Set((await options.collection.listAgents()).map((agent) => agent.agentName));
+    const records: Array<DefaultAgentInstallRecord> = [];
+
+    for (const [index, fileName] of fileNames.entries()) {
+        const agentSource = (await readFile(join(options.defaultAgentsDirectoryPath, fileName), 'utf-8')) as string_book;
+        const parsedAgentProfile = parseAgentSource(agentSource);
+        const agentName = parsedAgentProfile.agentName;
+
+        if (existingAgentNames.has(agentName)) {
+            options.logger?.info(`[default-agents] Skipping existing agent "${agentName}" from ${fileName}.`);
+            records.push({
+                fileName,
+                agentName,
+                status: 'skipped',
+            });
+            continue;
+        }
+
+        const createdAgent = await options.collection.createAgent(agentSource, {
+            sortOrder: index + 1,
+            visibility: DEFAULT_AGENT_VISIBILITY,
+        });
+
+        existingAgentNames.add(createdAgent.agentName);
+        options.logger?.info(`[default-agents] Installed "${createdAgent.agentName}" from ${fileName}.`);
+        records.push(createInstalledDefaultAgentRecord(fileName, createdAgent));
+    }
+
+    return {
+        installedCount: records.filter((record) => record.status === 'installed').length,
+        skippedCount: records.filter((record) => record.status === 'skipped').length,
+        records,
+    };
+}
+
+/**
+ * Creates a typed result record for a newly installed default agent.
+ *
+ * @param fileName - Source book filename.
+ * @param createdAgent - Created agent profile returned by the collection.
+ * @returns Installation record.
+ *
+ * @private utility of `installDefaultAgentsFromDirectory`
+ */
+function createInstalledDefaultAgentRecord(
+    fileName: string,
+    createdAgent: AgentBasicInformation & Required<Pick<AgentBasicInformation, 'permanentId'>>,
+): DefaultAgentInstallRecord {
+    return {
+        fileName,
+        agentName: createdAgent.agentName,
+        status: 'installed',
+        permanentId: createdAgent.permanentId,
+    };
+}

package/apps/agents-server/src/utils/defaultAgents/installDefaultAgents.ts

@@ -0,0 +1,139 @@
+import * as dotenv from 'dotenv';
+import { createClient, type SupabaseClient } from '@supabase/supabase-js';
+import { AgentCollectionInSupabase } from '../../../../../src/collection/agent-collection/constructors/agent-collection-in-supabase/AgentCollectionInSupabase';
+import type { AgentCollection } from '../../../../../src/collection/agent-collection/AgentCollection';
+import { isAgentsServerSqliteMode } from '../../database/agentsServerDatabaseMode';
+import { $provideLocalSqliteSupabase } from '../../database/sqlite/$provideLocalSqliteSupabase';
+import { installDefaultAgentsFromDirectory } from './defaultAgents';
+
+/**
+ * Environment variable pointing to the installed Agents Server `.env` file.
+ *
+ * @private install-time default-agent utility
+ */
+const AGENTS_SERVER_ENV_FILE_ENV_NAME = 'PTBK_AGENTS_SERVER_ENV_FILE';
+
+/**
+ * Environment variable pointing to the repository `agents/default` directory.
+ *
+ * @private install-time default-agent utility
+ */
+const DEFAULT_AGENTS_DIRECTORY_ENV_NAME = 'PTBK_DEFAULT_AGENTS_DIR';
+
+/**
+ * Environment variable containing the current server table prefix.
+ *
+ * @private install-time default-agent utility
+ */
+const SUPABASE_TABLE_PREFIX_ENV_NAME = 'SUPABASE_TABLE_PREFIX';
+
+/**
+ * Public Supabase URL environment variable.
+ *
+ * @private install-time default-agent utility
+ */
+const NEXT_PUBLIC_SUPABASE_URL_ENV_NAME = 'NEXT_PUBLIC_SUPABASE_URL';
+
+/**
+ * Supabase service role key environment variable.
+ *
+ * @private install-time default-agent utility
+ */
+const SUPABASE_SERVICE_ROLE_KEY_ENV_NAME = 'SUPABASE_SERVICE_ROLE_KEY';
+
+/**
+ * Public Supabase anon key environment variable used as a fallback when service role is unavailable.
+ *
+ * @private install-time default-agent utility
+ */
+const NEXT_PUBLIC_SUPABASE_ANON_KEY_ENV_NAME = 'NEXT_PUBLIC_SUPABASE_ANON_KEY';
+
+/**
+ * Loads the installed Agents Server environment for the detached installer script.
+ *
+ * @private install-time default-agent utility
+ */
+function loadDefaultAgentInstallEnvironment(): void {
+    const explicitEnvFilePath = process.env[AGENTS_SERVER_ENV_FILE_ENV_NAME]?.trim();
+    if (explicitEnvFilePath) {
+        const explicitLoadResult = dotenv.config({ path: explicitEnvFilePath });
+        if (!explicitLoadResult.error) {
+            return;
+        }
+    }
+
+    dotenv.config();
+}
+
+/**
+ * Creates the install-time agent collection using the same database backend as the server.
+ *
+ * @returns Agent collection bound to the configured table prefix.
+ *
+ * @private install-time default-agent utility
+ */
+function createDefaultAgentInstallCollection(): AgentCollection {
+    return new AgentCollectionInSupabase(createDefaultAgentInstallSupabaseClient(), {
+        tablePrefix: process.env[SUPABASE_TABLE_PREFIX_ENV_NAME] || '',
+    });
+}
+
+/**
+ * Creates the Supabase-shaped client used by the install-time agent collection.
+ *
+ * @returns Supabase or local SQLite client.
+ *
+ * @private install-time default-agent utility
+ */
+function createDefaultAgentInstallSupabaseClient(): SupabaseClient {
+    if (isAgentsServerSqliteMode()) {
+        return $provideLocalSqliteSupabase();
+    }
+
+    const supabaseUrl = process.env[NEXT_PUBLIC_SUPABASE_URL_ENV_NAME];
+    const supabaseKey =
+        process.env[SUPABASE_SERVICE_ROLE_KEY_ENV_NAME] || process.env[NEXT_PUBLIC_SUPABASE_ANON_KEY_ENV_NAME];
+
+    if (!supabaseUrl || !supabaseKey) {
+        throw new Error(
+            `Missing \`${NEXT_PUBLIC_SUPABASE_URL_ENV_NAME}\` and \`${SUPABASE_SERVICE_ROLE_KEY_ENV_NAME}\` for Supabase default-agent installation.`,
+        );
+    }
+
+    return createClient(supabaseUrl, supabaseKey, {
+        auth: {
+            autoRefreshToken: false,
+            persistSession: false,
+        },
+    });
+}
+
+/**
+ * Runs the default-agent install command.
+ *
+ * @private install-time default-agent utility
+ */
+async function installDefaultAgents(): Promise<void> {
+    loadDefaultAgentInstallEnvironment();
+
+    const defaultAgentsDirectoryPath = process.env[DEFAULT_AGENTS_DIRECTORY_ENV_NAME]?.trim();
+    if (!defaultAgentsDirectoryPath) {
+        throw new Error(`Missing \`${DEFAULT_AGENTS_DIRECTORY_ENV_NAME}\` environment variable.`);
+    }
+
+    const result = await installDefaultAgentsFromDirectory({
+        collection: createDefaultAgentInstallCollection(),
+        defaultAgentsDirectoryPath,
+        logger: console,
+    });
+
+    console.info(
+        `[default-agents] Finished. Installed ${result.installedCount}, skipped ${result.skippedCount}.`,
+    );
+}
+
+installDefaultAgents().catch((error) => {
+    console.error('[default-agents] Failed to install default agents.');
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+});

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

@@ -2,7 +2,7 @@ import { $getTableName } from '@/src/database/$getTableName';
 import { $provideSupabaseForServer } from '@/src/database/$provideSupabaseForServer';
 import type { Json } from '@/src/database/schema';
 import { FILE_SECURITY_CHECKERS } from '@/src/file-security-checkers';
-import { $provideUntrackedCdnForServer } from '@/src/tools/$provideCdnForServer';
+import { $provideCdnForServer } from '@/src/tools/$provideCdnForServer';
 import { $provideServer } from '@/src/tools/$provideServer';
 import { getUserFileCdnKey } from '@/src/utils/cdn/utils/getUserFileCdnKey';
 import { validateMimeType } from '@/src/utils/validators/validateMimeType';
@@ -231,12 +231,14 @@ async function createShareTargetAttachment(file: File, maxFileUploadBytes: numbe
 
     const mimeType = resolveShareTargetMimeType(file.type);
     const blobPath = getUserFileCdnKey(buffer, normalizedFilename);
-    const cdn = $provideUntrackedCdnForServer();
+    const cdn = $provideCdnForServer();
+    const storageUrl = cdn.getItemUrl(blobPath).href;
+
     await cdn.setItem(blobPath, {
-        data: buffer,
         type: mimeType,
-        fileSize: buffer.byteLength,
+        data: buffer,
         purpose: SHARE_TARGET_FILE_PURPOSE,
+        fileSize: buffer.byteLength,
     }).catch((error) => {
         throw new DatabaseError(
             spaceTrim(`
@@ -246,24 +248,14 @@ async function createShareTargetAttachment(file: File, maxFileUploadBytes: numbe
             `),
         );
     });
-    const storageUrl = cdn.getItemUrl(blobPath).href;
-    const fileRecordId = await insertShareTargetFileRecord({
-        fileName: normalizedFilename,
-        fileSize: buffer.byteLength,
-        fileType: mimeType,
-        storageUrl,
-    });
 
-    if (fileRecordId !== null) {
-        after(() =>
-            populateShareTargetFileSecurityResult({
-                fileId: fileRecordId,
-                storageUrl,
-            }).catch((error) => {
-                console.error('[share-target] Failed to finalize file security result', error);
-            }),
-        );
-    }
+    after(() =>
+        populateShareTargetFileSecurityResult({
+            storageUrl,
+        }).catch((error) => {
+            console.error('[share-target] Failed to finalize file security result', error);
+        }),
+    );
 
     return {
         name: normalizedFilename,
@@ -272,50 +264,10 @@ async function createShareTargetAttachment(file: File, maxFileUploadBytes: numbe
     };
 }
 
-/**
- * Inserts one admin-visible file row for a shared attachment.
- */
-async function insertShareTargetFileRecord(options: {
-    fileName: string;
-    fileSize: number;
-    fileType: string;
-    storageUrl: string;
-}): Promise<number | null> {
-    try {
-        const supabase = $provideSupabaseForServer() as TODO_any;
-        const fileTableName = await $getTableName('File');
-        const { data, error } = await supabase
-            .from(fileTableName)
-            .insert({
-                fileName: options.fileName,
-                fileSize: options.fileSize,
-                fileType: options.fileType,
-                storageUrl: options.storageUrl,
-                shortUrl: null,
-                purpose: SHARE_TARGET_FILE_PURPOSE,
-                status: 'COMPLETED',
-                agentId: null,
-                securityResult: null,
-            })
-            .select('id')
-            .maybeSingle();
-
-        if (error) {
-            console.error('[share-target] Failed to store uploaded file metadata', error);
-            return null;
-        }
-
-        return typeof data?.id === 'number' ? data.id : null;
-    } catch (error) {
-        console.error('[share-target] Failed to insert shared file metadata', error);
-        return null;
-    }
-}
-
 /**
  * Populates best-effort file-security results after the share redirect has already returned.
  */
-async function populateShareTargetFileSecurityResult(options: { fileId: number; storageUrl: string }): Promise<void> {
+async function populateShareTargetFileSecurityResult(options: { storageUrl: string }): Promise<void> {
     const securityResult: Record<string, unknown> = {};
 
     for (const checkerId of Object.keys(FILE_SECURITY_CHECKERS)) {
@@ -343,7 +295,7 @@ async function populateShareTargetFileSecurityResult(options: { fileId: number;
         .update({
             securityResult,
         })
-        .eq('id', options.fileId);
+        .eq('storageUrl', options.storageUrl);
 
     if (error) {
         throw new DatabaseError(

package/apps/agents-server/src/utils/upload/createBookEditorUploadHandler.ts

@@ -1,23 +1,20 @@
 'use client';
 
-import { upload } from '@vercel/blob/client';
-import type { number_percent, string_knowledge_source_content } from '@promptbook-local/types';
-import { isServerRoutedCdnUploadProvider, resolveCdnStorageProvider } from '../cdn/resolveCdnStorageProvider';
+import type { string_knowledge_source_content } from '@promptbook-local/types';
 import { getSafeCdnPath } from '../cdn/utils/getSafeCdnPath';
 import { normalizeUploadFilename } from '../normalization/normalizeUploadFilename';
+import {
+    buildDefaultUserFileUploadPath,
+    uploadFileToServer,
+    type FileUploadProgressCallback,
+} from './uploadFileToServer';
 
 /**
  * Progress callback invoked during file uploads.
  *
  * @private used by chat and book editors.
  */
-export type FileUploadProgressCallback = (
-    progress: number_percent,
-    stats?: {
-        loadedBytes: number;
-        totalBytes: number;
-    },
-) => void;
+export type { FileUploadProgressCallback };
 
 /**
  * Optional upload configuration such as progress reporting or cancellation.
@@ -56,8 +53,8 @@ type UploadPathBuilder = (normalizedFilename: string, pathPrefix: string) => str
 /**
  * Constant for build default user file path.
  */
-const buildDefaultUserFilePath: UploadPathBuilder = (normalizedFilename, pathPrefix) =>
-    pathPrefix ? `${pathPrefix}/user/files/${normalizedFilename}` : `user/files/${normalizedFilename}`;
+const buildDefaultUserFilePath: UploadPathBuilder = (normalizedFilename) =>
+    buildDefaultUserFileUploadPath(normalizedFilename);
 
 /**
  * Configuration of the shared upload handler.
@@ -76,109 +73,6 @@ type SharedUploadHandlerConfig = {
  */
 const DEFAULT_SHORT_URL_PREFIX = 'https://ptbk.io/k/';
 
-/**
- * Response returned by the server-routed upload API.
- *
- * @private used by chat and book editors.
- */
-type ServerRoutedUploadResponse = {
-    url: string;
-};
-
-/**
- * Uploads a file through `/api/upload` for S3-compatible storage providers.
- *
- * @private used by chat and book editors.
- */
-function uploadFileThroughServer(options: {
-    safeUploadPath: string;
-    file: File;
-    purpose: string;
-    abortSignal?: AbortSignal;
-    onProgress?: FileUploadProgressCallback;
-}): Promise<ServerRoutedUploadResponse> {
-    const { safeUploadPath, file, purpose, abortSignal, onProgress } = options;
-    const formData = new FormData();
-    formData.set('file', file);
-    formData.set('pathname', safeUploadPath);
-    formData.set('purpose', purpose);
-    formData.set('contentType', file.type || 'application/octet-stream');
-
-    return new Promise((resolve, reject) => {
-        const request = new XMLHttpRequest();
-
-        /**
-         * Removes abort listeners once the upload finishes.
-         */
-        const cleanup = () => {
-            abortSignal?.removeEventListener('abort', handleAbort);
-        };
-
-        /**
-         * Aborts the active XHR upload when the caller aborts.
-         */
-        const handleAbort = () => {
-            request.abort();
-            cleanup();
-            reject(new DOMException('Upload aborted.', 'AbortError'));
-        };
-
-        request.upload.addEventListener('progress', (event) => {
-            if (!event.lengthComputable) {
-                return;
-            }
-
-            onProgress?.((event.loaded / event.total) as number_percent, {
-                loadedBytes: event.loaded,
-                totalBytes: event.total,
-            });
-        });
-
-        request.addEventListener('load', () => {
-            cleanup();
-
-            if (request.status < 200 || request.status >= 300) {
-                reject(new Error(`Upload failed with HTTP ${request.status}: ${request.responseText}`));
-                return;
-            }
-
-            try {
-                const parsedResponse = JSON.parse(request.responseText) as Partial<ServerRoutedUploadResponse>;
-                if (typeof parsedResponse.url !== 'string' || parsedResponse.url.trim() === '') {
-                    reject(new Error('Upload response did not contain a file URL.'));
-                    return;
-                }
-
-                onProgress?.(1 as number_percent, {
-                    loadedBytes: file.size,
-                    totalBytes: file.size,
-                });
-                resolve({ url: parsedResponse.url });
-            } catch (error) {
-                reject(error);
-            }
-        });
-
-        request.addEventListener('error', () => {
-            cleanup();
-            reject(new Error('Upload failed before the server responded.'));
-        });
-
-        request.addEventListener('abort', () => {
-            cleanup();
-        });
-
-        if (abortSignal?.aborted) {
-            handleAbort();
-            return;
-        }
-
-        abortSignal?.addEventListener('abort', handleAbort);
-        request.open('POST', '/api/upload');
-        request.send(formData);
-    });
-}
-
 /**
  * Upload handler that normalizes the filename, uploads via `/api/upload`, and optionally returns a short URL.
  *
@@ -196,50 +90,29 @@ export function createFileUploadHandler<ReturnType extends string = string>(
 
     return async (file, optionsOrOnProgress) => {
         const { onProgress, abortSignal } = normalizeUploadOptions(optionsOrOnProgress);
-        const provider = resolveCdnStorageProvider();
-        const isServerRoutedUploadEnabled = isServerRoutedCdnUploadProvider(provider);
         const pathPrefix = process.env.NEXT_PUBLIC_CDN_PATH_PREFIX || '';
         const normalizedFilename = normalizeUploadFilename(file.name);
-        const publicUploadPath = pathBuilder(normalizedFilename, pathPrefix);
-        const storageUploadPath = pathBuilder(normalizedFilename, isServerRoutedUploadEnabled ? '' : pathPrefix);
-        const safeUploadPath = getSafeCdnPath({
-            pathname: storageUploadPath,
-            pathPrefix: isServerRoutedUploadEnabled ? pathPrefix : undefined,
+        const uploadPath = pathBuilder(normalizedFilename, pathPrefix);
+        const safeUploadPath = getSafeCdnPath({ pathname: uploadPath, pathPrefix });
+
+        const uploadResult = await uploadFileToServer({
+            file,
+            pathname: safeUploadPath,
+            purpose,
+            contentType: file.type || 'application/octet-stream',
+            abortSignal,
+            onProgress,
         });
 
-        const blob = isServerRoutedUploadEnabled
-            ? await uploadFileThroughServer({
-                  safeUploadPath,
-                  file,
-                  purpose,
-                  abortSignal,
-                  onProgress,
-              })
-            : await upload(safeUploadPath, file, {
-                  access: 'public',
-                  handleUploadUrl: '/api/upload',
-                  clientPayload: JSON.stringify({
-                      purpose,
-                      contentType: file.type || 'application/octet-stream',
-                  }),
-                  abortSignal,
-                  onUploadProgress: (progressEvent) => {
-                      onProgress?.(progressEvent.percentage / 100, {
-                          loadedBytes: progressEvent.loaded,
-                          totalBytes: progressEvent.total,
-                      });
-                  },
-              });
-
         if (returnShortUrl && process.env.NEXT_PUBLIC_CDN_PUBLIC_URL) {
-            const slashIndex = publicUploadPath.lastIndexOf('/');
-            const directoryPath = slashIndex === -1 ? '' : `${publicUploadPath.slice(0, slashIndex + 1)}`;
+            const slashIndex = uploadPath.lastIndexOf('/');
+            const directoryPath = slashIndex === -1 ? '' : `${uploadPath.slice(0, slashIndex + 1)}`;
             const longUrlPrefix = `${process.env.NEXT_PUBLIC_CDN_PUBLIC_URL}/${directoryPath}`;
-            const shortUrl = blob.url.split(longUrlPrefix).join(shortUrlPrefix);
+            const shortUrl = uploadResult.url.split(longUrlPrefix).join(shortUrlPrefix);
             return shortUrl as ReturnType;
         }
 
-        return blob.url as ReturnType;
+        return uploadResult.url as ReturnType;
     };
 }