larkup 0.1.14 → 0.1.21

package/app/api/deploy/ssh/route.ts

@@ -1,24 +1,24 @@
-import { NextRequest } from "next/server";
-import fs from "fs";
-import path from "path";
-import { getActiveServer } from "@larkup/core/workspace";
-import { NodeSSH } from "node-ssh";
-import crypto from "crypto";
+import { NextRequest } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import { getActiveServer } from '@larkup/core/workspace';
+import { NodeSSH } from 'node-ssh';
+import crypto from 'crypto';
 
 function getFilesRecursively(dir: string, baseDir: string): any[] {
   let results: any[] = [];
   if (!fs.existsSync(dir)) return results;
   const list = fs.readdirSync(dir);
   for (const file of list) {
-    if (file === "node_modules" || file === ".git" || file === "server.log") continue;
+    if (file === 'node_modules' || file === '.git' || file === 'server.log') continue;
     const filePath = path.join(dir, file);
     const stat = fs.statSync(filePath);
     if (stat && stat.isDirectory()) {
       results = results.concat(getFilesRecursively(filePath, baseDir));
     } else {
       const data = fs.readFileSync(filePath);
-      const relativePath = path.relative(baseDir, filePath).replace(/\\/g, "/");
-      results.push({ file: relativePath, data: data.toString("utf8") });
+      const relativePath = path.relative(baseDir, filePath).replace(/\\/g, '/');
+      results.push({ file: relativePath, data: data.toString('utf8') });
     }
   }
   return results;
@@ -26,7 +26,14 @@ function getFilesRecursively(dir: string, baseDir: string): any[] {
 
 export async function POST(req: NextRequest) {
   const body = await req.json();
-  let { serverId, host, username, privateKeyOrPassword, envVars, newPassword: userNewPassword } = body;
+  let {
+    serverId,
+    host,
+    username,
+    privateKeyOrPassword,
+    envVars,
+    newPassword: userNewPassword,
+  } = body;
 
   const stream = new ReadableStream({
     async start(controller) {
@@ -36,25 +43,29 @@ export async function POST(req: NextRequest) {
         } catch (e) {}
       }
       function log(msg: string) {
-        sendEvent({ type: "log", message: msg });
+        sendEvent({ type: 'log', message: msg });
       }
       function done(result: any) {
-        sendEvent({ type: "done", ...result });
-        try { controller.close(); } catch (e) {}
+        sendEvent({ type: 'done', ...result });
+        try {
+          controller.close();
+        } catch (e) {}
       }
       function errorMsg(err: string) {
-        sendEvent({ type: "error", error: err });
-        try { controller.close(); } catch (e) {}
+        sendEvent({ type: 'error', error: err });
+        try {
+          controller.close();
+        } catch (e) {}
       }
 
       let activeId = serverId;
-      if (activeId === "default") {
+      if (activeId === 'default') {
         const server = await getActiveServer();
         if (server) activeId = server.id;
       }
 
       if (!host || !username || !privateKeyOrPassword.value) {
-        return errorMsg("Host, username, and credentials are required.");
+        return errorMsg('Host, username, and credentials are required.');
       }
 
       try {
@@ -62,25 +73,25 @@ export async function POST(req: NextRequest) {
         const cwd = process.cwd();
         let config: any = null;
         const configCandidates = [
-          path.join(cwd, ".larkup", "servers", activeId, "config.json"),
-          path.join(cwd, ".larkup", "config.json"),
+          path.join(cwd, '.larkup', 'servers', activeId, 'config.json'),
+          path.join(cwd, '.larkup', 'config.json'),
         ];
         for (const cfgPath of configCandidates) {
           if (fs.existsSync(cfgPath)) {
             try {
-              config = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+              config = JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
               break;
             } catch {}
           }
         }
 
         if (!config) {
-          return errorMsg("Configuration not found. Please save your settings first.");
+          return errorMsg('Configuration not found. Please save your settings first.');
         }
 
-        const { generateServer } = await import("@larkup/core/generator/generate-server");
+        const { generateServer } = await import('@larkup/core/generator/generate-server');
         const generated = generateServer(config);
-        
+
         const filesToUpload: { localPath?: string; contents?: string; remotePath: string }[] = [];
 
         for (const f of generated.files) {
@@ -88,47 +99,49 @@ export async function POST(req: NextRequest) {
         }
 
         const envLines = Object.entries(envVars).map(([k, v]) => `${k}=${v}`);
-        const isLanceLocal = config.vectorStore === "lancedb" && config.storeConfig?.mode !== "cloud";
+        const isLanceLocal =
+          config.vectorStore === 'lancedb' && (config.storeConfig?.mode ?? 'local') === 'local';
         if (isLanceLocal) {
-          envLines.push("LANCEDB_PATH=./.larkup/lancedb");
+          envLines.push('LANCEDB_PATH=./.larkup/lancedb');
         }
-        filesToUpload.push({ contents: envLines.join("\n"), remotePath: ".env" });
+        filesToUpload.push({ contents: envLines.join('\n'), remotePath: '.env' });
 
         if (isLanceLocal) {
-          const lancedbDir = path.join(cwd, ".larkup", "servers", activeId, "lancedb");
+          const lancedbDir = path.join(cwd, '.larkup', 'servers', activeId, 'lancedb');
           if (fs.existsSync(lancedbDir)) {
             const lancedbFiles = getFilesRecursively(
               lancedbDir,
-              path.join(cwd, ".larkup", "servers", activeId)
+              path.join(cwd, '.larkup', 'servers', activeId),
             );
             for (const f of lancedbFiles) {
               filesToUpload.push({
-                localPath: path.join(cwd, ".larkup", "servers", activeId, f.file),
-                remotePath: f.file
+                localPath: path.join(cwd, '.larkup', 'servers', activeId, f.file),
+                remotePath: f.file,
               });
             }
           }
         }
 
-        let updatedPassword = userNewPassword || "";
+        let updatedPassword = userNewPassword || '';
         let ssh = new NodeSSH();
         log(`Connecting to ${username}@${host} via SSH...`);
-        
+
         const connectOpts = {
           host,
           username,
-          privateKey: privateKeyOrPassword.type === "key" ? privateKeyOrPassword.value : undefined,
-          password: privateKeyOrPassword.type === "password" ? privateKeyOrPassword.value : undefined,
+          privateKey: privateKeyOrPassword.type === 'key' ? privateKeyOrPassword.value : undefined,
+          password:
+            privateKeyOrPassword.type === 'password' ? privateKeyOrPassword.value : undefined,
           readyTimeout: 20000,
           tryKeyboard: true,
           onKeyboardInteractive: (
             _name: string,
             _instructions: string,
             _instructionsLang: string,
-            prompts: { prompt: string; echo: boolean }[],
-            finish: (responses: string[]) => void
+            prompts: any[],
+            finish: (responses: string[]) => void,
           ) => {
-            if (prompts.length > 0 && privateKeyOrPassword.type === "password") {
+            if (prompts.length > 0 && privateKeyOrPassword.type === 'password') {
               const answers = prompts.map((p) => {
                 return privateKeyOrPassword.value;
               });
@@ -136,7 +149,7 @@ export async function POST(req: NextRequest) {
             } else {
               finish([]);
             }
-          }
+          },
         };
 
         await ssh.connect(connectOpts);
@@ -144,113 +157,131 @@ export async function POST(req: NextRequest) {
 
         // Helper to run commands and stream output
         const runCommand = async (cmd: string, opts?: { cwd?: string; ignoreErrors?: boolean }) => {
-           log(`$ ${cmd}`);
-           const res = await ssh.execCommand(cmd, { 
-             cwd: opts?.cwd, 
-             onStdout: (chunk: Buffer) => log(chunk.toString('utf8').trimEnd()),
-             onStderr: (chunk: Buffer) => log(chunk.toString('utf8').trimEnd())
-           });
-           const combined = `${res.stdout} ${res.stderr}`.toLowerCase();
-           if (combined.includes("password change required") || combined.includes("password has expired")) {
-              throw new Error("PASSWORD_EXPIRED");
-           }
-           if (res.code !== 0 && !opts?.ignoreErrors) {
-             throw new Error(`Command failed (exit ${res.code}): ${cmd}\n${res.stderr}`);
-           }
-           return res;
+          log(`$ ${cmd}`);
+          const res = await ssh.execCommand(cmd, {
+            cwd: opts?.cwd,
+            onStdout: (chunk: Buffer) => log(chunk.toString('utf8').trimEnd()),
+            onStderr: (chunk: Buffer) => log(chunk.toString('utf8').trimEnd()),
+          });
+          const combined = `${res.stdout} ${res.stderr}`.toLowerCase();
+          if (
+            combined.includes('password change required') ||
+            combined.includes('password has expired')
+          ) {
+            throw new Error('PASSWORD_EXPIRED');
+          }
+          if (res.code !== 0 && !opts?.ignoreErrors) {
+            throw new Error(`Command failed (exit ${res.code}): ${cmd}\n${res.stderr}`);
+          }
+          return res;
         };
 
         const remoteDir = `/opt/buddyhere-rag-${activeId}`;
 
-        // ── Step 1: Test if the session works or if password change is needed ──
         let needsPasswordChange = false;
         try {
-          await runCommand("echo ok");
+          await runCommand('echo ok');
         } catch (err: any) {
-          if (err.message === "PASSWORD_EXPIRED") {
+          if (err.message === 'PASSWORD_EXPIRED') {
             needsPasswordChange = true;
           } else {
             throw err;
           }
         }
 
-        // ── Step 2: If password expired, handle password change ──
         if (needsPasswordChange) {
-          // If the user hasn't provided a new password yet, ask the frontend
           if (!updatedPassword) {
             log(`⚠️ Password has expired! A new password is required.`);
-            sendEvent({ type: "password_change_required" });
-            try { controller.close(); } catch (e) {}
+            sendEvent({ type: 'password_change_required' });
+            try {
+              controller.close();
+            } catch (e) {}
             return;
           }
 
-          // User provided a new password — change it via PTY
           log(`⚠️ Password has expired! Changing password...`);
-          
+
           await new Promise<void>((resolve, reject) => {
             const timeout = setTimeout(() => {
-              reject(new Error("Password change timed out after 30 seconds."));
+              reject(new Error('Password change timed out after 30 seconds.'));
             }, 30000);
 
-            ssh.requestShell({ term: 'xterm' }).then(shell => {
-              let buffer = "";
-              let stage = 0; // 0=waiting for current, 1=waiting for new, 2=waiting for retype, 3=done
-
-              shell.on('data', (data: Buffer) => {
-                const text = data.toString('utf8');
-                buffer += text;
-                // Stream raw shell output to the UI (clean up control chars)
-                const clean = text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').trim();
-                if (clean) log(clean);
-                
-                const lower = buffer.toLowerCase();
-                
-                if (stage === 0) {
-                  if ((lower.includes("current") || lower.includes("old")) && lower.includes("password")) {
-                    shell.write(privateKeyOrPassword.value + "\n");
-                    buffer = "";
-                    stage = 1;
-                  } else if (lower.includes("new") && lower.includes("password")) {
-                    // Hetzner sometimes skips asking for the current password
-                    shell.write(updatedPassword + "\n");
-                    buffer = "";
+            ssh
+              .requestShell({ term: 'xterm' })
+              .then((shell) => {
+                let buffer = '';
+                let stage = 0; // 0=waiting for current, 1=waiting for new, 2=waiting for retype, 3=done
+
+                shell.on('data', (data: Buffer) => {
+                  const text = data.toString('utf8');
+                  buffer += text;
+                  const clean = text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '').trim();
+                  if (clean) log(clean);
+
+                  const lower = buffer.toLowerCase();
+
+                  if (stage === 0) {
+                    if (
+                      (lower.includes('current') || lower.includes('old')) &&
+                      lower.includes('password')
+                    ) {
+                      shell.write(privateKeyOrPassword.value + '\n');
+                      buffer = '';
+                      stage = 1;
+                    } else if (lower.includes('new') && lower.includes('password')) {
+                      // Hetzner sometimes skips asking for the current password
+                      shell.write(updatedPassword + '\n');
+                      buffer = '';
+                      stage = 2;
+                    }
+                  } else if (stage === 1 && lower.includes('new') && lower.includes('password')) {
+                    shell.write(updatedPassword + '\n');
+                    buffer = '';
                     stage = 2;
+                  } else if (
+                    stage === 2 &&
+                    (lower.includes('retype') ||
+                      lower.includes('re-enter') ||
+                      lower.includes('confirm') ||
+                      (lower.includes('new') && lower.includes('password')))
+                  ) {
+                    shell.write(updatedPassword + '\n');
+                    buffer = '';
+                    stage = 3;
+                  } else if (
+                    stage === 3 &&
+                    (lower.includes('updated successfully') ||
+                      lower.includes('password changed') ||
+                      lower.includes('$') ||
+                      lower.includes('#'))
+                  ) {
+                    clearTimeout(timeout);
+                    shell.end();
+                    resolve();
                   }
-                } else if (stage === 1 && lower.includes("new") && lower.includes("password")) {
-                  shell.write(updatedPassword + "\n");
-                  buffer = "";
-                  stage = 2;
-                } else if (stage === 2 && (lower.includes("retype") || lower.includes("re-enter") || lower.includes("confirm") || (lower.includes("new") && lower.includes("password")))) {
-                  shell.write(updatedPassword + "\n");
-                  buffer = "";
-                  stage = 3;
-                } else if (stage === 3 && (lower.includes("updated successfully") || lower.includes("password changed") || lower.includes("$") || lower.includes("#"))) {
+                });
+
+                shell.on('close', () => {
                   clearTimeout(timeout);
-                  shell.end();
                   resolve();
-                }
-              });
-              
-              shell.on('close', () => {
-                clearTimeout(timeout);
-                resolve();
-              });
-              shell.on('error', (err: Error) => {
+                });
+                shell.on('error', (err: Error) => {
+                  clearTimeout(timeout);
+                  reject(err);
+                });
+              })
+              .catch((err: Error) => {
                 clearTimeout(timeout);
                 reject(err);
               });
-            }).catch((err: Error) => {
-              clearTimeout(timeout);
-              reject(err);
-            });
           });
 
-          log("✅ Password changed successfully.");
-          sendEvent({ type: "password_changed", newPassword: updatedPassword });
+          log('✅ Password changed successfully.');
+          sendEvent({ type: 'password_changed', newPassword: updatedPassword });
 
           // Disconnect and reconnect with the new password
           ssh.dispose();
-          log("Reconnecting with new password...");
+          log('Reconnecting with new password...');
           ssh = new NodeSSH();
           await ssh.connect({
             ...connectOpts,
@@ -259,25 +290,27 @@ export async function POST(req: NextRequest) {
               _name: string,
               _instructions: string,
               _instructionsLang: string,
-              prompts: { prompt: string; echo: boolean }[],
-              finish: (responses: string[]) => void
+              prompts: any[],
+              finish: (responses: string[]) => void,
             ) => {
               if (prompts.length > 0) {
                 finish(prompts.map(() => updatedPassword));
               } else {
                 finish([]);
               }
-            }
+            },
           });
-          log("Reconnected successfully.");
+          log('Reconnected successfully.');
         }
 
         // ── Step 3: Ensure Docker is installed ──
-        log("Checking for Docker...");
-        const dockerCheck = await runCommand("docker --version", { ignoreErrors: true });
+        log('Checking for Docker...');
+        const dockerCheck = await runCommand('docker --version', { ignoreErrors: true });
         if (dockerCheck.code !== 0) {
-          log("Docker not found. Installing Docker (this may take a few minutes)...");
-          await runCommand("curl -fsSL https://get.docker.com -o /tmp/get-docker.sh && sh /tmp/get-docker.sh");
+          log('Docker not found. Installing Docker (this may take a few minutes)...');
+          await runCommand(
+            'curl -fsSL https://get.docker.com -o /tmp/get-docker.sh && sh /tmp/get-docker.sh',
+          );
         }
 
         // ── Step 4: Upload files ──
@@ -287,17 +320,20 @@ export async function POST(req: NextRequest) {
         log(`Uploading ${filesToUpload.length} files...`);
         for (const f of filesToUpload) {
           const dir = path.posix.dirname(f.remotePath);
-          if (dir && dir !== ".") {
+          if (dir && dir !== '.') {
             await runCommand(`mkdir -p ${remoteDir}/${dir}`, { ignoreErrors: true });
           }
-          
+
           const target = `${remoteDir}/${f.remotePath}`;
           if (f.localPath) {
             log(`  ↑ ${f.remotePath}`);
             await ssh.putFile(f.localPath, target);
           } else if (f.contents) {
             log(`  ↑ ${f.remotePath}`);
-            const tempPath = path.join("/tmp", `buddyhere-upload-${Date.now()}-${Math.random().toString(36).substring(7)}`);
+            const tempPath = path.join(
+              '/tmp',
+              `buddyhere-upload-${Date.now()}-${Math.random().toString(36).substring(7)}`,
+            );
             fs.writeFileSync(tempPath, f.contents);
             await ssh.putFile(tempPath, target);
             fs.unlinkSync(tempPath);
@@ -306,12 +342,18 @@ export async function POST(req: NextRequest) {
 
         // ── Step 5: Docker Compose ──
         log(`Starting Docker containers...`);
-        await runCommand("docker compose down 2>/dev/null || true", { cwd: remoteDir, ignoreErrors: true });
-        
-        const composeRes = await runCommand("docker compose up -d --build", { cwd: remoteDir, ignoreErrors: true });
+        await runCommand('docker compose down 2>/dev/null || true', {
+          cwd: remoteDir,
+          ignoreErrors: true,
+        });
+
+        const composeRes = await runCommand('docker compose up -d --build', {
+          cwd: remoteDir,
+          ignoreErrors: true,
+        });
         if (composeRes.code !== 0) {
-          log("docker compose v2 failed, trying docker-compose v1...");
-          await runCommand("docker-compose up -d --build", { cwd: remoteDir });
+          log('docker compose v2 failed, trying docker-compose v1...');
+          await runCommand('docker-compose up -d --build', { cwd: remoteDir });
         }
 
         ssh.dispose();
@@ -322,19 +364,18 @@ export async function POST(req: NextRequest) {
           url: `http://${host}:8080`,
           newPassword: updatedPassword || undefined,
         });
-
       } catch (error: any) {
-        console.error("SSH Deploy Error:", error);
-        errorMsg(error.message || "Failed to deploy via SSH.");
+        console.error('SSH Deploy Error:', error);
+        errorMsg(error.message || 'Failed to deploy via SSH.');
       }
-    }
+    },
   });
 
   return new Response(stream, {
     headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      "Connection": "keep-alive",
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
     },
   });
 }

package/app/api/deployment/blob-setup/route.ts

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server';
+import { readDeploymentConfig, writeDeploymentConfig } from '@larkup/core/deployment-store';
+
+export async function GET() {
+  try {
+    const config = await readDeploymentConfig();
+    return NextResponse.json({ connected: !!config.vercelBlobToken });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}
+
+export async function POST(req: Request) {
+  try {
+    const { token } = await req.json();
+    if (!token) {
+      return NextResponse.json({ error: 'Token is required' }, { status: 400 });
+    }
+
+    const config = await readDeploymentConfig();
+    config.vercelBlobToken = token;
+    await writeDeploymentConfig(config);
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/deployment/config/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from 'next/server';
+import { readDeploymentConfig, writeDeploymentConfig } from '@larkup/core/deployment-store';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+  try {
+    const config = await readDeploymentConfig();
+    return NextResponse.json(config);
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}
+
+export async function PUT(req: Request) {
+  try {
+    const body = await req.json();
+    const config = await writeDeploymentConfig(body);
+    return NextResponse.json(config);
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/describe-image/route.ts

@@ -0,0 +1,84 @@
+import { NextResponse } from 'next/server';
+import { generateText } from 'ai';
+import { readConfig } from '@larkup/core/config-store';
+import { getModelsByType } from '@larkup/core/models-cache';
+import { runWithServer } from '@larkup/core/workspace';
+import { createChatModel, resolveConfiguredChatModel } from '@/lib/chat-model-provider';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function POST(req: Request) {
+  const serverId = new URL(req.url).searchParams.get('serverId');
+  const describe = () => describeImage(req);
+  return serverId ? runWithServer(serverId, describe) : describe();
+}
+
+async function describeImage(req: Request) {
+  try {
+    const { base64, base64Images, prompt } = (await req.json()) as {
+      base64?: string;
+      base64Images?: string[];
+      prompt?: string;
+    };
+    const images = (base64Images?.length ? base64Images : base64 ? [base64] : []).slice(0, 6);
+    if (images.length === 0) {
+      return NextResponse.json({ error: 'Missing image data' }, { status: 400 });
+    }
+
+    const config = await readConfig();
+    const models = await getModelsByType('language');
+    const resolved = resolveConfiguredChatModel(config, models, { requiredTag: 'vision' });
+    const model = createChatModel(
+      resolved.provider,
+      resolved.modelId,
+      resolved.apiKey,
+      config.customChatModels,
+    ) as any;
+
+    const defaultPrompt =
+      'Provide a very brief, high-level summary of what this image contains (e.g., "A database ER diagram about films and actors", "A bar chart showing quarterly revenue"). Do NOT extract all text or exhaustively describe relationships. Keep it under 2 sentences.';
+
+    const { text, usage } = await generateText({
+      model,
+      abortSignal: req.signal,
+      messages: [
+        {
+          role: 'user',
+          content: [
+            {
+              type: 'text',
+              text: prompt || defaultPrompt,
+            },
+            ...images.map((image) => ({
+              type: 'image' as const,
+              image: image.startsWith('data:') ? image : `data:image/jpeg;base64,${image}`,
+            })),
+          ],
+        },
+      ],
+    });
+
+    const { estimateCost, trackUsageEvent } = await import('@larkup/core/analytics-store');
+    void trackUsageEvent({
+      type: 'media_processing',
+      mediaType: 'image',
+      modelId: resolved.modelId,
+      provider: resolved.provider,
+      promptTokens: usage.inputTokens ?? 0,
+      completionTokens: usage.outputTokens ?? 0,
+      totalTokens: usage.totalTokens ?? 0,
+      estimatedCost: estimateCost(
+        resolved.modelId,
+        usage.inputTokens ?? 0,
+        usage.outputTokens ?? 0,
+      ),
+      timestamp: new Date().toISOString(),
+    });
+
+    return NextResponse.json({ description: text });
+  } catch (err: any) {
+    console.error('Image description failed:', err);
+    return NextResponse.json({ error: err.message }, { status: 500 });
+  }
+}