@thyn-ai/sqai 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -173,11 +173,15 @@ function fromAlgentaError(error) {
 }
 
 // src/env.ts
+var DEFAULT_BUILD_SERVICE_URL = "https://sqai-buildservice.fly.dev";
 function readEnv(env = process.env) {
   const apiKey = (env.SQAI_API_KEY ?? "").trim() || void 0;
   const engineUrl = (env.SQAI_ENGINE_URL ?? "").trim() || void 0;
   const autoInstall = (env.SQAI_RUNTIME_AUTO_INSTALL ?? "").trim() !== "0";
-  return { apiKey, engineUrl, autoInstall };
+  const modulesRaw = (env.SQAI_RUNTIME_MODULES ?? "").split(",").map((m) => m.trim()).filter((m) => m.length > 0);
+  const runtimeModules = modulesRaw.length > 0 ? modulesRaw : void 0;
+  const buildServiceUrl = (env.SQAI_BUILD_SERVICE_URL ?? "").trim() || DEFAULT_BUILD_SERVICE_URL;
+  return { apiKey, engineUrl, autoInstall, runtimeModules, buildServiceUrl };
 }
 function inferMode(explicit, resolved) {
   if (explicit) {
@@ -1029,7 +1033,7 @@ async function removeQuietly(path) {
   } catch {
   }
 }
-var RuntimeProvisioner = class {
+var RuntimeProvisioner = class _RuntimeProvisioner {
   options;
   trustRoot;
   runtime = null;
@@ -1089,8 +1093,110 @@ var RuntimeProvisioner = class {
   cacheDir() {
     return this.options.cacheDir ?? runtimeCacheDir();
   }
+  /** Normalized module filter (sorted, unique, non-empty) or null for the default bundle. */
+  filterModules() {
+    const mods = (this.options.runtimeModules ?? []).map((m) => m.trim()).filter((m) => m.length > 0);
+    if (mods.length === 0) {
+      return null;
+    }
+    return Array.from(new Set(mods)).sort();
+  }
+  /** Ask the build service to compile + sign a bundle for exactly these modules. */
+  async resolveFilteredBundle(modules, platformKey) {
+    if (this.options.resolveFilteredBundle) {
+      return this.options.resolveFilteredBundle(modules, platformKey);
+    }
+    const base = this.options.buildServiceUrl;
+    if (!base) {
+      throw new SqaiError(
+        "runtime_provision_failed",
+        "runtimeModules was set but no build service is configured. Set SQAI_BUILD_SERVICE_URL to a build-on-provision endpoint, or omit runtimeModules to use the default bundle.",
+        { details: { reason: "no_build_service", modules } }
+      );
+    }
+    let response;
+    try {
+      response = await fetch(`${base.replace(/\/$/, "")}/v1/runtime/build`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ modules, platform: platformKey })
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new SqaiError(
+        "runtime_provision_failed",
+        `Build service request failed: ${message}`,
+        { retryable: true, details: { reason: "build_service_unreachable", modules } }
+      );
+    }
+    if (!response.ok) {
+      throw new SqaiError(
+        "runtime_provision_failed",
+        `Build service returned HTTP ${response.status} for the requested filter.`,
+        { retryable: response.status >= 500, details: { reason: "build_failed", modules } }
+      );
+    }
+    const body = await response.json();
+    return {
+      url: body.url,
+      sha256: body.sha256,
+      version: body.version ?? this.options.contract.runtime_bundle.version,
+      cacheKey: body.cache_key
+    };
+  }
+  /**
+   * The filter's cache key, computed IDENTICALLY to the build service
+   * (sha256("mods|platform|version")[:20], mods = sorted+unique, comma-joined).
+   * Lets the reuse fast-path find an already-running filtered daemon without a
+   * build-service round-trip. The build service's returned key is authoritative
+   * for install; this only has to match for the reuse optimization to hit.
+   */
+  localCacheKey(modules, platformKey) {
+    const canonical = modules.join(",");
+    const version = this.options.contract.runtime_bundle.version;
+    return (0, import_node_crypto5.createHash)("sha256").update(`${canonical}|${platformKey}|${version}`).digest("hex").slice(0, 20);
+  }
+  /**
+   * Deterministic per-filter daemon endpoint so a filtered runtime never collides
+   * with the default (or another filter's) daemon on the shared default socket.
+   */
+  filterEndpoint(cacheKey) {
+    const seed = parseInt(cacheKey.slice(0, 6), 16) || 0;
+    const port = 50100 + seed % 800;
+    return { sock: (0, import_node_path2.join)(this.cacheDir(), `${cacheKey}.sock`), tcp: `127.0.0.1:${port}` };
+  }
+  static DAEMON_ENDPOINT_ENV = [
+    "ALGENTA_DAEMON_SOCK",
+    "ALGENTA_DAEMON_TCP",
+    "ALGENTA_MOJO_SOCK",
+    "ALGENTA_RUNTIME_DIR"
+  ];
+  /** Point the about-to-be-spawned daemon at a filter-specific socket/port/dir. */
+  applyDaemonEndpointEnv(endpoint, installDir) {
+    const saved = {};
+    for (const key of _RuntimeProvisioner.DAEMON_ENDPOINT_ENV) {
+      saved[key] = process.env[key];
+    }
+    process.env.ALGENTA_DAEMON_SOCK = endpoint.sock;
+    process.env.ALGENTA_DAEMON_TCP = endpoint.tcp;
+    process.env.ALGENTA_MOJO_SOCK = `${endpoint.sock}.worker`;
+    process.env.ALGENTA_RUNTIME_DIR = (0, import_node_path2.join)(installDir, ".runtime");
+    return saved;
+  }
+  restoreEnv(saved) {
+    for (const [key, value] of Object.entries(saved)) {
+      if (value === void 0) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
   async doEnsure() {
-    const runtime = this.newRuntime();
+    const platformKey = currentPlatformKey();
+    const filter = this.filterModules();
+    const probeEndpoint = filter ? this.filterEndpoint(this.localCacheKey(filter, platformKey)) : void 0;
+    const runtime = this.newRuntime(probeEndpoint ? { tcpAddress: probeEndpoint.tcp } : void 0);
     try {
       const health = await runtime.health();
       if (health.runtime_available) {
@@ -1099,40 +1205,54 @@ var RuntimeProvisioner = class {
       }
     } catch {
     }
-    const platformKey = currentPlatformKey();
-    const bundle = this.options.contract.runtime_bundle;
-    const platformBundle = bundle.platforms[platformKey];
-    if (!platformBundle) {
-      const supported = Object.keys(bundle.platforms);
-      throw new SqaiError(
-        "unsupported_platform",
-        supported.length === 0 ? "No managed runtime bundle is published yet for any platform. Start a local Algenta runtime daemon, or set SQAI_ENGINE_URL / SQAI_API_KEY to use a hosted engine." : `No managed runtime bundle is published for '${platformKey}'.`,
-        { details: { platform: platformKey, supported } }
-      );
+    let version;
+    let installKey;
+    let platformBundle;
+    let endpoint;
+    if (filter) {
+      const resolved = await this.resolveFilteredBundle(filter, platformKey);
+      version = resolved.version;
+      installKey = `filtered-${resolved.cacheKey}`;
+      platformBundle = { url: resolved.url, sha256: resolved.sha256 };
+      endpoint = this.filterEndpoint(resolved.cacheKey);
+    } else {
+      const bundle = this.options.contract.runtime_bundle;
+      const pinned = bundle.platforms[platformKey];
+      if (!pinned) {
+        const supported = Object.keys(bundle.platforms);
+        throw new SqaiError(
+          "unsupported_platform",
+          supported.length === 0 ? "No managed runtime bundle is published yet for any platform. Start a local Algenta runtime daemon, or set SQAI_ENGINE_URL / SQAI_API_KEY to use a hosted engine." : `No managed runtime bundle is published for '${platformKey}'.`,
+          { details: { platform: platformKey, supported } }
+        );
+      }
+      version = bundle.version;
+      installKey = version;
+      platformBundle = pinned;
     }
     if (!this.options.autoInstall) {
       throw new SqaiError(
         "runtime_provision_failed",
         "Automatic runtime installation is disabled (SQAI_RUNTIME_AUTO_INSTALL=0). Install manually with `sqai runtime install` or `sqai runtime install --from-file`.",
-        { details: { platform: platformKey, version: bundle.version } }
+        { details: { platform: platformKey, version } }
       );
     }
-    if (compareRuntimeVersions(bundle.version, this.trustRoot.minAcceptedRuntimeVersion) < 0) {
+    if (compareRuntimeVersions(version, this.trustRoot.minAcceptedRuntimeVersion) < 0) {
       throw new SqaiError(
         "runtime_provision_failed",
-        `Managed runtime ${bundle.version} is below the minimum accepted runtime version ${this.trustRoot.minAcceptedRuntimeVersion} (rollback protection).`,
+        `Managed runtime ${version} is below the minimum accepted runtime version ${this.trustRoot.minAcceptedRuntimeVersion} (rollback protection).`,
         {
           details: {
             reason: "rollback_protected",
             platform: platformKey,
-            version: bundle.version,
+            version,
             min_accepted_version: this.trustRoot.minAcceptedRuntimeVersion
           }
         }
       );
     }
-    const installed = await this.ensureInstalled(platformKey, bundle.version, platformBundle);
-    return this.spawnInstalled(platformKey, installed);
+    const installed = await this.ensureInstalled(platformKey, version, platformBundle, installKey);
+    return this.spawnInstalled(platformKey, installed, endpoint);
   }
   provisionError(reason, message, platformKey, version, extra = {}, retryable = false) {
     return new SqaiError("runtime_provision_failed", message, {
@@ -1174,8 +1294,8 @@ var RuntimeProvisioner = class {
     };
   }
   /** Verify an existing install if present; returns null when absent/invalid. */
-  async verifiedInstallOrNull(platformKey, version, removeOnFailure) {
-    const installDir = (0, import_node_path2.join)(this.cacheDir(), version);
+  async verifiedInstallOrNull(platformKey, version, removeOnFailure, installKey = version) {
+    const installDir = (0, import_node_path2.join)(this.cacheDir(), installKey);
     try {
       await import_node_fs2.promises.access((0, import_node_path2.join)(installDir, MANIFEST_NAME));
     } catch {
@@ -1226,15 +1346,15 @@ var RuntimeProvisioner = class {
       return true;
     }
   }
-  /** Serialize installers on `<cacheDir>/<version>.lock`; returns the verified install. */
-  async ensureInstalled(platformKey, version, platformBundle) {
+  /** Serialize installers on `<cacheDir>/<installKey>.lock`; returns the verified install. */
+  async ensureInstalled(platformKey, version, platformBundle, installKey = version) {
     const cacheDir = this.cacheDir();
     await import_node_fs2.promises.mkdir(cacheDir, { recursive: true });
-    const existing = await this.verifiedInstallOrNull(platformKey, version, true);
+    const existing = await this.verifiedInstallOrNull(platformKey, version, true, installKey);
     if (existing) {
       return existing;
     }
-    const lockPath = (0, import_node_path2.join)(cacheDir, `${version}.lock`);
+    const lockPath = (0, import_node_path2.join)(cacheDir, `${installKey}.lock`);
     const waitTimeoutMs = this.options.lockWaitTimeoutMs ?? LOCK_WAIT_TIMEOUT_MS;
     const pollIntervalMs = this.options.lockPollIntervalMs ?? LOCK_POLL_INTERVAL_MS;
     const deadline = Date.now() + waitTimeoutMs;
@@ -1246,12 +1366,12 @@ var RuntimeProvisioner = class {
         await removeQuietly(lockPath);
         continue;
       }
-      const finished = await this.verifiedInstallOrNull(platformKey, version, false);
+      const finished = await this.verifiedInstallOrNull(platformKey, version, false, installKey);
       if (finished) {
         return finished;
       }
       if (Date.now() >= deadline) {
-        const lastChance = await this.verifiedInstallOrNull(platformKey, version, false);
+        const lastChance = await this.verifiedInstallOrNull(platformKey, version, false, installKey);
         if (lastChance) {
           return lastChance;
         }
@@ -1260,29 +1380,29 @@ var RuntimeProvisioner = class {
           `Another installer holds the runtime install lock for ${version} and did not finish within ${Math.round(waitTimeoutMs / 1e3)}s. Retry, or remove the stale lock from the runtime cache directory.`,
           platformKey,
           version,
-          { lock_file: `${version}.lock` },
+          { lock_file: `${installKey}.lock` },
           true
         );
       }
       await sleep(pollIntervalMs);
     }
     try {
-      const raced = await this.verifiedInstallOrNull(platformKey, version, false);
+      const raced = await this.verifiedInstallOrNull(platformKey, version, false, installKey);
       if (raced) {
         return raced;
       }
-      return await this.downloadVerifyExtract(platformKey, version, platformBundle);
+      return await this.downloadVerifyExtract(platformKey, version, platformBundle, installKey);
     } finally {
       await removeQuietly(lockPath);
     }
   }
   /** Holder-of-the-lock path: download → verify → extract → atomic rename. */
-  async downloadVerifyExtract(platformKey, version, platformBundle) {
+  async downloadVerifyExtract(platformKey, version, platformBundle, installKey = version) {
     const cacheDir = this.cacheDir();
     const token = (0, import_node_crypto5.randomBytes)(6).toString("hex");
     const tarballPath = (0, import_node_path2.join)(cacheDir, `tmp-${token}.tgz`);
     const extractDir = (0, import_node_path2.join)(cacheDir, `tmp-${token}`);
-    const installDir = (0, import_node_path2.join)(cacheDir, version);
+    const installDir = (0, import_node_path2.join)(cacheDir, installKey);
     const url = resolveBundleUrl(platformBundle.url, version, platformKey);
     try {
       const download = this.options.downloadBundle ?? defaultDownloadBundle;
@@ -1329,7 +1449,7 @@ var RuntimeProvisioner = class {
       try {
         await import_node_fs2.promises.rename(extractDir, installDir);
       } catch (error) {
-        const raced = await this.verifiedInstallOrNull(platformKey, version, false);
+        const raced = await this.verifiedInstallOrNull(platformKey, version, false, installKey);
         if (raced) {
           return raced;
         }
@@ -1348,7 +1468,7 @@ var RuntimeProvisioner = class {
     }
   }
   /** Spawn the installed bundle's daemon through MojoRuntime autoStart. */
-  async spawnInstalled(platformKey, installed) {
+  async spawnInstalled(platformKey, installed, endpoint) {
     const version = installed.manifest.runtime_bundle_version;
     let entryRelative;
     try {
@@ -1361,7 +1481,10 @@ var RuntimeProvisioner = class {
       "start",
       "--foreground"
     ];
-    const managed = this.newRuntime({ autoStart: true, daemonCommand });
+    const managed = this.newRuntime(
+      endpoint ? { autoStart: true, daemonCommand, tcpAddress: endpoint.tcp } : { autoStart: true, daemonCommand }
+    );
+    const savedEnv = endpoint ? this.applyDaemonEndpointEnv(endpoint, installed.installDir) : null;
     try {
       const health = await managed.health();
       if (!health.runtime_available) {
@@ -1385,6 +1508,10 @@ var RuntimeProvisioner = class {
         version,
         { daemon_entry: entryRelative }
       );
+    } finally {
+      if (savedEnv) {
+        this.restoreEnv(savedEnv);
+      }
     }
     try {
       await import_node_fs2.promises.writeFile(
@@ -1651,7 +1778,9 @@ var SQAI = class {
     this.resultStore = new ResultStore(config.resultStore);
     this.provisioner = new RuntimeProvisioner({
       contract: this.contractIndex.contract,
-      autoInstall: env.autoInstall
+      autoInstall: env.autoInstall,
+      runtimeModules: config.runtimeModules ?? env.runtimeModules,
+      buildServiceUrl: config.buildServiceUrl ?? env.buildServiceUrl
     });
     if (config.runtime) {
       this.rawRuntime = config.runtime;