@promptbook/cli 0.103.0-9 → 0.104.0-0

package/apps/agents-server/src/app/agents/[agentName]/opengraph-image.tsx

@@ -0,0 +1,102 @@
+import { PROMPTBOOK_COLOR } from '@promptbook-local/core';
+import { serializeError } from '@promptbook-local/utils';
+import { ImageResponse } from 'next/og';
+import { assertsError } from '../../../../../../src/errors/assertsError';
+import { Color } from '../../../../../../src/utils/color/Color';
+import { textColor } from '../../../../../../src/utils/color/operators/furthest';
+import { grayscale } from '../../../../../../src/utils/color/operators/grayscale';
+import { getAgentName, getAgentProfile } from './_utils';
+
+// export const runtime = 'edge';
+// <- Note: On Vercel Edge runtime some modules are not working *(like `crypto`)*
+
+export const alt = 'Agent Profile';
+export const size = {
+    width: 1200,
+    height: 630,
+};
+
+export const contentType = 'image/png';
+
+export default async function Image({ params }: { params: Promise<{ agentName: string }> }) {
+    try {
+        const agentName = await getAgentName(params);
+        const agentProfile = await getAgentProfile(agentName);
+        const agentColor = Color.from(agentProfile.meta.color || PROMPTBOOK_COLOR);
+        const backgroundColor = agentColor.then(grayscale(0.5));
+
+        return new ImageResponse(
+            (
+                <div
+                    style={{
+                        width: '100%',
+                        height: '100%',
+                        backgroundColor: backgroundColor.toHex(),
+                        color: agentColor.then(textColor).toHex(),
+                        display: 'flex',
+                        alignItems: 'center',
+                        justifyContent: 'center',
+                    }}
+                >
+                    <div
+                        style={{
+                            width: '50%',
+                            display: 'flex',
+                            alignItems: 'center',
+                            justifyContent: 'center',
+                        }}
+                    >
+                        {/* Note: `next/image` is not working propperly with `next/og` */}
+                        {/* eslint-disable-next-line @next/next/no-img-element */}
+                        <img
+                            style={{
+                                width: '80%',
+                                backgroundColor: agentColor.toHex(),
+                                borderRadius: '50%',
+                            }}
+                            src={agentProfile.meta.image!}
+                            alt="Agent Icon"
+                        />
+                    </div>
+                    <div
+                        style={{
+                            width: '50%',
+                            display: 'flex',
+                            alignItems: 'center',
+                            justifyContent: 'center',
+                            textAlign: 'center',
+                        }}
+                    >
+                        <h1 style={{ fontSize: '100px' }}>{agentProfile.meta.fullname || agentName}</h1>
+                    </div>
+                </div>
+            ),
+            {
+                ...size,
+                emoji: 'openmoji',
+            },
+        );
+    } catch (error) {
+        assertsError(error);
+
+        console.error(error);
+
+        return new Response(
+            JSON.stringify(
+                serializeError(error),
+                // <- TODO: [🐱‍🚀] Rename `serializeError` to `errorToJson`
+                null,
+                4,
+                // <- TODO: [🐱‍🚀] Allow to configure pretty print for agent server
+            ),
+            {
+                status: 400, // <- TODO: [🐱‍🚀] Make `errorToHttpStatusCode`
+                headers: { 'Content-Type': 'application/json' },
+            },
+        );
+    }
+}
+
+/**
+ * TODO: [🦚] DRY
+ */

package/apps/agents-server/src/app/agents/[agentName]/page.tsx

@@ -0,0 +1,106 @@
+'use server';
+
+import { $provideServer } from '@/src/tools/$provideServer';
+import { isUserAdmin } from '@/src/utils/isUserAdmin';
+import { saturate } from '@promptbook-local/color';
+import { PROMPTBOOK_COLOR } from '@promptbook-local/core';
+import { notFound } from 'next/navigation';
+import { Color } from '../../../../../../src/utils/color/Color';
+import { getAgentName, getAgentProfile } from './_utils';
+import { getAgentLinks } from './agentLinks';
+import { AgentProfileChat } from './AgentProfileChat';
+import { AgentProfileWrapper } from './AgentProfileWrapper';
+import { generateAgentMetadata } from './generateAgentMetadata';
+import { ServiceWorkerRegister } from './ServiceWorkerRegister';
+
+export const generateMetadata = generateAgentMetadata;
+
+export default async function AgentPage({
+    params,
+    searchParams,
+}: {
+    params: Promise<{ agentName: string }>;
+    searchParams: Promise<{ headless?: string }>;
+}) {
+    const agentName = await getAgentName(params);
+    const isAdmin = await isUserAdmin();
+    const { headless: headlessParam } = await searchParams;
+    const isHeadless = headlessParam !== undefined;
+
+    let agentProfile;
+    try {
+        agentProfile = await getAgentProfile(agentName);
+    } catch (error) {
+        if (
+            error instanceof Error &&
+            // Note: This is a bit hacky, but valid way to check for specific error message
+            (error.message.includes('Cannot coerce the result to a single JSON object') ||
+                error.message.includes('JSON object requested, multiple (or no) results returned'))
+        ) {
+            notFound();
+        }
+        throw error;
+    }
+
+    const { publicUrl } = await $provideServer();
+
+    // Build agent page URL for QR and copy
+    const agentUrl = `${publicUrl.href}${encodeURIComponent(agentName)}`;
+    // <- TODO: [🐱‍🚀] Better
+
+    const agentEmail = `${agentName}@${publicUrl.hostname}`;
+
+    const brandColor = Color.fromSafe(agentProfile.meta.color || PROMPTBOOK_COLOR);
+    const brandColorHex = brandColor.then(saturate(-0.5)).toHex();
+
+    const fullname = (agentProfile.meta.fullname || agentProfile.agentName || 'Agent') as string;
+
+    return (
+        <>
+            <ServiceWorkerRegister scope={`/agents/${encodeURIComponent(agentName)}/`} />
+            <AgentProfileWrapper
+                agent={agentProfile}
+                agentUrl={agentUrl}
+                agentEmail={agentEmail}
+                agentName={agentName}
+                brandColorHex={brandColorHex}
+                isAdmin={isAdmin}
+                isHeadless={isHeadless}
+                actions={
+                    <>
+                        {getAgentLinks(agentName)
+                            .filter((link) => ['Edit Book', 'Integration', 'All Links'].includes(link.title))
+                            .map((link) => (
+                                <a
+                                    key={link.href}
+                                    href={link.href}
+                                    className="flex items-center gap-2 text-gray-600 hover:text-gray-900 transition-colors group"
+                                    title={link.title}
+                                >
+                                    <div className="p-2 rounded-full bg-white/40 group-hover:bg-white/60 transition-colors shadow-sm">
+                                        <link.icon className="w-5 h-5" />
+                                    </div>
+                                    <span className="font-medium text-sm">{link.title}</span>
+                                </a>
+                            ))}
+                    </>
+                }
+            >
+                <AgentProfileChat
+                    agentUrl={agentUrl}
+                    agentName={agentName}
+                    fullname={fullname}
+                    brandColorHex={brandColorHex}
+                    avatarSrc={agentProfile.meta.image!}
+                />
+            </AgentProfileWrapper>
+        </>
+    );
+}
+
+/**
+ * TODO: [🐱‍🚀] Make this page look nice - 🃏
+ * TODO: [🐱‍🚀] Show usage of LLM
+ * TODO: [🚗] Components and pages here should be just tiny UI wraper around proper agent logic and conponents
+ * TODO: [🎣][🧠] Maybe do API / Page for transpilers, Allow to export each agent
+ */

package/apps/agents-server/src/app/agents/[agentName]/website-integration/page.tsx

@@ -0,0 +1,72 @@
+'use server';
+
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { $provideServer } from '@/src/tools/$provideServer';
+import { PromptbookAgentIntegration } from '@promptbook-local/components';
+import { parseAgentSource } from '@promptbook-local/core';
+import { headers } from 'next/headers';
+import spaceTrim from 'spacetrim';
+import { $sideEffect } from '../../../../../../../src/utils/organization/$sideEffect';
+import { CodePreview } from '../../../../../../_common/components/CodePreview/CodePreview';
+import { generateAgentMetadata } from '../generateAgentMetadata';
+
+export const generateMetadata = generateAgentMetadata;
+
+export default async function WebsiteIntegrationAgentPage({ params }: { params: Promise<{ agentName: string }> }) {
+    $sideEffect(headers());
+    let { agentName } = await params;
+    agentName = decodeURIComponent(agentName);
+
+    const collection = await $provideAgentCollectionForServer();
+    const agentSource = await collection.getAgentSource(agentName);
+    const { meta } = parseAgentSource(agentSource);
+    const { fullname, color, image, ...restMeta } = meta;
+    const { publicUrl } = await $provideServer();
+    const agentUrl = `${publicUrl.href}agents/${encodeURIComponent(agentName)}`;
+
+    const code = spaceTrim(
+        (block) => `
+
+            import { PromptbookAgent } from '@promptbook/components';
+
+            export function YourComponent() {
+                return(
+                    <PromptbookAgent
+                        agentUrl="${agentUrl}"
+                        meta={${block(JSON.stringify({ fullname, color, image, ...restMeta }, null, 4))}}
+                    />
+                );
+            }
+            
+        `,
+    );
+
+    return (
+        <main className="w-screen h-screen p-4">
+            <h1 className="text-2xl font-bold p-4 border-b">{meta.fullname || agentName} Integration Code</h1>
+            <p className="mt-4 mb-8 text-gray-600">
+                Use the following code to integrate the <strong>{meta.fullname || agentName}</strong> agent into your
+                React application using the <code>{'<PromptbookAgent />'}</code> component.
+            </p>
+
+            <CodePreview code={code} />
+            <PromptbookAgentIntegration
+                // formfactor="profile"
+                agentUrl={agentUrl}
+                meta={meta}
+                style={
+                    {
+                        // width: '400px',
+                        // height: '600px',
+                        // outline: `2px solid red`
+                    }
+                }
+            />
+        </main>
+    );
+}
+
+/**
+ * TODO: Make this page better, bring from Promptbook.Studio
+ * TODO: [🚗] Components and pages here should be just tiny UI wraper around proper agent logic and conponents
+ */

package/apps/agents-server/src/app/agents/page.tsx

@@ -0,0 +1,11 @@
+'use server';
+
+import HomePage from '../page';
+
+export default async function AgentsPage() {
+    return <HomePage />;
+}
+
+/**
+ * TODO: [🐱‍🚀] Distinguish between `/` and `/agents` pages
+ */

package/apps/agents-server/src/app/api/agents/[agentName]/clone/route.ts

@@ -0,0 +1,47 @@
+// POST /api/agents/[agentName]/clone
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { AgentBasicInformation } from '../../../../../../../../src/book-2.0/agent-source/AgentBasicInformation';
+import { string_book } from '../../../../../../../../src/book-2.0/agent-source/string_book';
+import { TODO_any } from '@promptbook-local/types';
+import { NextResponse } from 'next/server';
+
+export async function POST(request: Request, { params }: { params: Promise<{ agentName: string }> }) {
+    const { agentName } = await params;
+    const collection = await $provideAgentCollectionForServer();
+
+    try {
+        const source = await collection.getAgentSource(agentName);
+
+        // Generate new name
+        // TODO: [🧠] Better naming strategy, maybe check for collisions
+        let newAgentName = `${agentName} (Copy)`;
+        let counter = 1;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            try {
+                await collection.getAgentSource(newAgentName);
+                 // If success, it means it exists, so we try next one
+                 counter++;
+                 newAgentName = `${agentName} (Copy ${counter})`;
+             } catch (error) {
+                 // If error, it likely means it does not exist (NotFoundError), so we can use it
+                 // TODO: [🧠] Check if it is really NotFoundError
+                 break;
+             }
+        }
+
+        const lines = source.split('\n');
+        lines[0] = newAgentName;
+        const newSource = lines.join('\n') as string_book;
+
+        const newAgent = await collection.createAgent(newSource);
+        
+        return NextResponse.json(newAgent);
+    } catch (error) {
+        return NextResponse.json(
+            { success: false, error: (error as TODO_any)?.message || 'Failed to clone agent' },
+            { status: 500 },
+        );
+    }
+}

package/apps/agents-server/src/app/api/agents/[agentName]/route.ts

@@ -0,0 +1,19 @@
+// DELETE /api/agents/[agentName]
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { TODO_any } from '@promptbook-local/types';
+import { NextResponse } from 'next/server';
+
+export async function DELETE(request: Request, { params }: { params: Promise<{ agentName: string }> }) {
+    const { agentName } = await params;
+    const collection = await $provideAgentCollectionForServer();
+
+    try {
+        await collection.deleteAgent(agentName);
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        return NextResponse.json(
+            { success: false, error: (error as TODO_any)?.message || 'Failed to delete agent' },
+            { status: 500 },
+        );
+    }
+}

package/apps/agents-server/src/app/api/agents/route.ts

@@ -0,0 +1,43 @@
+import { $provideServer } from '@/src/tools/$provideServer';
+import { NextResponse } from 'next/server';
+import { $provideAgentCollectionForServer } from '../../../tools/$provideAgentCollectionForServer';
+import { getFederatedServersFromMetadata } from '../../../utils/getFederatedServersFromMetadata';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+    try {
+        const collection = await $provideAgentCollectionForServer();
+        const agents = await collection.listAgents();
+        const federatedServers = await getFederatedServersFromMetadata();
+        const { publicUrl } = await $provideServer();
+
+        const agentsWithUrl = agents.map((agent) => ({
+            ...agent,
+            url: `${publicUrl.href}agents/${encodeURIComponent(agent.agentName)}`,
+        }));
+
+        const response = NextResponse.json({
+            agents: agentsWithUrl,
+            federatedServers,
+        });
+
+        // Add CORS headers
+        response.headers.set('Access-Control-Allow-Origin', '*');
+        response.headers.set('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        response.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+
+        return response;
+    } catch (error) {
+        console.error('Error fetching agents:', error);
+        return NextResponse.json({ error: 'Failed to fetch agents' }, { status: 500 });
+    }
+}
+
+export async function OPTIONS() {
+    const response = new NextResponse(null, { status: 200 });
+    response.headers.set('Access-Control-Allow-Origin', '*');
+    response.headers.set('Access-Control-Allow-Methods', 'GET, OPTIONS');
+    response.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+    return response;
+}

package/apps/agents-server/src/app/api/api-tokens/route.ts

@@ -0,0 +1,76 @@
+import { $getTableName } from '../../../database/$getTableName';
+import { $provideSupabase } from '../../../database/$provideSupabase';
+import { isUserAdmin } from '../../../utils/isUserAdmin';
+import { randomUUID } from 'crypto';
+import { NextRequest, NextResponse } from 'next/server';
+
+export async function GET(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const supabase = $provideSupabase();
+    const table = await $getTableName('ApiTokens');
+
+    const { data, error } = await supabase.from(table).select('*').order('createdAt', { ascending: false });
+
+    if (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+
+    return NextResponse.json(data);
+}
+
+export async function POST(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const body = await request.json();
+        const { note } = body;
+
+        const token = `ptbk_${randomUUID().replace(/-/g, '')}`;
+
+        const supabase = $provideSupabase();
+        const table = await $getTableName('ApiTokens');
+
+        const { data, error } = await supabase
+            .from(table)
+            .insert({ token, note })
+            .select()
+            .single();
+
+        if (error) {
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+
+        return NextResponse.json(data);
+    } catch (e) {
+        return NextResponse.json({ error: 'Invalid request body' }, { status: 400 });
+    }
+}
+
+export async function DELETE(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const searchParams = request.nextUrl.searchParams;
+    const id = searchParams.get('id');
+
+    if (!id) {
+        return NextResponse.json({ error: 'ID is required' }, { status: 400 });
+    }
+
+    const supabase = $provideSupabase();
+    const table = await $getTableName('ApiTokens');
+
+    const { error } = await supabase.from(table).delete().eq('id', parseInt(id, 10));
+
+    if (error) {
+        return NextResponse.json({ error: error.message }, { status: 500 });
+    }
+
+    return NextResponse.json({ success: true });
+}

package/apps/agents-server/src/app/api/auth/change-password/route.ts

@@ -0,0 +1,75 @@
+import { NextResponse } from 'next/server';
+import { $getTableName } from '../../../../database/$getTableName';
+import { $provideSupabaseForServer } from '../../../../database/$provideSupabaseForServer';
+import { AgentsServerDatabase } from '../../../../database/schema';
+import { hashPassword, verifyPassword } from '../../../../utils/auth';
+import { getCurrentUser } from '../../../../utils/getCurrentUser';
+
+export async function POST(request: Request) {
+    try {
+        const user = await getCurrentUser();
+        if (!user) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        const body = await request.json();
+        const { currentPassword, newPassword } = body;
+
+        if (!currentPassword || !newPassword) {
+            return NextResponse.json({ error: 'Missing password fields' }, { status: 400 });
+        }
+
+        // Special check for environment admin
+        if (user.username === 'admin' && process.env.ADMIN_PASSWORD) {
+            // Environment admin cannot change password through this API
+            // They must change the env variable
+            return NextResponse.json(
+                {
+                    error: 'You cannot change the admin password. Please update the `ADMIN_PASSWORD` environment variable.',
+                },
+                { status: 403 },
+            );
+        }
+
+        const supabase = $provideSupabaseForServer();
+        const { data: userData, error: fetchError } = await supabase
+            .from(await $getTableName('User'))
+            .select('*')
+            .eq('username', user.username)
+            .single();
+
+        if (fetchError || !userData) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        const userRow = userData as AgentsServerDatabase['public']['Tables']['User']['Row'];
+
+        // Verify current password
+        const isValid = await verifyPassword(currentPassword, userRow.passwordHash);
+        if (!isValid) {
+            return NextResponse.json({ error: 'Invalid current password' }, { status: 401 });
+        }
+
+        // Hash new password
+        const newPasswordHash = await hashPassword(newPassword);
+
+        // Update password
+        const { error: updateError } = await supabase
+            .from(await $getTableName('User'))
+            .update({
+                passwordHash: newPasswordHash,
+                updatedAt: new Date().toISOString(),
+            })
+            .eq('id', userRow.id);
+
+        if (updateError) {
+            console.error('Error updating password:', updateError);
+            return NextResponse.json({ error: 'Failed to update password' }, { status: 500 });
+        }
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error('Change password error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}

package/apps/agents-server/src/app/api/auth/login/route.ts

@@ -0,0 +1,27 @@
+import { authenticateUser } from '../../../../utils/authenticateUser';
+import { setSession } from '../../../../utils/session';
+import { NextResponse } from 'next/server';
+
+export async function POST(request: Request) {
+    try {
+        const body = await request.json();
+        const { username, password } = body;
+
+        if (!username || !password) {
+            return NextResponse.json({ error: 'Username and password are required' }, { status: 400 });
+        }
+
+        const user = await authenticateUser(username, password);
+
+        if (user) {
+            await setSession(user);
+            return NextResponse.json({ success: true });
+        } else {
+            return NextResponse.json({ error: 'Invalid credentials' }, { status: 401 });
+        }
+
+    } catch (error) {
+        console.error('Login error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}

package/apps/agents-server/src/app/api/auth/logout/route.ts

@@ -0,0 +1,7 @@
+import { clearSession } from '../../../../utils/session';
+import { NextResponse } from 'next/server';
+
+export async function POST() {
+    await clearSession();
+    return NextResponse.json({ success: true });
+}

package/apps/agents-server/src/app/api/chat/route.ts

@@ -0,0 +1,32 @@
+import { createOpenAiExecutionTools } from '@promptbook-local/openai';
+
+export async function GET(request: Request) {
+    const { searchParams } = new URL(request.url);
+    const message = searchParams.get('message') || 'Hello, who are you?';
+
+    const llmTools = createOpenAiExecutionTools({
+        apiKey: process.env.OPENAI_API_KEY,
+    });
+
+    const response = await llmTools.callChatModel({
+        title: 'Test Chat Call',
+        parameters: {},
+        modelRequirements: {
+            modelVariant: 'CHAT',
+            modelName: 'gpt-3.5-turbo',
+        },
+        content: message,
+    });
+
+    /*
+    return new Response(JSON.stringify(response, null, 4), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+    });
+    */
+
+    return new Response(response.content, {
+        status: 200,
+        headers: { 'Content-Type': 'text/markdown' },
+    });
+}

package/apps/agents-server/src/app/api/chat-feedback/[id]/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { $getTableName } from '../../../../database/$getTableName';
+import { $provideSupabase } from '../../../../database/$provideSupabase';
+import { isUserAdmin } from '../../../../utils/isUserAdmin';
+
+/**
+ * Delete a single chat feedback entry by ID.
+ */
+export async function DELETE(request: NextRequest, context: { params: Promise<{ id: string }> }) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+
+    const rawId = (await context.params).id;
+    const id = Number.parseInt(rawId, 10);
+
+    if (!Number.isFinite(id) || id <= 0) {
+        return NextResponse.json({ error: 'Invalid id' }, { status: 400 });
+    }
+
+    try {
+        const supabase = $provideSupabase();
+        const table = await $getTableName('ChatFeedback');
+
+        const { error } = await supabase.from(table).delete().eq('id', id);
+
+        if (error) {
+            console.error('Delete chat feedback row error:', error);
+            return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+        }
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error('Delete chat feedback row error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}