@ubiquity-os/plugin-sdk 2.0.1 → 2.0.2

package/dist/index.js

@@ -37,8 +37,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/server.ts
-var import_typebox = require("@sinclair/typebox");
-var import_value = require("@sinclair/typebox/value");
+var import_value2 = require("@sinclair/typebox/value");
 var import_ubiquity_os_logger2 = require("@ubiquity-os/ubiquity-os-logger");
 var import_hono = require("hono");
 var import_adapter2 = require("hono/adapter");
@@ -259,17 +258,36 @@ async function verifySignature(publicKeyPem, inputs, signature) {
   }
 }
 
-// src/server.ts
-var inputSchema = import_typebox.Type.Object({
-  stateId: import_typebox.Type.String(),
-  eventName: import_typebox.Type.String(),
-  eventPayload: import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Any()),
-  command: import_typebox.Type.Union([import_typebox.Type.Null(), import_typebox.Type.Object({ name: import_typebox.Type.String(), parameters: import_typebox.Type.Unknown() })]),
-  authToken: import_typebox.Type.String(),
-  settings: import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Any()),
-  ref: import_typebox.Type.String(),
-  signature: import_typebox.Type.String()
+// src/types/input-schema.ts
+var import_typebox3 = require("@sinclair/typebox");
+
+// src/types/command.ts
+var import_typebox = require("@sinclair/typebox");
+var commandCallSchema = import_typebox.Type.Union([import_typebox.Type.Null(), import_typebox.Type.Object({ name: import_typebox.Type.String(), parameters: import_typebox.Type.Unknown() })]);
+
+// src/types/util.ts
+var import_typebox2 = require("@sinclair/typebox");
+var import_value = require("@sinclair/typebox/value");
+function jsonType(type) {
+  return import_typebox2.Type.Transform(import_typebox2.Type.String()).Decode((value) => {
+    const parsed = JSON.parse(value);
+    return import_value.Value.Decode(type, import_value.Value.Default(type, parsed));
+  }).Encode((value) => JSON.stringify(value));
+}
+
+// src/types/input-schema.ts
+var inputSchema = import_typebox3.Type.Object({
+  stateId: import_typebox3.Type.String(),
+  eventName: import_typebox3.Type.String(),
+  eventPayload: jsonType(import_typebox3.Type.Record(import_typebox3.Type.String(), import_typebox3.Type.Any())),
+  command: jsonType(commandCallSchema),
+  authToken: import_typebox3.Type.String(),
+  settings: jsonType(import_typebox3.Type.Record(import_typebox3.Type.String(), import_typebox3.Type.Any())),
+  ref: import_typebox3.Type.String(),
+  signature: import_typebox3.Type.String()
 });
+
+// src/server.ts
 function createPlugin(handler, manifest, options) {
   const pluginOptions = getPluginOptions(options);
   const app = new import_hono.Hono();
@@ -281,22 +299,22 @@ function createPlugin(handler, manifest, options) {
       throw new import_http_exception.HTTPException(400, { message: "Content-Type must be application/json" });
     }
     const body = await ctx.req.json();
-    const inputSchemaErrors = [...import_value.Value.Errors(inputSchema, body)];
+    const inputSchemaErrors = [...import_value2.Value.Errors(inputSchema, body)];
     if (inputSchemaErrors.length) {
       console.log(inputSchemaErrors, { depth: null });
       throw new import_http_exception.HTTPException(400, { message: "Invalid body" });
     }
-    const inputs = import_value.Value.Decode(inputSchema, body);
-    const signature = inputs.signature;
-    if (!pluginOptions.bypassSignatureVerification && !await verifySignature(pluginOptions.kernelPublicKey, inputs, signature)) {
+    const signature = body.signature;
+    if (!pluginOptions.bypassSignatureVerification && !await verifySignature(pluginOptions.kernelPublicKey, body, signature)) {
       throw new import_http_exception.HTTPException(400, { message: "Invalid signature" });
     }
+    const inputs = import_value2.Value.Decode(inputSchema, body);
     let config2;
     if (pluginOptions.settingsSchema) {
       try {
-        config2 = import_value.Value.Decode(pluginOptions.settingsSchema, import_value.Value.Default(pluginOptions.settingsSchema, inputs.settings));
+        config2 = import_value2.Value.Decode(pluginOptions.settingsSchema, import_value2.Value.Default(pluginOptions.settingsSchema, inputs.settings));
       } catch (e) {
-        console.log(...import_value.Value.Errors(pluginOptions.settingsSchema, inputs.settings), { depth: null });
+        console.log(...import_value2.Value.Errors(pluginOptions.settingsSchema, inputs.settings), { depth: null });
         throw e;
       }
     } else {
@@ -306,9 +324,9 @@ function createPlugin(handler, manifest, options) {
     const honoEnvironment = (0, import_adapter2.env)(ctx);
     if (pluginOptions.envSchema) {
       try {
-        env = import_value.Value.Decode(pluginOptions.envSchema, import_value.Value.Default(pluginOptions.envSchema, honoEnvironment));
+        env = import_value2.Value.Decode(pluginOptions.envSchema, import_value2.Value.Default(pluginOptions.envSchema, honoEnvironment));
       } catch (e) {
-        console.log(...import_value.Value.Errors(pluginOptions.envSchema, honoEnvironment), { depth: null });
+        console.log(...import_value2.Value.Errors(pluginOptions.envSchema, honoEnvironment), { depth: null });
         throw e;
       }
     } else {
@@ -319,9 +337,9 @@ function createPlugin(handler, manifest, options) {
     let command = null;
     if (inputs.command && pluginOptions.commandSchema) {
       try {
-        command = import_value.Value.Decode(pluginOptions.commandSchema, import_value.Value.Default(pluginOptions.commandSchema, inputs.command));
+        command = import_value2.Value.Decode(pluginOptions.commandSchema, import_value2.Value.Default(pluginOptions.commandSchema, inputs.command));
       } catch (e) {
-        console.log(...import_value.Value.Errors(pluginOptions.commandSchema, inputs.command), { depth: null });
+        console.log(...import_value2.Value.Errors(pluginOptions.commandSchema, inputs.command), { depth: null });
         throw e;
       }
     } else if (inputs.command) {
@@ -359,37 +377,10 @@ function createPlugin(handler, manifest, options) {
 // src/actions.ts
 var core = __toESM(require("@actions/core"));
 var github2 = __toESM(require("@actions/github"));
-var import_typebox4 = require("@sinclair/typebox");
 var import_value3 = require("@sinclair/typebox/value");
 var import_ubiquity_os_logger3 = require("@ubiquity-os/ubiquity-os-logger");
 var import_dotenv = require("dotenv");
-
-// src/types/command.ts
-var import_typebox2 = require("@sinclair/typebox");
-var commandCallSchema = import_typebox2.Type.Union([import_typebox2.Type.Null(), import_typebox2.Type.Object({ name: import_typebox2.Type.String(), parameters: import_typebox2.Type.Unknown() })]);
-
-// src/types/util.ts
-var import_typebox3 = require("@sinclair/typebox");
-var import_value2 = require("@sinclair/typebox/value");
-function jsonType(type) {
-  return import_typebox3.Type.Transform(import_typebox3.Type.String()).Decode((value) => {
-    const parsed = JSON.parse(value);
-    return import_value2.Value.Decode(type, import_value2.Value.Default(type, parsed));
-  }).Encode((value) => JSON.stringify(value));
-}
-
-// src/actions.ts
 (0, import_dotenv.config)();
-var inputSchema2 = import_typebox4.Type.Object({
-  stateId: import_typebox4.Type.String(),
-  eventName: import_typebox4.Type.String(),
-  eventPayload: jsonType(import_typebox4.Type.Record(import_typebox4.Type.String(), import_typebox4.Type.Any())),
-  command: jsonType(commandCallSchema),
-  authToken: import_typebox4.Type.String(),
-  settings: jsonType(import_typebox4.Type.Record(import_typebox4.Type.String(), import_typebox4.Type.Any())),
-  ref: import_typebox4.Type.String(),
-  signature: import_typebox4.Type.String()
-});
 async function createActionsPlugin(handler, options) {
   const pluginOptions = getPluginOptions(options);
   const pluginGithubToken = process.env.PLUGIN_GITHUB_TOKEN;
@@ -404,13 +395,13 @@ async function createActionsPlugin(handler, options) {
     return;
   }
   const inputPayload = github2.context.payload.inputs;
-  const inputSchemaErrors = [...import_value3.Value.Errors(inputSchema2, inputPayload)];
+  const inputSchemaErrors = [...import_value3.Value.Errors(inputSchema, inputPayload)];
   if (inputSchemaErrors.length) {
     console.dir(inputSchemaErrors, { depth: null });
     core.setFailed(`Error: Invalid inputs payload: ${inputSchemaErrors.join(",")}`);
     return;
   }
-  const inputs = import_value3.Value.Decode(inputSchema2, inputPayload);
+  const inputs = import_value3.Value.Decode(inputSchema, inputPayload);
   let config2;
   if (pluginOptions.settingsSchema) {
     try {

package/dist/index.mjs

@@ -1,6 +1,5 @@
 // src/server.ts
-import { Type as T } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
+import { Value as Value2 } from "@sinclair/typebox/value";
 import { LogReturn as LogReturn2, Logs } from "@ubiquity-os/ubiquity-os-logger";
 import { Hono } from "hono";
 import { env as honoEnv } from "hono/adapter";
@@ -221,17 +220,36 @@ async function verifySignature(publicKeyPem, inputs, signature) {
   }
 }
 
-// src/server.ts
-var inputSchema = T.Object({
-  stateId: T.String(),
-  eventName: T.String(),
-  eventPayload: T.Record(T.String(), T.Any()),
-  command: T.Union([T.Null(), T.Object({ name: T.String(), parameters: T.Unknown() })]),
-  authToken: T.String(),
-  settings: T.Record(T.String(), T.Any()),
-  ref: T.String(),
-  signature: T.String()
+// src/types/input-schema.ts
+import { Type as T2 } from "@sinclair/typebox";
+
+// src/types/command.ts
+import { Type as T } from "@sinclair/typebox";
+var commandCallSchema = T.Union([T.Null(), T.Object({ name: T.String(), parameters: T.Unknown() })]);
+
+// src/types/util.ts
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+function jsonType(type) {
+  return Type.Transform(Type.String()).Decode((value) => {
+    const parsed = JSON.parse(value);
+    return Value.Decode(type, Value.Default(type, parsed));
+  }).Encode((value) => JSON.stringify(value));
+}
+
+// src/types/input-schema.ts
+var inputSchema = T2.Object({
+  stateId: T2.String(),
+  eventName: T2.String(),
+  eventPayload: jsonType(T2.Record(T2.String(), T2.Any())),
+  command: jsonType(commandCallSchema),
+  authToken: T2.String(),
+  settings: jsonType(T2.Record(T2.String(), T2.Any())),
+  ref: T2.String(),
+  signature: T2.String()
 });
+
+// src/server.ts
 function createPlugin(handler, manifest, options) {
   const pluginOptions = getPluginOptions(options);
   const app = new Hono();
@@ -243,22 +261,22 @@ function createPlugin(handler, manifest, options) {
       throw new HTTPException(400, { message: "Content-Type must be application/json" });
     }
     const body = await ctx.req.json();
-    const inputSchemaErrors = [...Value.Errors(inputSchema, body)];
+    const inputSchemaErrors = [...Value2.Errors(inputSchema, body)];
     if (inputSchemaErrors.length) {
       console.log(inputSchemaErrors, { depth: null });
       throw new HTTPException(400, { message: "Invalid body" });
     }
-    const inputs = Value.Decode(inputSchema, body);
-    const signature = inputs.signature;
-    if (!pluginOptions.bypassSignatureVerification && !await verifySignature(pluginOptions.kernelPublicKey, inputs, signature)) {
+    const signature = body.signature;
+    if (!pluginOptions.bypassSignatureVerification && !await verifySignature(pluginOptions.kernelPublicKey, body, signature)) {
       throw new HTTPException(400, { message: "Invalid signature" });
     }
+    const inputs = Value2.Decode(inputSchema, body);
     let config2;
     if (pluginOptions.settingsSchema) {
       try {
-        config2 = Value.Decode(pluginOptions.settingsSchema, Value.Default(pluginOptions.settingsSchema, inputs.settings));
+        config2 = Value2.Decode(pluginOptions.settingsSchema, Value2.Default(pluginOptions.settingsSchema, inputs.settings));
       } catch (e) {
-        console.log(...Value.Errors(pluginOptions.settingsSchema, inputs.settings), { depth: null });
+        console.log(...Value2.Errors(pluginOptions.settingsSchema, inputs.settings), { depth: null });
         throw e;
       }
     } else {
@@ -268,9 +286,9 @@ function createPlugin(handler, manifest, options) {
     const honoEnvironment = honoEnv(ctx);
     if (pluginOptions.envSchema) {
       try {
-        env = Value.Decode(pluginOptions.envSchema, Value.Default(pluginOptions.envSchema, honoEnvironment));
+        env = Value2.Decode(pluginOptions.envSchema, Value2.Default(pluginOptions.envSchema, honoEnvironment));
       } catch (e) {
-        console.log(...Value.Errors(pluginOptions.envSchema, honoEnvironment), { depth: null });
+        console.log(...Value2.Errors(pluginOptions.envSchema, honoEnvironment), { depth: null });
         throw e;
       }
     } else {
@@ -281,9 +299,9 @@ function createPlugin(handler, manifest, options) {
     let command = null;
     if (inputs.command && pluginOptions.commandSchema) {
       try {
-        command = Value.Decode(pluginOptions.commandSchema, Value.Default(pluginOptions.commandSchema, inputs.command));
+        command = Value2.Decode(pluginOptions.commandSchema, Value2.Default(pluginOptions.commandSchema, inputs.command));
       } catch (e) {
-        console.log(...Value.Errors(pluginOptions.commandSchema, inputs.command), { depth: null });
+        console.log(...Value2.Errors(pluginOptions.commandSchema, inputs.command), { depth: null });
         throw e;
       }
     } else if (inputs.command) {
@@ -321,37 +339,10 @@ function createPlugin(handler, manifest, options) {
 // src/actions.ts
 import * as core from "@actions/core";
 import * as github2 from "@actions/github";
-import { Type as T3 } from "@sinclair/typebox";
 import { Value as Value3 } from "@sinclair/typebox/value";
 import { LogReturn as LogReturn3, Logs as Logs2 } from "@ubiquity-os/ubiquity-os-logger";
 import { config } from "dotenv";
-
-// src/types/command.ts
-import { Type as T2 } from "@sinclair/typebox";
-var commandCallSchema = T2.Union([T2.Null(), T2.Object({ name: T2.String(), parameters: T2.Unknown() })]);
-
-// src/types/util.ts
-import { Type } from "@sinclair/typebox";
-import { Value as Value2 } from "@sinclair/typebox/value";
-function jsonType(type) {
-  return Type.Transform(Type.String()).Decode((value) => {
-    const parsed = JSON.parse(value);
-    return Value2.Decode(type, Value2.Default(type, parsed));
-  }).Encode((value) => JSON.stringify(value));
-}
-
-// src/actions.ts
 config();
-var inputSchema2 = T3.Object({
-  stateId: T3.String(),
-  eventName: T3.String(),
-  eventPayload: jsonType(T3.Record(T3.String(), T3.Any())),
-  command: jsonType(commandCallSchema),
-  authToken: T3.String(),
-  settings: jsonType(T3.Record(T3.String(), T3.Any())),
-  ref: T3.String(),
-  signature: T3.String()
-});
 async function createActionsPlugin(handler, options) {
   const pluginOptions = getPluginOptions(options);
   const pluginGithubToken = process.env.PLUGIN_GITHUB_TOKEN;
@@ -366,13 +357,13 @@ async function createActionsPlugin(handler, options) {
     return;
   }
   const inputPayload = github2.context.payload.inputs;
-  const inputSchemaErrors = [...Value3.Errors(inputSchema2, inputPayload)];
+  const inputSchemaErrors = [...Value3.Errors(inputSchema, inputPayload)];
   if (inputSchemaErrors.length) {
     console.dir(inputSchemaErrors, { depth: null });
     core.setFailed(`Error: Invalid inputs payload: ${inputSchemaErrors.join(",")}`);
     return;
   }
-  const inputs = Value3.Decode(inputSchema2, inputPayload);
+  const inputs = Value3.Decode(inputSchema, inputPayload);
   let config2;
   if (pluginOptions.settingsSchema) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubiquity-os/plugin-sdk",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "SDK for plugin support.",
   "author": "Ubiquity DAO",
   "license": "MIT",