sdn-flow 0.2.0

package/src/host/fetchService.js

@@ -0,0 +1,237 @@
+import { createInstalledFlowService } from "./installedFlowHost.js";
+
+function normalizeString(value, fallback = null) {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : fallback;
+}
+
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function normalizeHeaderEntries(headers) {
+  if (!headers) {
+    return [];
+  }
+  if (typeof headers.forEach === "function") {
+    const entries = [];
+    headers.forEach((value, key) => {
+      entries.push([key, value]);
+    });
+    return entries;
+  }
+  if (typeof headers.entries === "function") {
+    return Array.from(headers.entries());
+  }
+  if (Array.isArray(headers)) {
+    return headers;
+  }
+  if (isObject(headers)) {
+    return Object.entries(headers);
+  }
+  return [];
+}
+
+function normalizeHeadersObject(headers) {
+  const normalized = {};
+  for (const [key, value] of normalizeHeaderEntries(headers)) {
+    const headerName = normalizeString(key, null);
+    if (!headerName) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      normalized[headerName.toLowerCase()] = value
+        .map((item) => String(item))
+        .join(", ");
+      continue;
+    }
+    normalized[headerName.toLowerCase()] = String(value);
+  }
+  return normalized;
+}
+
+function normalizeHeadersInit(headers) {
+  const normalized = new Headers();
+  for (const [key, value] of normalizeHeaderEntries(headers)) {
+    const headerName = normalizeString(key, null);
+    if (!headerName || value === null || value === undefined) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        normalized.append(headerName, String(item));
+      }
+      continue;
+    }
+    normalized.set(headerName, String(value));
+  }
+  return normalized;
+}
+
+function normalizeUrlDetails(urlValue, baseUrl) {
+  if (!urlValue) {
+    return {
+      href: null,
+      origin: null,
+      path: "/",
+      query: {},
+    };
+  }
+
+  const url = baseUrl ? new URL(urlValue, baseUrl) : new URL(urlValue);
+  return {
+    href: url.href,
+    origin: url.origin,
+    path: url.pathname || "/",
+    query: Object.fromEntries(url.searchParams.entries()),
+  };
+}
+
+function normalizeBodyBytes(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (typeof value === "string") {
+    return new TextEncoder().encode(value);
+  }
+  return value;
+}
+
+async function readRequestBodyBytes(request) {
+  if (!request || typeof request.arrayBuffer !== "function") {
+    return normalizeBodyBytes(request?.body ?? request?.payload ?? null);
+  }
+
+  if (request.bodyUsed) {
+    throw new Error("Fetch request body has already been consumed.");
+  }
+
+  const method = normalizeString(request.method, "GET");
+  if (method === "GET" || method === "HEAD") {
+    return null;
+  }
+
+  const bodyBuffer = await request.arrayBuffer();
+  return bodyBuffer.byteLength > 0 ? new Uint8Array(bodyBuffer) : null;
+}
+
+export async function normalizeFetchRequest(request, options = {}) {
+  const baseUrl = normalizeString(options.baseUrl, "http://localhost");
+  const urlValue =
+    normalizeString(request?.url, null) ??
+    normalizeString(request?.href, null) ??
+    normalizeString(request?.path, null);
+  const urlDetails = normalizeUrlDetails(urlValue, baseUrl);
+  const requestId =
+    normalizeString(request?.requestId, null) ??
+    normalizeString(request?.headers?.get?.("x-request-id"), null);
+
+  return {
+    triggerId: normalizeString(request?.triggerId, null),
+    requestId,
+    method: normalizeString(request?.method, "GET"),
+    path: urlDetails.path,
+    query: urlDetails.query,
+    headers: normalizeHeadersObject(request?.headers),
+    body: await readRequestBodyBytes(request),
+    metadata: {
+      url: urlDetails.href,
+      origin: urlDetails.origin,
+      ...((isObject(options.metadata) && options.metadata) || {}),
+      ...((isObject(request?.metadata) && request.metadata) || {}),
+    },
+  };
+}
+
+function resolveHttpResponseFrame(result) {
+  if (!Array.isArray(result?.outputs) || result.outputs.length === 0) {
+    return null;
+  }
+  return result.outputs[0]?.frame ?? null;
+}
+
+export function createFetchResponse(result, options = {}) {
+  const frame = resolveHttpResponseFrame(result);
+  const metadata = isObject(frame?.metadata) ? frame.metadata : {};
+  const headers = normalizeHeadersInit(
+    metadata.responseHeaders ?? metadata.headers ?? {},
+  );
+  const contentType = normalizeString(
+    metadata.contentType ?? metadata.content_type,
+    null,
+  );
+  if (contentType && !headers.has("content-type")) {
+    headers.set("content-type", contentType);
+  }
+
+  const statusCode = Number(
+    metadata.statusCode ?? metadata.status ?? metadata.status_code ?? 200,
+  );
+  const status = Number.isInteger(statusCode) && statusCode >= 100
+    ? statusCode
+    : 200;
+  const body =
+    frame?.payload !== undefined && frame?.payload !== null
+      ? normalizeBodyBytes(frame.payload)
+      : null;
+
+  if (frame === null) {
+    return new Response(null, {
+      status:
+        Number.isInteger(options.emptyStatus) && options.emptyStatus >= 100
+          ? options.emptyStatus
+          : 204,
+      headers,
+    });
+  }
+
+  return new Response(body, {
+    status,
+    headers,
+  });
+}
+
+export function createInstalledFlowFetchHandler(options = {}) {
+  const service = options.service ?? createInstalledFlowService(options);
+  const requestMapper = options.requestMapper ?? normalizeFetchRequest;
+  const responseMapper = options.responseMapper ?? createFetchResponse;
+
+  const handler = async (request, context = {}) => {
+    await service.start();
+    const mappedRequest = await requestMapper(request, {
+      ...options,
+      context,
+    });
+    const result = await service.handleHttpRequest(mappedRequest);
+    return responseMapper(result, {
+      request,
+      context,
+      service,
+      ...options,
+    });
+  };
+
+  handler.service = service;
+  handler.start = () => service.start();
+  handler.stop = () => service.stop();
+
+  return handler;
+}
+
+export default {
+  createFetchResponse,
+  createInstalledFlowFetchHandler,
+  normalizeFetchRequest,
+};

package/src/host/httpHostAdapters.js

@@ -0,0 +1,280 @@
+import { startInstalledFlowAppHost } from "./appHost.js";
+
+function normalizeString(value, fallback = null) {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : fallback;
+}
+
+function resolveBindingUrl(binding = {}) {
+  const rawUrl = normalizeString(binding.url, null);
+  if (!rawUrl) {
+    throw new Error("HTTP binding is missing a url.");
+  }
+  return new URL(rawUrl);
+}
+
+function normalizeNodeHeaders(headers = {}) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === undefined) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      normalized[key] = value.join(", ");
+      continue;
+    }
+    normalized[key] = String(value);
+  }
+  return normalized;
+}
+
+async function readNodeRequestBody(request) {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  if (chunks.length === 0) {
+    return null;
+  }
+  return Buffer.concat(chunks);
+}
+
+async function createFetchRequestFromNodeIncomingMessage(request, binding) {
+  const bindingUrl = resolveBindingUrl(binding);
+  const requestUrl = new URL(request.url ?? bindingUrl.pathname, bindingUrl);
+  const method = normalizeString(request.method, "GET");
+  const headers = normalizeNodeHeaders(request.headers);
+  const body =
+    method === "GET" || method === "HEAD"
+      ? null
+      : await readNodeRequestBody(request);
+
+  return new Request(requestUrl, {
+    method,
+    headers,
+    body,
+  });
+}
+
+async function writeFetchResponseToNodeResponse(response, nodeResponse) {
+  nodeResponse.statusCode = response.status;
+  for (const [key, value] of response.headers.entries()) {
+    nodeResponse.setHeader(key, value);
+  }
+  if (response.body === null) {
+    nodeResponse.end();
+    return;
+  }
+  const bodyBuffer = Buffer.from(await response.arrayBuffer());
+  nodeResponse.end(bodyBuffer);
+}
+
+function closeHandle(handle) {
+  if (typeof handle === "function") {
+    return handle();
+  }
+  if (typeof handle?.stop === "function") {
+    return handle.stop();
+  }
+  if (typeof handle?.shutdown === "function") {
+    return handle.shutdown();
+  }
+  if (typeof handle?.abort === "function") {
+    return handle.abort();
+  }
+  if (typeof handle?.close === "function") {
+    return handle.close();
+  }
+  return undefined;
+}
+
+export function createDenoServeHttpAdapter(options = {}) {
+  const serve =
+    options.serve ??
+    (globalThis.Deno && typeof globalThis.Deno.serve === "function"
+      ? globalThis.Deno.serve.bind(globalThis.Deno)
+      : null);
+  if (typeof serve !== "function") {
+    throw new Error(
+      "createDenoServeHttpAdapter requires a Deno.serve-compatible function.",
+    );
+  }
+
+  return async function serveHttp({ binding, handler }) {
+    const url = resolveBindingUrl(binding);
+    const port = url.port ? Number(url.port) : 80;
+    const result = await serve(
+      {
+        hostname: url.hostname,
+        port,
+      },
+      handler,
+    );
+    return {
+      platform: "deno",
+      url: url.href,
+      hostname: url.hostname,
+      port,
+      server: result ?? null,
+      async close() {
+        await closeHandle(result);
+      },
+    };
+  };
+}
+
+export function createBunServeHttpAdapter(options = {}) {
+  const serve =
+    options.serve ??
+    (globalThis.Bun && typeof globalThis.Bun.serve === "function"
+      ? globalThis.Bun.serve.bind(globalThis.Bun)
+      : null);
+  if (typeof serve !== "function") {
+    throw new Error(
+      "createBunServeHttpAdapter requires a Bun.serve-compatible function.",
+    );
+  }
+
+  return async function serveHttp({ binding, handler }) {
+    const url = resolveBindingUrl(binding);
+    const port = url.port ? Number(url.port) : 80;
+    const result = await serve({
+      hostname: url.hostname,
+      port,
+      fetch: handler,
+    });
+    return {
+      platform: "bun",
+      url: url.href,
+      hostname: url.hostname,
+      port,
+      server: result ?? null,
+      async close() {
+        await closeHandle(result);
+      },
+    };
+  };
+}
+
+async function listenNodeServer(server, listenOptions) {
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(listenOptions);
+  });
+}
+
+async function closeNodeServer(server) {
+  await new Promise((resolve, reject) => {
+    server.close((error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+export function createNodeServeHttpAdapter(options = {}) {
+  return async function serveHttp({ binding, handler }) {
+    const { createServer } = await import("node:http");
+    const url = resolveBindingUrl(binding);
+    if (url.protocol && url.protocol !== "http:") {
+      throw new Error(
+        `createNodeServeHttpAdapter only supports http bindings, received ${url.protocol}.`,
+      );
+    }
+
+    const server = (options.createServer ?? createServer)(async (request, response) => {
+      try {
+        const fetchRequest = await createFetchRequestFromNodeIncomingMessage(
+          request,
+          binding,
+        );
+        const fetchResponse = await handler(fetchRequest, {
+          nodeRequest: request,
+          nodeResponse: response,
+          binding,
+        });
+        await writeFetchResponseToNodeResponse(fetchResponse, response);
+      } catch (error) {
+        response.statusCode = 500;
+        response.end(
+          typeof error?.message === "string"
+            ? error.message
+            : "Internal Server Error",
+        );
+      }
+    });
+
+    await listenNodeServer(server, {
+      host: url.hostname,
+      port: url.port ? Number(url.port) : 80,
+    });
+    const address = server.address();
+    const actualPort =
+      address && typeof address === "object" && "port" in address
+        ? address.port
+        : url.port
+          ? Number(url.port)
+          : 80;
+    const actualUrl = new URL(url.href);
+    actualUrl.port = String(actualPort);
+
+    return {
+      platform: "node",
+      url: actualUrl.href,
+      hostname: url.hostname,
+      port: actualPort,
+      server,
+      async close() {
+        await closeNodeServer(server);
+      },
+    };
+  };
+}
+
+export async function startInstalledFlowDenoHttpHost(options = {}) {
+  return startInstalledFlowAppHost({
+    ...options,
+    serveHttp:
+      options.serveHttp ?? createDenoServeHttpAdapter(options),
+  });
+}
+
+export async function startInstalledFlowBunHttpHost(options = {}) {
+  return startInstalledFlowAppHost({
+    ...options,
+    serveHttp:
+      options.serveHttp ?? createBunServeHttpAdapter(options),
+  });
+}
+
+export async function startInstalledFlowNodeHttpHost(options = {}) {
+  return startInstalledFlowAppHost({
+    ...options,
+    serveHttp:
+      options.serveHttp ?? createNodeServeHttpAdapter(options),
+  });
+}
+
+export default {
+  createBunServeHttpAdapter,
+  createDenoServeHttpAdapter,
+  createNodeServeHttpAdapter,
+  startInstalledFlowBunHttpHost,
+  startInstalledFlowDenoHttpHost,
+  startInstalledFlowNodeHttpHost,
+};

package/src/host/index.js

@@ -0,0 +1,91 @@
+export {
+  HostedRuntimeAdapter,
+  HostedRuntimeAuthority,
+  HostedRuntimeBindingDirection,
+  HostedRuntimeEngine,
+  HostedRuntimeKind,
+  HostedRuntimeStartupPhase,
+  HostedRuntimeTransport,
+} from "./constants.js";
+export {
+  bindCompiledRuntimeAbi,
+  DefaultRequiredRuntimeExportRoles,
+} from "./runtimeAbi.js";
+export {
+  bindCompiledInvocationAbi,
+  DefaultRequiredInvocationExportRoles,
+  FlowFrameDescriptorLayout,
+  FlowInvocationDescriptorLayout,
+} from "./invocationAbi.js";
+export {
+  bindCompiledDescriptorAbi,
+  DefaultRequiredDescriptorExportRoles,
+  FlowNodeDispatchDescriptorLayout,
+  SignedArtifactDependencyDescriptorLayout,
+} from "./descriptorAbi.js";
+export { instantiateEmbeddedDependencies } from "./dependencyRuntime.js";
+export { bindCompiledFlowRuntimeHost } from "./compiledFlowRuntimeHost.js";
+export {
+  evaluateHostedCapabilitySupport,
+  listHostedRuntimeCapabilities,
+  normalizeHostedRuntimeEngine,
+} from "./profile.js";
+export {
+  createInstalledFlowBrowserFetchEventListener,
+  matchesInstalledFlowHttpBindingRequest,
+  startInstalledFlowBrowserFetchHost,
+} from "./browserHostAdapters.js";
+export {
+  resolveInstalledFlowAutoHostEngine,
+  startInstalledFlowAutoHost,
+} from "./autoHost.js";
+export {
+  listInstalledFlowHttpBindings,
+  startInstalledFlowAppHost,
+} from "./appHost.js";
+export {
+  createBunServeHttpAdapter,
+  createDenoServeHttpAdapter,
+  createNodeServeHttpAdapter,
+  startInstalledFlowBunHttpHost,
+  startInstalledFlowDenoHttpHost,
+  startInstalledFlowNodeHttpHost,
+} from "./httpHostAdapters.js";
+export {
+  createFetchResponse,
+  createInstalledFlowFetchHandler,
+  normalizeFetchRequest,
+} from "./fetchService.js";
+export {
+  createInstalledFlowApp,
+  installWorkspacePluginPackage,
+  installWorkspacePackageReference,
+  normalizeInstalledFlowWorkspace,
+  removeWorkspacePackageReference,
+  readInstalledFlowWorkspace,
+  resolveInstalledFlowWorkspace,
+  uninstallWorkspacePluginPackage,
+  updateWorkspacePackageReference,
+  writeInstalledFlowWorkspace,
+} from "./workspace.js";
+export {
+  createInstalledFlowHost,
+  createInstalledFlowService,
+  createInstalledFlowHostedRuntimePlan,
+  discoverInstalledPluginPackages,
+  loadInstalledPluginPackage,
+  normalizeInstalledPluginPackage,
+  registerInstalledPluginPackage,
+  registerInstalledPluginPackages,
+} from "./installedFlowHost.js";
+export {
+  createCommandPackageManager,
+  createNodeCommandRunner,
+  createNpmPackageManager,
+} from "./packageManagers.js";
+export {
+  normalizeHostedBinding,
+  normalizeHostedRuntime,
+  normalizeHostedRuntimePlan,
+  summarizeHostedRuntimePlan,
+} from "./normalize.js";