@dexto/server 1.2.5

package/dist/hono/routes/webhooks.cjs

@@ -0,0 +1,228 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webhooks_exports = {};
+__export(webhooks_exports, {
+  createWebhooksRouter: () => createWebhooksRouter
+});
+module.exports = __toCommonJS(webhooks_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+const WebhookResponseSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Unique webhook identifier"),
+  url: import_zod_openapi.z.string().url().describe("Webhook URL"),
+  description: import_zod_openapi.z.string().optional().describe("Webhook description"),
+  createdAt: import_zod_openapi.z.union([import_zod_openapi.z.date(), import_zod_openapi.z.number()]).describe("Creation timestamp (Date or Unix ms)")
+}).strict().describe("Webhook response object");
+const WebhookTestResultSchema = import_zod_openapi.z.object({
+  success: import_zod_openapi.z.boolean().describe("Whether the webhook test succeeded"),
+  statusCode: import_zod_openapi.z.number().optional().describe("HTTP status code from webhook"),
+  responseTime: import_zod_openapi.z.number().optional().describe("Response time in milliseconds"),
+  error: import_zod_openapi.z.string().optional().describe("Error message if test failed")
+}).strict().describe("Webhook test result");
+const WebhookBodySchema = import_zod_openapi.z.object({
+  url: import_zod_openapi.z.string().url("Invalid URL format").describe("The URL to send webhook events to (must be a valid HTTP/HTTPS URL)"),
+  secret: import_zod_openapi.z.string().optional().describe("A secret key for HMAC signature verification"),
+  description: import_zod_openapi.z.string().optional().describe("A description of the webhook for reference")
+}).describe("Request body for registering a webhook");
+function createWebhooksRouter(getAgent, webhookSubscriber) {
+  const app = new import_zod_openapi.OpenAPIHono();
+  const registerRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/webhooks",
+    summary: "Register Webhook",
+    description: "Registers a new webhook endpoint to receive agent events",
+    tags: ["webhooks"],
+    request: { body: { content: { "application/json": { schema: WebhookBodySchema } } } },
+    responses: {
+      201: {
+        description: "Webhook registered",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              webhook: WebhookResponseSchema.describe(
+                "Registered webhook details"
+              )
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const listRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/webhooks",
+    summary: "List Webhooks",
+    description: "Retrieves a list of all registered webhooks",
+    tags: ["webhooks"],
+    responses: {
+      200: {
+        description: "List webhooks",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              webhooks: import_zod_openapi.z.array(WebhookResponseSchema).describe("Array of registered webhooks")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const getRoute = (0, import_zod_openapi.createRoute)({
+    method: "get",
+    path: "/webhooks/{webhookId}",
+    summary: "Get Webhook Details",
+    description: "Fetches details for a specific webhook",
+    tags: ["webhooks"],
+    request: { params: import_zod_openapi.z.object({ webhookId: import_zod_openapi.z.string().describe("The webhook identifier") }) },
+    responses: {
+      200: {
+        description: "Webhook",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              webhook: WebhookResponseSchema.describe("Webhook details")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const deleteRoute = (0, import_zod_openapi.createRoute)({
+    method: "delete",
+    path: "/webhooks/{webhookId}",
+    summary: "Delete Webhook",
+    description: "Permanently removes a webhook endpoint. This action cannot be undone",
+    tags: ["webhooks"],
+    request: { params: import_zod_openapi.z.object({ webhookId: import_zod_openapi.z.string().describe("The webhook identifier") }) },
+    responses: {
+      200: {
+        description: "Removed",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              status: import_zod_openapi.z.literal("removed").describe("Operation status indicating successful removal"),
+              webhookId: import_zod_openapi.z.string().describe("ID of the removed webhook")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const testRoute = (0, import_zod_openapi.createRoute)({
+    method: "post",
+    path: "/webhooks/{webhookId}/test",
+    summary: "Test Webhook",
+    description: "Sends a sample event to test webhook connectivity and configuration",
+    tags: ["webhooks"],
+    request: { params: import_zod_openapi.z.object({ webhookId: import_zod_openapi.z.string().describe("The webhook identifier") }) },
+    responses: {
+      200: {
+        description: "Test result",
+        content: {
+          "application/json": {
+            schema: import_zod_openapi.z.object({
+              test: import_zod_openapi.z.literal("completed").describe("Test status indicating completion"),
+              result: WebhookTestResultSchema.describe("Test execution results")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  return app.openapi(registerRoute, async (ctx) => {
+    const agent = getAgent();
+    const { url, secret, description } = ctx.req.valid("json");
+    const webhookId = `wh_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    const webhook = {
+      id: webhookId,
+      url,
+      createdAt: /* @__PURE__ */ new Date(),
+      ...secret && { secret },
+      ...description && { description }
+    };
+    webhookSubscriber.addWebhook(webhook);
+    agent.logger.info(`Webhook registered: ${webhookId} -> ${url}`);
+    return ctx.json(
+      {
+        webhook: {
+          id: webhook.id,
+          url: webhook.url,
+          description: webhook.description,
+          createdAt: webhook.createdAt
+        }
+      },
+      201
+    );
+  }).openapi(listRoute, async (ctx) => {
+    const webhooks = webhookSubscriber.getWebhooks().map((webhook) => ({
+      id: webhook.id,
+      url: webhook.url,
+      description: webhook.description,
+      createdAt: webhook.createdAt
+    }));
+    return ctx.json({ webhooks });
+  }).openapi(getRoute, (ctx) => {
+    const { webhookId } = ctx.req.valid("param");
+    const webhook = webhookSubscriber.getWebhook(webhookId);
+    if (!webhook) {
+      return ctx.json({ error: "Webhook not found" }, 404);
+    }
+    return ctx.json({
+      webhook: {
+        id: webhook.id,
+        url: webhook.url,
+        description: webhook.description,
+        createdAt: webhook.createdAt
+      }
+    });
+  }).openapi(deleteRoute, (ctx) => {
+    const agent = getAgent();
+    const { webhookId } = ctx.req.valid("param");
+    const removed = webhookSubscriber.removeWebhook(webhookId);
+    if (!removed) {
+      return ctx.json({ error: "Webhook not found" }, 404);
+    }
+    agent.logger.info(`Webhook removed: ${webhookId}`);
+    return ctx.json({ status: "removed", webhookId });
+  }).openapi(testRoute, async (ctx) => {
+    const agent = getAgent();
+    const { webhookId } = ctx.req.valid("param");
+    const webhook = webhookSubscriber.getWebhook(webhookId);
+    if (!webhook) {
+      return ctx.json({ error: "Webhook not found" }, 404);
+    }
+    agent.logger.info(`Testing webhook: ${webhookId}`);
+    const result = await webhookSubscriber.testWebhook(webhookId);
+    return ctx.json({
+      test: "completed",
+      result: {
+        success: result.success,
+        statusCode: result.statusCode,
+        responseTime: result.responseTime,
+        error: result.error
+      }
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWebhooksRouter
+});

package/dist/hono/routes/webhooks.d.ts

@@ -0,0 +1,127 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent } from '@dexto/core';
+import { WebhookEventSubscriber } from '../../events/webhook-subscriber.js';
+export declare function createWebhooksRouter(getAgent: () => DextoAgent, webhookSubscriber: WebhookEventSubscriber): OpenAPIHono<import("hono").Env, {
+    "/webhooks": {
+        $post: {
+            input: {
+                json: {
+                    url: string;
+                    description?: string | undefined;
+                    secret?: string | undefined;
+                };
+            };
+            output: {
+                webhook: {
+                    id: string;
+                    createdAt: string | number;
+                    url: string;
+                    description?: string | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/webhooks": {
+        $get: {
+            input: {};
+            output: {
+                webhooks: {
+                    id: string;
+                    createdAt: string | number;
+                    url: string;
+                    description?: string | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/webhooks/:webhookId": {
+        $get: {
+            input: {
+                param: {
+                    webhookId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    webhookId: string;
+                };
+            };
+            output: {
+                webhook: {
+                    id: string;
+                    createdAt: string | number;
+                    url: string;
+                    description?: string | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/webhooks/:webhookId": {
+        $delete: {
+            input: {
+                param: {
+                    webhookId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    webhookId: string;
+                };
+            };
+            output: {
+                status: "removed";
+                webhookId: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/webhooks/:webhookId/test": {
+        $post: {
+            input: {
+                param: {
+                    webhookId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    webhookId: string;
+                };
+            };
+            output: {
+                result: {
+                    success: boolean;
+                    error?: string | undefined;
+                    responseTime?: number | undefined;
+                    statusCode?: number | undefined;
+                };
+                test: "completed";
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=webhooks.d.ts.map

package/dist/hono/routes/webhooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../../../src/hono/routes/webhooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAmC5E,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,MAAM,UAAU,EAC1B,iBAAiB,EAAE,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0N5C"}

package/dist/hono/routes/webhooks.js

@@ -0,0 +1,204 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+const WebhookResponseSchema = z.object({
+  id: z.string().describe("Unique webhook identifier"),
+  url: z.string().url().describe("Webhook URL"),
+  description: z.string().optional().describe("Webhook description"),
+  createdAt: z.union([z.date(), z.number()]).describe("Creation timestamp (Date or Unix ms)")
+}).strict().describe("Webhook response object");
+const WebhookTestResultSchema = z.object({
+  success: z.boolean().describe("Whether the webhook test succeeded"),
+  statusCode: z.number().optional().describe("HTTP status code from webhook"),
+  responseTime: z.number().optional().describe("Response time in milliseconds"),
+  error: z.string().optional().describe("Error message if test failed")
+}).strict().describe("Webhook test result");
+const WebhookBodySchema = z.object({
+  url: z.string().url("Invalid URL format").describe("The URL to send webhook events to (must be a valid HTTP/HTTPS URL)"),
+  secret: z.string().optional().describe("A secret key for HMAC signature verification"),
+  description: z.string().optional().describe("A description of the webhook for reference")
+}).describe("Request body for registering a webhook");
+function createWebhooksRouter(getAgent, webhookSubscriber) {
+  const app = new OpenAPIHono();
+  const registerRoute = createRoute({
+    method: "post",
+    path: "/webhooks",
+    summary: "Register Webhook",
+    description: "Registers a new webhook endpoint to receive agent events",
+    tags: ["webhooks"],
+    request: { body: { content: { "application/json": { schema: WebhookBodySchema } } } },
+    responses: {
+      201: {
+        description: "Webhook registered",
+        content: {
+          "application/json": {
+            schema: z.object({
+              webhook: WebhookResponseSchema.describe(
+                "Registered webhook details"
+              )
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const listRoute = createRoute({
+    method: "get",
+    path: "/webhooks",
+    summary: "List Webhooks",
+    description: "Retrieves a list of all registered webhooks",
+    tags: ["webhooks"],
+    responses: {
+      200: {
+        description: "List webhooks",
+        content: {
+          "application/json": {
+            schema: z.object({
+              webhooks: z.array(WebhookResponseSchema).describe("Array of registered webhooks")
+            }).strict()
+          }
+        }
+      }
+    }
+  });
+  const getRoute = createRoute({
+    method: "get",
+    path: "/webhooks/{webhookId}",
+    summary: "Get Webhook Details",
+    description: "Fetches details for a specific webhook",
+    tags: ["webhooks"],
+    request: { params: z.object({ webhookId: z.string().describe("The webhook identifier") }) },
+    responses: {
+      200: {
+        description: "Webhook",
+        content: {
+          "application/json": {
+            schema: z.object({
+              webhook: WebhookResponseSchema.describe("Webhook details")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const deleteRoute = createRoute({
+    method: "delete",
+    path: "/webhooks/{webhookId}",
+    summary: "Delete Webhook",
+    description: "Permanently removes a webhook endpoint. This action cannot be undone",
+    tags: ["webhooks"],
+    request: { params: z.object({ webhookId: z.string().describe("The webhook identifier") }) },
+    responses: {
+      200: {
+        description: "Removed",
+        content: {
+          "application/json": {
+            schema: z.object({
+              status: z.literal("removed").describe("Operation status indicating successful removal"),
+              webhookId: z.string().describe("ID of the removed webhook")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  const testRoute = createRoute({
+    method: "post",
+    path: "/webhooks/{webhookId}/test",
+    summary: "Test Webhook",
+    description: "Sends a sample event to test webhook connectivity and configuration",
+    tags: ["webhooks"],
+    request: { params: z.object({ webhookId: z.string().describe("The webhook identifier") }) },
+    responses: {
+      200: {
+        description: "Test result",
+        content: {
+          "application/json": {
+            schema: z.object({
+              test: z.literal("completed").describe("Test status indicating completion"),
+              result: WebhookTestResultSchema.describe("Test execution results")
+            }).strict()
+          }
+        }
+      },
+      404: { description: "Not found" }
+    }
+  });
+  return app.openapi(registerRoute, async (ctx) => {
+    const agent = getAgent();
+    const { url, secret, description } = ctx.req.valid("json");
+    const webhookId = `wh_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    const webhook = {
+      id: webhookId,
+      url,
+      createdAt: /* @__PURE__ */ new Date(),
+      ...secret && { secret },
+      ...description && { description }
+    };
+    webhookSubscriber.addWebhook(webhook);
+    agent.logger.info(`Webhook registered: ${webhookId} -> ${url}`);
+    return ctx.json(
+      {
+        webhook: {
+          id: webhook.id,
+          url: webhook.url,
+          description: webhook.description,
+          createdAt: webhook.createdAt
+        }
+      },
+      201
+    );
+  }).openapi(listRoute, async (ctx) => {
+    const webhooks = webhookSubscriber.getWebhooks().map((webhook) => ({
+      id: webhook.id,
+      url: webhook.url,
+      description: webhook.description,
+      createdAt: webhook.createdAt
+    }));
+    return ctx.json({ webhooks });
+  }).openapi(getRoute, (ctx) => {
+    const { webhookId } = ctx.req.valid("param");
+    const webhook = webhookSubscriber.getWebhook(webhookId);
+    if (!webhook) {
+      return ctx.json({ error: "Webhook not found" }, 404);
+    }
+    return ctx.json({
+      webhook: {
+        id: webhook.id,
+        url: webhook.url,
+        description: webhook.description,
+        createdAt: webhook.createdAt
+      }
+    });
+  }).openapi(deleteRoute, (ctx) => {
+    const agent = getAgent();
+    const { webhookId } = ctx.req.valid("param");
+    const removed = webhookSubscriber.removeWebhook(webhookId);
+    if (!removed) {
+      return ctx.json({ error: "Webhook not found" }, 404);
+    }
+    agent.logger.info(`Webhook removed: ${webhookId}`);
+    return ctx.json({ status: "removed", webhookId });
+  }).openapi(testRoute, async (ctx) => {
+    const agent = getAgent();
+    const { webhookId } = ctx.req.valid("param");
+    const webhook = webhookSubscriber.getWebhook(webhookId);
+    if (!webhook) {
+      return ctx.json({ error: "Webhook not found" }, 404);
+    }
+    agent.logger.info(`Testing webhook: ${webhookId}`);
+    const result = await webhookSubscriber.testWebhook(webhookId);
+    return ctx.json({
+      test: "completed",
+      result: {
+        success: result.success,
+        statusCode: result.statusCode,
+        responseTime: result.responseTime,
+        error: result.error
+      }
+    });
+  });
+}
+export {
+  createWebhooksRouter
+};