@w3kits-com/plugin-opendesign 0.1.11 → 0.1.12

package/dist/__w3kits/webcontainer-runtime/workspace-packages/@open-design/sidecar/dist/index.mjs

@@ -0,0 +1,412 @@
+// src/index.ts
+import { lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { createConnection, createServer as createNetServer } from "node:net";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+function isWindowsNamedPipePath(value) {
+  return typeof value === "string" && value.startsWith("\\\\.\\pipe\\");
+}
+function normalizeIpcPath(ipc) {
+  if (typeof ipc !== "string") throw new Error("sidecar ipc path must be a string");
+  if (ipc.length === 0) throw new Error("sidecar ipc path must not be empty");
+  if (ipc.trim() !== ipc) throw new Error("sidecar ipc path must not contain leading or trailing whitespace");
+  if (ipc.includes("\0")) throw new Error("sidecar ipc path must not contain null bytes");
+  if (isWindowsNamedPipePath(ipc)) return ipc;
+  if (!isAbsolute(ipc)) throw new Error(`sidecar ipc path must be absolute: ${ipc}`);
+  return ipc;
+}
+function resolveNamespace(options) {
+  return options.contract.normalizeNamespace(
+    options.namespace ?? options.env?.[options.contract.env.namespace] ?? options.contract.defaults.namespace
+  );
+}
+function resolveProjectRoot(projectRoot) {
+  if (typeof projectRoot !== "string" || projectRoot.trim().length === 0) {
+    throw new Error("projectRoot must be a non-empty string");
+  }
+  return resolve(projectRoot);
+}
+function resolveProjectTmpRoot({
+  contract,
+  projectRoot
+}) {
+  return join(resolveProjectRoot(projectRoot), contract.defaults.projectTmpDirName);
+}
+function resolveSourceRuntimeRoot({
+  contract,
+  projectRoot,
+  source
+}) {
+  return join(resolveProjectTmpRoot({ contract, projectRoot }), contract.normalizeSource(source));
+}
+function resolveSidecarBase({
+  base,
+  contract,
+  env = process.env,
+  projectRoot = process.cwd(),
+  source
+}) {
+  return resolve(base ?? env[contract.env.base] ?? resolveSourceRuntimeRoot({ contract, projectRoot, source }));
+}
+function resolveNamespaceRoot({
+  base,
+  contract,
+  namespace
+}) {
+  return join(resolve(base), contract.normalizeNamespace(namespace));
+}
+function resolveRuntimeRoot({
+  base,
+  contract,
+  namespace,
+  runId
+}) {
+  return join(resolveNamespaceRoot({ base, contract, namespace }), "runs", runId);
+}
+function resolvePointerPath({ base, contract, namespace }) {
+  return join(resolveNamespaceRoot({ base, contract, namespace }), "current.json");
+}
+function resolveManifestPath({ runtimeRoot }) {
+  return join(runtimeRoot, "manifest.json");
+}
+function resolveLogsDir({
+  app,
+  contract,
+  runtimeRoot
+}) {
+  return join(runtimeRoot, "logs", contract.normalizeApp(app));
+}
+function resolveLogFilePath({
+  app,
+  contract,
+  fileName = "latest.log",
+  runtimeRoot
+}) {
+  return join(resolveLogsDir({ app, contract, runtimeRoot }), fileName);
+}
+function resolveAppRuntimeDir({
+  app,
+  contract,
+  namespaceRoot
+}) {
+  return join(namespaceRoot, contract.normalizeApp(app));
+}
+function resolveAppRuntimePath({
+  app,
+  contract,
+  fileName,
+  namespaceRoot
+}) {
+  if (fileName.length === 0 || fileName.includes("\0") || /[\\/]/.test(fileName)) {
+    throw new Error(`app runtime fileName must be a simple path segment: ${fileName}`);
+  }
+  return join(resolveAppRuntimeDir({ app, contract, namespaceRoot }), fileName);
+}
+function resolveAppIpcPath({
+  app,
+  contract,
+  env = process.env,
+  namespace
+}) {
+  const normalizedApp = contract.normalizeApp(app);
+  const normalizedNamespace = contract.normalizeNamespace(namespace);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\${contract.defaults.windowsPipePrefix}-${normalizedNamespace}-${normalizedApp}`;
+  }
+  const ipcBase = resolve(env[contract.env.ipcBase] ?? contract.defaults.ipcBase);
+  return join(ipcBase, normalizedNamespace, `${normalizedApp}.sock`);
+}
+function createSidecarLaunchEnv({
+  base,
+  contract,
+  extraEnv = process.env,
+  stamp
+}) {
+  const normalizedStamp = contract.normalizeStamp(stamp);
+  return {
+    ...extraEnv,
+    [contract.env.base]: resolveSidecarBase({ base, contract, env: extraEnv, source: normalizedStamp.source }),
+    [contract.env.ipcPath]: normalizedStamp.ipc,
+    [contract.env.namespace]: normalizedStamp.namespace,
+    [contract.env.source]: normalizedStamp.source
+  };
+}
+function assertMatchingEnv(env, key, expected) {
+  const current = env[key];
+  if (current != null && current !== expected) {
+    throw new Error(`sidecar env mismatch for ${key}: expected ${expected}, received ${current}`);
+  }
+}
+function bootstrapSidecarRuntime(stampInput, env, options) {
+  const stamp = options.contract.normalizeStamp(stampInput);
+  const expectedApp = options.contract.normalizeApp(options.app);
+  if (stamp.app !== expectedApp) {
+    throw new Error(`sidecar stamp app mismatch: expected ${expectedApp}, received ${stamp.app}`);
+  }
+  const base = resolveSidecarBase({
+    base: options.base,
+    contract: options.contract,
+    env,
+    projectRoot: options.projectRoot,
+    source: stamp.source
+  });
+  const ipc = resolveAppIpcPath({ app: stamp.app, contract: options.contract, env, namespace: stamp.namespace });
+  if (stamp.ipc !== ipc) {
+    throw new Error(`sidecar ipc path mismatch: expected ${ipc}, received ${stamp.ipc}`);
+  }
+  assertMatchingEnv(env, options.contract.env.ipcPath, stamp.ipc);
+  assertMatchingEnv(env, options.contract.env.namespace, stamp.namespace);
+  assertMatchingEnv(env, options.contract.env.source, stamp.source);
+  env[options.contract.env.ipcPath] = ipc;
+  env[options.contract.env.namespace] = stamp.namespace;
+  env[options.contract.env.source] = stamp.source;
+  return {
+    app: stamp.app,
+    base,
+    ipc,
+    mode: stamp.mode,
+    namespace: stamp.namespace,
+    source: stamp.source
+  };
+}
+async function closeServer(server) {
+  if (!server.listening) return;
+  await new Promise((resolveClose, rejectClose) => {
+    server.close((error) => error == null ? resolveClose() : rejectClose(error));
+  });
+}
+async function listenOnPort(port, host) {
+  const server = createNetServer();
+  await new Promise((resolveListen, rejectListen) => {
+    server.once("error", rejectListen);
+    server.listen({ port, host, exclusive: true }, () => {
+      server.off("error", rejectListen);
+      resolveListen();
+    });
+  });
+  return server;
+}
+function parsePort(value, label) {
+  if (value == null || value === "") return null;
+  const port = Number(value);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw new Error(`${label} port must be an integer between 1 and 65535`);
+  }
+  return port;
+}
+function errorCode(error) {
+  if (typeof error !== "object" || error == null || !("code" in error)) return null;
+  const code = error.code;
+  return code == null ? null : String(code);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function jsonIpcError(error) {
+  return {
+    ...errorCode(error) == null ? {} : { code: errorCode(error) },
+    message: errorMessage(error)
+  };
+}
+async function allocateForcedPort(port, label, host, reserved) {
+  if (reserved.has(port)) {
+    throw new Error(`forced ${label} port ${port} conflicts with another managed port`);
+  }
+  let server = null;
+  try {
+    server = await listenOnPort(port, host);
+  } catch (error) {
+    throw new Error(`forced ${label} port ${port} is not available (${errorCode(error) ?? errorMessage(error)})`);
+  } finally {
+    if (server) await closeServer(server);
+  }
+  reserved.add(port);
+  return { port, source: "forced" };
+}
+async function allocateDynamicPort(label, host, reserved) {
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const server = await listenOnPort(0, host);
+    const address = server.address();
+    await closeServer(server);
+    if (address == null || typeof address === "string") {
+      throw new Error(`failed to allocate dynamic ${label} port`);
+    }
+    if (!reserved.has(address.port)) {
+      reserved.add(address.port);
+      return { port: address.port, source: "dynamic" };
+    }
+  }
+  throw new Error(`failed to allocate dynamic ${label} port without conflict`);
+}
+async function allocatePort({
+  host = "127.0.0.1",
+  label = "runtime",
+  port,
+  reserved = /* @__PURE__ */ new Set()
+} = {}) {
+  const forcedPort = parsePort(port, label);
+  return forcedPort == null ? await allocateDynamicPort(label, host, reserved) : await allocateForcedPort(forcedPort, label, host, reserved);
+}
+async function readJsonFile(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function writeJsonFile(filePath, payload) {
+  await mkdir(dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tmpPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  await rename(tmpPath, filePath);
+}
+async function removeFile(filePath) {
+  await rm(filePath, { force: true });
+}
+async function removePointerIfCurrent(pointerPath, runId) {
+  const pointer = await readJsonFile(pointerPath);
+  if (pointer?.runId === runId) await removeFile(pointerPath);
+}
+async function staleUnixSocketExists(socketPath) {
+  try {
+    const stat = await lstat(socketPath);
+    if (!stat.isSocket()) return false;
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return false;
+    throw error;
+  }
+  return await new Promise((resolveStale, rejectStale) => {
+    const socket = createConnection(socketPath);
+    let settled = false;
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      socket.removeAllListeners();
+      socket.destroy();
+      callback();
+    };
+    socket.once("connect", () => settle(() => resolveStale(false)));
+    socket.once("error", (error) => {
+      const code = errorCode(error);
+      if (code === "ENOENT" || code === "ECONNREFUSED") {
+        settle(() => resolveStale(true));
+        return;
+      }
+      settle(() => rejectStale(error));
+    });
+  });
+}
+async function prepareIpcPath(socketPath) {
+  if (isWindowsNamedPipePath(socketPath)) return;
+  await mkdir(dirname(socketPath), { recursive: true });
+  if (await staleUnixSocketExists(socketPath)) await rm(socketPath, { force: true });
+}
+async function createJsonIpcServer({
+  handler,
+  socketPath
+}) {
+  await prepareIpcPath(socketPath);
+  const server = createNetServer((socket) => {
+    let buffer = "";
+    socket.on("error", () => {
+    });
+    socket.on("data", async (chunk) => {
+      buffer += chunk.toString();
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex < 0) return;
+      const frame = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      try {
+        const result = await handler(JSON.parse(frame));
+        socket.end(`${JSON.stringify({ ok: true, result })}
+`);
+      } catch (error) {
+        socket.end(
+          `${JSON.stringify({
+            ok: false,
+            error: jsonIpcError(error)
+          })}
+`
+        );
+      }
+    });
+  });
+  await new Promise((resolveListen, rejectListen) => {
+    server.once("error", rejectListen);
+    server.listen(socketPath, () => {
+      server.off("error", rejectListen);
+      resolveListen();
+    });
+  });
+  return {
+    async close() {
+      await closeServer(server);
+      if (!isWindowsNamedPipePath(socketPath)) await rm(socketPath, { force: true });
+    }
+  };
+}
+async function requestJsonIpc(socketPath, payload, { timeoutMs = 1500 } = {}) {
+  return await new Promise((resolveRequest, rejectRequest) => {
+    const socket = createConnection(socketPath);
+    let settled = false;
+    let buffer = "";
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      callback();
+    };
+    const timeout = setTimeout(() => {
+      socket.destroy();
+      settle(() => rejectRequest(new Error(`IPC request timed out: ${socketPath}`)));
+    }, timeoutMs);
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify(payload)}
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex < 0) return;
+      socket.end();
+      settle(() => {
+        const response = JSON.parse(buffer.slice(0, newlineIndex));
+        if (!response.ok) {
+          rejectRequest(new Error(response.error?.message ?? "IPC request failed"));
+          return;
+        }
+        resolveRequest(response.result);
+      });
+    });
+    socket.on("error", (error) => {
+      settle(() => rejectRequest(error));
+    });
+  });
+}
+export {
+  allocatePort,
+  bootstrapSidecarRuntime,
+  createJsonIpcServer,
+  createSidecarLaunchEnv,
+  isWindowsNamedPipePath,
+  normalizeIpcPath,
+  readJsonFile,
+  removeFile,
+  removePointerIfCurrent,
+  requestJsonIpc,
+  resolveAppIpcPath,
+  resolveAppRuntimeDir,
+  resolveAppRuntimePath,
+  resolveLogFilePath,
+  resolveLogsDir,
+  resolveManifestPath,
+  resolveNamespace,
+  resolveNamespaceRoot,
+  resolvePointerPath,
+  resolveProjectRoot,
+  resolveProjectTmpRoot,
+  resolveRuntimeRoot,
+  resolveSidecarBase,
+  resolveSourceRuntimeRoot,
+  writeJsonFile
+};

package/dist/__w3kits/webcontainer-runtime/workspace-packages/@open-design/sidecar/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@open-design/sidecar",
+  "version": "0.7.0",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    }
+  }
+}