@promptbook/cli 0.103.0-52 → 0.103.0-54

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/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

@@ -11,13 +11,18 @@ type AgentsApiResponse = {
     federatedServers: string[];
 };
 
+export type AgentsByServer = {
+    serverUrl: string;
+    agents: AgentWithUrl[];
+};
+
 /**
  * Fetches agents from federated servers recursively
  */
-export async function getFederatedAgents(initialServers: string[]): Promise<AgentWithUrl[]> {
+export async function getFederatedAgents(initialServers: string[]): Promise<AgentsByServer[]> {
     const visited = new Set<string>();
     const queue = [...initialServers];
-    const externalAgentsMap = new Map<string, AgentWithUrl>();
+    const agentsByServer = new Map<string, AgentWithUrl[]>();
     const MAX_SERVERS = 20;
 
     while (queue.length > 0 && visited.size < MAX_SERVERS) {
@@ -30,10 +35,10 @@ export async function getFederatedAgents(initialServers: string[]): Promise<Agen
 
         try {
             // TODO: [🧠] Should we use some shorter timeout?
-            const response = await fetch(`${normalizedUrl}/api/agents`, { 
-                next: { revalidate: 600 } // Cache for 10 minutes
+            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;
@@ -42,11 +47,26 @@ export async function getFederatedAgents(initialServers: string[]): Promise<Agen
             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 && !externalAgentsMap.has(agent.url)) {
-                        externalAgentsMap.set(agent.url, agent);
+                    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)) {
@@ -62,5 +82,8 @@ export async function getFederatedAgents(initialServers: string[]): Promise<Agen
         }
     }
 
-    return Array.from(externalAgentsMap.values());
+    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),
+    );
+}

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

@@ -4,13 +4,13 @@ import { getSession } from './session';
 /**
  * Checks if the current user is an admin
  * 
- * Note: If `process.env.ADMIN_PASSWORD` is not set, everyone is admin
+ * Note: If `process.env.ADMIN_PASSWORD` is not set, no one is admin
  * 
  * @returns true if the user is admin
  */
 export async function isUserAdmin(): Promise<boolean> {
     if (!process.env.ADMIN_PASSWORD) {
-        return true;
+        return false;
     }
 
     // Check legacy admin token

package/apps/agents-server/vercel.json

@@ -0,0 +1,7 @@
+{
+    "build": {
+        "env": {
+            "VERCEL_FORCE_NO_BUILD_CACHE": "1"
+        }
+    }
+}