@elevasis/sdk 0.2.0 → 0.3.1

package/dist/server/index.js

@@ -0,0 +1,174 @@
+import { createServer } from 'http';
+
+// src/server/index.ts
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+function json(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function resolveNext(next, data) {
+  if (next === null) return null;
+  if (next.type === "linear") return next.target;
+  for (const route of next.routes) {
+    if (route.condition(data)) return route.target;
+  }
+  return next.default;
+}
+async function executeWorkflow(workflow, input, context) {
+  let currentData = workflow.contract.inputSchema.parse(input);
+  let stepId = workflow.entryPoint;
+  while (stepId !== null) {
+    if (context.signal?.aborted) {
+      throw new Error("Execution cancelled");
+    }
+    const step = workflow.steps[stepId];
+    if (!step) {
+      throw new Error(`Step '${stepId}' not found in workflow '${workflow.config.resourceId}'`);
+    }
+    const stepInput = step.inputSchema.parse(currentData);
+    const rawOutput = await step.handler(stepInput, context);
+    currentData = step.outputSchema.parse(rawOutput);
+    stepId = resolveNext(step.next, currentData);
+  }
+  if (workflow.contract.outputSchema) {
+    currentData = workflow.contract.outputSchema.parse(currentData);
+  }
+  return currentData;
+}
+function withLogCapture(fn) {
+  const logs = [];
+  const orig = { log: console.log, warn: console.warn, error: console.error };
+  const capture = (level, origFn) => (...args) => {
+    logs.push({ level, message: args.map(String).join(" "), timestamp: Date.now() });
+    origFn(...args);
+  };
+  console.log = capture("info", orig.log);
+  console.warn = capture("warn", orig.warn);
+  console.error = capture("error", orig.error);
+  return fn().then((result) => ({ result, logs })).finally(() => {
+    console.log = orig.log;
+    console.warn = orig.warn;
+    console.error = orig.error;
+  });
+}
+function startServer(org) {
+  const port = parseInt(process.env.PORT || "3000");
+  const workflows = new Map(
+    (org.workflows ?? []).map((w) => [w.config.resourceId, w])
+  );
+  const agents = new Map(
+    (org.agents ?? []).map((a) => [a.config.resourceId, a])
+  );
+  const controllers = /* @__PURE__ */ new Map();
+  const server = createServer(async (req, res) => {
+    try {
+      if (req.url === "/health" && req.method === "GET") {
+        res.writeHead(200).end("ok");
+        return;
+      }
+      if (req.url === "/manifest" && req.method === "GET") {
+        json(res, 200, {
+          workflows: (org.workflows ?? []).map((w) => ({
+            resourceId: w.config.resourceId,
+            name: w.config.name,
+            type: w.config.type,
+            status: w.config.status,
+            description: w.config.description,
+            version: w.config.version
+          })),
+          agents: (org.agents ?? []).map((a) => ({
+            resourceId: a.config.resourceId,
+            name: a.config.name,
+            type: a.config.type,
+            status: a.config.status,
+            description: a.config.description,
+            version: a.config.version
+          }))
+        });
+        return;
+      }
+      if (req.url === "/execute" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const { resourceId, executionId, input } = body;
+        const workflow = workflows.get(resourceId);
+        if (workflow) {
+          const controller = new AbortController();
+          controllers.set(executionId, controller);
+          const deadline = req.headers["x-elevasis-deadline"];
+          const timer = deadline ? setTimeout(() => controller.abort(), Number(deadline) - Date.now()) : void 0;
+          const context = {
+            executionId,
+            organizationId: "",
+            organizationName: "",
+            resourceId,
+            executionDepth: 0,
+            store: /* @__PURE__ */ new Map(),
+            signal: controller.signal,
+            logger: {
+              debug: (msg) => console.log(`[debug] ${msg}`),
+              info: (msg) => console.log(`[info] ${msg}`),
+              warn: (msg) => console.warn(`[warn] ${msg}`),
+              error: (msg) => console.error(`[error] ${msg}`)
+            }
+          };
+          try {
+            const { result: output, logs } = await withLogCapture(
+              () => executeWorkflow(workflow, input, context)
+            );
+            json(res, 200, { status: "completed", output, logs });
+          } catch (err) {
+            const { logs } = await withLogCapture(async () => {
+            });
+            json(res, 500, { status: "failed", error: String(err), logs });
+          } finally {
+            controllers.delete(executionId);
+            if (timer) clearTimeout(timer);
+          }
+          return;
+        }
+        const agent = agents.get(resourceId);
+        if (agent) {
+          json(res, 501, {
+            status: "failed",
+            error: `Agent execution is not supported in SDK server v0.3.0. Resource '${resourceId}' is an agent.`,
+            logs: []
+          });
+          return;
+        }
+        json(res, 404, { error: `Resource not found: ${resourceId}` });
+        return;
+      }
+      if (req.url === "/cancel" && req.method === "POST") {
+        const body = JSON.parse(await readBody(req));
+        const { executionId } = body;
+        const controller = controllers.get(executionId);
+        if (controller) {
+          controller.abort();
+          controllers.delete(executionId);
+          json(res, 200, { cancelled: true });
+        } else {
+          json(res, 404, { error: `No running execution: ${executionId}` });
+        }
+        return;
+      }
+      res.writeHead(404).end();
+    } catch (err) {
+      console.error("Unhandled server error:", err);
+      if (!res.headersSent) {
+        json(res, 500, { error: "Internal server error" });
+      }
+    }
+  });
+  server.listen(port, () => {
+    console.log(`Elevasis SDK server listening on port ${port}`);
+  });
+}
+
+export { startServer };

package/package.json

@@ -1,32 +1,51 @@
 {
   "name": "@elevasis/sdk",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "SDK for building Elevasis organization resources",
+  "comment:bin": "IMPORTANT: This package shares the 'elevasis' binary name with @repo/cli. They never conflict because @elevasis/sdk must NEVER be added as a dependency of any workspace package (apps/*, packages/*, organizations/*). Workspace projects use @repo/cli for the 'elevasis' binary. External developers (outside the workspace) get this SDK's binary via npm install.",
   "type": "module",
+  "bin": {
+    "elevasis": "./dist/cli.cjs",
+    "elevasis-sdk": "./dist/cli.cjs"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./server": {
+      "import": "./dist/server/index.js"
     }
   },
   "files": [
     "dist/index.js",
-    "dist/index.d.ts"
+    "dist/index.d.ts",
+    "dist/server/index.js",
+    "dist/cli.cjs"
   ],
+  "scripts": {
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.core-dts.json && tsc -p tsconfig.build.json && tsup && rollup -c rollup.dts.config.mjs && esbuild src/cli/index.ts --bundle --platform=node --outfile=dist/cli.cjs --format=cjs --external:esbuild --external:jiti --banner:js=\"#!/usr/bin/env node\"",
+    "check-types": "tsc --noEmit"
+  },
+  "dependencies": {
+    "esbuild": "^0.25.0",
+    "jiti": "^2.0.0"
+  },
   "peerDependencies": {
     "zod": "^4.1.0"
   },
   "devDependencies": {
+    "@repo/core": "workspace:*",
+    "@repo/typescript-config": "workspace:*",
+    "@types/node": "^22.0.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "dotenv": "^16.0.0",
+    "ora": "^7.0.1",
     "rollup": "^4.59.0",
     "rollup-plugin-dts": "^6.3.0",
     "tsup": "^8.0.0",
     "typescript": "5.9.2",
-    "zod": "^4.1.0",
-    "@repo/core": "0.0.0",
-    "@repo/typescript-config": "0.0.0"
-  },
-  "scripts": {
-    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.core-dts.json && tsc -p tsconfig.build.json && tsup && rollup -c rollup.dts.config.mjs",
-    "check-types": "tsc --noEmit"
+    "zod": "^4.1.0"
   }
-}
+}