blun-king-cli 9.1.469 → 9.1.471

package/bin/agent-api-http-adapter.mjs

@@ -137,6 +137,24 @@ function publicErrorResponse(error) {
       },
     });
   }
+  if (code === 'AGENT_API_SESSION_NOT_FOUND') {
+    return jsonResponse(404, {
+      error: {
+        type: 'invalid_request_error',
+        code,
+        message: 'Agent session was not found.',
+      },
+    });
+  }
+  if (code === 'AGENT_API_SESSION_LIMIT' || code === 'AGENT_API_PRINCIPAL_LIMIT') {
+    return jsonResponse(429, {
+      error: {
+        type: 'rate_limit_error',
+        code,
+        message: 'Agent session limit reached.',
+      },
+    });
+  }
   if (code.startsWith('AGENT_API_INVALID_')) {
     return jsonResponse(400, {
       error: {
@@ -193,27 +211,35 @@ function createAgentApiHttpAdapter(options = {}) {
 
   function requireOwner(principalId, sessionId, requestId) {
     const key = scopeKey(sessionId, requestId);
-    const owner = owners.get(key);
-    if (owner === undefined) {
+    const scopeOwners = owners.get(key);
+    if (scopeOwners === undefined) {
       throw adapterError(
         'AGENT_API_TURN_NOT_ACTIVE',
         'Agent turn is not active.',
         409,
       );
     }
-    if (owner !== principalId) {
+    const internalSessionId = scopeOwners.get(principalId);
+    if (internalSessionId === undefined) {
       throw adapterError(
         'AGENT_API_FORBIDDEN',
         'Agent turn belongs to a different account.',
         403,
       );
     }
-    return key;
+    return { internalSessionId, key };
   }
 
-  function trackScope(key, principalId, response) {
-    if (responseNeedsToolResult(response)) owners.set(key, principalId);
-    else owners.delete(key);
+  function trackScope(key, principalId, internalSessionId, response) {
+    if (responseNeedsToolResult(response)) {
+      const scopeOwners = owners.get(key) ?? new Map();
+      scopeOwners.set(principalId, internalSessionId);
+      owners.set(key, scopeOwners);
+      return;
+    }
+    const scopeOwners = owners.get(key);
+    scopeOwners?.delete(principalId);
+    if (scopeOwners?.size === 0) owners.delete(key);
   }
 
   async function handleStart(input, principalId) {
@@ -232,46 +258,53 @@ function createAgentApiHttpAdapter(options = {}) {
       sessionId,
       create: true,
     });
-    if (session?.id !== sessionId) {
+    if (typeof session?.id !== 'string' || session.id.trim().length === 0) {
       throw adapterError(
         'AGENT_API_SESSION_SCOPE_MISMATCH',
-        'resolved session does not match session_id',
+        'resolved session does not have an isolated session ID',
         403,
       );
     }
+    const internalSessionId = session.id.trim();
     const response = publicCompletion(await controller.startTurn({
       session,
+      publicSessionId: sessionId,
       requestId,
       prompt: normalizePrompt(body.input),
       tools: normalizeTools(body.tools),
     }));
-    trackScope(scopeKey(sessionId, requestId), principalId, response);
+    trackScope(
+      scopeKey(sessionId, requestId),
+      principalId,
+      internalSessionId,
+      response,
+    );
     return jsonResponse(200, response);
   }
 
   async function handleContinue(input, principalId, requestId) {
     const body = requireBody(input.body);
     const sessionId = requirePublicId(body.session_id, 'session_id');
-    const key = requireOwner(principalId, sessionId, requestId);
+    const owner = requireOwner(principalId, sessionId, requestId);
     const response = publicCompletion(await controller.continueTurn({
-      sessionId,
+      sessionId: owner.internalSessionId,
       requestId,
       toolResults: body.tool_results,
     }));
-    trackScope(key, principalId, response);
+    trackScope(owner.key, principalId, owner.internalSessionId, response);
     return jsonResponse(200, response);
   }
 
   async function handleCancel(input, principalId, requestId) {
     const body = requireBody(input.body ?? {});
     const sessionId = requirePublicId(body.session_id, 'session_id');
-    const key = requireOwner(principalId, sessionId, requestId);
+    const owner = requireOwner(principalId, sessionId, requestId);
     await controller.cancelTurn({
-      sessionId,
+      sessionId: owner.internalSessionId,
       requestId,
       reason: typeof body.reason === 'string' ? body.reason : undefined,
     });
-    owners.delete(key);
+    trackScope(owner.key, principalId, owner.internalSessionId, null);
     return jsonResponse(200, {
       id: `agent-${requestId}`,
       object: 'agent.turn.cancelled',

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/bin/agent-api-session-registry.mjs

@@ -0,0 +1,291 @@
+import { createHmac } from 'node:crypto';
+import { mkdir } from 'node:fs/promises';
+import path from 'node:path';
+
+const DEFAULT_MAX_SESSIONS_PER_PRINCIPAL = 16;
+const DEFAULT_MAX_PRINCIPALS = 1024;
+const PRINCIPAL_PATTERN = /^[A-Za-z0-9@._:+-]{1,256}$/u;
+const PUBLIC_SESSION_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/u;
+
+class AgentApiSessionRegistryError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'AgentApiSessionRegistryError';
+    this.code = code;
+  }
+}
+
+function registryError(code, message) {
+  return new AgentApiSessionRegistryError(code, message);
+}
+
+function requirePattern(value, pattern, label) {
+  if (typeof value !== 'string' || !pattern.test(value)) {
+    throw registryError('AGENT_API_INVALID_SCOPE', `${label} is invalid`);
+  }
+  return value;
+}
+
+function requireRootDir(value) {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new TypeError('rootDir must be a non-empty path');
+  }
+  return path.resolve(value);
+}
+
+function requireLimit(value) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError('maxSessionsPerPrincipal must be a positive integer');
+  }
+  return value;
+}
+
+function validateIsolationSecret(value) {
+  if (typeof value !== 'string' || Buffer.byteLength(value, 'utf8') < 32) {
+    throw new TypeError('isolationSecret must contain at least 32 bytes');
+  }
+  return value;
+}
+
+function opaqueHash(secret, ...parts) {
+  return createHmac('sha256', secret).update(parts.join('\0')).digest('hex');
+}
+
+function validateHarness(harness) {
+  if (harness === null || typeof harness !== 'object'
+    || typeof harness.createSession !== 'function') {
+    throw new TypeError('createHarness must return a harness with createSession');
+  }
+  return harness;
+}
+
+function validateSession(session, internalSessionId) {
+  if (session === null || typeof session !== 'object' || session.id !== internalSessionId) {
+    throw registryError(
+      'AGENT_API_SESSION_SCOPE_MISMATCH',
+      'SDK session does not match the isolated session scope',
+    );
+  }
+  return session;
+}
+
+function normalizeSessionOptions(value) {
+  if (value === undefined) return {};
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError('sessionOptions must resolve to an object');
+  }
+  return { ...value };
+}
+
+function createAgentApiSessionRegistry(options = {}) {
+  const rootDir = requireRootDir(options.rootDir);
+  const isolationSecret = validateIsolationSecret(options.isolationSecret);
+  if (typeof options.createHarness !== 'function') {
+    throw new TypeError('createHarness must be a function');
+  }
+  if (options.prepareHarness !== undefined && typeof options.prepareHarness !== 'function') {
+    throw new TypeError('prepareHarness must be a function');
+  }
+  if (options.sessionOptions !== undefined
+    && typeof options.sessionOptions !== 'function'
+    && (options.sessionOptions === null
+      || typeof options.sessionOptions !== 'object'
+      || Array.isArray(options.sessionOptions))) {
+    throw new TypeError('sessionOptions must be an object or function');
+  }
+
+  const maxSessionsPerPrincipal = requireLimit(
+    options.maxSessionsPerPrincipal ?? DEFAULT_MAX_SESSIONS_PER_PRINCIPAL,
+  );
+  const maxPrincipals = requireLimit(options.maxPrincipals ?? DEFAULT_MAX_PRINCIPALS);
+  const principals = new Map();
+  let closed = false;
+
+  function ensureOpen() {
+    if (closed) {
+      throw registryError('AGENT_API_SESSION_REGISTRY_CLOSED', 'session registry is closed');
+    }
+  }
+
+  function createPrincipalRecord(principalId) {
+    const principalKey = opaqueHash(isolationSecret, 'principal', principalId).slice(0, 40);
+    const principalRoot = path.join(rootDir, 'principals', principalKey);
+    const homeDir = path.join(principalRoot, 'home');
+    const workRoot = path.join(principalRoot, 'work');
+    const record = {
+      harnessReady: false,
+      harnessPromise: undefined,
+      homeDir,
+      principalKey,
+      principalRoot,
+      sessions: new Map(),
+      workRoot,
+    };
+    record.harnessPromise = (async () => {
+      await mkdir(homeDir, { recursive: true });
+      await mkdir(workRoot, { recursive: true });
+      const harness = validateHarness(await options.createHarness({
+        homeDir,
+        principalKey,
+        uiMode: 'api',
+      }));
+      try {
+        if (typeof harness.ensureConfigFile === 'function') {
+          await harness.ensureConfigFile();
+        }
+        if (options.prepareHarness !== undefined) {
+          await options.prepareHarness({ harness, homeDir, principalKey });
+        }
+        record.harnessReady = true;
+      } catch (error) {
+        try {
+          await harness.close?.();
+        } catch {
+          // Preserve the preparation error.
+        }
+        throw error;
+      }
+      return harness;
+    })();
+    principals.set(principalId, record);
+    return record;
+  }
+
+  function getOrCreatePrincipal(principalId) {
+    const existing = principals.get(principalId);
+    if (existing !== undefined) return existing;
+    if (principals.size >= maxPrincipals) {
+      throw registryError(
+        'AGENT_API_PRINCIPAL_LIMIT',
+        'Agent API active customer limit reached',
+      );
+    }
+    return createPrincipalRecord(principalId);
+  }
+
+  async function sessionOptionsFor(input) {
+    const configured = typeof options.sessionOptions === 'function'
+      ? await options.sessionOptions(input)
+      : options.sessionOptions;
+    return normalizeSessionOptions(configured);
+  }
+
+  async function createSession(record, principalId, publicSessionId) {
+    const sessionHash = opaqueHash(
+      isolationSecret,
+      'session',
+      principalId,
+      publicSessionId,
+    );
+    const internalSessionId = `agent_api_${sessionHash.slice(0, 48)}`;
+    const workDir = path.join(record.workRoot, sessionHash.slice(0, 48));
+    await mkdir(workDir, { recursive: true });
+    const harness = await record.harnessPromise;
+    const configured = await sessionOptionsFor({
+      internalSessionId,
+      principalKey: record.principalKey,
+      publicSessionId,
+      workDir,
+    });
+    const session = await harness.createSession({
+      ...configured,
+      id: internalSessionId,
+      model: configured.model ?? 'king',
+      permission: configured.permission ?? 'auto',
+      workDir,
+    });
+    return validateSession(session, internalSessionId);
+  }
+
+  async function resolveSession(input) {
+    ensureOpen();
+    if (input === null || typeof input !== 'object') {
+      throw registryError('AGENT_API_INVALID_SCOPE', 'session scope is required');
+    }
+    const principalId = requirePattern(input.principalId, PRINCIPAL_PATTERN, 'principalId');
+    const publicSessionId = requirePattern(
+      input.sessionId,
+      PUBLIC_SESSION_PATTERN,
+      'sessionId',
+    );
+    let record = principals.get(principalId);
+    const existing = record?.sessions.get(publicSessionId);
+    if (existing !== undefined) return existing;
+    if (input.create !== true) {
+      throw registryError('AGENT_API_SESSION_NOT_FOUND', 'Agent API session was not found');
+    }
+    record = getOrCreatePrincipal(principalId);
+    if (record.sessions.size >= maxSessionsPerPrincipal) {
+      throw registryError(
+        'AGENT_API_SESSION_LIMIT',
+        'Agent API session limit reached for this customer',
+      );
+    }
+
+    const pending = createSession(record, principalId, publicSessionId);
+    record.sessions.set(publicSessionId, pending);
+    try {
+      return await pending;
+    } catch (error) {
+      if (record.sessions.get(publicSessionId) === pending) {
+        record.sessions.delete(publicSessionId);
+      }
+      if (!record.harnessReady
+        && record.sessions.size === 0
+        && principals.get(principalId) === record) {
+        principals.delete(principalId);
+      }
+      throw error;
+    }
+  }
+
+  async function closeSession(input) {
+    ensureOpen();
+    if (input === null || typeof input !== 'object') {
+      throw registryError('AGENT_API_INVALID_SCOPE', 'session scope is required');
+    }
+    const principalId = requirePattern(input.principalId, PRINCIPAL_PATTERN, 'principalId');
+    const publicSessionId = requirePattern(
+      input.sessionId,
+      PUBLIC_SESSION_PATTERN,
+      'sessionId',
+    );
+    const record = principals.get(principalId);
+    const pending = record?.sessions.get(publicSessionId);
+    if (pending === undefined) return false;
+    record.sessions.delete(publicSessionId);
+    const session = await pending;
+    await session.close?.();
+    if (record.sessions.size === 0 && principals.get(principalId) === record) {
+      principals.delete(principalId);
+      const harness = await record.harnessPromise.catch(() => null);
+      await harness?.close?.();
+    }
+    return true;
+  }
+
+  async function close() {
+    if (closed) return;
+    closed = true;
+    const records = [...principals.values()];
+    principals.clear();
+    for (const record of records) {
+      const sessions = await Promise.allSettled([...record.sessions.values()]);
+      record.sessions.clear();
+      for (const outcome of sessions) {
+        if (outcome.status === 'fulfilled') await outcome.value.close?.();
+      }
+      const harness = await record.harnessPromise.catch(() => null);
+      await harness?.close?.();
+    }
+  }
+
+  return Object.freeze({ close, closeSession, resolveSession });
+}
+
+export {
+  AgentApiSessionRegistryError,
+  DEFAULT_MAX_PRINCIPALS,
+  DEFAULT_MAX_SESSIONS_PER_PRINCIPAL,
+  createAgentApiSessionRegistry,
+};

package/bin/agent-api-turn-controller.mjs

@@ -123,7 +123,7 @@ function openAiEnvelope(turn, message, finishReason) {
     blun: {
       mode: 'agent',
       task_id: turn.taskId,
-      session_id: turn.sessionId,
+      session_id: turn.publicSessionId,
       request_id: turn.requestId,
     },
   };
@@ -337,6 +337,9 @@ function createAgentApiTurnController(options = {}) {
       throw controllerError('AGENT_API_INVALID_REQUEST', 'turn input must be an object');
     }
     const sessionId = validateSession(input.session);
+    const publicSessionId = input.publicSessionId === undefined
+      ? sessionId
+      : requireId(input.publicSessionId, 'publicSessionId');
     const requestId = requireId(input.requestId, 'requestId');
     if (activeTurns.has(sessionId)) {
       throw controllerError(
@@ -360,6 +363,7 @@ function createAgentApiTurnController(options = {}) {
       closed: false,
       created: Math.floor(Number(now()) / 1000),
       publicModel,
+      publicSessionId,
       requestId,
       session: input.session,
       sessionId,

package/package.json

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