larkup 0.1.14 → 0.1.21

package/app/api/media/route.ts

@@ -0,0 +1,284 @@
+import { NextResponse } from 'next/server';
+import {
+  readMediaAssets,
+  deleteMediaAsset,
+  deleteMediaAssets,
+  mediaStats,
+  recoverStaleMediaAssets,
+  type NewMediaAssetInput,
+} from '@larkup/core/media-store';
+import { isToolInstalled } from '@larkup/marketplace/installer';
+import { loadTool } from '@larkup/marketplace/loader';
+import { createStorageProvider } from '@larkup/marketplace/storage';
+import { deleteDocuments } from '@larkup/core/documents-store';
+import { readConfig } from '@larkup/core/config-store';
+import { createAdapter } from '@larkup/vector-stores/factory';
+import type { MediaType } from '@larkup/core/types';
+import { runWithServer } from '@larkup/core/workspace';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/** GET → list media assets, optionally filtered by type. */
+export async function GET(req: Request) {
+  return withRequestServer(req, () => listMedia(req));
+}
+
+async function listMedia(req: Request) {
+  const url = new URL(req.url);
+  const typeFilter = url.searchParams.get('type') as MediaType | null;
+
+  await recoverStaleMediaAssets();
+  const [assets, stats] = await Promise.all([readMediaAssets(), mediaStats()]);
+  const filtered = typeFilter ? assets.filter((a) => a.type === typeFilter) : assets;
+
+  // Sort newest first
+  filtered.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+  const storage = createStorageProvider();
+  const storageStats = await storage.stats();
+
+  return NextResponse.json({
+    assets: filtered,
+    stats,
+    storage: {
+      usedBytes: storageStats.usedBytes,
+      fileCount: storageStats.fileCount,
+    },
+  });
+}
+
+/**
+ * POST → upload media files.
+ * Accepts multipart/form-data with one or more "file" fields.
+ */
+export async function POST(req: Request) {
+  return withRequestServer(req, () => saveMedia(req));
+}
+
+async function saveMedia(req: Request) {
+  try {
+    if (req.headers.get('content-type')?.includes('application/json')) {
+      return await importRemoteMedia(req);
+    }
+
+    const formData = await req.formData();
+    const files = formData.getAll('file') as File[];
+
+    if (files.length === 0) {
+      return NextResponse.json({ error: 'No files provided.' }, { status: 400 });
+    }
+
+    const storage = createStorageProvider();
+    const results: NewMediaAssetInput[] = [];
+
+    for (const file of files) {
+      const type = detectMediaType(file.type);
+      if (!type) {
+        continue; // skip unsupported types silently
+      }
+
+      const buffer = Buffer.from(await file.arrayBuffer());
+      const ext = file.name.split('.').pop() || 'bin';
+      const key = `${type}s/${Date.now()}_${Math.random().toString(36).slice(2)}.${ext}`;
+
+      const storageUri = await storage.store(key, buffer, file.type);
+
+      results.push({
+        type,
+        fileName: file.name,
+        mimeType: file.type,
+        storageUri,
+        fileSize: file.size,
+      });
+    }
+
+    if (results.length === 0) {
+      return NextResponse.json({ error: 'No supported media files found.' }, { status: 400 });
+    }
+
+    // Batch create media asset records
+    const { addMediaAssets } = await import('@larkup/core/media-store');
+    const assets = await addMediaAssets(results);
+
+    return NextResponse.json({ assets, count: assets.length }, { status: 201 });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to upload media.';
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+async function importRemoteMedia(req: Request) {
+  const body = (await req.json()) as {
+    urls?: string[];
+    estimateOnly?: boolean;
+    mediaType?: 'video' | 'audio';
+  };
+  const urls = [...new Set(body.urls?.map((url) => url.trim()).filter(Boolean) ?? [])];
+  if (urls.length === 0 || urls.length > 10) {
+    return NextResponse.json({ error: 'Provide between 1 and 10 media URLs.' }, { status: 400 });
+  }
+  if (!(await isToolInstalled('video-audio'))) {
+    return NextResponse.json(
+      { error: 'Install the Video & Audio tool before importing media URLs.' },
+      { status: 409 },
+    );
+  }
+
+  const tool = await loadTool<any>('video-audio');
+  if (!tool?.importMediaUrl || !tool?.inspectMediaUrl) {
+    return NextResponse.json(
+      { error: 'The installed Video & Audio tool needs an update.' },
+      { status: 409 },
+    );
+  }
+
+  if (body.estimateOnly) {
+    const estimates = [];
+    for (const url of urls) {
+      const estimate = await tool.inspectMediaUrl(url);
+      if (
+        body.mediaType &&
+        estimate.mediaType !== 'unknown' &&
+        estimate.mediaType !== body.mediaType
+      ) {
+        return NextResponse.json(
+          { error: `The URL points to ${estimate.mediaType}, not ${body.mediaType}.` },
+          { status: 400 },
+        );
+      }
+      estimates.push(estimate);
+    }
+    return NextResponse.json({ estimates });
+  }
+
+  const { addMediaAssets } = await import('@larkup/core/media-store');
+  const inputs: import('@larkup/core/media-store').NewMediaAssetInput[] = urls.map((url) => {
+    return {
+      type: body.mediaType || 'video',
+      fileName: 'Importing URL...',
+      mimeType: 'application/octet-stream',
+      storageUri: `pending://${url}`,
+      fileSize: 0,
+      originalUrl: url,
+    };
+  });
+
+  const assets = await addMediaAssets(inputs);
+  return NextResponse.json({ assets, count: assets.length }, { status: 201 });
+}
+
+/** DELETE → remove media assets. ?id=X or ?ids=X,Y */
+export async function DELETE(req: Request) {
+  return withRequestServer(req, () => removeMedia(req));
+}
+
+async function removeMedia(req: Request) {
+  const url = new URL(req.url);
+  const id = url.searchParams.get('id');
+  const ids = url.searchParams.get('ids');
+
+  const storage = createStorageProvider();
+
+  if (id) {
+    const { getMediaAsset } = await import('@larkup/core/media-store');
+    const asset = await getMediaAsset(id);
+    if (asset) {
+      if (isMediaProcessing(asset)) {
+        return NextResponse.json(
+          { error: 'Wait for the media indexing job to finish before deleting it.' },
+          { status: 409 },
+        );
+      }
+      const documentIds = allMediaDocumentIds(asset);
+      await deleteMediaDocuments(documentIds);
+      await storage.delete(asset.storageUri).catch(() => {});
+      if (asset.thumbnailUri) await storage.delete(asset.thumbnailUri).catch(() => {});
+      await deleteDocuments(documentIds);
+    }
+    await deleteMediaAsset(id);
+  } else if (ids) {
+    const idList = ids.split(',');
+    const assets = await readMediaAssets();
+    const selectedAssets = assets.filter((asset) => idList.includes(asset.id));
+    if (selectedAssets.some(isMediaProcessing)) {
+      return NextResponse.json(
+        { error: 'Wait for all selected media indexing jobs to finish before deleting them.' },
+        { status: 409 },
+      );
+    }
+    for (const asset of selectedAssets) {
+      const documentIds = allMediaDocumentIds(asset);
+      await deleteMediaDocuments(documentIds);
+      await storage.delete(asset.storageUri).catch(() => {});
+      if (asset.thumbnailUri) await storage.delete(asset.thumbnailUri).catch(() => {});
+      await deleteDocuments(documentIds);
+    }
+    await deleteMediaAssets(idList);
+  }
+
+  return NextResponse.json({ ok: true });
+}
+
+function isMediaProcessing(asset: {
+  processingStatus: string;
+  processingMessage?: string;
+}): boolean {
+  return (
+    asset.processingStatus === 'processing' ||
+    (asset.processingStatus === 'pending' &&
+      asset.processingMessage === 'Queued for background processing...')
+  );
+}
+
+function withRequestServer<T>(req: Request, fn: () => T): T {
+  const serverId = new URL(req.url).searchParams.get('serverId');
+  return serverId ? runWithServer(serverId, fn) : fn();
+}
+
+async function deleteMediaDocuments(documentIds: string[]): Promise<void> {
+  if (documentIds.length === 0) return;
+  const adapter = await createAdapter(await readConfig());
+  await adapter.deleteByDocumentIds(documentIds);
+}
+
+function allMediaDocumentIds(asset: {
+  documentIds: string[];
+  pendingDocumentIds?: string[];
+  supersededDocumentIds?: string[];
+}): string[] {
+  return [
+    ...new Set([
+      ...asset.documentIds,
+      ...(asset.pendingDocumentIds ?? []),
+      ...(asset.supersededDocumentIds ?? []),
+    ]),
+  ];
+}
+
+/* ------------------------------------------------------------------ */
+/* Helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+function detectMediaType(mimeType: string): MediaType | null {
+  if (mimeType.startsWith('image/')) return 'image';
+  if (mimeType.startsWith('video/')) return 'video';
+  if (mimeType.startsWith('audio/')) return 'audio';
+  return null;
+}
+
+function mimeFromFileName(fileName: string): string {
+  const ext = fileName.split('.').pop()?.toLowerCase();
+  const types: Record<string, string> = {
+    mp4: 'video/mp4',
+    webm: 'video/webm',
+    mov: 'video/quicktime',
+    mkv: 'video/x-matroska',
+    mp3: 'audio/mpeg',
+    m4a: 'audio/mp4',
+    wav: 'audio/wav',
+    ogg: 'audio/ogg',
+    flac: 'audio/flac',
+  };
+  return types[ext ?? ''] ?? 'application/octet-stream';
+}

package/app/api/media/stream/route.ts

@@ -0,0 +1,113 @@
+import { readMediaAssets, recoverStaleMediaAssets } from '@larkup/core/media-store';
+import { createStorageProvider } from '@larkup/marketplace/storage';
+import type { MediaType } from '@larkup/core/types';
+import { runWithServer } from '@larkup/core/workspace';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+const encoder = new TextEncoder();
+
+async function snapshot(
+  typeFilter: MediaType | null,
+  storageSnapshot: { usedBytes: number; fileCount: number },
+) {
+  const assets = await readMediaAssets();
+  const filtered = typeFilter ? assets.filter((asset) => asset.type === typeFilter) : assets;
+  filtered.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+  const stats = {
+    total: assets.length,
+    byType: { image: 0, video: 0, audio: 0 },
+    byStatus: { pending: 0, processing: 0, completed: 0, failed: 0 },
+    totalBytes: 0,
+  };
+  for (const asset of assets) {
+    stats.byType[asset.type]++;
+    stats.byStatus[asset.processingStatus]++;
+    stats.totalBytes += asset.fileSize;
+  }
+  return {
+    assets: filtered,
+    stats,
+    storage: storageSnapshot,
+  };
+}
+
+/**
+ * Streams persisted media state changes to the open Media tab. This replaces
+ * frequent client-side list requests while keeping the progress UI truthful:
+ * a new event is sent only after the background worker saves a change.
+ */
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const type = url.searchParams.get('type');
+  const serverId = url.searchParams.get('serverId');
+  const typeFilter: MediaType | null =
+    type === 'image' || type === 'video' || type === 'audio' ? type : null;
+  const scoped = <T>(fn: () => T): T => (serverId ? runWithServer(serverId, fn) : fn());
+
+  await scoped(() => recoverStaleMediaAssets());
+
+  let interval: ReturnType<typeof setInterval> | undefined;
+  let keepAlive: ReturnType<typeof setInterval> | undefined;
+  const stream = new ReadableStream<Uint8Array>({
+    async start(controller) {
+      let lastPayload = '';
+      let checking = false;
+      let storageSnapshot = { usedBytes: 0, fileCount: 0 };
+      let storageCheckedAt = 0;
+      const publish = async () => {
+        if (checking) return;
+        checking = true;
+        try {
+          if (Date.now() - storageCheckedAt > 30_000) {
+            try {
+              const storageStats = await scoped(() => createStorageProvider().stats());
+              storageSnapshot = {
+                usedBytes: storageStats.usedBytes,
+                fileCount: storageStats.fileCount,
+              };
+            } catch {
+              // Progress remains streamable even if a remote storage provider
+              // cannot calculate aggregate usage at this moment.
+            }
+            storageCheckedAt = Date.now();
+          }
+          const nextSnapshot = await scoped(() => snapshot(typeFilter, storageSnapshot));
+          const payload = JSON.stringify(nextSnapshot);
+          if (payload !== lastPayload) {
+            lastPayload = payload;
+            const revision = Math.max(
+              0,
+              ...nextSnapshot.assets.map((asset) => asset.processingRevision ?? 0),
+            );
+            controller.enqueue(
+              encoder.encode(`id: ${revision}\nevent: media-update\ndata: ${payload}\n\n`),
+            );
+          }
+        } catch {
+          // Keep the connection open; the next change check can recover.
+        } finally {
+          checking = false;
+        }
+      };
+
+      await publish();
+      interval = setInterval(() => void publish(), 1_000);
+      keepAlive = setInterval(() => controller.enqueue(encoder.encode(': keep-alive\n\n')), 15_000);
+    },
+    cancel() {
+      if (interval) clearInterval(interval);
+      if (keepAlive) clearInterval(keepAlive);
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  });
+}

package/app/api/models/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server"
+import { getAllModels, getAllProviders, type GatewayModel } from "@larkup/core/models-cache"
+
+export const runtime = "nodejs"
+export const dynamic = "force-dynamic"
+
+export async function GET(req: Request) {
+  const url = new URL(req.url)
+  const type = url.searchParams.get("type") as GatewayModel["type"] | null
+  const provider = url.searchParams.get("provider")
+
+  try {
+    let models = await getAllModels()
+    if (type) models = models.filter((m) => m.type === type)
+    if (provider) models = models.filter((m) => m.owned_by === provider)
+    const providers = await getAllProviders(type || undefined)
+
+    return NextResponse.json({ providers, models })
+  } catch (error) {
+    console.error("[api/models]", error)
+    return NextResponse.json({ error: "Failed to fetch models", providers: [], models: [] }, { status: 500 })
+  }
+}

package/app/api/proxy/verify/route.ts

@@ -0,0 +1,66 @@
+import { NextResponse } from 'next/server';
+import * as http from 'node:http';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function POST(req: Request) {
+  try {
+    const { server, username, password } = await req.json();
+
+    if (!server) {
+      return NextResponse.json({ error: 'Proxy server URL is required' }, { status: 400 });
+    }
+
+    let proxyUrl: URL;
+    try {
+      proxyUrl = new URL(server);
+    } catch {
+      return NextResponse.json({ error: 'Invalid proxy server URL' }, { status: 400 });
+    }
+
+    await new Promise((resolve, reject) => {
+      const headers: Record<string, string> = {
+        Host: 'example.com',
+      };
+
+      if (username && password) {
+        const auth = Buffer.from(`${username}:${password}`).toString('base64');
+        headers['Proxy-Authorization'] = `Basic ${auth}`;
+      }
+
+      const options: http.RequestOptions = {
+        hostname: proxyUrl.hostname,
+        port: proxyUrl.port || (proxyUrl.protocol === 'https:' ? 443 : 80),
+        path: 'http://example.com/',
+        method: 'GET',
+        headers,
+        timeout: 10000,
+      };
+
+      const request = http.request(options, (res) => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 400) {
+          resolve(true);
+        } else {
+          reject(new Error(`Proxy returned status code ${res.statusCode}`));
+        }
+      });
+
+      request.on('error', (err) => {
+        reject(err);
+      });
+
+      request.on('timeout', () => {
+        request.destroy();
+        reject(new Error('Proxy verification timed out'));
+      });
+
+      request.end();
+    });
+
+    return NextResponse.json({ success: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Verification failed';
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/app/api/sandbox/route.ts

@@ -0,0 +1,59 @@
+import { NextResponse } from "next/server"
+import { SandboxManager } from "@larkup/sandbox"
+import type { ExecutionRequest } from "@larkup/sandbox"
+
+export const runtime = "nodejs"
+export const dynamic = "force-dynamic"
+export const maxDuration = 60
+
+const manager = new SandboxManager({ backend: "docker" })
+
+/** GET /api/sandbox — Check sandbox health/status. */
+export async function GET() {
+  try {
+    const health = await manager.healthCheck()
+    return NextResponse.json(health)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Health check failed"
+    return NextResponse.json(
+      { status: "error", error: message },
+      { status: 500 },
+    )
+  }
+}
+
+/** POST /api/sandbox — Setup sandbox (build Docker image). */
+export async function POST(req: Request) {
+  try {
+    const url = new URL(req.url)
+    const action = url.searchParams.get("action")
+
+    if (action === "setup") {
+      const logs: string[] = []
+      await manager.setup((msg) => logs.push(msg))
+      return NextResponse.json({ ok: true, logs })
+    }
+
+    // Default: execute code
+    const body: ExecutionRequest = await req.json()
+
+    if (!body.code) {
+      return NextResponse.json(
+        { error: "code is required" },
+        { status: 400 },
+      )
+    }
+
+    const result = await manager.execute({
+      code: body.code,
+      language: body.language ?? "python",
+      files: body.files,
+      timeout: body.timeout,
+    })
+
+    return NextResponse.json(result)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Execution failed"
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}

package/app/api/search/bing/route.ts

@@ -0,0 +1,87 @@
+import { NextResponse } from 'next/server';
+import { readConfig } from '@larkup/core/config-store';
+import { SerperSearchResponse, SerperSearchItem } from '../google/route';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function POST(req: Request) {
+  const config = await readConfig();
+  const apiKey = config.bingApiKey;
+
+  if (!apiKey) {
+    return NextResponse.json(
+      {
+        error: 'Bing search is not configured. Set BING_API_KEY in your environment.',
+        configured: false,
+      },
+      { status: 503 },
+    );
+  }
+
+  let body: { query?: string; page?: number };
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid request body.' }, { status: 400 });
+  }
+
+  const { query, page = 1 } = body;
+  if (!query?.trim()) {
+    return NextResponse.json({ error: 'A search query is required.' }, { status: 400 });
+  }
+
+  const clampedPage = Math.max(1, Math.min(page, 10));
+  const offset = (clampedPage - 1) * 10;
+
+  try {
+    const res = await fetch(
+      `https://serpapi.com/search.json?engine=bing&q=${encodeURIComponent(query.trim())}&first=${
+        offset + 1
+      }&api_key=${apiKey}`,
+      {
+        method: 'GET',
+        cache: 'no-store',
+      },
+    );
+
+    const json = await res.json();
+
+    if (!res.ok || json.error) {
+      const msg = json.error ?? `Bing (SerpApi) error (${res.status})`;
+      return NextResponse.json({ error: msg }, { status: res.status });
+    }
+
+    const items: SerperSearchItem[] = (json.organic_results ?? []).map((r: any) => ({
+      url: r.link,
+      title: r.title,
+      description: r.snippet,
+    }));
+
+    // SerpApi doesn't easily expose total results for Bing sometimes, but we can check if there's a next page or just estimate
+    const rawTotal = 100; // Fake a large number for pagination
+    const gotFullPage = items.length >= 10; // Assuming 10 results per page default
+    const hasMore = gotFullPage && clampedPage < 10;
+
+    const totalPages = hasMore ? clampedPage + 1 : clampedPage;
+
+    return NextResponse.json({
+      items,
+      totalResults: rawTotal,
+      totalResultsIsEstimate: true,
+      currentPage: clampedPage,
+      totalPages,
+      hasMore,
+      query: query.trim(),
+    } satisfies SerperSearchResponse & { totalResultsIsEstimate: boolean });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'Bing search failed.';
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}
+
+export async function GET() {
+  const config = await readConfig();
+  const configured = Boolean(config.bingApiKey);
+  return NextResponse.json({ configured });
+}