@larkup/workspace-server 0.0.0-stage → 0.2.0

package/src/app/api/doc-editor/restore/route.ts

@@ -0,0 +1,70 @@
+import { restoreSession, parseDocument } from '@larkup/tool-doc-editor';
+import type { EditorSession } from '@larkup/tool-doc-editor';
+
+export async function POST(req: Request) {
+  try {
+    const { sessionId, fileBase64, parsedDocument, fileName, mimeType, activeFileType } =
+      await req.json();
+
+    if (!sessionId || !fileBase64) {
+      return Response.json({ error: 'Missing sessionId or fileBase64' }, { status: 400 });
+    }
+
+    const buffer = Buffer.from(fileBase64, 'base64');
+
+    // Re-parse the actual file to get proper fields and pages.
+    // This is critical: if we don't have a parsedDocument with fields,
+    // any subsequent fill attempts will fail because field ID resolution
+    // relies on session.parsed.fields being populated.
+    let parsed;
+    if (parsedDocument && parsedDocument.fields && parsedDocument.fields.length > 0) {
+      parsed = parsedDocument;
+    } else {
+      try {
+        const resolvedMime = mimeType || 'application/pdf';
+        const resolvedName = fileName || 'Document';
+        parsed = await parseDocument(buffer, resolvedName, resolvedMime);
+        parsed.sessionId = sessionId;
+      } catch (parseErr: any) {
+        console.warn('[doc-editor/restore] Re-parse failed, using empty parsed:', parseErr.message);
+        parsed = {
+          sessionId,
+          fileName: fileName || 'Document',
+          type: activeFileType || 'pdf',
+          mimeType: mimeType || 'application/pdf',
+          fileSize: buffer.length,
+          pages: [],
+          fields: [],
+          rawText: '',
+          metadata: {},
+          totalPages: 1,
+        };
+      }
+    }
+
+    const session: EditorSession = {
+      id: sessionId,
+      fileName: fileName || parsed.fileName || 'Document',
+      type: activeFileType || parsed.type || 'pdf',
+      mimeType: mimeType || parsed.mimeType || 'application/pdf',
+      originalFileBase64: fileBase64,
+      currentFileBase64: fileBase64,
+      parsed: parsed,
+      edits: [],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    restoreSession(session);
+    console.log(
+      `[doc-editor/restore] Session ${sessionId} restored with ${
+        parsed.fields?.length ?? 0
+      } fields`,
+    );
+
+    return Response.json({ success: true, message: 'Session restored in backend' });
+  } catch (error: any) {
+    console.error('Error restoring session:', error);
+    return Response.json({ error: error.message || 'Failed to restore session' }, { status: 500 });
+  }
+}

package/src/app/api/document/sign/route.ts

@@ -0,0 +1,55 @@
+import { applySignature } from '@larkup/tool-doc-editor';
+import { z } from 'zod';
+
+const requestSchema = z.object({
+  sessionId: z.string(),
+  signatureData: z.object({
+    mode: z.enum(['type', 'draw', 'upload']),
+    imagePayload: z.string().optional(),
+    text: z.string().optional(),
+    font: z.string().optional(),
+    color: z.string().optional(),
+    date: z.string().optional(),
+    extraText: z.string().optional(),
+    pageIndex: z.number(),
+    x: z.number().optional(),
+    y: z.number().optional(),
+    scale: z.number().optional(),
+    base64Override: z.string().optional(),
+    detectedContext: z.string().optional(),
+    placementNote: z.string().optional(),
+  }),
+});
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const result = requestSchema.safeParse(body);
+
+    if (!result.success) {
+      return Response.json(
+        { error: 'Invalid request data', details: result.error.issues },
+        { status: 400 },
+      );
+    }
+
+    const { sessionId, signatureData } = result.data;
+    const editResult = await applySignature(sessionId, signatureData as any);
+
+    if (!editResult.success) {
+      return Response.json({ error: editResult.error }, { status: 500 });
+    }
+
+    // Since EditResult no longer returns `document` but `parsed` and `fileBase64`, we return those.
+    return Response.json({
+      document: {
+        parsed: (editResult as any).parsed,
+        fileBase64: (editResult as any).fileBase64,
+        updatedFields: (editResult as any).updatedFields,
+      },
+    });
+  } catch (err: any) {
+    console.error('Sign doc error:', err);
+    return Response.json({ error: 'Internal Server Error' }, { status: 500 });
+  }
+}

package/src/app/api/files/remote/route.ts

@@ -0,0 +1,32 @@
+import { downloadRemoteFile } from '@larkup/workspace-server/lib/remote-files';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+export const maxDuration = 60;
+
+export async function POST(request: Request) {
+  try {
+    const body = (await request.json()) as { url?: unknown };
+    if (typeof body.url !== 'string' || !body.url.trim()) {
+      return Response.json({ error: 'Enter a file URL to continue.' }, { status: 400 });
+    }
+
+    const file = await downloadRemoteFile(body.url);
+    const responseBody = file.bytes.buffer.slice(
+      file.bytes.byteOffset,
+      file.bytes.byteOffset + file.bytes.byteLength,
+    ) as ArrayBuffer;
+    return new Response(responseBody, {
+      headers: {
+        'Content-Type': file.contentType,
+        'Content-Length': String(file.bytes.byteLength),
+        'Cache-Control': 'no-store',
+        'X-Larkup-File-Name': encodeURIComponent(file.fileName),
+        'X-Larkup-Source-Url': encodeURIComponent(file.sourceUrl),
+      },
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Could not download the remote file.';
+    return Response.json({ error: message }, { status: 422 });
+  }
+}

package/src/app/api/mcp/[connectionId]/route.ts

@@ -0,0 +1,29 @@
+import { deleteMcpConnection, updateMcpConnection } from '@larkup/core/mcp-store';
+
+type Params = { params: Promise<{ connectionId: string }> };
+
+export async function PUT(req: Request, { params }: Params) {
+  try {
+    const { connectionId } = await params;
+    const updated = await updateMcpConnection(connectionId, await req.json());
+    if (!updated) return Response.json({ error: 'MCP connection not found' }, { status: 404 });
+    return Response.json(updated);
+  } catch (error) {
+    return Response.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 },
+    );
+  }
+}
+
+export async function DELETE(_req: Request, { params }: Params) {
+  try {
+    const { connectionId } = await params;
+    if (!(await deleteMcpConnection(connectionId))) {
+      return Response.json({ error: 'MCP connection not found' }, { status: 404 });
+    }
+    return Response.json({ success: true });
+  } catch (error) {
+    return Response.json({ error: String(error) }, { status: 500 });
+  }
+}

package/src/app/api/mcp/[connectionId]/test/route.ts

@@ -0,0 +1,13 @@
+import { testMcpConnection } from '@larkup/core/mcp-store';
+
+type Params = { params: Promise<{ connectionId: string }> };
+
+export async function POST(_req: Request, { params }: Params) {
+  try {
+    const { connectionId } = await params;
+    return Response.json(await testMcpConnection(connectionId));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return Response.json({ error: message }, { status: message.includes('not found') ? 404 : 502 });
+  }
+}

package/src/app/api/mcp/route.ts

@@ -0,0 +1,22 @@
+import { createMcpConnection, listMcpConnections } from '@larkup/core/mcp-store';
+
+/** Workspace MCP connections. Credentials are redacted by the core store. */
+export async function GET() {
+  try {
+    return Response.json({ connections: await listMcpConnections() });
+  } catch (error) {
+    return Response.json({ error: String(error) }, { status: 500 });
+  }
+}
+
+export async function POST(req: Request) {
+  try {
+    const connection = await createMcpConnection(await req.json());
+    return Response.json(connection, { status: 201 });
+  } catch (error) {
+    return Response.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 },
+    );
+  }
+}

package/src/app/api/parse-file/route.ts

@@ -0,0 +1,86 @@
+import mammoth from 'mammoth';
+import { getData } from 'pdf-parse/worker';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+// Use pdf-parse's packaged worker payload. Unlike a filesystem path, it is
+// preserved in Next's standalone output and always matches the parser version.
+let pdfParserPromise: Promise<(typeof import('pdf-parse'))['PDFParse']> | undefined;
+
+async function getPdfParser() {
+  if (!pdfParserPromise) {
+    pdfParserPromise = (async () => {
+      // Let PDF.js load its own compatible Node canvas implementation. Mixing
+      // it with the app-level canvas package creates incompatible Path2D
+      // instances and prevents the same PDF from being rendered later.
+      const { PDFParse } = await import('pdf-parse');
+      PDFParse.setWorker(getData());
+      return PDFParse;
+    })();
+  }
+  return pdfParserPromise;
+}
+
+/** pdf-parse adds page counters even when a scanned PDF has no text layer. */
+export function hasReadablePdfText(text: string): boolean {
+  return text.replace(/^\s*--\s*\d+\s+of\s+\d+\s*--\s*$/gim, '').replace(/[\s\f]+/g, '').length > 0;
+}
+
+export async function POST(req: Request) {
+  try {
+    const formData = await req.formData();
+    const file = formData.get('file') as File | null;
+
+    if (!file) {
+      return Response.json({ error: 'No file provided' }, { status: 400 });
+    }
+
+    const buffer = Buffer.from(await file.arrayBuffer());
+    let text = '';
+
+    if (file.type === 'application/pdf' || file.name.endsWith('.pdf')) {
+      // pdf-parse accepts typed-array input consistently across Next's Node
+      // runtime and standalone builds. Passing Buffer directly can fail for
+      // otherwise-valid PDFs after bundling.
+      const PDFParse = await getPdfParser();
+      const parser = new PDFParse({ data: new Uint8Array(buffer) });
+      try {
+        text = (await parser.getText()).text;
+      } finally {
+        await parser.destroy();
+      }
+    } else if (
+      file.type === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' ||
+      file.name.endsWith('.docx')
+    ) {
+      const result = await mammoth.extractRawText({ buffer });
+      text = result.value;
+    } else {
+      return Response.json({ error: 'Unsupported file type' }, { status: 400 });
+    }
+
+    const hasReadableText =
+      file.type === 'application/pdf' || file.name.toLowerCase().endsWith('.pdf')
+        ? hasReadablePdfText(text)
+        : Boolean(text.trim());
+
+    // Image-only PDFs are still valid sources. The shared upload UI renders
+    // their pages and sends them through the configured vision model.
+    if (
+      !hasReadableText &&
+      (file.type === 'application/pdf' || file.name.toLowerCase().endsWith('.pdf'))
+    ) {
+      return Response.json({ text: '', hasReadableText: false });
+    }
+
+    if (!hasReadableText) {
+      return Response.json({ error: 'No readable text was found in this file.' }, { status: 422 });
+    }
+
+    return Response.json({ text, hasReadableText: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to parse file.';
+    return Response.json({ error: message }, { status: 500 });
+  }
+}

package/src/app/api/pdf-page/route.ts

@@ -0,0 +1,40 @@
+import { readDocuments } from '@larkup/core/documents-store';
+import { runWithProject } from '@larkup/core/project-store';
+import { renderStoredPdfPage } from '@larkup/workspace-server/lib/media/pdf-inspection';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: Request) {
+  const url = new URL(request.url);
+  const documentId = url.searchParams.get('documentId');
+  const pageNumber = Number(url.searchParams.get('page'));
+  const projectId = url.searchParams.get('projectId');
+  if (!documentId || !Number.isInteger(pageNumber) || pageNumber < 1) {
+    return Response.json(
+      { error: 'documentId and a positive page are required.' },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const findDocument = async () =>
+      (await readDocuments()).find((document) => document.id === documentId);
+    const document = projectId
+      ? await runWithProject(projectId, findDocument)
+      : await findDocument();
+    if (!document) return Response.json({ error: 'PDF document not found.' }, { status: 404 });
+    const rendered = await renderStoredPdfPage(document, pageNumber);
+    return new Response(new Uint8Array(rendered.data), {
+      headers: {
+        'Content-Type': rendered.contentType,
+        'Cache-Control': 'private, max-age=300',
+      },
+    });
+  } catch (error: any) {
+    return Response.json(
+      { error: error.message ?? 'Could not render the PDF page.' },
+      { status: 422 },
+    );
+  }
+}

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

@@ -0,0 +1,78 @@
+import * as http from 'node:http';
+import * as https from 'node:https';
+
+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 Response.json({ error: 'Proxy server URL is required' }, { status: 400 });
+    }
+
+    let proxyUrl: URL;
+    try {
+      proxyUrl = new URL(server);
+    } catch {
+      return Response.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 = (proxyUrl.protocol === 'https:' ? https : http).request(options, (res) => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 400) {
+          let data = '';
+          res.on('data', (chunk) => {
+            data += chunk;
+          });
+          res.on('end', () => {
+            if (data.includes('Example Domain')) {
+              resolve(true);
+            } else {
+              reject(
+                new Error('Proxy connection succeeded, but received invalid response from target'),
+              );
+            }
+          });
+        } 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 Response.json({ success: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Verification failed';
+    return Response.json({ error: message }, { status: 400 });
+  }
+}

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

@@ -0,0 +1,86 @@
+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 Response.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 Response.json({ error: 'Invalid request body.' }, { status: 400 });
+  }
+
+  const { query, page = 1 } = body;
+  if (!query?.trim()) {
+    return Response.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 Response.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 Response.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 Response.json({ error: msg }, { status: 500 });
+  }
+}
+
+export async function GET() {
+  const config = await readConfig();
+  const configured = Boolean(config.bingApiKey);
+  return Response.json({ configured });
+}

package/src/app/api/search/brave/route.ts

@@ -0,0 +1,88 @@
+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.braveApiKey;
+
+  if (!apiKey) {
+    return Response.json(
+      {
+        error: 'Brave search is not configured. Set BRAVE_API_KEY in your environment.',
+        configured: false,
+      },
+      { status: 503 },
+    );
+  }
+
+  let body: { query?: string; page?: number };
+  try {
+    body = await req.json();
+  } catch {
+    return Response.json({ error: 'Invalid request body.' }, { status: 400 });
+  }
+
+  const { query, page = 1 } = body;
+  if (!query?.trim()) {
+    return Response.json({ error: 'A search query is required.' }, { status: 400 });
+  }
+
+  const clampedPage = Math.max(1, Math.min(page, 10)); // Brave offset logic can be complex, just map page to offset
+  const offset = (clampedPage - 1) * 10;
+
+  try {
+    const res = await fetch(
+      `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(
+        query.trim(),
+      )}&count=10&offset=${offset}`,
+      {
+        method: 'GET',
+        headers: {
+          Accept: 'application/json',
+          'Accept-Encoding': 'gzip',
+          'X-Subscription-Token': apiKey,
+        },
+        cache: 'no-store',
+      },
+    );
+
+    const json = await res.json();
+
+    if (!res.ok) {
+      const msg = json.message ?? `Brave API error (${res.status})`;
+      return Response.json({ error: msg }, { status: res.status });
+    }
+
+    const items: SerperSearchItem[] = (json.web?.results ?? []).map((r: any) => ({
+      url: r.url,
+      title: r.title,
+      description: r.description,
+    }));
+
+    const rawTotal = 100; // Brave doesn't give a total results count easily, cap at 100 for pagination
+    const hasMore = items.length === 10 && clampedPage < 10;
+    const totalPages = hasMore ? 10 : clampedPage;
+
+    return Response.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 : 'Brave search failed.';
+    return Response.json({ error: msg }, { status: 500 });
+  }
+}
+
+export async function GET() {
+  const config = await readConfig();
+  const configured = Boolean(config.braveApiKey);
+  return Response.json({ configured });
+}