@qontinui/ui-bridge 0.2.0 → 0.3.1

package/dist/server/nextjs.d.mts

@@ -0,0 +1,128 @@
+import { U as UIBridgeServerConfig, c as UIBridgeServerHandlers } from '../types-gO696T_t.mjs';
+import '../types-suaYwWWg.mjs';
+import '../types-CJGrBEhC.mjs';
+import '../types-D_ypYl3T.mjs';
+import '../render-log/index.mjs';
+import '../types-UBtp7R0u.mjs';
+
+/**
+ * Next.js Adapter
+ *
+ * Next.js API route handlers for UI Bridge server.
+ */
+interface NextRequest extends Request {
+    nextUrl: URL;
+}
+
+/**
+ * Next.js specific configuration
+ */
+interface NextJSAdapterConfig extends UIBridgeServerConfig {
+    /** Runtime for edge/serverless */
+    runtime?: 'edge' | 'nodejs';
+}
+/**
+ * Route handler factory for Next.js App Router
+ */
+type NextRouteHandler = (request: NextRequest, context: {
+    params: Record<string, string>;
+}) => Promise<Response>;
+/**
+ * Create Next.js route handlers for UI Bridge
+ *
+ * Use this to create route handlers for the App Router.
+ *
+ * @example
+ * ```ts
+ * // app/api/ui-bridge/[...path]/route.ts
+ * import { createNextRouteHandlers } from 'ui-bridge-server/nextjs';
+ * import { handlers } from '@/lib/ui-bridge';
+ *
+ * export const { GET, POST, DELETE } = createNextRouteHandlers(handlers);
+ * ```
+ */
+declare function createNextRouteHandlers(handlers: UIBridgeServerHandlers, config?: NextJSAdapterConfig): {
+    GET: NextRouteHandler;
+    POST: NextRouteHandler;
+    PUT: NextRouteHandler;
+    DELETE: NextRouteHandler;
+};
+/**
+ * Individual route handler creators for more granular control
+ */
+declare function createRenderLogHandlers(handlers: UIBridgeServerHandlers): {
+    GET(request: NextRequest): Promise<Response>;
+    DELETE(): Promise<Response>;
+};
+declare function createControlHandlers(handlers: UIBridgeServerHandlers): {
+    elements: {
+        GET(): Promise<Response>;
+    };
+    element: {
+        GET(_request: NextRequest, context: {
+            params: {
+                id: string;
+            };
+        }): Promise<Response>;
+        POST(request: NextRequest, context: {
+            params: {
+                id: string;
+            };
+        }): Promise<Response>;
+    };
+    components: {
+        GET(): Promise<Response>;
+    };
+    component: {
+        GET(_request: NextRequest, context: {
+            params: {
+                id: string;
+            };
+        }): Promise<Response>;
+        POST(request: NextRequest, context: {
+            params: {
+                id: string;
+                actionId: string;
+            };
+        }): Promise<Response>;
+    };
+    find: {
+        POST(request: NextRequest): Promise<Response>;
+    };
+    discover: {
+        /**
+         * @deprecated Use /control/find instead
+         */
+        POST(request: NextRequest): Promise<Response>;
+    };
+    snapshot: {
+        GET(): Promise<Response>;
+    };
+    workflows: {
+        GET(): Promise<Response>;
+    };
+    workflow: {
+        POST(request: NextRequest, context: {
+            params: {
+                id: string;
+            };
+        }): Promise<Response>;
+    };
+};
+declare function createDebugHandlers(handlers: UIBridgeServerHandlers): {
+    actionHistory: {
+        GET(request: NextRequest): Promise<Response>;
+    };
+    metrics: {
+        GET(): Promise<Response>;
+    };
+    highlight: {
+        POST(_request: NextRequest, context: {
+            params: {
+                id: string;
+            };
+        }): Promise<Response>;
+    };
+};
+
+export { type NextJSAdapterConfig, type NextRouteHandler, createControlHandlers, createDebugHandlers, createNextRouteHandlers, createRenderLogHandlers };

package/dist/server/nextjs.d.ts

@@ -0,0 +1,128 @@
+import { U as UIBridgeServerConfig, c as UIBridgeServerHandlers } from '../types-B2EfvEaq.js';
+import '../types-suaYwWWg.js';
+import '../types-C7gVYRnF.js';
+import '../types-CebMQj76.js';
+import '../render-log/index.js';
+import '../types-UBtp7R0u.js';
+
+/**
+ * Next.js Adapter
+ *
+ * Next.js API route handlers for UI Bridge server.
+ */
+interface NextRequest extends Request {
+    nextUrl: URL;
+}
+
+/**
+ * Next.js specific configuration
+ */
+interface NextJSAdapterConfig extends UIBridgeServerConfig {
+    /** Runtime for edge/serverless */
+    runtime?: 'edge' | 'nodejs';
+}
+/**
+ * Route handler factory for Next.js App Router
+ */
+type NextRouteHandler = (request: NextRequest, context: {
+    params: Record<string, string>;
+}) => Promise<Response>;
+/**
+ * Create Next.js route handlers for UI Bridge
+ *
+ * Use this to create route handlers for the App Router.
+ *
+ * @example
+ * ```ts
+ * // app/api/ui-bridge/[...path]/route.ts
+ * import { createNextRouteHandlers } from 'ui-bridge-server/nextjs';
+ * import { handlers } from '@/lib/ui-bridge';
+ *
+ * export const { GET, POST, DELETE } = createNextRouteHandlers(handlers);
+ * ```
+ */
+declare function createNextRouteHandlers(handlers: UIBridgeServerHandlers, config?: NextJSAdapterConfig): {
+    GET: NextRouteHandler;
+    POST: NextRouteHandler;
+    PUT: NextRouteHandler;
+    DELETE: NextRouteHandler;
+};
+/**
+ * Individual route handler creators for more granular control
+ */
+declare function createRenderLogHandlers(handlers: UIBridgeServerHandlers): {
+    GET(request: NextRequest): Promise<Response>;
+    DELETE(): Promise<Response>;
+};
+declare function createControlHandlers(handlers: UIBridgeServerHandlers): {
+    elements: {
+        GET(): Promise<Response>;
+    };
+    element: {
+        GET(_request: NextRequest, context: {
+            params: {
+                id: string;
+            };
+        }): Promise<Response>;
+        POST(request: NextRequest, context: {
+            params: {
+                id: string;
+            };
+        }): Promise<Response>;
+    };
+    components: {
+        GET(): Promise<Response>;
+    };
+    component: {
+        GET(_request: NextRequest, context: {
+            params: {
+                id: string;
+            };
+        }): Promise<Response>;
+        POST(request: NextRequest, context: {
+            params: {
+                id: string;
+                actionId: string;
+            };
+        }): Promise<Response>;
+    };
+    find: {
+        POST(request: NextRequest): Promise<Response>;
+    };
+    discover: {
+        /**
+         * @deprecated Use /control/find instead
+         */
+        POST(request: NextRequest): Promise<Response>;
+    };
+    snapshot: {
+        GET(): Promise<Response>;
+    };
+    workflows: {
+        GET(): Promise<Response>;
+    };
+    workflow: {
+        POST(request: NextRequest, context: {
+            params: {
+                id: string;
+            };
+        }): Promise<Response>;
+    };
+};
+declare function createDebugHandlers(handlers: UIBridgeServerHandlers): {
+    actionHistory: {
+        GET(request: NextRequest): Promise<Response>;
+    };
+    metrics: {
+        GET(): Promise<Response>;
+    };
+    highlight: {
+        POST(_request: NextRequest, context: {
+            params: {
+                id: string;
+            };
+        }): Promise<Response>;
+    };
+};
+
+export { type NextJSAdapterConfig, type NextRouteHandler, createControlHandlers, createDebugHandlers, createNextRouteHandlers, createRenderLogHandlers };

package/dist/server/nextjs.js

@@ -0,0 +1,390 @@
+'use strict';
+
+// src/server/types.ts
+var UI_BRIDGE_ROUTES = [
+  // Render log
+  { method: "GET", path: "/render-log", handler: "getRenderLog" },
+  { method: "DELETE", path: "/render-log", handler: "clearRenderLog" },
+  { method: "POST", path: "/render-log/snapshot", handler: "captureSnapshot" },
+  { method: "GET", path: "/render-log/path", handler: "getRenderLogPath" },
+  // Control - Elements
+  { method: "GET", path: "/control/elements", handler: "getElements" },
+  { method: "GET", path: "/control/element/:id", handler: "getElement", params: ["id"] },
+  { method: "GET", path: "/control/element/:id/state", handler: "getElementState", params: ["id"] },
+  {
+    method: "POST",
+    path: "/control/element/:id/action",
+    handler: "executeElementAction",
+    params: ["id"],
+    bodyRequired: true
+  },
+  // Control - Components
+  { method: "GET", path: "/control/components", handler: "getComponents" },
+  { method: "GET", path: "/control/component/:id", handler: "getComponent", params: ["id"] },
+  {
+    method: "GET",
+    path: "/control/component/:id/state",
+    handler: "getComponentState",
+    params: ["id"]
+  },
+  {
+    method: "POST",
+    path: "/control/component/:id/action/:actionId",
+    handler: "executeComponentAction",
+    params: ["id", "actionId"],
+    bodyRequired: true
+  },
+  // Find (formerly Discovery)
+  { method: "POST", path: "/control/find", handler: "find" },
+  { method: "POST", path: "/control/discover", handler: "discover" },
+  // @deprecated Use /control/find
+  { method: "GET", path: "/control/snapshot", handler: "getControlSnapshot" },
+  // Workflows
+  { method: "GET", path: "/control/workflows", handler: "getWorkflows" },
+  { method: "POST", path: "/control/workflow/:id/run", handler: "runWorkflow", params: ["id"] },
+  {
+    method: "GET",
+    path: "/control/workflow/:runId/status",
+    handler: "getWorkflowStatus",
+    params: ["runId"]
+  },
+  // Debug
+  { method: "GET", path: "/debug/action-history", handler: "getActionHistory" },
+  { method: "GET", path: "/debug/metrics", handler: "getMetrics" },
+  { method: "POST", path: "/debug/highlight/:id", handler: "highlightElement", params: ["id"] },
+  { method: "GET", path: "/debug/element-tree", handler: "getElementTree" },
+  { method: "GET", path: "/control/console-errors", handler: "getConsoleErrors" },
+  { method: "POST", path: "/control/console-errors/clear", handler: "clearConsoleErrors" },
+  // AI-native endpoints
+  { method: "POST", path: "/ai/search", handler: "aiSearch", bodyRequired: true },
+  { method: "POST", path: "/ai/execute", handler: "aiExecute", bodyRequired: true },
+  { method: "POST", path: "/ai/assert", handler: "aiAssert", bodyRequired: true },
+  { method: "POST", path: "/ai/assert/batch", handler: "aiAssertBatch", bodyRequired: true },
+  { method: "GET", path: "/ai/snapshot", handler: "getSemanticSnapshot" },
+  { method: "GET", path: "/ai/diff", handler: "getSemanticDiff" },
+  { method: "GET", path: "/ai/summary", handler: "getPageSummary" },
+  { method: "POST", path: "/ai/semantic-search", handler: "aiSemanticSearch", bodyRequired: true },
+  // State management (static routes before parameterized)
+  { method: "GET", path: "/control/states", handler: "getStates" },
+  { method: "GET", path: "/control/states/active", handler: "getActiveStates" },
+  { method: "GET", path: "/control/states/snapshot", handler: "getStateSnapshot" },
+  { method: "POST", path: "/control/states/find-path", handler: "findPath", bodyRequired: true },
+  { method: "POST", path: "/control/states/navigate", handler: "navigateTo", bodyRequired: true },
+  { method: "GET", path: "/control/state/:id", handler: "getState", params: ["id"] },
+  { method: "POST", path: "/control/state/:id/activate", handler: "activateState", params: ["id"] },
+  {
+    method: "POST",
+    path: "/control/state/:id/deactivate",
+    handler: "deactivateState",
+    params: ["id"]
+  },
+  { method: "GET", path: "/control/state-groups", handler: "getStateGroups" },
+  {
+    method: "POST",
+    path: "/control/state-group/:id/activate",
+    handler: "activateStateGroup",
+    params: ["id"]
+  },
+  {
+    method: "POST",
+    path: "/control/state-group/:id/deactivate",
+    handler: "deactivateStateGroup",
+    params: ["id"]
+  },
+  { method: "GET", path: "/control/transitions", handler: "getTransitions" },
+  {
+    method: "GET",
+    path: "/control/transition/:id/can-execute",
+    handler: "canExecuteTransition",
+    params: ["id"]
+  },
+  {
+    method: "POST",
+    path: "/control/transition/:id/execute",
+    handler: "executeTransition",
+    params: ["id"]
+  },
+  // Intent endpoints
+  { method: "GET", path: "/ai/intents", handler: "listIntents" },
+  { method: "POST", path: "/ai/intents/execute", handler: "executeIntent", bodyRequired: true },
+  { method: "POST", path: "/ai/intents/find", handler: "findIntent", bodyRequired: true },
+  { method: "POST", path: "/ai/intents/register", handler: "registerIntent", bodyRequired: true },
+  {
+    method: "POST",
+    path: "/ai/intents/execute-from-query",
+    handler: "executeIntentFromQuery",
+    bodyRequired: true
+  },
+  // Recovery endpoints
+  {
+    method: "POST",
+    path: "/ai/recovery/attempt",
+    handler: "attemptRecovery",
+    bodyRequired: true
+  },
+  // Cross-app analysis endpoints
+  { method: "GET", path: "/ai/analyze/data", handler: "analyzePageData" },
+  { method: "GET", path: "/ai/analyze/regions", handler: "analyzePageRegions" },
+  { method: "GET", path: "/ai/analyze/structured-data", handler: "analyzeStructuredData" },
+  {
+    method: "POST",
+    path: "/ai/analyze/cross-app-compare",
+    handler: "crossAppCompare",
+    bodyRequired: true
+  },
+  // Page navigation
+  { method: "POST", path: "/control/page/refresh", handler: "pageRefresh" },
+  { method: "POST", path: "/control/page/navigate", handler: "pageNavigate", bodyRequired: true },
+  { method: "POST", path: "/control/page/back", handler: "pageGoBack" },
+  { method: "POST", path: "/control/page/forward", handler: "pageGoForward" },
+  // Annotations (static routes before parameterized)
+  { method: "GET", path: "/annotations", handler: "getAnnotations" },
+  { method: "GET", path: "/annotations/export", handler: "exportAnnotations" },
+  { method: "GET", path: "/annotations/coverage", handler: "getAnnotationCoverage" },
+  { method: "POST", path: "/annotations/import", handler: "importAnnotations", bodyRequired: true },
+  { method: "GET", path: "/annotations/:id", handler: "getAnnotation", params: ["id"] },
+  {
+    method: "PUT",
+    path: "/annotations/:id",
+    handler: "setAnnotation",
+    params: ["id"],
+    bodyRequired: true
+  },
+  { method: "DELETE", path: "/annotations/:id", handler: "deleteAnnotation", params: ["id"] },
+  // Performance diagnostics
+  { method: "GET", path: "/control/performance-entries", handler: "getPerformanceEntries" },
+  {
+    method: "POST",
+    path: "/control/performance-entries/clear",
+    handler: "clearPerformanceEntries"
+  },
+  { method: "GET", path: "/control/browser-events", handler: "getBrowserEvents" }
+];
+
+// src/server/nextjs.ts
+function wrapError(error, code) {
+  return {
+    success: false,
+    error: typeof error === "string" ? error : error.message,
+    code,
+    timestamp: Date.now()
+  };
+}
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+function createNextRouteHandlers(handlers, config = {}) {
+  const authenticate = config.authenticate;
+  async function handleRequest(request, context) {
+    try {
+      if (authenticate) {
+        const authenticated = await authenticate(request);
+        if (!authenticated) {
+          return jsonResponse(wrapError("Unauthorized", "UNAUTHORIZED"), 401);
+        }
+      }
+      const pathParam = context.params.path;
+      const path = Array.isArray(pathParam) ? "/" + pathParam.join("/") : "/" + pathParam;
+      const method = request.method;
+      const route = findMatchingRoute(path, method);
+      if (!route) {
+        return jsonResponse(wrapError("Not found", "NOT_FOUND"), 404);
+      }
+      const params = extractParams(path, route);
+      const handlerName = route.handler;
+      const handler = handlers[handlerName];
+      if (!handler) {
+        return jsonResponse(wrapError("Handler not found", "NOT_IMPLEMENTED"), 501);
+      }
+      const args = [];
+      if (route.params) {
+        for (const param of route.params) {
+          args.push(params[param]);
+        }
+      }
+      if (route.bodyRequired || method === "POST" || method === "PUT" || method === "PATCH") {
+        try {
+          const body = await request.json();
+          args.push(body);
+        } catch {
+          args.push({});
+        }
+      }
+      if (method === "GET") {
+        const searchParams = Object.fromEntries(request.nextUrl.searchParams);
+        if (Object.keys(searchParams).length > 0) {
+          args.push(searchParams);
+        }
+      }
+      const result = await handler(
+        ...args
+      );
+      return jsonResponse(result);
+    } catch (error) {
+      console.error("UI Bridge error:", error);
+      return jsonResponse(wrapError(error, "INTERNAL_ERROR"), 500);
+    }
+  }
+  return {
+    GET: handleRequest,
+    POST: handleRequest,
+    PUT: handleRequest,
+    DELETE: handleRequest
+  };
+}
+function findMatchingRoute(path, method) {
+  for (const route of UI_BRIDGE_ROUTES) {
+    if (route.method !== method) continue;
+    const routeRegex = route.path.replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
+    const regex = new RegExp(`^${routeRegex}$`);
+    if (regex.test(path)) {
+      return route;
+    }
+  }
+  return null;
+}
+function extractParams(path, route) {
+  const params = {};
+  if (!route.params) return params;
+  const routeParts = route.path.split("/");
+  const pathParts = path.split("/");
+  for (let i = 0; i < routeParts.length; i++) {
+    const routePart = routeParts[i];
+    if (routePart.startsWith(":")) {
+      const paramName = routePart.slice(1);
+      params[paramName] = pathParts[i];
+    }
+  }
+  return params;
+}
+function createRenderLogHandlers(handlers) {
+  return {
+    async GET(request) {
+      const searchParams = Object.fromEntries(request.nextUrl.searchParams);
+      const query = {
+        type: searchParams.type,
+        since: searchParams.since ? parseInt(searchParams.since) : void 0,
+        until: searchParams.until ? parseInt(searchParams.until) : void 0,
+        limit: searchParams.limit ? parseInt(searchParams.limit) : void 0
+      };
+      const result = await handlers.getRenderLog(query);
+      return jsonResponse(result);
+    },
+    async DELETE() {
+      const result = await handlers.clearRenderLog();
+      return jsonResponse(result);
+    }
+  };
+}
+function createControlHandlers(handlers) {
+  return {
+    elements: {
+      async GET() {
+        const result = await handlers.getElements();
+        return jsonResponse(result);
+      }
+    },
+    element: {
+      async GET(_request, context) {
+        const result = await handlers.getElement(context.params.id);
+        return jsonResponse(result);
+      },
+      async POST(request, context) {
+        const body = await request.json();
+        const result = await handlers.executeElementAction(context.params.id, body);
+        return jsonResponse(result);
+      }
+    },
+    components: {
+      async GET() {
+        const result = await handlers.getComponents();
+        return jsonResponse(result);
+      }
+    },
+    component: {
+      async GET(_request, context) {
+        const result = await handlers.getComponent(context.params.id);
+        return jsonResponse(result);
+      },
+      async POST(request, context) {
+        const body = await request.json();
+        const result = await handlers.executeComponentAction(context.params.id, {
+          ...body,
+          action: context.params.actionId
+        });
+        return jsonResponse(result);
+      }
+    },
+    find: {
+      async POST(request) {
+        const body = await request.json();
+        const result = await handlers.find(body);
+        return jsonResponse(result);
+      }
+    },
+    discover: {
+      /**
+       * @deprecated Use /control/find instead
+       */
+      async POST(request) {
+        const body = await request.json();
+        const result = await handlers.discover(body);
+        return jsonResponse(result);
+      }
+    },
+    snapshot: {
+      async GET() {
+        const result = await handlers.getControlSnapshot();
+        return jsonResponse(result);
+      }
+    },
+    workflows: {
+      async GET() {
+        const result = await handlers.getWorkflows();
+        return jsonResponse(result);
+      }
+    },
+    workflow: {
+      async POST(request, context) {
+        const body = await request.json();
+        const result = await handlers.runWorkflow(context.params.id, body);
+        return jsonResponse(result);
+      }
+    }
+  };
+}
+function createDebugHandlers(handlers) {
+  return {
+    actionHistory: {
+      async GET(request) {
+        const limit = request.nextUrl.searchParams.get("limit");
+        const result = await handlers.getActionHistory(limit ? parseInt(limit) : void 0);
+        return jsonResponse(result);
+      }
+    },
+    metrics: {
+      async GET() {
+        const result = await handlers.getMetrics();
+        return jsonResponse(result);
+      }
+    },
+    highlight: {
+      async POST(_request, context) {
+        const result = await handlers.highlightElement(context.params.id);
+        return jsonResponse(result);
+      }
+    }
+  };
+}
+
+exports.createControlHandlers = createControlHandlers;
+exports.createDebugHandlers = createDebugHandlers;
+exports.createNextRouteHandlers = createNextRouteHandlers;
+exports.createRenderLogHandlers = createRenderLogHandlers;
+//# sourceMappingURL=nextjs.js.map
+//# sourceMappingURL=nextjs.js.map