blun-king-cli 9.1.475 → 9.1.476

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

@@ -0,0 +1,236 @@
+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/package.json

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