@promptbook/cli 0.103.0-9 → 0.104.0-0

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');
+    }
+}

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

@@ -0,0 +1,96 @@
+import type { AgentsServerDatabase } from '../database/schema';
+
+export type ChatHistoryRow = AgentsServerDatabase['public']['Tables']['ChatHistory']['Row'];
+export type ChatHistorySortField = 'createdAt' | 'agentName' | 'id';
+export type ChatHistorySortOrder = 'asc' | 'desc';
+
+export type ChatHistoryListResponse = {
+    items: ChatHistoryRow[];
+    total: number;
+    page: number;
+    pageSize: number;
+    sortBy: ChatHistorySortField;
+    sortOrder: ChatHistorySortOrder;
+};
+
+export type ChatHistoryListParams = {
+    page?: number;
+    pageSize?: number;
+    agentName?: string;
+    search?: string;
+    sortBy?: ChatHistorySortField;
+    sortOrder?: ChatHistorySortOrder;
+};
+
+/**
+ * Build query string for chat history listing.
+ */
+function buildQuery(params: ChatHistoryListParams): 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 history from the admin API.
+ *
+ * This is shared between the admin page and other admin UIs (e.g. per-agent tools)
+ * to keep the API surface DRY.
+ */
+export async function $fetchChatHistory(params: ChatHistoryListParams = {}): Promise<ChatHistoryListResponse> {
+    const qs = buildQuery(params);
+    const response = await fetch(`/api/chat-history${qs}`, {
+        method: 'GET',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to load chat history');
+    }
+
+    return (await response.json()) as ChatHistoryListResponse;
+}
+
+/**
+ * Clear chat history for a specific agent.
+ */
+export async function $clearAgentChatHistory(agentName: string): Promise<void> {
+    if (!agentName) {
+        throw new Error('agentName is required to clear chat history');
+    }
+
+    const response = await fetch(`/api/chat-history?agentName=${encodeURIComponent(agentName)}`, {
+        method: 'DELETE',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to clear chat history');
+    }
+}
+
+/**
+ * Delete a single chat history row by ID.
+ */
+export async function $deleteChatHistoryRow(id: number): Promise<void> {
+    if (!id || id <= 0) {
+        throw new Error('Valid id is required to delete chat history row');
+    }
+
+    const response = await fetch(`/api/chat-history/${encodeURIComponent(String(id))}`, {
+        method: 'DELETE',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to delete chat history row');
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * Converts an array of objects to a CSV string
+ */
+export function convertToCsv(data: Array<Record<string, unknown>>): string {
+    if (data.length === 0) {
+        return '';
+    }
+
+    const headers = Object.keys(data[0]);
+    const csvRows = [headers.join(',')];
+
+    for (const row of data) {
+        const values = headers.map((header) => {
+            let value = row[header];
+
+            if (value === null || value === undefined) {
+                value = '';
+            } else if (typeof value === 'object') {
+                value = JSON.stringify(value);
+            } else {
+                value = String(value);
+            }
+
+            const escaped = (value as string).replace(/"/g, '""');
+            return `"${escaped}"`;
+        });
+        csvRows.push(values.join(','));
+    }
+
+    return csvRows.join('\n');
+}

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

@@ -0,0 +1,32 @@
+import { cookies } from 'next/headers';
+import { getSession } from './session';
+
+export type UserInfo = {
+    username: string;
+    isAdmin: boolean;
+};
+
+export async function getCurrentUser(): Promise<UserInfo | null> {
+    // Check session
+    const session = await getSession();
+    if (session) {
+        return {
+            username: session.username,
+            isAdmin: session.isAdmin
+        };
+    }
+
+    // Check legacy admin token
+    if (process.env.ADMIN_PASSWORD) {
+        const cookieStore = await cookies();
+        const adminToken = cookieStore.get('adminToken');
+        if (adminToken?.value === process.env.ADMIN_PASSWORD) {
+            return {
+                username: 'admin',
+                isAdmin: true
+            };
+        }
+    }
+
+    return null;
+}

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

@@ -0,0 +1,22 @@
+import type { string_promptbook_server_url } from '../../../../src/types/typeAliases';
+import { AUTO_FEDERATED_AGENT_SERVER_URLS } from '../../../../servers';
+
+/**
+ * Computes the effective list of federated servers for the current Agents Server.
+ *
+ * - Combines servers listed in the FEDERATED_SERVERS metadata (comma-separated)
+ *   with a set of auto-federated servers defined in the root servers.ts config.
+ * - Ensures uniqueness and trims whitespace.
+ */
+export function getEffectiveFederatedServers(federatedServersString: string): Array<string_promptbook_server_url> {
+    const manualFederatedServers = federatedServersString
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s): s is string_promptbook_server_url => s !== '');
+
+    const merged = Array.from(
+        new Set<string_promptbook_server_url>([...manualFederatedServers, ...AUTO_FEDERATED_AGENT_SERVER_URLS]),
+    );
+
+    return merged;
+}

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

@@ -0,0 +1,89 @@
+import { AgentCollection } from '@promptbook-local/types';
+
+type Agent = Awaited<ReturnType<AgentCollection['listAgents']>>[number];
+
+type AgentWithUrl = Agent & {
+    url: string;
+};
+
+type AgentsApiResponse = {
+    agents: AgentWithUrl[];
+    federatedServers: string[];
+};
+
+export type AgentsByServer = {
+    serverUrl: string;
+    agents: AgentWithUrl[];
+};
+
+/**
+ * Fetches agents from federated servers recursively
+ */
+export async function getFederatedAgents(initialServers: string[]): Promise<AgentsByServer[]> {
+    const visited = new Set<string>();
+    const queue = [...initialServers];
+    const agentsByServer = new Map<string, AgentWithUrl[]>();
+    const MAX_SERVERS = 20;
+
+    while (queue.length > 0 && visited.size < MAX_SERVERS) {
+        const serverUrl = queue.shift();
+        if (!serverUrl) continue;
+
+        const normalizedUrl = serverUrl.trim().replace(/\/$/, '');
+        if (visited.has(normalizedUrl)) continue;
+        visited.add(normalizedUrl);
+
+        try {
+            // TODO: [🧠] Should we use some shorter timeout?
+            const response = await fetch(`${normalizedUrl}/api/agents`, {
+                next: { revalidate: 600 }, // Cache for 10 minutes
+            });
+
+            if (!response.ok) {
+                console.warn(`Failed to fetch agents from ${normalizedUrl}: ${response.status} ${response.statusText}`);
+                continue;
+            }
+
+            const data: AgentsApiResponse = await response.json();
+
+            if (data.agents && Array.isArray(data.agents)) {
+                const serverAgents: AgentWithUrl[] = [];
+                const existingAgentUrls = new Set<string>();
+
+                // Collect all existing agent URLs across all servers
+                for (const agents of agentsByServer.values()) {
+                    for (const agent of agents) {
+                        existingAgentUrls.add(agent.url);
+                    }
+                }
+
+                for (const agent of data.agents) {
+                    if (agent.url && !existingAgentUrls.has(agent.url)) {
+                        serverAgents.push(agent);
+                        existingAgentUrls.add(agent.url);
+                    }
+                }
+
+                if (serverAgents.length > 0) {
+                    agentsByServer.set(normalizedUrl, serverAgents);
+                }
+            }
+
+            if (data.federatedServers && Array.isArray(data.federatedServers)) {
+                for (const server of data.federatedServers) {
+                    const normalizedServer = server.trim().replace(/\/$/, '');
+                    if (!visited.has(normalizedServer) && normalizedServer !== '') {
+                        queue.push(normalizedServer);
+                    }
+                }
+            }
+        } catch (error) {
+            console.error(`Error fetching agents from ${normalizedUrl}:`, error);
+        }
+    }
+
+    return Array.from(agentsByServer.entries()).map(([serverUrl, agents]) => ({
+        serverUrl,
+        agents,
+    }));
+}

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

@@ -0,0 +1,10 @@
+import { getMetadata } from '../database/getMetadata';
+import { getEffectiveFederatedServers } from './getEffectiveFederatedServers';
+
+/**
+ * Reads FEDERATED_SERVERS metadata and returns a normalized list of server URLs.
+ */
+export async function getFederatedServersFromMetadata(): Promise<string[]> {
+    const federatedServersString = (await getMetadata('FEDERATED_SERVERS')) || '';
+    return getEffectiveFederatedServers(federatedServersString);
+}

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

@@ -0,0 +1,12 @@
+import { getGroupedCommitmentDefinitions } from '../../../../src/commitments';
+import { NotYetImplementedCommitmentDefinition } from '../../../../src/commitments/_base/NotYetImplementedCommitmentDefinition';
+
+/**
+ * Gets visible commitment definitions for documentation
+ * Excluding those that are not yet implemented
+ */
+export function getVisibleCommitmentDefinitions() {
+    return getGroupedCommitmentDefinitions().filter(
+        (group) => !(group.primary instanceof NotYetImplementedCommitmentDefinition),
+    );
+}