blun-king-cli 9.1.468 → 9.1.470

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-private-http-server.mjs

@@ -0,0 +1,268 @@
+import { createHash, timingSafeEqual } from 'node:crypto';
+import { createServer } from 'node:http';
+
+const DEFAULT_HOST = '127.0.0.1';
+const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+const INTERNAL_SECRET_HEADER = 'x-blun-agent-secret';
+const PRINCIPAL_HEADER = 'x-blun-principal-id';
+const PRINCIPAL_PATTERN = /^[A-Za-z0-9._:-]{1,256}$/u;
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', '::1']);
+
+class AgentApiPrivateHttpServerError extends Error {
+  constructor(code, message, status) {
+    super(message);
+    this.name = 'AgentApiPrivateHttpServerError';
+    this.code = code;
+    this.status = status;
+  }
+}
+
+function serverError(code, message, status) {
+  return new AgentApiPrivateHttpServerError(code, message, status);
+}
+
+function validateAdapter(adapter) {
+  if (adapter === null || typeof adapter !== 'object'
+    || typeof adapter.handleRequest !== 'function') {
+    throw new TypeError('adapter.handleRequest is required');
+  }
+  return adapter;
+}
+
+function validateSecret(secret) {
+  if (typeof secret !== 'string' || Buffer.byteLength(secret, 'utf8') < 32) {
+    throw new TypeError('internalSecret must contain at least 32 bytes');
+  }
+  return secret;
+}
+
+function validateMaxBodyBytes(value) {
+  if (!Number.isSafeInteger(value) || value < 1024) {
+    throw new TypeError('maxBodyBytes must be an integer of at least 1024');
+  }
+  return value;
+}
+
+function singleHeader(headers, name) {
+  const value = headers[name];
+  return typeof value === 'string' ? value : undefined;
+}
+
+function secretMatches(actual, expected) {
+  if (typeof actual !== 'string') return false;
+  const actualHash = createHash('sha256').update(actual, 'utf8').digest();
+  const expectedHash = createHash('sha256').update(expected, 'utf8').digest();
+  return timingSafeEqual(actualHash, expectedHash);
+}
+
+function requirePrincipal(headers) {
+  const principalId = singleHeader(headers, PRINCIPAL_HEADER);
+  if (principalId === undefined || !PRINCIPAL_PATTERN.test(principalId)) {
+    throw serverError(
+      'AGENT_API_UNAUTHENTICATED',
+      'Trusted Agent API principal is required.',
+      401,
+    );
+  }
+  return principalId;
+}
+
+function declaredLength(headers) {
+  const raw = singleHeader(headers, 'content-length');
+  if (raw === undefined) return undefined;
+  if (!/^\d+$/u.test(raw)) {
+    throw serverError('AGENT_API_INVALID_BODY', 'Request body length is invalid.', 400);
+  }
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value)) {
+    throw serverError('AGENT_API_INVALID_BODY', 'Request body length is invalid.', 400);
+  }
+  return value;
+}
+
+function collectBody(request, maxBodyBytes) {
+  const length = declaredLength(request.headers);
+  if (length !== undefined && length > maxBodyBytes) {
+    request.resume();
+    throw serverError('AGENT_API_BODY_TOO_LARGE', 'Agent API request is too large.', 413);
+  }
+
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    let settled = false;
+
+    request.on('data', (chunk) => {
+      if (settled) return;
+      size += chunk.length;
+      if (size > maxBodyBytes) {
+        settled = true;
+        chunks.length = 0;
+        request.resume();
+        reject(serverError(
+          'AGENT_API_BODY_TOO_LARGE',
+          'Agent API request is too large.',
+          413,
+        ));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    request.on('end', () => {
+      if (settled) return;
+      settled = true;
+      resolve(Buffer.concat(chunks, size));
+    });
+    request.on('aborted', () => {
+      if (settled) return;
+      settled = true;
+      reject(serverError('AGENT_API_INVALID_BODY', 'Agent API request was aborted.', 400));
+    });
+    request.on('error', (error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    });
+  });
+}
+
+async function readJsonBody(request, maxBodyBytes) {
+  const buffer = await collectBody(request, maxBodyBytes);
+  if (buffer.length === 0) return {};
+  const contentType = singleHeader(request.headers, 'content-type');
+  if (contentType === undefined || !/^application\/json(?:\s*;|\s*$)/iu.test(contentType)) {
+    throw serverError(
+      'AGENT_API_UNSUPPORTED_MEDIA_TYPE',
+      'Agent API requests must use application/json.',
+      415,
+    );
+  }
+  try {
+    return JSON.parse(buffer.toString('utf8'));
+  } catch {
+    throw serverError('AGENT_API_INVALID_JSON', 'Request body is not valid JSON.', 400);
+  }
+}
+
+function publicError(error) {
+  if (error instanceof AgentApiPrivateHttpServerError) {
+    return {
+      status: error.status,
+      body: {
+        error: {
+          type: 'invalid_request_error',
+          code: error.code,
+          message: error.message,
+        },
+      },
+    };
+  }
+  return {
+    status: 500,
+    body: {
+      error: {
+        type: 'internal_error',
+        code: 'AGENT_API_INTERNAL',
+        message: 'Agent request failed.',
+      },
+    },
+  };
+}
+
+function writeJson(response, status, body, headers = {}) {
+  if (response.headersSent || response.destroyed) return;
+  response.writeHead(status, {
+    ...headers,
+    'cache-control': 'no-store',
+    'content-type': 'application/json',
+    'x-content-type-options': 'nosniff',
+  });
+  response.end(JSON.stringify(body));
+}
+
+function createAgentApiPrivateHttpServer(options = {}) {
+  const adapter = validateAdapter(options.adapter);
+  const internalSecret = validateSecret(options.internalSecret);
+  const maxBodyBytes = validateMaxBodyBytes(
+    options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES,
+  );
+
+  async function handle(request, response) {
+    try {
+      if (!secretMatches(singleHeader(request.headers, INTERNAL_SECRET_HEADER), internalSecret)) {
+        request.resume();
+        throw serverError('AGENT_API_UNAUTHENTICATED', 'Agent API authentication failed.', 401);
+      }
+      const principalId = requirePrincipal(request.headers);
+      const body = await readJsonBody(request, maxBodyBytes);
+      const result = await adapter.handleRequest({
+        method: request.method,
+        path: request.url,
+        principalId,
+        body,
+      });
+      if (result === null) {
+        writeJson(response, 404, {
+          error: {
+            type: 'invalid_request_error',
+            code: 'AGENT_API_ROUTE_NOT_FOUND',
+            message: 'Agent API route not found.',
+          },
+        });
+        return;
+      }
+      writeJson(response, result.status, result.body, result.headers);
+    } catch (error) {
+      const result = publicError(error);
+      writeJson(response, result.status, result.body);
+    }
+  }
+
+  const server = createServer((request, response) => {
+    void handle(request, response);
+  });
+  server.maxHeadersCount = 64;
+  server.headersTimeout = 10_000;
+  server.requestTimeout = 30_000;
+  server.keepAliveTimeout = 5_000;
+
+  function listen(input = {}) {
+    const host = input.host ?? DEFAULT_HOST;
+    const port = input.port ?? 0;
+    if (!LOOPBACK_HOSTS.has(host)) {
+      throw new TypeError('Agent API private server may listen on loopback only');
+    }
+    if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+      throw new TypeError('port must be an integer from 0 through 65535');
+    }
+    return new Promise((resolve, reject) => {
+      const onError = (error) => reject(error);
+      server.once('error', onError);
+      server.listen({ host, port, exclusive: true }, () => {
+        server.off('error', onError);
+        resolve(server.address());
+      });
+    });
+  }
+
+  function close() {
+    if (!server.listening) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      server.close((error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
+  return Object.freeze({ close, listen, server });
+}
+
+export {
+  AgentApiPrivateHttpServerError,
+  DEFAULT_HOST,
+  DEFAULT_MAX_BODY_BYTES,
+  INTERNAL_SECRET_HEADER,
+  PRINCIPAL_HEADER,
+  createAgentApiPrivateHttpServer,
+};

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.468",
+  "version": "9.1.470",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {