@sandblocks/cli 0.5.0-b.0 → 0.5.0-b.2

package/dist/runtime.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+// src/runtime.ts
+import { spawn } from "node:child_process";
+import { access, chmod, mkdir, readdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+var RUNTIME_PATTERN = /^[a-z][a-z0-9-]{0,62}$/;
+var NODE_ENV_RUNTIME = {
+  production: "prod",
+  development: "dev",
+  test: "local"
+};
+async function runRuntimeCommand(args) {
+  const [action, ...rest] = args;
+  if (action !== "prepare")
+    throw new Error("runtime action must be prepare");
+  const options = parse(rest);
+  const root = path.resolve(options.positionals[0] ?? process.cwd());
+  const runtime = normalizedRuntime(option(options, "runtime") ?? process.env.SANDBLOCKS_RUNTIME ?? "development" ?? "development");
+  const targetRoot = contained(root, option(options, "target") ?? ".locker", "runtime target");
+  const runtimeRoot = path.join(targetRoot, runtime);
+  const config = contained(root, option(options, "config") ?? "config/dotlocker.config.ts", "Dotlocker config");
+  const dotlocker = path.resolve(root, option(options, "dotlocker") ?? path.join("node_modules", ".bin", "dotlocker"));
+  if (!await exists(config))
+    throw new Error(`Dotlocker config does not exist: ${config}`);
+  if (!await exists(dotlocker)) {
+    throw new Error("Dotlocker is not installed; add @dotlocker/dotlocker to the workspace");
+  }
+  await rm(targetRoot, { recursive: true, force: true });
+  await mkdir(runtimeRoot, { recursive: true, mode: 493 });
+  await run(dotlocker, ["pull", "--config", config, "--runtime", runtime, "--out", runtimeRoot], root);
+  const envFile = path.join(runtimeRoot, ".env");
+  if (!await exists(envFile)) {
+    throw new Error(`Dotlocker did not materialize ${path.relative(root, envFile)}`);
+  }
+  await normalizePermissions(targetRoot);
+  console.log(`runtime   ${runtime}
+environment ${path.relative(root, envFile)}`);
+}
+function run(executable, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(executable, args, { cwd, env: process.env, stdio: "inherit" });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (code === 0)
+        resolve();
+      else
+        reject(new Error(`Dotlocker pull failed (${signal ? `signal ${signal}` : `exit ${code ?? "unknown"}`})`));
+    });
+  });
+}
+async function exists(file) {
+  try {
+    await access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizedRuntime(value) {
+  const runtime = NODE_ENV_RUNTIME[value.trim()] ?? value.trim();
+  if (!RUNTIME_PATTERN.test(runtime))
+    throw new Error(`invalid runtime '${value}'`);
+  return runtime;
+}
+function contained(root, value, label) {
+  const resolved = path.resolve(root, value);
+  const relative = path.relative(root, resolved);
+  if (!relative || !relative.startsWith("..") && !path.isAbsolute(relative))
+    return resolved;
+  throw new Error(`${label} must remain within the repository`);
+}
+async function normalizePermissions(directory) {
+  await chmod(directory, 493);
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const child = path.join(directory, entry.name);
+    if (entry.isSymbolicLink())
+      throw new Error("Dotlocker output must not contain symbolic links");
+    if (entry.isDirectory())
+      await normalizePermissions(child);
+    else if (entry.isFile())
+      await chmod(child, 420);
+    else
+      throw new Error("Dotlocker output contains an unsupported file type");
+  }
+}
+function parse(args) {
+  const options = { positionals: [] };
+  for (let index = 0;index < args.length; index += 1) {
+    const value = args[index] ?? "";
+    if (!value.startsWith("--")) {
+      options.positionals.push(value);
+      continue;
+    }
+    const key = value.slice(2);
+    const next = args[index + 1];
+    if (next && !next.startsWith("--")) {
+      options[key] = next;
+      index += 1;
+    } else
+      options[key] = true;
+  }
+  return options;
+}
+function option(options, key) {
+  const value = options[key];
+  return typeof value === "string" ? value : undefined;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+  runRuntimeCommand(process.argv.slice(2)).catch((error) => {
+    console.error(`sandblocks-runtime: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  });
+}
+export {
+  runRuntimeCommand
+};

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@sandblocks/cli",
-  "version": "0.5.0-b.0",
+  "version": "0.5.0-b.2",
   "type": "module",
   "description": "Sandblocks command-line interface for workspaces, deployments, and agent sandboxes.",
   "bin": {
-    "sandblocks": "dist/cli.js"
+    "sandblocks": "dist/cli.js",
+    "sandblocks-runtime": "dist/runtime.js"
   },
   "files": [
     "dist"
   ],
   "scripts": {
     "start": "bun src/cli.ts",
-    "build": "rm -rf dist && bun build src/cli.ts --outdir dist --target=bun --format=esm --sourcemap=external",
+    "build": "rm -rf dist && bun build src/cli.ts --outdir dist --target=bun --format=esm --sourcemap=external && bun build src/runtime.ts --outfile dist/runtime.js --target=node --format=esm",
     "test": "bun test",
     "prepack": "bun run build && bun run test"
   },