@cybernetyx1/atlasflow-runtime 0.1.0

package/dist/chunk-4DU4GJ2X.js

@@ -0,0 +1,347 @@
+// src/sandbox.ts
+function sandboxHeaderFromEnv(env, options = {}) {
+  if (!env || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(env)) throw new Error(`Invalid sandbox credential env name: ${env}`);
+  return { env, prefix: options.prefix, required: options.required };
+}
+function resolveSandboxNetworkPolicy(policy, env = {}) {
+  if (!policy) return void 0;
+  const allowedUrlPrefixes = policy.allowedUrlPrefixes?.map((entry) => {
+    if (typeof entry === "string") return entry;
+    const headers = resolveSandboxHeaders(entry.headers, env);
+    return Object.keys(headers).length ? { url: entry.url, transform: [{ headers }] } : { url: entry.url };
+  });
+  return {
+    ...policy,
+    allowedUrlPrefixes
+  };
+}
+function resolveSandboxHeaders(headers, env) {
+  const out = {};
+  for (const [name, value] of Object.entries(headers ?? {})) {
+    const resolved = resolveSandboxHeaderValue(value, env);
+    if (resolved !== void 0) out[name] = resolved;
+  }
+  return out;
+}
+function resolveSandboxHeaderValue(value, env) {
+  if (typeof value === "string") return value;
+  const raw = env[value.env];
+  if (typeof raw === "string" && raw.length > 0) return `${value.prefix ?? ""}${raw}`;
+  if (value.required === false) return void 0;
+  throw new Error(`Sandbox network credential "${value.env}" is not configured.`);
+}
+function defineSandbox(input) {
+  if (isSandboxFactory(input)) return input;
+  let bootstrapped;
+  return {
+    async createSessionEnv(options) {
+      const ctx = { id: options.id, cwd: options.cwd, env: options.env };
+      if (!bootstrapped) bootstrapped = Promise.resolve(input.bootstrap?.(ctx)).then(() => void 0);
+      await bootstrapped;
+      const factory = typeof input.factory === "function" ? input.factory(ctx) : input.factory;
+      if (!isSandboxFactory(factory)) throw new Error("defineSandbox factory must return a SandboxFactory.");
+      const env = await factory.createSessionEnv(options);
+      await input.onSession?.(env, ctx);
+      if (!input.cleanup) return env;
+      const wrapped = {
+        cwd: env.cwd,
+        resolvePath: (path) => env.resolvePath(path),
+        exec: (command, execOptions) => env.exec(command, execOptions),
+        scope: env.scope ? (scopeOptions) => env.scope(scopeOptions) : void 0,
+        readFile: (path) => env.readFile(path),
+        readFileBuffer: (path) => env.readFileBuffer(path),
+        writeFile: (path, data) => env.writeFile(path, data),
+        stat: (path) => env.stat(path),
+        readdir: (path) => env.readdir(path),
+        exists: (path) => env.exists(path),
+        mkdir: (path, mkdirOptions) => env.mkdir(path, mkdirOptions),
+        rm: (path, rmOptions) => env.rm(path, rmOptions),
+        dispose: async () => {
+          try {
+            await env.dispose?.();
+          } finally {
+            await input.cleanup?.(ctx);
+          }
+        }
+      };
+      return wrapped;
+    }
+  };
+}
+function sandboxCascade(entries) {
+  if (!entries.length) throw new Error("sandboxCascade requires at least one provider.");
+  return {
+    async createSessionEnv(options) {
+      const ctx = { id: options.id, cwd: options.cwd, env: options.env };
+      const skipped = [];
+      const failures = [];
+      for (const [index, entry] of entries.entries()) {
+        const name = sandboxProviderName(entry, index);
+        try {
+          const provider = normalizeCascadeEntry(entry);
+          if (provider.when && !await provider.when(ctx)) {
+            skipped.push(name);
+            continue;
+          }
+          const factory = typeof provider.factory === "function" ? await provider.factory(ctx) : provider.factory;
+          if (!factory) {
+            skipped.push(name);
+            continue;
+          }
+          if (!isSandboxFactory(factory)) throw new Error("provider did not return a SandboxFactory.");
+          return await factory.createSessionEnv(options);
+        } catch (err) {
+          failures.push(`${name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      const detail = [
+        failures.length ? `failed [${failures.join("; ")}]` : void 0,
+        skipped.length ? `skipped [${skipped.join(", ")}]` : void 0
+      ].filter(Boolean);
+      throw new Error(`No sandbox provider could create a session${detail.length ? `: ${detail.join("; ")}` : "."}`);
+    }
+  };
+}
+function normalizeCascadeEntry(entry) {
+  return isSandboxFactory(entry) ? { name: "sandbox", factory: entry } : entry;
+}
+function sandboxProviderName(entry, index) {
+  if (isSandboxFactory(entry)) return `provider-${index + 1}`;
+  return entry.name || `provider-${index + 1}`;
+}
+function isSandboxFactory(value) {
+  return typeof value === "object" && value !== null && typeof value.createSessionEnv === "function";
+}
+function makeFs(env) {
+  return {
+    readFile: (p) => env.readFile(p),
+    readFileBuffer: (p) => env.readFileBuffer(p),
+    writeFile: (p, d) => env.writeFile(p, d),
+    stat: (p) => env.stat(p),
+    readdir: (p) => env.readdir(p),
+    exists: (p) => env.exists(p),
+    mkdir: (p, o) => env.mkdir(p, o),
+    rm: (p, o) => env.rm(p, o)
+  };
+}
+async function writeFileCreatingParents(write, mkdirParent) {
+  try {
+    await write();
+    return;
+  } catch {
+  }
+  try {
+    await mkdirParent();
+  } catch {
+  }
+  await write();
+}
+function createCwdSessionEnv(parentEnv, cwd) {
+  const scopedCwd = normalizePath(cwd);
+  const resolvePath = makeResolvePath(scopedCwd);
+  return {
+    cwd: scopedCwd,
+    resolvePath,
+    exec(command, options) {
+      return parentEnv.exec(command, {
+        cwd: options?.cwd !== void 0 ? resolvePath(options.cwd) : scopedCwd,
+        env: options?.env,
+        timeoutMs: options?.timeoutMs,
+        signal: options?.signal
+      });
+    },
+    scope: async (options) => {
+      const commands = options?.commands ?? [];
+      if (commands.length && !parentEnv.scope) {
+        throw new Error(
+          "Cannot use commands: this sandbox does not support scoped command execution. Use the default virtual sandbox or a connector that implements SessionEnv.scope()."
+        );
+      }
+      const scopedParent = parentEnv.scope ? await parentEnv.scope({ commands }) : parentEnv;
+      return createCwdSessionEnv(scopedParent, scopedCwd);
+    },
+    readFile: (p) => parentEnv.readFile(resolvePath(p)),
+    readFileBuffer: (p) => parentEnv.readFileBuffer(resolvePath(p)),
+    writeFile: (p, data) => parentEnv.writeFile(resolvePath(p), data),
+    stat: (p) => parentEnv.stat(resolvePath(p)),
+    readdir: (p) => parentEnv.readdir(resolvePath(p)),
+    exists: (p) => parentEnv.exists(resolvePath(p)),
+    mkdir: (p, options) => parentEnv.mkdir(resolvePath(p), options),
+    rm: (p, options) => parentEnv.rm(resolvePath(p), options),
+    dispose: () => parentEnv.dispose?.() ?? Promise.resolve()
+  };
+}
+function makeResolvePath(cwd) {
+  return (path) => {
+    if (path.startsWith("/")) return normalizePath(path);
+    if (cwd === "/") return normalizePath(`/${path}`);
+    return normalizePath(`${cwd}/${path}`);
+  };
+}
+function normalizePath(path) {
+  const out = [];
+  for (const part of path.split("/")) {
+    if (!part || part === ".") continue;
+    if (part === "..") out.pop();
+    else out.push(part);
+  }
+  return `/${out.join("/")}`;
+}
+var BaseSandboxEnv = class {
+  async exists(path) {
+    try {
+      await this.stat(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  resolvePath(path) {
+    if (path.startsWith("/")) return path;
+    return `${this.cwd.replace(/\/$/, "")}/${path}`;
+  }
+};
+
+// src/virtual-sandbox.ts
+import { Bash, InMemoryFs } from "just-bash";
+var DEFAULT_VIRTUAL_NETWORK = {
+  dangerouslyAllowFullInternetAccess: true,
+  denyPrivateRanges: true
+};
+function bash(factory) {
+  return {
+    async createSessionEnv(options) {
+      const env = await bashFactoryToSessionEnv(factory);
+      return options.cwd ? createCwdSessionEnv(env, options.cwd) : env;
+    }
+  };
+}
+async function bashFactoryToSessionEnv(factory) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  async function createBash() {
+    const bash2 = await factory();
+    assertBashLike(bash2);
+    if (seen.has(bash2)) {
+      throw new Error("BashFactory must return a fresh Bash-like object for each scoped operation.");
+    }
+    seen.add(bash2);
+    return bash2;
+  }
+  async function createScope(commands) {
+    const scoped = await createBash();
+    registerCommands(scoped, commands);
+    return createBashSessionEnv(scoped, createScope);
+  }
+  return createBashSessionEnv(await createBash(), createScope);
+}
+function createBashSessionEnv(bash2, createScope) {
+  const fs = bash2.fs;
+  const cwd = bash2.getCwd();
+  const resolvePath = (p) => p.startsWith("/") ? p : fs.resolvePath(cwd, p);
+  return {
+    cwd,
+    resolvePath,
+    scope: (options) => createScope(options?.commands ?? []),
+    async exec(command, options) {
+      let timeout;
+      let timedOut = false;
+      const signals = [];
+      if (options?.signal) signals.push(options.signal);
+      if (options?.timeoutMs) {
+        const controller = new AbortController();
+        timeout = setTimeout(() => {
+          timedOut = true;
+          controller.abort(new Error(`command timed out after ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+        signals.push(controller.signal);
+      }
+      const signal = signals.length === 0 ? void 0 : signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+      try {
+        const result = await bash2.exec(command, { cwd: options?.cwd, env: options?.env, signal });
+        if (timedOut) return { ...result, stderr: `${result.stderr}
+[command timed out after ${options?.timeoutMs}ms]`.trim(), exitCode: result.exitCode || 124 };
+        return { stdout: result.stdout, stderr: result.stderr, exitCode: result.exitCode };
+      } catch (err) {
+        if (timedOut) return { stdout: "", stderr: `[command timed out after ${options?.timeoutMs}ms]`, exitCode: 124 };
+        throw err;
+      } finally {
+        if (timeout) clearTimeout(timeout);
+      }
+    },
+    readFile: (p) => fs.readFile(resolvePath(p)),
+    readFileBuffer: (p) => fs.readFileBuffer(resolvePath(p)),
+    writeFile(p, data) {
+      const resolved = resolvePath(p);
+      const dir = dirnameOf(resolved);
+      return writeFileCreatingParents(
+        () => fs.writeFile(resolved, data),
+        () => dir ? fs.mkdir(dir, { recursive: true }) : Promise.resolve()
+      );
+    },
+    async stat(p) {
+      const s = await fs.stat(resolvePath(p));
+      return { isFile: s.isFile, isDirectory: s.isDirectory, isSymbolicLink: s.isSymbolicLink, size: s.size, mtimeMs: s.mtime.getTime() };
+    },
+    readdir: (p) => fs.readdir(resolvePath(p)),
+    exists: (p) => fs.exists(resolvePath(p)),
+    mkdir: (p, options) => fs.mkdir(resolvePath(p), options),
+    rm: (p, options) => fs.rm(resolvePath(p), options),
+    dispose: async () => {
+    }
+  };
+}
+function registerCommands(bash2, commands) {
+  if (!commands.length) return;
+  if (typeof bash2.registerCommand !== "function") throw new Error("Cannot use commands: this Bash-like sandbox does not support command registration.");
+  for (const command of commands) {
+    bash2.registerCommand({
+      name: command.name,
+      trusted: true,
+      execute: (args, ctx) => command.execute(args, ctx?.signal)
+    });
+  }
+}
+function virtualSandbox(options = {}) {
+  return {
+    async createSessionEnv(createOptions = { id: "virtual" }) {
+      const fs = new InMemoryFs();
+      const network = resolveSandboxNetworkPolicy(options.network, createOptions.env) ?? options.bash?.network ?? DEFAULT_VIRTUAL_NETWORK;
+      const env = await bashFactoryToSessionEnv(
+        () => new Bash({
+          fs,
+          cwd: options.cwd,
+          env: options.env,
+          ...options.bash,
+          network
+        })
+      );
+      return createOptions.cwd ? createCwdSessionEnv(env, createOptions.cwd) : env;
+    }
+  };
+}
+function assertBashLike(value) {
+  if (typeof value !== "object" || value === null || typeof value.exec !== "function" || typeof value.getCwd !== "function" || typeof value.fs !== "object" || value.fs === null) {
+    throw new Error("BashFactory must return a fresh Bash-like object.");
+  }
+}
+function dirnameOf(path) {
+  const normalized = path.replace(/\/+$/, "");
+  const idx = normalized.lastIndexOf("/");
+  if (idx <= 0) return idx === 0 ? "/" : void 0;
+  return normalized.slice(0, idx);
+}
+
+export {
+  sandboxHeaderFromEnv,
+  resolveSandboxNetworkPolicy,
+  defineSandbox,
+  sandboxCascade,
+  isSandboxFactory,
+  makeFs,
+  writeFileCreatingParents,
+  createCwdSessionEnv,
+  BaseSandboxEnv,
+  bash,
+  bashFactoryToSessionEnv,
+  virtualSandbox
+};

package/dist/chunk-HO6QHSUS.js

@@ -0,0 +1,85 @@
+// src/providers.ts
+import {
+  getApiProvider,
+  getApiProviders,
+  getModel,
+  getModels,
+  registerApiProvider,
+  unregisterApiProviders
+} from "@earendil-works/pi-ai";
+var providersById = /* @__PURE__ */ new Map();
+var ProviderRegistrationError = class extends Error {
+  constructor(providerId) {
+    super(`Provider "${providerId}" is not in the pi-ai catalog; registerProvider() must include api and baseUrl.`);
+    this.name = "ProviderRegistrationError";
+  }
+};
+function registerProvider(providerId, registration) {
+  const known = getModels(providerId).length > 0;
+  if (!known && (registration.api === void 0 || registration.baseUrl === void 0)) {
+    throw new ProviderRegistrationError(providerId);
+  }
+  providersById.set(providerId, { ...registration });
+}
+function resetProvidersForTests() {
+  providersById.clear();
+}
+function hasRegisteredProvider(providerId) {
+  return providersById.has(providerId);
+}
+function getRegisteredApiKey(providerId) {
+  return providersById.get(providerId)?.apiKey;
+}
+function getRegisteredStoreResponses(providerId) {
+  return providersById.get(providerId)?.storeResponses === true;
+}
+function resolveRegisteredModel(providerId, modelId) {
+  const registration = providersById.get(providerId);
+  if (!registration) return void 0;
+  const catalog = getModel(providerId, modelId);
+  const providerDefaults = catalog ?? getModels(providerId)[0];
+  const api = registration.api ?? providerDefaults?.api;
+  const baseUrl = registration.baseUrl ?? providerDefaults?.baseUrl;
+  if (api === void 0 || baseUrl === void 0) throw new ProviderRegistrationError(providerId);
+  const base = catalog ?? zeroMetadataModel(providerId, modelId, api, baseUrl);
+  const modelOverride = registration.models?.[modelId];
+  return {
+    ...base,
+    id: modelId,
+    name: modelOverride?.name ?? base.name ?? modelId,
+    api,
+    provider: providerId,
+    baseUrl,
+    headers: base.headers || registration.headers ? { ...base.headers ?? {}, ...registration.headers ?? {} } : void 0,
+    contextWindow: modelOverride?.contextWindow ?? registration.contextWindow ?? base.contextWindow,
+    maxTokens: modelOverride?.maxTokens ?? registration.maxTokens ?? base.maxTokens
+  };
+}
+function zeroMetadataModel(providerId, modelId, api, baseUrl) {
+  return {
+    id: modelId,
+    name: modelId,
+    api,
+    provider: providerId,
+    baseUrl,
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 0,
+    maxTokens: 0
+  };
+}
+
+export {
+  getApiProvider,
+  getApiProviders,
+  registerApiProvider,
+  unregisterApiProviders,
+  ProviderRegistrationError,
+  registerProvider,
+  resetProvidersForTests,
+  hasRegisteredProvider,
+  getRegisteredApiKey,
+  getRegisteredStoreResponses,
+  resolveRegisteredModel
+};