blun-king-cli 9.1.470 → 9.1.471

package/bin/agent-api-service-host.mjs

@@ -0,0 +1,198 @@
+import path from 'node:path';
+
+import { createAgentApiHttpAdapter } from './agent-api-http-adapter.mjs';
+import { createAgentApiPrivateHttpServer } from './agent-api-private-http-server.mjs';
+import { createAgentApiRuntime } from './agent-api-runtime.mjs';
+import { createAgentApiSessionRegistry } from './agent-api-session-registry.mjs';
+import { createAgentApiTurnController } from './agent-api-turn-controller.mjs';
+
+const MIN_SECRET_BYTES = 32;
+
+function requireSecret(value, label) {
+  if (typeof value !== 'string' || Buffer.byteLength(value, 'utf8') < MIN_SECRET_BYTES) {
+    throw new TypeError(`${label} must contain at least ${MIN_SECRET_BYTES} bytes`);
+  }
+  return value;
+}
+
+function requireAbsoluteRoot(value) {
+  if (typeof value !== 'string' || !path.isAbsolute(value)) {
+    throw new TypeError('rootDir must be an absolute path');
+  }
+  return path.resolve(value);
+}
+
+function requireObject(value, label) {
+  if (value === undefined) return {};
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object`);
+  }
+  return value;
+}
+
+function cloneHarnessConfig(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError('harnessConfig must be an object');
+  }
+  let config;
+  try {
+    config = structuredClone(value);
+  } catch {
+    throw new TypeError('harnessConfig must be structured-cloneable');
+  }
+  if (config.defaultModel !== 'king') {
+    throw new TypeError('harnessConfig.defaultModel must be king');
+  }
+  if (config.models === null
+    || typeof config.models !== 'object'
+    || Array.isArray(config.models)
+    || config.models.king === null
+    || typeof config.models.king !== 'object'
+    || Array.isArray(config.models.king)) {
+    throw new TypeError('harnessConfig.models.king must be an object');
+  }
+  const provider = config.models.king.provider;
+  if (typeof provider !== 'string'
+    || provider.length === 0
+    || config.providers === null
+    || typeof config.providers !== 'object'
+    || Array.isArray(config.providers)
+    || !Object.hasOwn(config.providers, provider)) {
+    throw new TypeError('harnessConfig must define the provider used by models.king');
+  }
+  return config;
+}
+
+async function createBundledHarness(input) {
+  const { createBlunHarness } = await import('../blun.mjs');
+  return createBlunHarness(input);
+}
+
+function resolveHarnessPreparation(options) {
+  const hasConfig = options.harnessConfig !== undefined;
+  const hasPrepare = options.prepareHarness !== undefined;
+  if (hasConfig && hasPrepare) {
+    throw new TypeError('only one of harnessConfig or prepareHarness may be provided');
+  }
+  if (!hasConfig && !hasPrepare) {
+    throw new TypeError('harnessConfig or prepareHarness is required');
+  }
+  if (hasPrepare) {
+    if (typeof options.prepareHarness !== 'function') {
+      throw new TypeError('prepareHarness must be a function');
+    }
+    return options.prepareHarness;
+  }
+
+  const config = cloneHarnessConfig(options.harnessConfig);
+  return async ({ harness }) => {
+    if (typeof harness?.setConfig !== 'function') {
+      throw new TypeError('Agent API harness must provide setConfig');
+    }
+    await harness.setConfig(structuredClone(config));
+  };
+}
+
+function createAgentApiServiceHost(options = {}) {
+  const rootDir = requireAbsoluteRoot(options.rootDir);
+  const internalSecret = requireSecret(options.internalSecret, 'internalSecret');
+  const isolationSecret = requireSecret(options.isolationSecret, 'isolationSecret');
+  if (internalSecret === isolationSecret) {
+    throw new TypeError('internalSecret and isolationSecret must be different');
+  }
+  if (options.createHarness !== undefined && typeof options.createHarness !== 'function') {
+    throw new TypeError('createHarness must be a function');
+  }
+
+  const runtimeOptions = requireObject(options.runtimeOptions, 'runtimeOptions');
+  const controllerOptions = requireObject(options.controllerOptions, 'controllerOptions');
+  const prepareHarness = resolveHarnessPreparation(options);
+  const runtime = createAgentApiRuntime(runtimeOptions);
+  const controller = createAgentApiTurnController({
+    ...controllerOptions,
+    runtime,
+    publicModel: 'king',
+  });
+  const sessionRegistry = createAgentApiSessionRegistry({
+    rootDir,
+    isolationSecret,
+    createHarness: options.createHarness ?? createBundledHarness,
+    prepareHarness,
+    sessionOptions: options.sessionOptions,
+    maxPrincipals: options.maxPrincipals,
+    maxSessionsPerPrincipal: options.maxSessionsPerPrincipal,
+  });
+  const adapter = createAgentApiHttpAdapter({
+    controller,
+    resolveSession: sessionRegistry.resolveSession,
+  });
+  const privateServer = createAgentApiPrivateHttpServer({
+    adapter,
+    internalSecret,
+    maxBodyBytes: options.maxBodyBytes,
+  });
+
+  let state = 'idle';
+  let listenPromise;
+  let closePromise;
+
+  async function listen(input = {}) {
+    if (state === 'closed' || state === 'closing') {
+      throw new Error('Agent API service host is closed');
+    }
+    if (state !== 'idle') {
+      throw new Error('Agent API service host is already listening');
+    }
+    state = 'starting';
+    try {
+      listenPromise = privateServer.listen(input);
+      const address = await listenPromise;
+      if (state === 'closing' || state === 'closed') {
+        await privateServer.close();
+        throw new Error('Agent API service host is closed');
+      }
+      state = 'listening';
+      return address;
+    } catch (error) {
+      if (state === 'starting') state = 'idle';
+      throw error;
+    } finally {
+      listenPromise = undefined;
+    }
+  }
+
+  function close() {
+    if (closePromise !== undefined) return closePromise;
+    state = 'closing';
+    closePromise = (async () => {
+      let firstError;
+      if (listenPromise !== undefined) {
+        try {
+          await listenPromise;
+        } catch {
+          // The listen failure remains with its caller; cleanup continues here.
+        }
+      }
+      try {
+        await privateServer.close();
+      } catch (error) {
+        firstError = error;
+      }
+      try {
+        await sessionRegistry.close();
+      } catch (error) {
+        firstError ??= error;
+      }
+      state = 'closed';
+      if (firstError !== undefined) throw firstError;
+    })();
+    return closePromise;
+  }
+
+  return Object.freeze({ close, listen });
+}
+
+export {
+  MIN_SECRET_BYTES,
+  createAgentApiServiceHost,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.470",
+  "version": "9.1.471",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {