blun-king-cli 9.1.587 → 9.1.588

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

@@ -1,236 +0,0 @@
-import path from 'node:path';
-
-import { createAgentApiServiceHost } from './agent-api-service-host.mjs';
-
-const LOOPBACK_HOST = '127.0.0.1';
-const PROVIDER_NAME = 'privateAgentProvider';
-const PUBLIC_MODEL = 'king';
-
-function requireEnvironment(env) {
-  if (env === null || typeof env !== 'object' || Array.isArray(env)) {
-    throw new TypeError('env must be an object');
-  }
-  return env;
-}
-
-function requiredValue(env, name, options = {}) {
-  const value = env[name];
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw new TypeError(`${name} is required`);
-  }
-  const normalized = options.preserve === true ? value : value.trim();
-  return normalized;
-}
-
-function optionalValue(env, name) {
-  if (!Object.hasOwn(env, name)) return undefined;
-  const value = env[name];
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw new TypeError(`${name} must be a non-empty string`);
-  }
-  return value.trim();
-}
-
-function integerValue(value, name, options = {}) {
-  if (!/^\d+$/u.test(value)) {
-    throw new TypeError(`${name} must be a positive safe integer`);
-  }
-  const parsed = Number(value);
-  const minimum = options.minimum ?? 1;
-  const maximum = options.maximum ?? Number.MAX_SAFE_INTEGER;
-  if (!Number.isSafeInteger(parsed) || parsed < minimum || parsed > maximum) {
-    if (options.rangeMessage !== undefined) {
-      throw new TypeError(`${name} ${options.rangeMessage}`);
-    }
-    if (minimum === 1024) {
-      throw new TypeError(`${name} must be an integer of at least 1024`);
-    }
-    throw new TypeError(`${name} must be a positive safe integer`);
-  }
-  return parsed;
-}
-
-function requireSecret(env, name) {
-  const value = requiredValue(env, name, { preserve: true });
-  if (Buffer.byteLength(value, 'utf8') < 32) {
-    throw new TypeError(`${name} must contain at least 32 bytes`);
-  }
-  return value;
-}
-
-function requireAbsoluteRoot(env) {
-  const value = requiredValue(env, 'BLUN_AGENT_API_ROOT_DIR');
-  if (!path.isAbsolute(value)) {
-    throw new TypeError('BLUN_AGENT_API_ROOT_DIR must be an absolute path');
-  }
-  return path.resolve(value);
-}
-
-function requireProviderBaseUrl(env) {
-  const value = requiredValue(env, 'BLUN_AGENT_API_PROVIDER_BASE_URL');
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new TypeError('BLUN_AGENT_API_PROVIDER_BASE_URL must be a valid URL');
-  }
-  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-    throw new TypeError('BLUN_AGENT_API_PROVIDER_BASE_URL must use http or https');
-  }
-  if (parsed.username.length > 0 || parsed.password.length > 0) {
-    throw new TypeError('BLUN_AGENT_API_PROVIDER_BASE_URL must not contain credentials');
-  }
-  if (parsed.search.length > 0 || parsed.hash.length > 0) {
-    throw new TypeError('BLUN_AGENT_API_PROVIDER_BASE_URL must not contain a query or fragment');
-  }
-  return value;
-}
-
-function loadAgentApiServiceEnvironment(input = process.env) {
-  const env = requireEnvironment(input);
-  const rootDir = requireAbsoluteRoot(env);
-  const internalSecret = requireSecret(env, 'BLUN_AGENT_API_INTERNAL_SECRET');
-  const isolationSecret = requireSecret(env, 'BLUN_AGENT_API_ISOLATION_SECRET');
-  if (internalSecret === isolationSecret) {
-    throw new TypeError('Agent API internal and isolation secrets must be different');
-  }
-
-  const port = integerValue(
-    requiredValue(env, 'BLUN_AGENT_API_PORT'),
-    'BLUN_AGENT_API_PORT',
-    { maximum: 65_535, rangeMessage: 'must be an integer from 1 through 65535' },
-  );
-  const providerBaseUrl = requireProviderBaseUrl(env);
-  const providerApiKey = requiredValue(
-    env,
-    'BLUN_AGENT_API_PROVIDER_API_KEY',
-    { preserve: true },
-  );
-  const providerModel = requiredValue(env, 'BLUN_AGENT_API_PROVIDER_MODEL');
-  const maxContextSize = integerValue(
-    requiredValue(env, 'BLUN_AGENT_API_MAX_CONTEXT_TOKENS'),
-    'BLUN_AGENT_API_MAX_CONTEXT_TOKENS',
-  );
-  const maxOutputSize = integerValue(
-    requiredValue(env, 'BLUN_AGENT_API_MAX_OUTPUT_TOKENS'),
-    'BLUN_AGENT_API_MAX_OUTPUT_TOKENS',
-  );
-  if (maxOutputSize > maxContextSize) {
-    throw new TypeError(
-      'BLUN_AGENT_API_MAX_OUTPUT_TOKENS must not exceed BLUN_AGENT_API_MAX_CONTEXT_TOKENS',
-    );
-  }
-  const maxBodyBytes = integerValue(
-    requiredValue(env, 'BLUN_AGENT_API_MAX_BODY_BYTES'),
-    'BLUN_AGENT_API_MAX_BODY_BYTES',
-    { minimum: 1024 },
-  );
-  const maxPrincipals = integerValue(
-    requiredValue(env, 'BLUN_AGENT_API_MAX_PRINCIPALS'),
-    'BLUN_AGENT_API_MAX_PRINCIPALS',
-  );
-  const maxSessionsPerPrincipal = integerValue(
-    requiredValue(env, 'BLUN_AGENT_API_MAX_SESSIONS_PER_PRINCIPAL'),
-    'BLUN_AGENT_API_MAX_SESSIONS_PER_PRINCIPAL',
-  );
-
-  const idleTimeoutRaw = optionalValue(env, 'BLUN_AGENT_API_SESSION_IDLE_TIMEOUT_MS');
-  const idleSweepRaw = optionalValue(env, 'BLUN_AGENT_API_IDLE_SWEEP_INTERVAL_MS');
-  const sessionIdleTimeoutMs = idleTimeoutRaw === undefined
-    ? 0
-    : integerValue(idleTimeoutRaw, 'BLUN_AGENT_API_SESSION_IDLE_TIMEOUT_MS');
-  if (idleSweepRaw !== undefined && sessionIdleTimeoutMs === 0) {
-    throw new TypeError(
-      'BLUN_AGENT_API_IDLE_SWEEP_INTERVAL_MS requires BLUN_AGENT_API_SESSION_IDLE_TIMEOUT_MS',
-    );
-  }
-  const idleSweepIntervalMs = idleSweepRaw === undefined
-    ? undefined
-    : integerValue(idleSweepRaw, 'BLUN_AGENT_API_IDLE_SWEEP_INTERVAL_MS');
-
-  const providerConfig = Object.freeze({
-    type: 'blun',
-    apiKey: providerApiKey,
-    baseUrl: providerBaseUrl,
-    defaultModel: providerModel,
-  });
-  const modelConfig = Object.freeze({
-    provider: PROVIDER_NAME,
-    model: providerModel,
-    maxContextSize,
-    maxOutputSize,
-    capabilities: Object.freeze(['tool_use']),
-  });
-  const harnessConfig = Object.freeze({
-    providers: Object.freeze({ [PROVIDER_NAME]: providerConfig }),
-    models: Object.freeze({ [PUBLIC_MODEL]: modelConfig }),
-    defaultModel: PUBLIC_MODEL,
-  });
-  const hostOptions = Object.freeze({
-    rootDir,
-    internalSecret,
-    isolationSecret,
-    harnessConfig,
-    maxBodyBytes,
-    maxPrincipals,
-    maxSessionsPerPrincipal,
-    sessionIdleTimeoutMs,
-    idleSweepIntervalMs,
-  });
-
-  return Object.freeze({
-    listen: Object.freeze({ host: LOOPBACK_HOST, port }),
-    hostOptions,
-  });
-}
-
-async function startAgentApiServiceFromEnvironment(options = {}) {
-  const createServiceHost = options.createServiceHost === undefined
-    ? createAgentApiServiceHost
-    : options.createServiceHost;
-  if (typeof createServiceHost !== 'function') {
-    throw new TypeError('createServiceHost must be a function');
-  }
-  const config = loadAgentApiServiceEnvironment(
-    options.env === undefined ? process.env : options.env,
-  );
-  const service = createServiceHost(config.hostOptions);
-  if (service === null || typeof service !== 'object'
-    || typeof service.listen !== 'function'
-    || typeof service.close !== 'function') {
-    throw new TypeError('Agent API service host must provide listen and close');
-  }
-
-  let address;
-  try {
-    address = await service.listen(config.listen);
-  } catch (error) {
-    try {
-      await service.close();
-    } catch {
-      // The listen failure is the actionable error; cleanup remains best-effort.
-    }
-    throw error;
-  }
-
-  let closePromise;
-  return Object.freeze({
-    address: Object.freeze({
-      address: address.address,
-      family: address.family,
-      port: address.port,
-    }),
-    close() {
-      closePromise ??= Promise.resolve().then(() => service.close());
-      return closePromise;
-    },
-  });
-}
-
-export {
-  LOOPBACK_HOST,
-  PROVIDER_NAME,
-  PUBLIC_MODEL,
-  loadAgentApiServiceEnvironment,
-  startAgentApiServiceFromEnvironment,
-};

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

@@ -1,209 +0,0 @@
-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',
-  });
-  let adapter;
-  const sessionRegistry = createAgentApiSessionRegistry({
-    rootDir,
-    isolationSecret,
-    createHarness: options.createHarness ?? createBundledHarness,
-    prepareHarness,
-    sessionOptions: options.sessionOptions,
-    maxPrincipals: options.maxPrincipals,
-    maxSessionsPerPrincipal: options.maxSessionsPerPrincipal,
-    sessionIdleTimeoutMs: options.sessionIdleTimeoutMs,
-    idleSweepIntervalMs: options.idleSweepIntervalMs,
-    now: options.now,
-    scheduleInterval: options.scheduleInterval,
-    cancelInterval: options.cancelInterval,
-    isSessionActive(input) {
-      return adapter?.isSessionActive(input) === true;
-    },
-  });
-  adapter = createAgentApiHttpAdapter({
-    controller,
-    resolveSession: sessionRegistry.resolveSession,
-    closeSession: sessionRegistry.closeSession,
-    touchSession: sessionRegistry.touchSession,
-  });
-  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/bin/agent-api-service-process.mjs

@@ -1,171 +0,0 @@
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-
-import { startAgentApiServiceFromEnvironment } from './agent-api-service-environment.mjs';
-
-function requireProcessLike(value) {
-  if (value === null
-    || typeof value !== 'object'
-    || typeof value.on !== 'function'
-    || typeof value.removeListener !== 'function') {
-    throw new TypeError('processLike must provide on and removeListener');
-  }
-  return value;
-}
-
-function requireFunction(value, label) {
-  if (typeof value !== 'function') {
-    throw new TypeError(`${label} must be a function`);
-  }
-  return value;
-}
-
-function copyAddress(value) {
-  if (value === null
-    || typeof value !== 'object'
-    || typeof value.address !== 'string'
-    || typeof value.family !== 'string'
-    || !Number.isInteger(value.port)) {
-    throw new TypeError('Agent API service must provide a network address');
-  }
-  return Object.freeze({
-    address: value.address,
-    family: value.family,
-    port: value.port,
-  });
-}
-
-async function runAgentApiServiceProcess(options = {}) {
-  const processLike = requireProcessLike(
-    options.processLike === undefined ? process : options.processLike,
-  );
-  const startService = requireFunction(
-    options.startService === undefined
-      ? startAgentApiServiceFromEnvironment
-      : options.startService,
-    'startService',
-  );
-  const writeStdout = requireFunction(
-    options.writeStdout === undefined
-      ? (value) => process.stdout.write(value)
-      : options.writeStdout,
-    'writeStdout',
-  );
-  const writeStderr = requireFunction(
-    options.writeStderr === undefined
-      ? (value) => process.stderr.write(value)
-      : options.writeStderr,
-    'writeStderr',
-  );
-
-  let running;
-  let requestedSignal;
-  let shutdownPromise;
-  let resolveClosed;
-  let rejectClosed;
-  const closed = new Promise((resolve, reject) => {
-    resolveClosed = resolve;
-    rejectClosed = reject;
-  });
-  closed.catch(() => {});
-
-  function removeSignalHandlers() {
-    processLike.removeListener('SIGINT', onSigint);
-    processLike.removeListener('SIGTERM', onSigterm);
-  }
-
-  function beginShutdown(signal) {
-    if (shutdownPromise !== undefined) return shutdownPromise;
-    removeSignalHandlers();
-    shutdownPromise = (async () => {
-      try {
-        await running.close();
-        if (signal !== undefined) {
-          processLike.exitCode = 0;
-          writeStdout(`Agent API service stopped after ${signal}.\n`);
-        }
-        resolveClosed();
-      } catch (error) {
-        if (signal !== undefined) {
-          processLike.exitCode = 1;
-          writeStderr('Agent API service shutdown failed.\n');
-        }
-        rejectClosed(error);
-        throw error;
-      }
-    })();
-    return shutdownPromise;
-  }
-
-  function requestShutdown(signal) {
-    if (requestedSignal !== undefined) return;
-    requestedSignal = signal;
-    if (running !== undefined) {
-      void beginShutdown(signal).catch(() => {});
-    }
-  }
-
-  function onSigint() {
-    requestShutdown('SIGINT');
-  }
-
-  function onSigterm() {
-    requestShutdown('SIGTERM');
-  }
-
-  processLike.on('SIGINT', onSigint);
-  processLike.on('SIGTERM', onSigterm);
-
-  try {
-    running = await startService({
-      env: options.env === undefined ? process.env : options.env,
-    });
-    if (running === null
-      || typeof running !== 'object'
-      || typeof running.close !== 'function') {
-      throw new TypeError('Agent API service must provide close');
-    }
-    const address = copyAddress(running.address);
-    if (requestedSignal !== undefined) {
-      void beginShutdown(requestedSignal).catch(() => {});
-    } else {
-      writeStdout(`Agent API service listening on ${address.address}:${address.port}.\n`);
-    }
-    return Object.freeze({
-      address,
-      close() {
-        return beginShutdown();
-      },
-      closed,
-    });
-  } catch (error) {
-    removeSignalHandlers();
-    if (running !== undefined
-      && typeof running?.close === 'function'
-      && shutdownPromise === undefined) {
-      try {
-        await running.close();
-      } catch {
-        // The startup error remains the actionable failure.
-      }
-    }
-    rejectClosed(error);
-    throw error;
-  }
-}
-
-function isDirectExecution() {
-  if (typeof process.argv[1] !== 'string' || process.argv[1].length === 0) return false;
-  return pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url;
-}
-
-if (isDirectExecution()) {
-  runAgentApiServiceProcess().catch(() => {
-    process.exitCode = 1;
-    process.stderr.write('Agent API service failed to start.\n');
-  });
-}
-
-export {
-  runAgentApiServiceProcess,
-};