@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0

package/dist/webcontainer-XWCE56F3.js

@@ -0,0 +1,281 @@
+import {
+  asStringArray,
+  buildContainerLiteCommand,
+  extractUrls,
+  isRecord,
+  validateContainerLiteNetworkPolicy
+} from "./chunk-YJEZWCYV.js";
+import "./chunk-UJDUQNE2.js";
+import {
+  WebContainerManager,
+  WebContainerManager_default
+} from "./chunk-LLGZTP3G.js";
+import "./chunk-DKFJIILR.js";
+import "./chunk-KHR7ZYCX.js";
+import "./chunk-QWZRZKLZ.js";
+import "./chunk-OSSRZOGC.js";
+import "./chunk-TSQ3BGLA.js";
+import "./chunk-2WTYE4SW.js";
+import "./chunk-QJFKEQHF.js";
+import "./chunk-WGBCRNMB.js";
+import "./chunk-3LFMIVJM.js";
+import "./chunk-AFDUOYHD.js";
+import "./chunk-NTMBOESX.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/machines/core/webcontainer-adapter.ts
+var WebContainerAdapter = class _WebContainerAdapter {
+  static instance = null;
+  constructor() {
+  }
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new _WebContainerAdapter();
+    }
+    return this.instance;
+  }
+  getManager() {
+    return WebContainerManager.getExistingInstance();
+  }
+  /**
+   * Check if WebContainer is available
+   */
+  isAvailable() {
+    return this.getManager() !== null;
+  }
+  /**
+   * Mount a filesystem tree
+   */
+  async mountProject(files, options) {
+    const manager = this.getManager();
+    if (!manager) throw new Error("WebContainerManager not initialized");
+    await manager.mount(files, options);
+  }
+  /**
+   * Install npm dependencies
+   */
+  async installDependencies(opts) {
+    const manager = this.getManager();
+    if (!manager) throw new Error("WebContainerManager not initialized");
+    const process = await manager.spawn("npm", ["install"], { cwd: opts?.cwd });
+    let output = "";
+    const outputPromise = new Promise((resolve) => {
+      process.output.pipeTo(
+        new WritableStream({
+          write(chunk) {
+            output += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+          },
+          close() {
+            resolve();
+          },
+          abort() {
+            resolve();
+          }
+        })
+      ).catch((err) => {
+        console.warn("[WebContainerAdapter] install output pipe failed", err);
+        resolve();
+      });
+    });
+    const exitCode = await process.exit;
+    await outputPromise.catch((err) => console.warn("[WebContainerAdapter] install output collection failed", err));
+    return { exitCode, output };
+  }
+  /**
+   * Spawn a command with captured output
+   */
+  async spawn(cmd, args, opts) {
+    const manager = this.getManager();
+    if (!manager) throw new Error("WebContainerManager not initialized");
+    const process = await manager.spawn(cmd, args, opts);
+    let stdout = "";
+    const outputPromise = new Promise((resolve) => {
+      process.output.pipeTo(
+        new WritableStream({
+          write(chunk) {
+            stdout += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+          },
+          close() {
+            resolve();
+          },
+          abort() {
+            resolve();
+          }
+        })
+      ).catch((err) => {
+        console.warn("[WebContainerAdapter] spawn output pipe failed", err);
+        resolve();
+      });
+    });
+    const exitCode = await process.exit;
+    await outputPromise.catch((err) => console.warn("[WebContainerAdapter] spawn output collection failed", err));
+    return { exitCode, stdout, stderr: "" };
+  }
+  /**
+   * Write a file to the WebContainer filesystem
+   */
+  async writeFile(path, contents) {
+    const manager = this.getManager();
+    if (!manager) throw new Error("WebContainerManager not initialized");
+    const container = manager.getContainer();
+    if (!container) throw new Error("WebContainer not booted");
+    await container.fs.writeFile(path, contents);
+  }
+  /**
+   * Read a file from the WebContainer filesystem
+   */
+  async readFile(path) {
+    const manager = this.getManager();
+    if (!manager) throw new Error("WebContainerManager not initialized");
+    const container = manager.getContainer();
+    if (!container) throw new Error("WebContainer not booted");
+    return await container.fs.readFile(path, "utf-8");
+  }
+};
+var webContainerAdapter = WebContainerAdapter.getInstance();
+
+// ../../lib/terminals-tech/machines/core/runners/webcontainer-session.ts
+var WebContainerSession = class {
+  workdir;
+  manager;
+  adapter;
+  baseTree = null;
+  constructor(options = {}) {
+    const manager = WebContainerManager_default.getInstance({
+      autoInstallDependencies: false,
+      keepAlive: true,
+      suppressLifecycleLogs: true,
+      ...options
+    });
+    if (!manager) {
+      throw new Error("WebContainerManager unavailable.");
+    }
+    this.manager = manager;
+    this.adapter = WebContainerAdapter.getInstance();
+    this.workdir = options.workdir || "/home/project";
+  }
+  isAvailable() {
+    return this.adapter.isAvailable();
+  }
+  async start() {
+    await this.manager.activate();
+  }
+  async mountBaseTree(files) {
+    this.baseTree = files;
+    await this.adapter.mountProject(files, { mountPoint: this.workdir });
+  }
+  async remountBaseTree() {
+    if (!this.baseTree) {
+      throw new Error("WebContainer base tree not initialized.");
+    }
+    await this.adapter.mountProject(this.baseTree, { mountPoint: this.workdir });
+  }
+  async installDependencies(cwd = this.workdir) {
+    return this.adapter.installDependencies({ cwd });
+  }
+  async exec(command, args = [], options = {}) {
+    return this.adapter.spawn(command, args, {
+      cwd: options.cwd || this.workdir,
+      env: options.env
+    });
+  }
+  async writeFile(path, contents) {
+    await this.adapter.writeFile(path, contents);
+  }
+  async readFile(path) {
+    return this.adapter.readFile(path);
+  }
+  async writeWorkspaceFile(relativePath, contents) {
+    const normalizedPath = relativePath.startsWith("/") ? relativePath : `${this.workdir}/${relativePath}`;
+    await this.adapter.writeFile(normalizedPath, contents);
+  }
+  async readWorkspaceFile(relativePath) {
+    const normalizedPath = relativePath.startsWith("/") ? relativePath : `${this.workdir}/${relativePath}`;
+    return this.adapter.readFile(normalizedPath);
+  }
+  async destroy() {
+    await this.manager.destroy();
+  }
+};
+
+// ../../lib/terminals-tech/machines/core/runners/webcontainer.ts
+async function runInWebContainer(manifest, input, ctx) {
+  const urls = extractUrls(input);
+  if (urls.length > 0) {
+    const validation = await validateContainerLiteNetworkPolicy(urls, ctx);
+    if (!validation.allowed) {
+      return {
+        input,
+        runtime: "webcontainer:policy-denied",
+        error: `Network egress denied for URL: ${validation.deniedUrl}`
+      };
+    }
+  }
+  let session;
+  try {
+    session = new WebContainerSession();
+  } catch (error) {
+    return {
+      input,
+      runtime: "webcontainer:error",
+      error: error instanceof Error ? error.message : "WebContainerManager not initialized"
+    };
+  }
+  try {
+    await session.start();
+    const manifestWithFs = manifest;
+    const fsTree = manifestWithFs.filesystem || input.filesystem;
+    if (fsTree && typeof fsTree === "object") {
+      await session.mountBaseTree(fsTree);
+    } else {
+      await session.mountBaseTree({
+        "README.md": { file: { contents: "# Terminals WebContainer" } }
+      });
+    }
+    const packageJson = fsTree?.["package.json"];
+    if (packageJson) {
+      const { exitCode: exitCode2, output } = await session.installDependencies();
+      if (exitCode2 !== 0) {
+        return {
+          input,
+          runtime: "webcontainer",
+          exitCode: exitCode2,
+          error: "npm install failed",
+          npmOutput: output
+        };
+      }
+    }
+    const ep = manifest.entrypoints?.webcontainer;
+    const cmd = typeof input.command === "string" && input.command || ep?.command || "node";
+    const args = Array.isArray(input.args) ? input.args.filter((value) => typeof value === "string") : ep?.args || ["-e", 'console.log("webcontainer-ok")'];
+    const cwd = typeof input.cwd === "string" ? input.cwd : ep?.cwd ? `${session.workdir}/${ep.cwd}` : session.workdir;
+    const env = isRecord(input.env) ? Object.fromEntries(
+      Object.entries(input.env).filter((entry) => typeof entry[1] === "string").map(([key, value]) => [key, value])
+    ) : {};
+    const bootstrapCommands = asStringArray(input.bootstrapCommands);
+    for (const command of bootstrapCommands) {
+      await session.exec("sh", ["-c", command], { cwd });
+    }
+    const { exitCode, stdout, stderr } = await session.exec(cmd, args, {
+      cwd,
+      env
+    });
+    return {
+      input,
+      runtime: "webcontainer",
+      exitCode,
+      stdout,
+      stderr,
+      commandPreview: buildContainerLiteCommand(cmd, args, env)
+    };
+  } catch (error) {
+    return {
+      input,
+      runtime: "webcontainer:error",
+      error: error.message
+    };
+  }
+}
+export {
+  runInWebContainer
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@terminals-tech/sdk",
-  "version": "1.0.0-rc.1",
-  "description": "Private Terminals OS SDK facade for internal packaging and dry-run verification. Patent Pending.",
+  "version": "1.0.0",
+  "description": "Terminals OS SDK — observable, coherence-aware primitives for building intelligent software. Patent Pending.",
   "license": "BUSL-1.1",
   "author": "Intuition Labs LLC",
   "notice": "Terminals OS architecture is Patent Pending. © 2026 Intuition Labs LLC.",
@@ -34,13 +34,19 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts --out-dir dist",
+    "build": "tsup src/index.ts --format esm,cjs --dts --out-dir dist --external @electric-sql/pglite --external onnxruntime-node --external @huggingface/transformers --external sharp --external rxjs --external @xenova/transformers",
     "clean": "rm -rf dist",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "pack:dry-run": "npm run build && npm pack --json --dry-run --ignore-scripts",
     "publish:check": "npm run clean && npm run build && node ../../scripts/verify-sdk-package.mjs",
     "prepack": "npm run build"
   },
+  "dependencies": {
+    "rxjs": "^7.8.0"
+  },
+  "optionalDependencies": {
+    "@electric-sql/pglite": ">=0.2.0"
+  },
   "peerDependencies": {
     "typescript": ">=5.0.0"
   }