blun-king-cli 9.1.587 → 9.1.588

package/bin/agent-api-session-registry.mjs

@@ -1,428 +0,0 @@
-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 requireIdleDuration(value, label, { allowZero = true } = {}) {
-  if (!Number.isSafeInteger(value) || value < (allowZero ? 0 : 1)) {
-    throw new TypeError(`${label} must be ${allowZero ? 'a non-negative' : '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 sessionIdleTimeoutMs = requireIdleDuration(
-    options.sessionIdleTimeoutMs ?? 0,
-    'sessionIdleTimeoutMs',
-  );
-  if (sessionIdleTimeoutMs === 0 && options.idleSweepIntervalMs !== undefined) {
-    throw new TypeError('idleSweepIntervalMs requires sessionIdleTimeoutMs');
-  }
-  const idleSweepIntervalMs = sessionIdleTimeoutMs === 0
-    ? 0
-    : requireIdleDuration(
-      options.idleSweepIntervalMs ?? Math.min(sessionIdleTimeoutMs, 60_000),
-      'idleSweepIntervalMs',
-      { allowZero: false },
-    );
-  const now = options.now ?? Date.now;
-  const scheduleInterval = options.scheduleInterval ?? setInterval;
-  const cancelInterval = options.cancelInterval ?? clearInterval;
-  if (typeof now !== 'function') throw new TypeError('now must be a function');
-  if (typeof scheduleInterval !== 'function') {
-    throw new TypeError('scheduleInterval must be a function');
-  }
-  if (typeof cancelInterval !== 'function') {
-    throw new TypeError('cancelInterval must be a function');
-  }
-  if (options.isSessionActive !== undefined && typeof options.isSessionActive !== 'function') {
-    throw new TypeError('isSessionActive must be a function');
-  }
-  const principals = new Map();
-  let closed = false;
-  let sweepHandle;
-  let sweepPromise = Promise.resolve(0);
-
-  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) {
-      if (existing.closingPromise !== undefined) {
-        await existing.closingPromise;
-        return resolveSession(input);
-      }
-      existing.lastActiveAt = now();
-      return existing.pending;
-    }
-    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) {
-      await pruneIdleSessions({ principalId });
-      record = principals.get(principalId) ?? getOrCreatePrincipal(principalId);
-    }
-    if (record.sessions.size >= maxSessionsPerPrincipal) {
-      throw registryError(
-        'AGENT_API_SESSION_LIMIT',
-        'Agent API session limit reached for this customer',
-      );
-    }
-
-    const entry = {
-      closingPromise: undefined,
-      lastActiveAt: now(),
-      pending: undefined,
-      ready: false,
-    };
-    entry.pending = createSession(record, principalId, publicSessionId).then((session) => {
-      entry.ready = true;
-      entry.lastActiveAt = now();
-      return session;
-    });
-    record.sessions.set(publicSessionId, entry);
-    try {
-      return await entry.pending;
-    } catch (error) {
-      if (record.sessions.get(publicSessionId) === entry) {
-        record.sessions.delete(publicSessionId);
-      }
-      if (!record.harnessReady
-        && record.sessions.size === 0
-        && principals.get(principalId) === record) {
-        principals.delete(principalId);
-      }
-      throw error;
-    }
-  }
-
-  function touchSession(input) {
-    if (closed || input === null || typeof input !== 'object') return false;
-    const record = principals.get(input.principalId);
-    const entry = record?.sessions.get(input.sessionId);
-    if (entry === undefined || entry.closingPromise !== undefined) return false;
-    entry.lastActiveAt = now();
-    return true;
-  }
-
-  function sessionIsActive(principalId, publicSessionId) {
-    if (options.isSessionActive === undefined) return false;
-    try {
-      const result = options.isSessionActive({ principalId, sessionId: publicSessionId });
-      return result === true || result?.then !== undefined;
-    } catch {
-      return true;
-    }
-  }
-
-  async function closeEntry(record, principalId, publicSessionId, entry) {
-    if (entry.closingPromise !== undefined) return entry.closingPromise;
-    entry.closingPromise = (async () => {
-      let failure;
-      try {
-        const session = await entry.pending;
-        await session.close?.();
-      } catch (error) {
-        failure = error;
-      }
-      if (record.sessions.get(publicSessionId) === entry) {
-        record.sessions.delete(publicSessionId);
-      }
-      if (record.sessions.size === 0 && principals.get(principalId) === record) {
-        principals.delete(principalId);
-        const harness = await record.harnessPromise.catch(() => null);
-        try {
-          await harness?.close?.();
-        } catch (error) {
-          failure ??= error;
-        }
-      }
-      if (failure !== undefined) throw failure;
-      return true;
-    })();
-    return entry.closingPromise;
-  }
-
-  async function pruneIdleSessions(input = {}) {
-    if (closed || sessionIdleTimeoutMs === 0) return 0;
-    const principalFilter = input.principalId;
-    const cutoff = now() - sessionIdleTimeoutMs;
-    const closing = [];
-    for (const [principalId, record] of principals) {
-      if (principalFilter !== undefined && principalId !== principalFilter) continue;
-      for (const [publicSessionId, entry] of record.sessions) {
-        if (!entry.ready
-          || entry.closingPromise !== undefined
-          || entry.lastActiveAt > cutoff
-          || sessionIsActive(principalId, publicSessionId)) {
-          continue;
-        }
-        closing.push(closeEntry(record, principalId, publicSessionId, entry));
-      }
-    }
-    const outcomes = await Promise.allSettled(closing);
-    return outcomes.filter((outcome) => outcome.status === 'fulfilled').length;
-  }
-
-  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 entry = record?.sessions.get(publicSessionId);
-    if (entry === undefined) return false;
-    return closeEntry(record, principalId, publicSessionId, entry);
-  }
-
-  async function close() {
-    if (closed) return;
-    closed = true;
-    if (sweepHandle !== undefined) cancelInterval(sweepHandle);
-    await sweepPromise;
-    const records = [...principals.values()];
-    principals.clear();
-    for (const record of records) {
-      const sessions = await Promise.allSettled(
-        [...record.sessions.values()].map(async (entry) => {
-          if (entry.closingPromise !== undefined) {
-            await entry.closingPromise;
-            return null;
-          }
-          return entry.pending;
-        }),
-      );
-      record.sessions.clear();
-      for (const outcome of sessions) {
-        if (outcome.status === 'fulfilled' && outcome.value !== null) {
-          await outcome.value.close?.();
-        }
-      }
-      const harness = await record.harnessPromise.catch(() => null);
-      await harness?.close?.();
-    }
-  }
-
-  if (sessionIdleTimeoutMs > 0) {
-    sweepHandle = scheduleInterval(() => {
-      sweepPromise = sweepPromise.then(() => pruneIdleSessions()).catch(() => 0);
-      return sweepPromise;
-    }, idleSweepIntervalMs);
-    sweepHandle?.unref?.();
-  }
-
-  return Object.freeze({ close, closeSession, pruneIdleSessions, resolveSession, touchSession });
-}
-
-export {
-  AgentApiSessionRegistryError,
-  DEFAULT_MAX_PRINCIPALS,
-  DEFAULT_MAX_SESSIONS_PER_PRINCIPAL,
-  createAgentApiSessionRegistry,
-};

package/bin/agent-api-tool-broker.cjs

@@ -1,248 +0,0 @@
-'use strict';
-
-const DEFAULT_MAX_PENDING_TOOL_CALLS = 32;
-
-class AgentApiToolBrokerError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.name = 'AgentApiToolBrokerError';
-    this.code = code;
-  }
-}
-
-function brokerError(code, message) {
-  return new AgentApiToolBrokerError(code, message);
-}
-
-function requireId(value, label) {
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw brokerError('AGENT_API_INVALID_SCOPE', `${label} must be a non-empty string`);
-  }
-  return value.trim();
-}
-
-function normalizeToolNames(value) {
-  if (!Array.isArray(value)) {
-    throw brokerError('AGENT_API_INVALID_TOOLS', 'toolNames must be an array');
-  }
-  const names = value.map((name) => requireId(name, 'tool name'));
-  if (new Set(names).size !== names.length) {
-    throw brokerError('AGENT_API_INVALID_TOOLS', 'toolNames must not contain duplicates');
-  }
-  return new Set(names);
-}
-
-function normalizeMaxPendingToolCalls(value) {
-  const normalized = value ?? DEFAULT_MAX_PENDING_TOOL_CALLS;
-  if (!Number.isSafeInteger(normalized) || normalized < 1) {
-    throw brokerError(
-      'AGENT_API_INVALID_LIMIT',
-      'maxPendingToolCalls must be a positive safe integer',
-    );
-  }
-  return normalized;
-}
-
-function normalizeToolResult(input) {
-  if (typeof input.output !== 'string') {
-    throw brokerError('AGENT_API_INVALID_TOOL_RESULT', 'tool result output must be a string');
-  }
-  if (input.isError !== undefined && typeof input.isError !== 'boolean') {
-    throw brokerError('AGENT_API_INVALID_TOOL_RESULT', 'tool result isError must be a boolean');
-  }
-  return {
-    output: input.output,
-    isError: input.isError === true,
-  };
-}
-
-function cloneArgs(value) {
-  try {
-    return structuredClone(value);
-  } catch {
-    throw brokerError('AGENT_API_INVALID_TOOL_ARGS', 'tool arguments must be structured-cloneable');
-  }
-}
-
-function createDeferred() {
-  let resolve;
-  let reject;
-  const promise = new Promise((resolvePromise, rejectPromise) => {
-    resolve = resolvePromise;
-    reject = rejectPromise;
-  });
-  return { promise, reject, resolve };
-}
-
-function createAgentApiToolBroker(options = {}) {
-  const maxPendingToolCalls = normalizeMaxPendingToolCalls(options.maxPendingToolCalls);
-  const activeRequests = new Map();
-
-  function requestForScope(input) {
-    const sessionId = requireId(input.sessionId, 'sessionId');
-    const requestId = requireId(input.requestId, 'requestId');
-    const request = activeRequests.get(sessionId);
-    if (request === undefined) {
-      throw brokerError('AGENT_API_REQUEST_NOT_ACTIVE', 'no active Agent API request for session');
-    }
-    if (request.requestId !== requestId) {
-      throw brokerError(
-        'AGENT_API_TOOL_RESULT_SCOPE_MISMATCH',
-        'Agent API request does not match the active session request',
-      );
-    }
-    return request;
-  }
-
-  function pendingToolCallCount() {
-    let count = 0;
-    for (const request of activeRequests.values()) count += request.pending.size;
-    return count;
-  }
-
-  function deliverEvent(request, event) {
-    const waiter = request.eventWaiters.shift();
-    if (waiter !== undefined) {
-      waiter.resolve(event);
-      return;
-    }
-    request.events.push(event);
-  }
-
-  function beginRequest(input) {
-    const sessionId = requireId(input.sessionId, 'sessionId');
-    const requestId = requireId(input.requestId, 'requestId');
-    if (activeRequests.has(sessionId)) {
-      throw brokerError(
-        'AGENT_API_SESSION_BUSY',
-        'session already has an active Agent API request',
-      );
-    }
-    const request = {
-      sessionId,
-      requestId,
-      toolNames: normalizeToolNames(input.toolNames),
-      seenToolCallIds: new Set(),
-      pending: new Map(),
-      events: [],
-      eventWaiters: [],
-    };
-    activeRequests.set(sessionId, request);
-    return { sessionId, requestId };
-  }
-
-  function handleToolCall(input) {
-    const sessionId = requireId(input.sessionId, 'sessionId');
-    const toolCallId = requireId(input.toolCallId, 'toolCallId');
-    const toolName = requireId(input.toolName, 'toolName');
-    const request = activeRequests.get(sessionId);
-    if (request === undefined) {
-      return Promise.reject(brokerError(
-        'AGENT_API_REQUEST_NOT_ACTIVE',
-        'no active Agent API request for SDK tool call',
-      ));
-    }
-    if (!request.toolNames.has(toolName)) {
-      return Promise.reject(brokerError(
-        'AGENT_API_TOOL_NOT_DECLARED',
-        `tool "${toolName}" was not declared by the API client`,
-      ));
-    }
-    if (request.seenToolCallIds.has(toolCallId)) {
-      return Promise.reject(brokerError(
-        'AGENT_API_TOOL_CALL_DUPLICATE',
-        `tool call "${toolCallId}" has already been accepted`,
-      ));
-    }
-    if (pendingToolCallCount() >= maxPendingToolCalls) {
-      return Promise.reject(brokerError(
-        'AGENT_API_TOOL_CALL_LIMIT',
-        'too many client tool calls are waiting for results',
-      ));
-    }
-
-    const deferred = createDeferred();
-    request.seenToolCallIds.add(toolCallId);
-    request.pending.set(toolCallId, deferred);
-    deliverEvent(request, Object.freeze({
-      type: 'client_tool_call',
-      sessionId,
-      requestId: request.requestId,
-      turnId: input.turnId,
-      toolCallId,
-      toolName,
-      args: cloneArgs(input.args),
-    }));
-    return deferred.promise;
-  }
-
-  function nextToolCall(input) {
-    const request = requestForScope(input);
-    const event = request.events.shift();
-    if (event !== undefined) return Promise.resolve(event);
-    const deferred = createDeferred();
-    request.eventWaiters.push(deferred);
-    return deferred.promise;
-  }
-
-  function submitToolResult(input) {
-    const request = requestForScope(input);
-    const toolCallId = requireId(input.toolCallId, 'toolCallId');
-    const pending = request.pending.get(toolCallId);
-    if (pending === undefined) {
-      throw brokerError(
-        'AGENT_API_TOOL_CALL_NOT_PENDING',
-        `tool call "${toolCallId}" is not waiting for a result`,
-      );
-    }
-    const result = normalizeToolResult(input);
-    request.pending.delete(toolCallId);
-    pending.resolve(result);
-    return true;
-  }
-
-  function abortRequest(input) {
-    const request = requestForScope(input);
-    const reason = typeof input.reason === 'string' && input.reason.trim().length > 0
-      ? input.reason.trim()
-      : 'request aborted';
-    const error = brokerError('AGENT_API_REQUEST_ABORTED', reason);
-    activeRequests.delete(request.sessionId);
-    request.events.length = 0;
-    for (const waiter of request.eventWaiters.splice(0)) waiter.reject(error);
-    for (const pending of request.pending.values()) pending.reject(error);
-    request.pending.clear();
-    return true;
-  }
-
-  function finishRequest(input) {
-    const request = requestForScope(input);
-    if (request.pending.size > 0) {
-      throw brokerError(
-        'AGENT_API_REQUEST_HAS_PENDING_TOOLS',
-        'cannot finish a request while client tool results are pending',
-      );
-    }
-    const error = brokerError('AGENT_API_REQUEST_FINISHED', 'Agent API request finished');
-    activeRequests.delete(request.sessionId);
-    request.events.length = 0;
-    for (const waiter of request.eventWaiters.splice(0)) waiter.reject(error);
-    return true;
-  }
-
-  return Object.freeze({
-    abortRequest,
-    beginRequest,
-    finishRequest,
-    handleToolCall,
-    nextToolCall,
-    pendingToolCallCount,
-    submitToolResult,
-  });
-}
-
-module.exports = {
-  AgentApiToolBrokerError,
-  DEFAULT_MAX_PENDING_TOOL_CALLS,
-  createAgentApiToolBroker,
-};