npm - postgresai - Versions diffs - 0.14.0-dev.43 → 0.14.0-dev.44 - Mend

postgresai 0.14.0-dev.43 → 0.14.0-dev.44

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (58) hide show

package/bin/postgres-ai.ts +649 -310
package/bun.lock +258 -0
package/dist/bin/postgres-ai.js +29491 -1910
package/dist/sql/01.role.sql +16 -0
package/dist/sql/02.permissions.sql +37 -0
package/dist/sql/03.optional_rds.sql +6 -0
package/dist/sql/04.optional_self_managed.sql +8 -0
package/dist/sql/05.helpers.sql +415 -0
package/lib/auth-server.ts +58 -97
package/lib/checkup-api.ts +175 -0
package/lib/checkup.ts +833 -0
package/lib/config.ts +3 -0
package/lib/init.ts +106 -74
package/lib/issues.ts +121 -194
package/lib/mcp-server.ts +6 -17
package/lib/metrics-loader.ts +156 -0
package/package.json +13 -9
package/sql/02.permissions.sql +9 -5
package/sql/05.helpers.sql +415 -0
package/test/checkup.test.ts +953 -0
package/test/init.integration.test.ts +396 -0
package/test/init.test.ts +345 -0
package/test/schema-validation.test.ts +188 -0
package/tsconfig.json +12 -20
package/dist/bin/postgres-ai.d.ts +0 -3
package/dist/bin/postgres-ai.d.ts.map +0 -1
package/dist/bin/postgres-ai.js.map +0 -1
package/dist/lib/auth-server.d.ts +0 -31
package/dist/lib/auth-server.d.ts.map +0 -1
package/dist/lib/auth-server.js +0 -263
package/dist/lib/auth-server.js.map +0 -1
package/dist/lib/config.d.ts +0 -45
package/dist/lib/config.d.ts.map +0 -1
package/dist/lib/config.js +0 -181
package/dist/lib/config.js.map +0 -1
package/dist/lib/init.d.ts +0 -85
package/dist/lib/init.d.ts.map +0 -1
package/dist/lib/init.js +0 -644
package/dist/lib/init.js.map +0 -1
package/dist/lib/issues.d.ts +0 -75
package/dist/lib/issues.d.ts.map +0 -1
package/dist/lib/issues.js +0 -336
package/dist/lib/issues.js.map +0 -1
package/dist/lib/mcp-server.d.ts +0 -9
package/dist/lib/mcp-server.d.ts.map +0 -1
package/dist/lib/mcp-server.js +0 -168
package/dist/lib/mcp-server.js.map +0 -1
package/dist/lib/pkce.d.ts +0 -32
package/dist/lib/pkce.d.ts.map +0 -1
package/dist/lib/pkce.js +0 -101
package/dist/lib/pkce.js.map +0 -1
package/dist/lib/util.d.ts +0 -27
package/dist/lib/util.d.ts.map +0 -1
package/dist/lib/util.js +0 -46
package/dist/lib/util.js.map +0 -1
package/dist/package.json +0 -46
package/test/init.integration.test.cjs +0 -382
package/test/init.test.cjs +0 -392

package/lib/auth-server.ts CHANGED Viewed

@@ -1,6 +1,3 @@
-import * as http from "http";
-import { URL } from "url";
 /**
  * OAuth callback result
  */
@@ -13,7 +10,7 @@ export interface CallbackResult {
  * Callback server structure
  */
 export interface CallbackServer {
-  server: http.Server;
+  server: { stop: () => void };
   promise: Promise<CallbackResult>;
   getPort: () => number;
 }
@@ -34,11 +31,18 @@ function escapeHtml(str: string | null): string {
 }
 /**
- * Create and start callback server, returning server object and promise
+ * Create and start callback server using Bun.serve
+ *
  * @param port - Port to listen on (0 for random available port)
  * @param expectedState - Expected state parameter for CSRF protection
  * @param timeoutMs - Timeout in milliseconds
  * @returns Server object with promise and getPort function
+ *
+ * @remarks
+ * The server stops asynchronously ~100ms after the callback resolves/rejects.
+ * This delay ensures the HTTP response is fully sent before closing the connection.
+ * Callers should not attempt to reuse the same port immediately after the promise
+ * resolves - wait at least 200ms or use a different port.
  */
 export function createCallbackServer(
   port: number = 0,
@@ -46,42 +50,42 @@ export function createCallbackServer(
   timeoutMs: number = 300000
 ): CallbackServer {
   let resolved = false;
-  let server: http.Server | null = null;
   let actualPort = port;
   let resolveCallback: (value: CallbackResult) => void;
   let rejectCallback: (reason: Error) => void;
+  let serverInstance: ReturnType<typeof Bun.serve> | null = null;
   const promise = new Promise<CallbackResult>((resolve, reject) => {
     resolveCallback = resolve;
     rejectCallback = reject;
   });
   // Timeout handler
   const timeout = setTimeout(() => {
     if (!resolved) {
       resolved = true;
-      if (server) {
-        server.close();
+      if (serverInstance) {
+        serverInstance.stop();
       }
       rejectCallback(new Error("Authentication timeout. Please try again."));
     }
   }, timeoutMs);
-  // Request handler
-  const requestHandler = (req: http.IncomingMessage, res: http.ServerResponse): void => {
-    if (resolved) {
-      return;
-    }
-    // Only handle /callback path
-    if (!req.url || !req.url.startsWith("/callback")) {
-      res.writeHead(404, { "Content-Type": "text/plain" });
-      res.end("Not Found");
-      return;
-    }
+  serverInstance = Bun.serve({
+    port: port,
+    hostname: "127.0.0.1",
+    fetch(req) {
+      if (resolved) {
+        return new Response("Already handled", { status: 200 });
+      }
+      const url = new URL(req.url);
+      // Only handle /callback path
+      if (!url.pathname.startsWith("/callback")) {
+        return new Response("Not Found", { status: 404 });
+      }
-    try {
-      const url = new URL(req.url, `http://localhost:${actualPort}`);
       const code = url.searchParams.get("code");
       const state = url.searchParams.get("state");
       const error = url.searchParams.get("error");
@@ -91,9 +95,11 @@ export function createCallbackServer(
       if (error) {
         resolved = true;
         clearTimeout(timeout);
-        res.writeHead(400, { "Content-Type": "text/html" });
-        res.end(`
+        setTimeout(() => serverInstance?.stop(), 100);
+        rejectCallback(new Error(`OAuth error: ${error}${errorDescription ? ` - ${errorDescription}` : ""}`));
+        return new Response(`
 <!DOCTYPE html>
 <html>
 <head>
@@ -114,19 +120,12 @@ export function createCallbackServer(
   </div>
 </body>
 </html>
-        `);
-        if (server) {
-          server.close();
-        }
-        rejectCallback(new Error(`OAuth error: ${error}${errorDescription ? ` - ${errorDescription}` : ""}`));
-        return;
+        `, { status: 400, headers: { "Content-Type": "text/html" } });
       }
       // Validate required parameters
       if (!code || !state) {
-        res.writeHead(400, { "Content-Type": "text/html" });
-        res.end(`
+        return new Response(`
 <!DOCTYPE html>
 <html>
 <head>
@@ -145,17 +144,18 @@ export function createCallbackServer(
   </div>
 </body>
 </html>
-        `);
-        return;
+        `, { status: 400, headers: { "Content-Type": "text/html" } });
       }
       // Validate state (CSRF protection)
       if (expectedState && state !== expectedState) {
         resolved = true;
         clearTimeout(timeout);
-        res.writeHead(400, { "Content-Type": "text/html" });
-        res.end(`
+        setTimeout(() => serverInstance?.stop(), 100);
+        rejectCallback(new Error("State mismatch (possible CSRF attack)"));
+        return new Response(`
 <!DOCTYPE html>
 <html>
 <head>
@@ -174,21 +174,19 @@ export function createCallbackServer(
   </div>
 </body>
 </html>
-        `);
-        if (server) {
-          server.close();
-        }
-        rejectCallback(new Error("State mismatch (possible CSRF attack)"));
-        return;
+        `, { status: 400, headers: { "Content-Type": "text/html" } });
       }
       // Success!
       resolved = true;
       clearTimeout(timeout);
-      res.writeHead(200, { "Content-Type": "text/html" });
-      res.end(`
+      // Resolve first, then stop server asynchronously after response is sent.
+      // The 100ms delay ensures the HTTP response is fully written before closing.
+      resolveCallback({ code, state });
+      setTimeout(() => serverInstance?.stop(), 100);
+      return new Response(`
 <!DOCTYPE html>
 <html>
 <head>
@@ -207,61 +205,24 @@ export function createCallbackServer(
   </div>
 </body>
 </html>
-      `);
-      if (server) {
-        server.close();
-      }
-      resolveCallback({ code, state });
-    } catch (err) {
-      if (!resolved) {
-        resolved = true;
-        clearTimeout(timeout);
-        res.writeHead(500, { "Content-Type": "text/plain" });
-        res.end("Internal Server Error");
-        if (server) {
-          server.close();
-        }
-        rejectCallback(err instanceof Error ? err : new Error(String(err)));
-      }
-    }
-  };
-  // Create server
-  server = http.createServer(requestHandler);
-  server.on("error", (err: Error) => {
-    if (!resolved) {
-      resolved = true;
-      clearTimeout(timeout);
-      rejectCallback(err);
-    }
+      `, { status: 200, headers: { "Content-Type": "text/html" } });
+    },
   });
-  server.listen(port, "127.0.0.1", () => {
-    const address = server?.address();
-    if (address && typeof address === "object") {
-      actualPort = address.port;
-    }
-  });
+  actualPort = serverInstance.port;
   return {
-    server,
+    server: { stop: () => serverInstance?.stop() },
     promise,
-    getPort: () => {
-      const address = server?.address();
-      return address && typeof address === "object" ? address.port : 0;
-    },
+    getPort: () => actualPort,
   };
 }
 /**
  * Get the actual port the server is listening on
- * @param server - HTTP server instance
+ * @param server - Bun server instance
  * @returns Port number
  */
-export function getServerPort(server: http.Server): number {
-  const address = server.address();
-  return address && typeof address === "object" ? address.port : 0;
+export function getServerPort(server: ReturnType<typeof Bun.serve>): number {
+  return server.port;
 }

package/lib/checkup-api.ts ADDED Viewed

@@ -0,0 +1,175 @@
+import * as https from "https";
+import { URL } from "url";
+import { normalizeBaseUrl } from "./util";
+export class RpcError extends Error {
+  rpcName: string;
+  statusCode: number;
+  payloadText: string;
+  payloadJson: any | null;
+  constructor(params: { rpcName: string; statusCode: number; payloadText: string; payloadJson: any | null }) {
+    const { rpcName, statusCode, payloadText, payloadJson } = params;
+    super(`RPC ${rpcName} failed: HTTP ${statusCode}`);
+    this.name = "RpcError";
+    this.rpcName = rpcName;
+    this.statusCode = statusCode;
+    this.payloadText = payloadText;
+    this.payloadJson = payloadJson;
+  }
+}
+export function formatRpcErrorForDisplay(err: RpcError): string[] {
+  const lines: string[] = [];
+  lines.push(`Error: RPC ${err.rpcName} failed: HTTP ${err.statusCode}`);
+  const obj = err.payloadJson && typeof err.payloadJson === "object" ? err.payloadJson : null;
+  const details = obj && typeof (obj as any).details === "string" ? (obj as any).details : "";
+  const hint = obj && typeof (obj as any).hint === "string" ? (obj as any).hint : "";
+  const message = obj && typeof (obj as any).message === "string" ? (obj as any).message : "";
+  if (message) lines.push(`Message: ${message}`);
+  if (details) lines.push(`Details: ${details}`);
+  if (hint) lines.push(`Hint: ${hint}`);
+  // Fallback to raw payload if we couldn't extract anything useful.
+  if (!message && !details && !hint) {
+    const t = (err.payloadText || "").trim();
+    if (t) lines.push(t);
+  }
+  return lines;
+}
+function unwrapRpcResponse(parsed: unknown): any {
+  // Some deployments return a plain object, others return an array of rows,
+  // and some wrap OUT params under a "result" key.
+  if (Array.isArray(parsed)) {
+    if (parsed.length === 1) return unwrapRpcResponse(parsed[0]);
+    return parsed;
+  }
+  if (parsed && typeof parsed === "object") {
+    const obj = parsed as any;
+    if (obj.result !== undefined) return obj.result;
+  }
+  return parsed as any;
+}
+async function postRpc<T>(params: {
+  apiKey: string;
+  apiBaseUrl: string;
+  rpcName: string;
+  bodyObj: Record<string, unknown>;
+}): Promise<T> {
+  const { apiKey, apiBaseUrl, rpcName, bodyObj } = params;
+  if (!apiKey) throw new Error("API key is required");
+  const base = normalizeBaseUrl(apiBaseUrl);
+  const url = new URL(`${base}/rpc/${rpcName}`);
+  const body = JSON.stringify(bodyObj);
+  const headers: Record<string, string> = {
+    // The backend RPC functions accept access_token in body, but we also set the header
+    // for compatibility with other endpoints and deployments.
+    "access-token": apiKey,
+    "Prefer": "return=representation",
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body).toString(),
+  };
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      url,
+      {
+        method: "POST",
+        headers,
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              const parsed = JSON.parse(data);
+              resolve(unwrapRpcResponse(parsed) as T);
+            } catch {
+              reject(new Error(`Failed to parse RPC response: ${data}`));
+            }
+          } else {
+            const statusCode = res.statusCode || 0;
+            let payloadJson: any | null = null;
+            if (data) {
+              try {
+                payloadJson = JSON.parse(data);
+              } catch {
+                payloadJson = null;
+              }
+            }
+            reject(new RpcError({ rpcName, statusCode, payloadText: data, payloadJson }));
+          }
+        });
+      }
+    );
+    req.on("error", (err: Error) => reject(err));
+    req.write(body);
+    req.end();
+  });
+}
+export async function createCheckupReport(params: {
+  apiKey: string;
+  apiBaseUrl: string;
+  project: string;
+  status?: string;
+}): Promise<{ reportId: number }> {
+  const { apiKey, apiBaseUrl, project, status } = params;
+  const bodyObj: Record<string, unknown> = {
+    access_token: apiKey,
+    project,
+  };
+  if (status) bodyObj.status = status;
+  const resp = await postRpc<any>({
+    apiKey,
+    apiBaseUrl,
+    rpcName: "checkup_report_create",
+    bodyObj,
+  });
+  const reportId = Number(resp?.report_id);
+  if (!Number.isFinite(reportId) || reportId <= 0) {
+    throw new Error(`Unexpected checkup_report_create response: ${JSON.stringify(resp)}`);
+  }
+  return { reportId };
+}
+export async function uploadCheckupReportJson(params: {
+  apiKey: string;
+  apiBaseUrl: string;
+  reportId: number;
+  filename: string;
+  checkId: string;
+  jsonText: string;
+}): Promise<{ reportChunkId: number }> {
+  const { apiKey, apiBaseUrl, reportId, filename, checkId, jsonText } = params;
+  const bodyObj: Record<string, unknown> = {
+    access_token: apiKey,
+    checkup_report_id: reportId,
+    filename,
+    check_id: checkId,
+    data: jsonText,
+    type: "json",
+    generate_issue: true,
+  };
+  const resp = await postRpc<any>({
+    apiKey,
+    apiBaseUrl,
+    rpcName: "checkup_report_file_post",
+    bodyObj,
+  });
+  const chunkId = Number(resp?.report_chunck_id ?? resp?.report_chunk_id);
+  if (!Number.isFinite(chunkId) || chunkId <= 0) {
+    throw new Error(`Unexpected checkup_report_file_post response: ${JSON.stringify(resp)}`);
+  }
+  return { reportChunkId: chunkId };
+}