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

package/dist/container-lite-QD3CRLS4.js

@@ -0,0 +1,327 @@
+import {
+  DEFAULT_CONTAINER_LITE_IMAGE,
+  DEFAULT_CONTAINER_LITE_TIMEOUT_MS,
+  asStringArray,
+  buildContainerLiteCommand,
+  extractUrls,
+  flattenFilesystemTree,
+  isRecord,
+  resolveContainerLiteCwd,
+  shellQuote,
+  validateContainerLiteNetworkPolicy
+} from "./chunk-YJEZWCYV.js";
+import "./chunk-UJDUQNE2.js";
+import {
+  runners
+} from "./chunk-PPFTKJDB.js";
+import "./chunk-KASHT6C5.js";
+import "./chunk-H3POJCFA.js";
+import "./chunk-KHR7ZYCX.js";
+import "./chunk-PWAHFID5.js";
+import "./chunk-Y2EULKA2.js";
+import "./chunk-WU4OTGJE.js";
+import "./chunk-OCLSAUCD.js";
+import "./chunk-BYXBJQAS.js";
+import "./chunk-BCOQMFKT.js";
+import "./chunk-2WTYE4SW.js";
+import "./chunk-FOXUEYWK.js";
+import "./chunk-EXI3LJVJ.js";
+import "./chunk-QJFKEQHF.js";
+import "./chunk-ZVO47SQV.js";
+import "./chunk-XPJ63Y6T.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/runners/container-lite-session.ts
+import path2 from "path";
+
+// ../../lib/terminals-tech/machines/core/runners/container-lite-adapter.ts
+import { spawnSync } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+var DEFAULT_COMMAND_TIMEOUT_MS = 12e4;
+function shellQuote2(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function tailText(value, maxChars = 2e3) {
+  if (value.length <= maxChars) {
+    return value;
+  }
+  return value.slice(value.length - maxChars);
+}
+function sanitizeName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 80) || "artifact";
+}
+var ContainerLiteAdapter = class {
+  containerName;
+  workdir;
+  image;
+  scratchDir;
+  defaultTimeoutMs;
+  maxBufferBytes;
+  constructor(options) {
+    this.containerName = `terminals-swe-${sanitizeName(options.name)}`;
+    this.workdir = options.workdir ?? "/workspace";
+    this.image = options.image;
+    this.defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+    this.maxBufferBytes = options.maxBufferBytes ?? 16 * 1024 * 1024;
+    this.scratchDir = mkdtempSync(path.join(os.tmpdir(), "terminals-swe-"));
+  }
+  ensureDockerAvailable() {
+    const result = this.runDocker(["version"], this.defaultTimeoutMs);
+    if (result.exitCode !== 0) {
+      throw new Error(this.formatFailure("docker version", result));
+    }
+  }
+  start(command = ["tail", "-f", "/dev/null"]) {
+    this.ensureDockerAvailable();
+    this.removeContainer();
+    const runResult = this.runDocker([
+      "run",
+      "-d",
+      "--name",
+      this.containerName,
+      this.image,
+      ...command
+    ]);
+    if (runResult.exitCode !== 0) {
+      throw new Error(this.formatFailure(runResult.command, runResult));
+    }
+  }
+  exec(command, options = {}) {
+    const result = this.runDocker(
+      ["exec", this.containerName, "bash", "-lc", command],
+      options.timeoutMs ?? this.defaultTimeoutMs
+    );
+    if (!options.allowFailure && result.exitCode !== 0) {
+      throw new Error(this.formatFailure(command, result));
+    }
+    return result;
+  }
+  writeText(targetPath, content) {
+    const localPath = path.join(
+      this.scratchDir,
+      `${sanitizeName(path.basename(targetPath))}-${Date.now()}`
+    );
+    writeFileSync(localPath, content, "utf8");
+    const result = this.runDocker(["cp", localPath, `${this.containerName}:${targetPath}`]);
+    if (result.exitCode !== 0) {
+      throw new Error(this.formatFailure(`docker cp ${localPath} ${targetPath}`, result));
+    }
+  }
+  readText(relativePath) {
+    const result = this.exec(
+      `cd ${shellQuote2(this.workdir)} && python -c ${shellQuote2(
+        "from pathlib import Path; import sys; print(Path(sys.argv[1]).read_text(encoding='utf-8', errors='ignore'))"
+      )} ${shellQuote2(relativePath)}`
+    );
+    return result.stdout;
+  }
+  listChangedFiles(glob) {
+    const result = this.exec(
+      `cd ${shellQuote2(this.workdir)} && git diff --name-only --diff-filter=ACM -- ${shellQuote2(glob)}`,
+      { allowFailure: true }
+    );
+    return result.stdout.split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean);
+  }
+  reset() {
+    this.exec(`cd ${shellQuote2(this.workdir)} && git reset --hard HEAD && git clean -fd`);
+  }
+  destroy() {
+    this.removeContainer();
+    this.releaseScratch();
+  }
+  releaseScratch() {
+    rmSync(this.scratchDir, { recursive: true, force: true });
+  }
+  formatFailure(command, result) {
+    return [
+      `Command failed: ${command}`,
+      `Exit code: ${result.exitCode}`,
+      result.stdout ? `STDOUT:
+${tailText(result.stdout)}` : "",
+      result.stderr ? `STDERR:
+${tailText(result.stderr)}` : ""
+    ].filter(Boolean).join("\n\n");
+  }
+  removeContainer() {
+    this.runDocker(["rm", "-f", this.containerName], this.defaultTimeoutMs);
+  }
+  runDocker(args, timeoutMs = this.defaultTimeoutMs) {
+    const result = spawnSync("docker", args, {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      maxBuffer: this.maxBufferBytes
+    });
+    const timedOut = result.error?.message?.toLowerCase().includes("timed out") ?? false;
+    const exitCode = typeof result.status === "number" ? result.status : timedOut ? 124 : 1;
+    const stderr = timedOut ? `${result.stderr ?? ""}
+Command timed out after ${timeoutMs}ms.` : `${result.stderr ?? ""}${result.error && !timedOut ? `
+${String(result.error.message ?? result.error)}` : ""}`;
+    return {
+      command: ["docker", ...args].join(" "),
+      stdout: result.stdout ?? "",
+      stderr,
+      exitCode
+    };
+  }
+};
+
+// ../../lib/terminals-tech/machines/core/runners/container-lite-session.ts
+var ContainerLiteSession = class {
+  adapter;
+  constructor(options) {
+    this.adapter = new ContainerLiteAdapter({
+      name: options.name,
+      image: options.image,
+      workdir: options.workdir
+    });
+  }
+  get containerName() {
+    return this.adapter.containerName;
+  }
+  get workdir() {
+    return this.adapter.workdir;
+  }
+  start() {
+    this.adapter.start();
+  }
+  ensureWorkspace() {
+    this.adapter.exec(`mkdir -p ${shellQuote(this.workdir)}`);
+  }
+  cloneRepository(repositoryUrl, checkout, timeoutMs = DEFAULT_CONTAINER_LITE_TIMEOUT_MS) {
+    this.adapter.exec(`git clone ${shellQuote(repositoryUrl)} ${shellQuote(this.workdir)}`, {
+      timeoutMs: timeoutMs * 3
+    });
+    if (checkout) {
+      this.adapter.exec(`cd ${shellQuote(this.workdir)} && git checkout ${shellQuote(checkout)}`, {
+        timeoutMs
+      });
+    }
+  }
+  materializeFilesystem(tree) {
+    const files = flattenFilesystemTree(tree);
+    this.writeFiles(files);
+  }
+  writeFiles(files) {
+    for (const file of files) {
+      const targetPath = path2.posix.join(this.workdir, file.path);
+      const targetDir = path2.posix.dirname(targetPath);
+      this.adapter.exec(`mkdir -p ${shellQuote(targetDir)}`);
+      this.adapter.writeText(targetPath, file.content);
+    }
+  }
+  writeWorkspaceFile(relativePath, content) {
+    const targetPath = path2.posix.join(this.workdir, relativePath);
+    const targetDir = path2.posix.dirname(targetPath);
+    this.adapter.exec(`mkdir -p ${shellQuote(targetDir)}`);
+    this.adapter.writeText(targetPath, content);
+  }
+  writeTempFile(label, content) {
+    const targetPath = `/tmp/${label}-${Date.now()}`;
+    this.adapter.writeText(targetPath, content);
+    return targetPath;
+  }
+  runBootstrap(commands, timeoutMs = DEFAULT_CONTAINER_LITE_TIMEOUT_MS) {
+    for (const command of commands) {
+      this.execInWorkspace(command, { timeoutMs: timeoutMs * 3 });
+    }
+  }
+  exec(command, options = {}) {
+    return this.adapter.exec(command, options);
+  }
+  execInWorkspace(command, options = {}) {
+    const cwd = resolveContainerLiteCwd(this.workdir, options.cwd);
+    return this.adapter.exec(`cd ${shellQuote(cwd)} && ${command}`, options);
+  }
+  readWorkspaceFile(relativePath) {
+    return this.adapter.readText(relativePath);
+  }
+  listChangedFiles(glob) {
+    return this.adapter.listChangedFiles(glob);
+  }
+  resetWorkspace() {
+    this.adapter.reset();
+  }
+  releaseScratch() {
+    this.adapter.releaseScratch();
+  }
+  destroy() {
+    this.adapter.destroy();
+  }
+};
+
+// ../../lib/terminals-tech/machines/core/runners/container-lite.ts
+async function runInContainerLite(manifest, input, ctx) {
+  const urls = extractUrls(input);
+  if (urls.length > 0) {
+    const validation = await validateContainerLiteNetworkPolicy(urls, ctx);
+    if (!validation.allowed) {
+      return {
+        input,
+        runtime: "container-lite:policy-denied",
+        error: `Network egress denied for URL: ${validation.deniedUrl}`
+      };
+    }
+  }
+  const entry = manifest.entrypoints["container-lite"];
+  if (!entry) {
+    throw new Error(`Manifest ${manifest.id} is missing a container-lite entrypoint.`);
+  }
+  const metadata = isRecord(manifest.metadata) ? manifest.metadata.containerLite ?? {} : {};
+  const image = typeof input.containerImage === "string" && input.containerImage || metadata.image || DEFAULT_CONTAINER_LITE_IMAGE;
+  const session = new ContainerLiteSession({
+    name: `${ctx.stackId}-${ctx.nodeId}`,
+    image
+  });
+  try {
+    session.start();
+    const repositoryUrl = typeof input.repositoryUrl === "string" && input.repositoryUrl || metadata.repositoryUrl;
+    const checkout = typeof input.checkout === "string" && input.checkout || metadata.checkout;
+    if (repositoryUrl) {
+      session.cloneRepository(repositoryUrl, checkout, DEFAULT_CONTAINER_LITE_TIMEOUT_MS);
+    } else {
+      session.ensureWorkspace();
+    }
+    session.materializeFilesystem(
+      manifest.filesystem
+    );
+    session.materializeFilesystem(input.filesystem);
+    session.runBootstrap(
+      [...asStringArray(metadata.bootstrapCommands), ...asStringArray(input.bootstrapCommands)],
+      DEFAULT_CONTAINER_LITE_TIMEOUT_MS
+    );
+    const command = typeof input.command === "string" && input.command || entry.command;
+    const args = Array.isArray(input.args) ? input.args.filter((value) => typeof value === "string") : entry.args || [];
+    const env = isRecord(input.env) ? Object.fromEntries(
+      Object.entries(input.env).filter((entry2) => typeof entry2[1] === "string").map(([key, value]) => [key, value])
+    ) : {};
+    const requestedCwd = typeof input.cwd === "string" ? input.cwd : entry.cwd;
+    const cwd = resolveContainerLiteCwd(session.workdir, requestedCwd);
+    const timeoutMs = typeof input.timeoutMs === "number" ? input.timeoutMs : DEFAULT_CONTAINER_LITE_TIMEOUT_MS;
+    const result = session.execInWorkspace(buildContainerLiteCommand(command, args, env), {
+      allowFailure: true,
+      timeoutMs,
+      cwd
+    });
+    return {
+      input,
+      runtime: "container-lite",
+      image,
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      cwd
+    };
+  } finally {
+    session.destroy();
+  }
+}
+runners.registerRunner("container-lite", runInContainerLite);
+export {
+  runInContainerLite
+};

package/dist/core-H2UUDATO.js

@@ -0,0 +1,146 @@
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/core/base/adapters.ts
+async function core() {
+  return await import("./dist-VXJEKX3T.js");
+}
+function makeTimeline(windowISO) {
+  const windowMs = (() => {
+    try {
+      if (!windowISO) return 6e4;
+      return /PT(\d+)M/.test(windowISO) ? Number(RegExp.$1) * 6e4 : 6e4;
+    } catch {
+      return 6e4;
+    }
+  })();
+  return {
+    process(events) {
+      const now = Date.now();
+      const start = now - windowMs;
+      const windowEvents = (Array.isArray(events) ? events : []).filter((e) => {
+        const t = typeof e?.t === "number" ? e.t : Date.parse(e?.time || e?.timestamp || "");
+        return Number.isFinite(t) && t >= start && t <= now;
+      });
+      const ticks = [now];
+      return { windowEvents, ticks };
+    }
+  };
+}
+function temporalKV() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    handle(input) {
+      if (input?.put) {
+        const { key, value, ttlMs } = input.put;
+        store.set(String(key), {
+          t: Date.now(),
+          v: value,
+          ttl: typeof ttlMs === "number" ? ttlMs : void 0
+        });
+      }
+      if (input?.get) {
+        const { key } = input.get;
+        const rec = store.get(String(key));
+        if (!rec) return { value: null };
+        if (rec.ttl && Date.now() - rec.t > rec.ttl) {
+          store.delete(String(key));
+          return { value: null };
+        }
+        return { value: rec.v };
+      }
+      if (input?.query?.sinceMs) {
+        const since = Date.now() - Number(input.query.sinceMs);
+        const items = Array.from(store.entries()).filter(([, rec]) => rec.t >= since).map(([k, rec]) => ({ key: k, value: rec.v, at: rec.t }));
+        return { items };
+      }
+      return {};
+    }
+  };
+}
+function fieldStore3d() {
+  const points = [];
+  return {
+    handle(input) {
+      if (Array.isArray(input?.upsert)) {
+        for (const p of input.upsert) {
+          const { x, y, z, t, ...a } = p || {};
+          points.push({
+            x: Number(x) || 0,
+            y: Number(y) || 0,
+            z: Number(z) || 0,
+            t: typeof t === "number" ? t : void 0,
+            a
+          });
+        }
+      }
+      if (input?.query) {
+        const { box, sinceMs, limit = 256 } = input.query;
+        let res = points;
+        if (box) {
+          const { min, max } = box;
+          res = res.filter(
+            (p) => p.x >= min[0] && p.y >= min[1] && p.z >= min[2] && p.x <= max[0] && p.y <= max[1] && p.z <= max[2]
+          );
+        }
+        if (sinceMs) {
+          const since = Date.now() - Number(sinceMs);
+          res = res.filter((p) => (p.t || 0) >= since);
+        }
+        return { points: res.slice(0, limit) };
+      }
+      return { count: points.length };
+    }
+  };
+}
+function zeroAgent() {
+  return {
+    async handle(input) {
+      const { prompt, memory } = input || {};
+      const c = await core();
+      try {
+        const llm = c?.llm;
+        if (llm?.chat) {
+          const out = await llm.chat({
+            messages: [{ role: "user", content: String(prompt || "") }],
+            memory
+          });
+          return {
+            messages: out?.messages || [],
+            artifacts: out?.artifacts || []
+          };
+        }
+      } catch {
+      }
+      return {
+        messages: [{ role: "assistant", content: String(prompt || "") }]
+      };
+    }
+  };
+}
+function httpOracle(policies) {
+  return {
+    async handle(input) {
+      const req = input?.request || input;
+      const url = req?.url || req?.href;
+      const method = (req?.method || "GET").toUpperCase();
+      const allow = policies?.network?.allowList;
+      if (allow && !allow.some((a) => String(url || "").startsWith(a))) {
+        throw new Error("network egress blocked by policy");
+      }
+      const res = await fetch(String(url), {
+        method,
+        headers: req?.headers || {},
+        body: req?.body ? JSON.stringify(req.body) : void 0
+      });
+      const text = await res.text();
+      return { response: { status: res.status, ok: res.ok, body: text } };
+    }
+  };
+}
+export {
+  fieldStore3d,
+  httpOracle,
+  makeTimeline,
+  temporalKV,
+  zeroAgent
+};

package/dist/crypto-D4LMI2RN.js

@@ -0,0 +1,45 @@
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/machines/core/crypto.ts
+import crypto from "crypto";
+function getKey() {
+  const raw = process.env.TERMINALS_VAULT_KEY || "";
+  if (!raw) throw new Error("TERMINALS_VAULT_KEY is not set");
+  try {
+    return Buffer.from(raw, "base64");
+  } catch {
+  }
+  try {
+    return Buffer.from(raw, "hex");
+  } catch {
+  }
+  const buf = Buffer.alloc(32);
+  buf.write(raw.slice(0, 32), "utf8");
+  return buf;
+}
+function encrypt(value) {
+  const key = getKey();
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key.slice(0, 32), iv);
+  const ct = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("base64"),
+    ct: Buffer.concat([ct, tag]).toString("base64")
+  };
+}
+function decrypt(payload) {
+  const key = getKey();
+  const iv = Buffer.from(payload.iv, "base64");
+  const data = Buffer.from(payload.ct, "base64");
+  const tag = data.slice(data.length - 16);
+  const body = data.slice(0, data.length - 16);
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key.slice(0, 32), iv);
+  decipher.setAuthTag(tag);
+  const pt = Buffer.concat([decipher.update(body), decipher.final()]);
+  return pt.toString("utf8");
+}
+export {
+  decrypt,
+  encrypt
+};

package/dist/db-BWC2GGBN.js

@@ -0,0 +1,50 @@
+import {
+  PGLiteConnectionPool,
+  checkConnectionPoolHealth,
+  forceHardReset,
+  forceRecycleStale,
+  getConnectionPoolStats,
+  getCurrentDataDir,
+  getCurrentScope,
+  getDB,
+  getDataDirForScope,
+  getDatabase,
+  getDbHealth,
+  getDbInitStatus,
+  getPoolStatus,
+  getSchemaVersion,
+  isDatabaseReady,
+  onDbInitStatusChange,
+  restartDbInit,
+  retryDbInit,
+  setDbScope,
+  shutdownPool,
+  withDB,
+  withTransaction
+} from "./chunk-AFDUOYHD.js";
+import "./chunk-NTMBOESX.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  PGLiteConnectionPool,
+  checkConnectionPoolHealth,
+  forceHardReset,
+  forceRecycleStale,
+  getConnectionPoolStats,
+  getCurrentDataDir,
+  getCurrentScope,
+  getDB,
+  getDataDirForScope,
+  getDatabase,
+  getDbHealth,
+  getDbInitStatus,
+  getPoolStatus,
+  getSchemaVersion,
+  isDatabaseReady,
+  onDbInitStatusChange,
+  restartDbInit,
+  retryDbInit,
+  setDbScope,
+  shutdownPool,
+  withDB,
+  withTransaction
+};

package/dist/demo-T655Z5S4.js

@@ -0,0 +1,87 @@
+import {
+  runners
+} from "./chunk-PPFTKJDB.js";
+import "./chunk-KASHT6C5.js";
+import "./chunk-H3POJCFA.js";
+import "./chunk-KHR7ZYCX.js";
+import "./chunk-PWAHFID5.js";
+import "./chunk-Y2EULKA2.js";
+import "./chunk-WU4OTGJE.js";
+import {
+  registerNode
+} from "./chunk-OCLSAUCD.js";
+import "./chunk-BYXBJQAS.js";
+import "./chunk-BCOQMFKT.js";
+import "./chunk-2WTYE4SW.js";
+import "./chunk-FOXUEYWK.js";
+import "./chunk-EXI3LJVJ.js";
+import "./chunk-QJFKEQHF.js";
+import "./chunk-ZVO47SQV.js";
+import "./chunk-XPJ63Y6T.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/runners/demo.ts
+registerNode({
+  id: "system.input.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Stack Input",
+  description: "Defines the inputs for a stack.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: { type: "object" },
+  // Freeform input
+  outputsSchema: { type: "object" }
+  // Outputs whatever it receives
+});
+registerNode({
+  id: "system.output.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Stack Output",
+  description: "Defines the outputs of a stack.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: { type: "object" },
+  // Freeform input
+  outputsSchema: { type: "object" }
+  // Outputs whatever it receives
+});
+runners.registerWorker("system.input.v1", async (manifest, input) => {
+  return input;
+});
+runners.registerWorker("system.output.v1", async (manifest, input) => {
+  return input;
+});
+runners.registerWorker("demo.echo.v1", async (manifest, input) => {
+  return { echoed: input };
+});
+runners.registerWorker("demo.webhook.post.v1", async (manifest, input, ctx) => {
+  const webhookInput = input;
+  const url = webhookInput.url;
+  const body = webhookInput.body;
+  const token = webhookInput.__secrets?.AUTH_TOKEN;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    },
+    body: JSON.stringify(body)
+  });
+  return { status: res.status, ok: res.ok, body: await res.text() };
+});
+runners.registerWorker("astro.transform.extractObsIds.v1", async (_manifest, input) => {
+  const obsInput = input;
+  const rows = Array.isArray(obsInput?.rows) ? obsInput.rows : [];
+  const ids = Array.from(
+    new Set(
+      rows.map((r) => r?.obsid ?? r?.parentID ?? r?.observationId).filter((v) => v !== void 0)
+    )
+  );
+  return { obsids: ids };
+});