@flowdular/sandbox 0.2.0

package/bin/flowdular-sandbox.mjs

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+
+// ../sandbox/bin/flowdular-sandbox.mjs
+import "./register-types.mjs";
+import process2 from "node:process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer } from "vite";
+
+// ../dev-console/src/index.mjs
+import { createLogger } from "vite";
+var ansiPattern = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+var ansi = {
+  reset: "\x1B[0m",
+  brand: "\x1B[1;38;5;42m",
+  label: "\x1B[2;37m",
+  text: "\x1B[37m",
+  success: "\x1B[38;5;42m",
+  info: "\x1B[36m",
+  warning: "\x1B[33m",
+  error: "\x1B[31m",
+  muted: "\x1B[90m"
+};
+function shouldUseColor(environment = process.env, isTerminal = process.stdout.isTTY) {
+  if (Object.hasOwn(environment, "FORCE_COLOR") && environment.FORCE_COLOR !== "0") {
+    return true;
+  }
+  if (Object.hasOwn(environment, "NO_COLOR")) return false;
+  if (environment.TERM === "dumb") return false;
+  return Boolean(
+    isTerminal || environment.COLORTERM || environment.TERM_PROGRAM
+  );
+}
+function createTheme(enabled) {
+  const paint = (code) => enabled ? (value) => `${code}${String(value)}${ansi.reset}` : (value) => String(value);
+  return {
+    enabled,
+    brand: paint(ansi.brand),
+    label: paint(ansi.label),
+    text: paint(ansi.text),
+    success: paint(ansi.success),
+    info: paint(ansi.info),
+    warning: paint(ansi.warning),
+    error: paint(ansi.error),
+    muted: paint(ansi.muted)
+  };
+}
+function formatDevEvent(kind, message, useColor = shouldUseColor()) {
+  const theme = createTheme(useColor);
+  const label = kind === "process" ? "[octane]" : `[octane:${kind}]`;
+  const tone = kind === "error" ? theme.error : kind === "notice" ? theme.warning : kind === "routes" ? theme.success : kind === "reload" ? theme.info : theme.muted;
+  return `${tone(label)} ${tone(message)}`;
+}
+function clean(message) {
+  return String(message).replace(ansiPattern, "").trim();
+}
+function statusLine(theme, label, value, tone = "text") {
+  return `  ${theme.label(label.padEnd(12))}${theme[tone](value)}`;
+}
+function printReady({ title, subtitle, lines, theme }) {
+  console.log("");
+  console.log(`  ${theme.brand(title)}  ${theme.muted(subtitle)}`);
+  for (const [label, value, tone = "text"] of lines) {
+    if (value === null || value === void 0) continue;
+    console.log(statusLine(theme, label, value, tone));
+  }
+  console.log("");
+}
+function createOctaneLogger(verbose, useColor) {
+  const viteLogger = createLogger("info", { allowClearScreen: false });
+  const warnings = /* @__PURE__ */ new Set();
+  let hasWarned = false;
+  const warn = (message, options) => {
+    hasWarned = true;
+    if (verbose) {
+      viteLogger.warn(message, options);
+      return;
+    }
+    const normalized = clean(message);
+    if (warnings.has(normalized)) return;
+    warnings.add(normalized);
+    if (warnings.size === 1) {
+      console.warn(
+        formatDevEvent(
+          "notice",
+          "Tool warnings are hidden. Restart with --verbose to inspect them.",
+          useColor
+        )
+      );
+    }
+  };
+  return {
+    get hasWarned() {
+      return hasWarned;
+    },
+    info(message, options) {
+      if (verbose) viteLogger.info(message, options);
+    },
+    warn,
+    warnOnce(message, options) {
+      if (verbose) {
+        hasWarned = true;
+        viteLogger.warnOnce(message, options);
+        return;
+      }
+      if (!warnings.has(clean(message))) warn(message, options);
+    },
+    error(message, options) {
+      console.error(formatDevEvent("error", clean(message), useColor));
+      if (verbose && options?.error?.stack) {
+        console.error(options.error.stack);
+      }
+    },
+    clearScreen() {
+    },
+    hasErrorLogged(error) {
+      return viteLogger.hasErrorLogged(error);
+    }
+  };
+}
+function isClientDisconnectLog(values) {
+  if (typeof values[0] !== "string") return false;
+  if (!values[0].startsWith("[octane] SSR render error:")) return false;
+  return values.slice(1).some(
+    (value) => value instanceof Error && value.message.includes("client disconnected")
+  );
+}
+function installOctaneConsoleBridge(verbose, useColor) {
+  const originalLog = console.log.bind(console);
+  const originalError = console.error.bind(console);
+  console.log = (...values) => {
+    const message = values[0];
+    if (!verbose && typeof message === "string" && message.startsWith("[@octanejs/vite-plugin]")) {
+      const loaded = message.match(/Loaded (\d+) routes/);
+      const reloaded = message.match(/Reloaded (\d+) routes/);
+      if (loaded) {
+        originalLog(
+          formatDevEvent("routes", `${loaded[1]} routes loaded`, useColor)
+        );
+      } else if (reloaded) {
+        originalLog(
+          formatDevEvent("routes", `${reloaded[1]} routes reloaded`, useColor)
+        );
+      }
+      return;
+    }
+    originalLog(...values);
+  };
+  console.error = (...values) => {
+    const message = values[0];
+    if (!verbose && isClientDisconnectLog(values)) return;
+    if (typeof message === "string" && message.startsWith("[@octanejs/vite-plugin]")) {
+      originalError(
+        formatDevEvent(
+          "error",
+          message.slice("[@octanejs/vite-plugin]".length).trim(),
+          useColor
+        ),
+        ...values.slice(1)
+      );
+      return;
+    }
+    originalError(...values);
+  };
+  return () => {
+    console.log = originalLog;
+    console.error = originalError;
+  };
+}
+function watchReloads(server, root, useColor) {
+  let lastChange = "";
+  let lastChangeAt = 0;
+  server.watcher.on("change", (path) => {
+    const changed = path.startsWith(root) ? path.slice(root.length + 1) : path;
+    const now = Date.now();
+    if (changed === lastChange && now - lastChangeAt < 100) return;
+    lastChange = changed;
+    lastChangeAt = now;
+    console.log(formatDevEvent("reload", changed, useColor));
+  });
+}
+
+// ../sandbox/bin/flowdular-sandbox.mjs
+var appRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+function parseSandboxArguments(argv = []) {
+  const options = {
+    host: "127.0.0.1",
+    port: 4320,
+    mode: "loopback",
+    workspace: process2.cwd(),
+    verbose: process2.env.FD_SANDBOX_VERBOSE === "true",
+    help: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--help" || argument === "-h") {
+      options.help = true;
+      continue;
+    }
+    if (argument === "--verbose" || argument === "-v") {
+      options.verbose = true;
+      continue;
+    }
+    const take = (name) => {
+      const inline = argument.startsWith(`--${name}=`) ? argument.slice(name.length + 3) : void 0;
+      if (inline !== void 0) return inline;
+      if (argument !== `--${name}`) return void 0;
+      const value = argv[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error(`--${name} requires a value.`);
+      }
+      index += 1;
+      return value;
+    };
+    const host = take("host");
+    if (host !== void 0) {
+      options.host = host;
+      continue;
+    }
+    const port = take("port");
+    if (port !== void 0) {
+      options.port = Number(port);
+      continue;
+    }
+    const workspace = take("workspace");
+    if (workspace !== void 0) {
+      options.workspace = resolve(workspace);
+      continue;
+    }
+    const mode = take("mode");
+    if (mode !== void 0) {
+      if (mode !== "loopback" && mode !== "self-hosted") {
+        throw new Error("--mode must be loopback or self-hosted.");
+      }
+      options.mode = mode;
+      continue;
+    }
+    throw new Error(`Unknown sandbox option: ${argument}`);
+  }
+  if (!Number.isInteger(options.port) || options.port < 1 || options.port > 65535) {
+    throw new Error("--port must be an integer between 1 and 65535.");
+  }
+  if (options.mode === "loopback" && !isLoopbackHost(options.host)) {
+    options.mode = "self-hosted";
+  }
+  return options;
+}
+function isLoopbackHost(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "::1";
+}
+function printHelp() {
+  console.log(`Flowdular sandbox
+
+Usage: npx @flowdular/sandbox [options]
+
+Options:
+  --workspace <path>  Flowdular workspace to use (default: current directory)
+  --host <host>       Bind address (default: 127.0.0.1)
+  --port <port>       HTTP port (default: 4320)
+  --mode <mode>       loopback or self-hosted (default: loopback)
+  -v, --verbose       Show Vite and tool warnings
+  -h, --help          Show this help`);
+}
+async function sandboxStatus(server, workspace) {
+  const local = server.resolvedUrls?.local?.[0] ?? "http://127.0.0.1:4320/";
+  try {
+    const state = await fetch(new URL("/sandbox/api/state", local), {
+      headers: { accept: "application/json" }
+    }).then((response) => response.json());
+    if (state.error) {
+      return {
+        platform: `${state.configuration?.platformUrl ?? "not configured"} \xB7 sign in required`,
+        connected: false,
+        agents: "after sign-in",
+        hasAgents: false,
+        sessions: 0
+      };
+    }
+    const offered = (state.drivers ?? []).filter((driver) => driver.offered).map((driver) => driver.label);
+    const tenant = state.connection?.authority?.principal?.tenantName ?? "connected";
+    return {
+      platform: state.connection?.connected ? `${state.configuration.platformUrl} \xB7 ${tenant}` : `${state.configuration?.platformUrl ?? "not configured"} \xB7 not connected`,
+      connected: Boolean(state.connection?.connected),
+      agents: offered.length > 0 ? offered.join(" \xB7 ") : "none available",
+      hasAgents: offered.length > 0,
+      sessions: (state.sessions ?? []).length
+    };
+  } catch {
+    return {
+      platform: "unavailable",
+      connected: false,
+      agents: "unknown",
+      hasAgents: false,
+      sessions: 0
+    };
+  }
+}
+async function startSandbox(argv = process2.argv.slice(2)) {
+  const options = parseSandboxArguments(argv);
+  const useColor = shouldUseColor();
+  const theme = createTheme(useColor);
+  if (options.help) {
+    printHelp(theme);
+    return null;
+  }
+  process2.env.FD_SANDBOX_WORKSPACE = options.workspace;
+  process2.env.FD_SANDBOX_MODE = options.mode;
+  process2.env.FD_SANDBOX_PORT = String(options.port);
+  const startedAt = performance.now();
+  const restoreConsole = installOctaneConsoleBridge(options.verbose, useColor);
+  const logger = createOctaneLogger(options.verbose, useColor);
+  let server;
+  try {
+    server = await createServer({
+      root: appRoot,
+      configFile: resolve(appRoot, "vite.config.ts"),
+      customLogger: logger,
+      clearScreen: false,
+      server: { host: options.host, port: options.port, strictPort: true }
+    });
+    await server.listen();
+  } catch (error) {
+    restoreConsole();
+    throw error;
+  }
+  const status = await sandboxStatus(server, options.workspace);
+  printReady({
+    title: "FLOWDULAR SANDBOX",
+    subtitle: "agentic workspace",
+    theme,
+    lines: [
+      ["ready", `${Math.round(performance.now() - startedAt)} ms`, "success"],
+      [
+        "local",
+        server.resolvedUrls?.local?.[0] ?? `http://${options.host}:${options.port}/`,
+        "info"
+      ],
+      ...(server.resolvedUrls?.network ?? []).map((url) => [
+        "network",
+        url,
+        "info"
+      ]),
+      [
+        "mode",
+        options.mode,
+        options.mode === "loopback" ? "success" : "warning"
+      ],
+      ["workspace", options.workspace, "muted"],
+      [
+        "sessions",
+        status.sessions === 1 ? "1 open" : `${status.sessions} open`,
+        "text"
+      ],
+      ["platform", status.platform, status.connected ? "success" : "warning"],
+      ["agents", status.agents, status.hasAgents ? "success" : "warning"],
+      ["reload", "TSRX \xB7 TypeScript \xB7 CSS", "info"],
+      [
+        "diagnostics",
+        options.verbose ? "verbose" : "quiet \xB7 use --verbose",
+        options.verbose ? "warning" : "muted"
+      ]
+    ]
+  });
+  watchReloads(server, appRoot, useColor);
+  const close = async () => {
+    console.log(`
+${formatDevEvent("process", "Sandbox stopped.", useColor)}`);
+    await server.close();
+    restoreConsole();
+    process2.exit(0);
+  };
+  process2.once("SIGINT", () => void close());
+  process2.once("SIGTERM", () => void close());
+  return server;
+}
+if (process2.argv[1] && resolve(process2.argv[1]) === fileURLToPath(import.meta.url)) {
+  startSandbox().catch((error) => {
+    console.error(
+      formatDevEvent(
+        "error",
+        error instanceof Error ? error.message : String(error)
+      )
+    );
+    if (process2.argv.includes("--verbose") && error instanceof Error) {
+      console.error(error.stack);
+    }
+    process2.exitCode = 1;
+  });
+}
+export {
+  isLoopbackHost,
+  parseSandboxArguments,
+  startSandbox
+};

package/bin/register-types.mjs

@@ -0,0 +1,53 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import {
+	createRequire,
+	registerHooks,
+	stripTypeScriptTypes,
+} from 'node:module';
+import { dirname, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// SDK server entrypoints are source TypeScript. Node deliberately does not strip
+// types in node_modules, even with --experimental-transform-types. Transform only
+// this application's and its SDK's source; never install a global package loader.
+const packageRoot = realpathSync(fileURLToPath(new URL('..', import.meta.url)));
+const roots = [packageRoot];
+try {
+	const require = createRequire(import.meta.url);
+	roots.push(
+		realpathSync(dirname(require.resolve('@flowdular/sdk/package.json'))),
+	);
+} catch (error) {
+	if (
+		error.code !== 'MODULE_NOT_FOUND' &&
+		error.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED'
+	)
+		throw error;
+	// The authoring workspace uses ordinary, linked source packages.
+}
+// The host resolves the consumer's SDK before applying worker permissions. This
+// avoids granting the worker access to platform/package.json or following its
+// dependency links outside the permitted physical package roots.
+if (process.env.FD_INTERNAL_SANDBOX_SDK_ROOT)
+	roots.push(realpathSync(process.env.FD_INTERNAL_SANDBOX_SDK_ROOT));
+
+registerHooks({
+	load(url, context, nextLoad) {
+		if (!url.startsWith('file:')) return nextLoad(url, context);
+		const path = resolve(fileURLToPath(url));
+		if (
+			!path.endsWith('.ts') ||
+			!roots.some((root) => path.startsWith(root + sep))
+		) {
+			return nextLoad(url, context);
+		}
+		return {
+			format: 'module',
+			source: stripTypeScriptTypes(readFileSync(path, 'utf8'), {
+				mode: 'transform',
+				sourceUrl: url,
+			}),
+			shortCircuit: true,
+		};
+	},
+});