@bbigbang/agent-node 0.1.0

package/dist/agentHost.js

@@ -0,0 +1,483 @@
+import fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { BindingRuntime, createRun, finishRun, getUiMode, log, } from '@bbigbang/runtime-acp';
+import { ClaudeDirectRuntime } from './claudeDirectRuntime.js';
+import { CodexAppServerRuntime } from './codexAppServerRuntime.js';
+import { buildHostAssetCacheRoot } from './assetCachePaths.js';
+import { NodeSink } from './nodeSink.js';
+export class HostDispatchRejectedError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'HostDispatchRejectedError';
+        this.code = code;
+    }
+}
+export class AgentHost {
+    hostKey;
+    sessionKey;
+    hostInstanceId;
+    nodeProcessInstanceId;
+    workspaceRoot;
+    assetCacheRoot;
+    runtime;
+    db;
+    send;
+    hooks;
+    maxInboxSize;
+    state = 'idle';
+    inbox = [];
+    processing = false;
+    currentRunId = null;
+    lastWakeAt = null;
+    lastSleepAt = Date.now();
+    lastError = null;
+    closeRequested = false;
+    closeWaiters = [];
+    constructor(params) {
+        this.hostKey = params.hostKey;
+        this.sessionKey = params.sessionKey;
+        this.hostInstanceId = params.hostInstanceId ?? randomUUID();
+        this.nodeProcessInstanceId = params.config.processInstanceId;
+        this.workspaceRoot = params.workspaceRoot;
+        this.assetCacheRoot = params.assetCacheRoot?.trim()
+            || (params.assetAccessConfig
+                ? buildHostAssetCacheRoot(params.assetAccessConfig.agentId, params.assetAccessConfig.conversationId, this.hostInstanceId)
+                : null);
+        this.db = params.db;
+        this.send = params.send;
+        this.hooks = params.hooks ?? {};
+        this.maxInboxSize = Math.max(1, params.config.hostInboxLimit);
+        const onAssetMaterialized = params.assetAccessConfig
+            ? (event) => {
+                this.send({
+                    type: 'asset.materialized',
+                    assetId: event.assetId,
+                    agentId: params.assetAccessConfig.agentId,
+                    conversationId: params.assetAccessConfig.conversationId,
+                    nodeProcessInstanceId: this.nodeProcessInstanceId,
+                    hostKey: this.hostKey,
+                    hostInstanceId: this.hostInstanceId,
+                    runId: event.runId ?? null,
+                    localPath: event.localPath,
+                    materializedAt: event.materializedAt,
+                });
+            }
+            : undefined;
+        if (params.agentType === 'claude_sdk') {
+            this.runtime = new ClaudeDirectRuntime({
+                db: params.db,
+                sessionKey: params.sessionKey,
+                bindingKey: params.bindingKey,
+                workspaceRoot: params.workspaceRoot,
+                env: params.env,
+                model: params.model,
+                reasoningEffort: params.reasoningEffort,
+                claudePermissionMode: params.claudePermissionMode,
+                disabledToolKinds: params.disabledToolKinds,
+                channelBridgeMcpEntry: params.channelBridgeMcpEntry,
+                agentSurfaceMode: params.config.agentSurfaceMode,
+                toolAuth: params.toolAuth,
+                workspaceLockManager: params.workspaceLockManager,
+                assetAccessConfig: params.assetAccessConfig,
+                assetCacheRoot: this.assetCacheRoot,
+                onAssetMaterialized,
+                queryImpl: params.claudeQueryImpl,
+            });
+        }
+        else if (params.agentType === 'codex_app_server') {
+            this.runtime = new CodexAppServerRuntime({
+                db: params.db,
+                sessionKey: params.sessionKey,
+                bindingKey: params.bindingKey,
+                toolAuth: params.toolAuth,
+                workspaceRoot: params.workspaceRoot,
+                agentCommand: params.agentCommand,
+                agentArgs: params.agentArgs,
+                env: params.env,
+                model: params.model,
+                reasoningEffort: params.reasoningEffort,
+                serviceTier: params.codexServiceTier,
+                disabledToolKinds: params.disabledToolKinds,
+                channelBridgeMcpEntry: params.channelBridgeMcpEntry,
+                agentSurfaceMode: params.config.agentSurfaceMode,
+                assetAccessConfig: params.assetAccessConfig,
+                assetCacheRoot: this.assetCacheRoot,
+                onAssetMaterialized,
+                workspaceLockManager: params.workspaceLockManager,
+            });
+        }
+        else {
+            this.runtime = new BindingRuntime({
+                db: params.db,
+                config: params.config,
+                toolAuth: params.toolAuth,
+                sessionKey: params.sessionKey,
+                bindingKey: params.bindingKey,
+                workspaceRoot: params.workspaceRoot,
+                agentCommand: params.agentCommand,
+                agentArgs: params.agentArgs,
+                env: params.env,
+                disabledToolKinds: params.disabledToolKinds,
+                channelBridgeMcpEntry: params.channelBridgeMcpEntry,
+                workspaceLockManager: params.workspaceLockManager,
+            });
+        }
+    }
+    getState() {
+        return this.state;
+    }
+    getHostInstanceId() {
+        return this.hostInstanceId;
+    }
+    getCurrentRunId() {
+        return this.currentRunId;
+    }
+    getLastWakeAt() {
+        return this.lastWakeAt;
+    }
+    getLastSleepAt() {
+        return this.lastSleepAt;
+    }
+    getInboxSize() {
+        return this.inbox.length;
+    }
+    getLastError() {
+        return this.lastError;
+    }
+    getWorkspaceRoot() {
+        return this.workspaceRoot;
+    }
+    hasPendingApproval() {
+        return this.runtime.hasPendingPermission();
+    }
+    isIdleExpired(now, idleTimeoutMs) {
+        if (this.state !== 'idle')
+            return false;
+        if (this.currentRunId)
+            return false;
+        if (this.inbox.length > 0)
+            return false;
+        if (this.hasPendingApproval())
+            return false;
+        if (!this.lastSleepAt)
+            return false;
+        return now - this.lastSleepAt >= idleTimeoutMs;
+    }
+    async dispatch(msg) {
+        return new Promise((resolve, reject) => {
+            if (this.closeRequested) {
+                reject(new HostDispatchRejectedError('HOST_CLOSED', `Host ${this.hostKey} closed`));
+                return;
+            }
+            if (this.state === 'failed') {
+                reject(new HostDispatchRejectedError('HOST_FAILED', this.lastError ?? `Host ${this.hostKey} is failed`));
+                return;
+            }
+            if (this.inbox.length >= this.maxInboxSize) {
+                reject(new HostDispatchRejectedError('HOST_INBOX_OVERFLOW', `Host ${this.hostKey} inbox overflow (limit=${this.maxInboxSize})`));
+                return;
+            }
+            if (this.processing || this.currentRunId) {
+                log.info('[agent-host] queued dispatch in inbox', {
+                    hostKey: this.hostKey,
+                    runId: msg.runId,
+                    conversationId: msg.conversationId,
+                    inboxSize: this.inbox.length + 1,
+                });
+            }
+            this.inbox.push({ msg, resolve, reject });
+            void this.processInbox();
+        });
+    }
+    async processInbox() {
+        if (this.processing || this.state === 'failed')
+            return;
+        this.processing = true;
+        try {
+            while (this.inbox.length > 0) {
+                const pending = this.inbox.shift();
+                try {
+                    await this.runDispatch(pending.msg);
+                    pending.resolve();
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    pending.reject(err);
+                    if (this.getState() === 'failed') {
+                        this.failPendingInbox(err);
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            this.processing = false;
+            if (this.getState() !== 'failed' && !this.currentRunId) {
+                this.state = 'idle';
+                this.lastSleepAt = Date.now();
+            }
+            this.notifyCloseWaitersIfDrained();
+        }
+    }
+    async runDispatch(msg) {
+        const { runId, conversationId, prompt } = msg;
+        let deliveryAckSent = false;
+        const sendDeliveryAck = async () => {
+            if (deliveryAckSent || !msg.delivery)
+                return;
+            deliveryAckSent = true;
+            this.send({
+                type: 'run.delivery.ack',
+                deliveryId: msg.delivery.deliveryId,
+                roundId: msg.delivery.roundId,
+                runId,
+                conversationId,
+                ackedThroughSeq: msg.delivery.ackedThroughSeq,
+                mode: 'dispatch',
+            });
+        };
+        const sink = new NodeSink(runId, conversationId, this.send, {
+            onPermissionRequest: () => {
+                this.hooks.onAwaitingApproval?.(msg);
+            },
+        });
+        if (msg.dispatchMode === 'resume') {
+            log.info('[agent-host] waking existing host', {
+                hostKey: this.hostKey,
+                sessionKey: this.sessionKey,
+                lastWakeAt: this.lastWakeAt,
+                lastSleepAt: this.lastSleepAt,
+            });
+        }
+        const existingRun = this.db
+            .prepare(`SELECT run_id as runId FROM runs WHERE run_id = ?`)
+            .get(runId);
+        if (!existingRun) {
+            createRun(this.db, { runId, sessionKey: this.sessionKey, promptText: prompt });
+        }
+        const hadPreviousWake = this.lastWakeAt != null;
+        this.state = 'active';
+        this.currentRunId = runId;
+        this.lastWakeAt = Date.now();
+        this.lastSleepAt = null;
+        this.lastError = null;
+        this.writeRunContext(msg);
+        this.hooks.onRunStart?.(msg);
+        const nowMs = Date.now();
+        this.send({
+            type: 'run.event',
+            runId,
+            conversationId,
+            event: { type: 'turn.begin', turnId: runId, startedAt: nowMs, promptText: prompt },
+        });
+        this.send({
+            type: 'run.event',
+            runId,
+            conversationId,
+            event: { type: 'conversation.status', conversationId, status: 'active' },
+        });
+        try {
+            this.runtime.updateConfig?.({
+                model: msg.model,
+                reasoningEffort: msg.reasoningEffort,
+                claudePermissionMode: msg.claudePermissionMode,
+                codexServiceTier: msg.codexServiceTier,
+                disabledToolKinds: msg.disabledToolKinds,
+                envVars: msg.envVars,
+            });
+            const uiMode = getUiMode(this.db, `node:${conversationId}:-:node_user`) ?? 'summary';
+            const shouldInjectResumeContext = msg.dispatchMode === 'resume' && !hadPreviousWake;
+            const recoveryContextText = msg.dispatchMode === 'resume' && !shouldInjectResumeContext
+                ? msg.resumeContextText
+                : undefined;
+            const result = await this.runtime.prompt({
+                runId,
+                promptText: prompt,
+                sink,
+                uiMode,
+                dreamMode: msg.dispatchMode === 'dream',
+                disabledToolKinds: [...(msg.disabledToolKinds ?? [])],
+                attachments: msg.attachments,
+                promptResources: msg.attachments,
+                runtimeOverrides: msg.runtimeOverrides,
+                systemPromptText: msg.systemPromptText,
+                contextText: msg.contextText,
+                resumeContextText: shouldInjectResumeContext ? msg.resumeContextText : undefined,
+                recoveryContextText,
+                actorUserId: 'node_user',
+                onPrepared: async (prepared) => {
+                    this.send({
+                        type: 'run.debug.snapshot',
+                        runId,
+                        conversationId,
+                        sessionKey: this.sessionKey,
+                        acpSessionId: prepared.sessionId,
+                        isFreshSession: prepared.isFreshSession,
+                        isExact: prepared.isFreshSession || Boolean(prepared.effectiveSystemPromptText),
+                        effectiveSystemPromptText: prepared.effectiveSystemPromptText,
+                        effectiveContextText: prepared.effectiveContextText,
+                    });
+                },
+                onDelivered: sendDeliveryAck,
+            });
+            finishRun(this.db, { runId, stopReason: result.stopReason });
+            this.state = 'idle';
+            log.info('[agent-host] run finished', {
+                hostKey: this.hostKey,
+                runId,
+                conversationId,
+                stopReason: result.stopReason,
+                dispatchMode: msg.dispatchMode,
+                inboxSize: this.inbox.length,
+            });
+            this.send({ type: 'run.end', runId, conversationId, stopReason: result.stopReason });
+        }
+        catch (error) {
+            const errMsg = String(error?.message ?? error);
+            this.state = 'failed';
+            this.lastError = errMsg;
+            log.warn('[agent-host] run error', {
+                hostKey: this.hostKey,
+                runId,
+                conversationId,
+                error: errMsg,
+            });
+            finishRun(this.db, { runId, error: errMsg });
+            this.send({ type: 'run.end', runId, conversationId, error: errMsg });
+            throw error instanceof Error ? error : new Error(errMsg);
+        }
+        finally {
+            this.hooks.onRunFinish?.(msg);
+            this.currentRunId = null;
+            if (this.state !== 'failed') {
+                this.state = 'idle';
+                this.lastSleepAt = Date.now();
+            }
+        }
+    }
+    failPendingInbox(cause) {
+        while (this.inbox.length > 0) {
+            const pending = this.inbox.shift();
+            this.send({
+                type: 'run.end',
+                runId: pending.msg.runId,
+                conversationId: pending.msg.conversationId,
+                error: cause.message,
+            });
+            pending.reject(cause);
+        }
+    }
+    async cancelRun(runId) {
+        if (this.currentRunId !== runId)
+            return false;
+        return this.runtime.cancelCurrentRun(runId);
+    }
+    async steerRun(runId, promptText, attachments) {
+        if (this.currentRunId !== runId)
+            return false;
+        if (!this.runtime.steerCurrentRun)
+            return false;
+        return this.runtime.steerCurrentRun(runId, promptText, attachments);
+    }
+    async handlePermissionResponse(requestId, decision, selectedActionId, responseText, answers) {
+        return this.runtime.respondToPermission(requestId, decision, selectedActionId, responseText, answers);
+    }
+    async getClaudeControls() {
+        if (!this.runtime.getClaudeControls) {
+            throw new Error('Claude controls are unavailable for this runtime.');
+        }
+        return this.runtime.getClaudeControls();
+    }
+    async setClaudeMode(modeId) {
+        if (!this.runtime.setClaudeMode) {
+            throw new Error('Claude mode control is unavailable for this runtime.');
+        }
+        return this.runtime.setClaudeMode(modeId);
+    }
+    async setClaudeModel(modelId) {
+        if (!this.runtime.setClaudeModel) {
+            throw new Error('Claude model control is unavailable for this runtime.');
+        }
+        return this.runtime.setClaudeModel(modelId);
+    }
+    async executeClaudeCommand(commandName, args) {
+        if (!this.runtime.executeClaudeCommand) {
+            throw new Error('Claude commands are unavailable for this runtime.');
+        }
+        return this.runtime.executeClaudeCommand(commandName, args);
+    }
+    close() {
+        this.closeRequested = true;
+        this.failPendingInbox(new Error(`Host ${this.hostKey} closed`));
+        void Promise.resolve(this.runtime.close()).finally(() => {
+            this.cleanupAssetCacheRoot();
+        });
+    }
+    async closeAndWait(timeoutMs = 4_500) {
+        this.closeRequested = true;
+        this.failPendingInbox(new Error(`Host ${this.hostKey} closed`));
+        await Promise.resolve(this.runtime.close()).finally(() => {
+            this.cleanupAssetCacheRoot();
+        });
+        if (!this.processing && !this.currentRunId)
+            return;
+        await new Promise((resolve, reject) => {
+            const onDrained = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            const timer = setTimeout(() => {
+                this.closeWaiters = this.closeWaiters.filter((waiter) => waiter !== onDrained);
+                reject(new Error(`Timed out waiting for host ${this.hostKey} to close`));
+            }, timeoutMs);
+            this.closeWaiters.push(onDrained);
+            this.notifyCloseWaitersIfDrained();
+        });
+    }
+    notifyCloseWaitersIfDrained() {
+        if (!this.closeRequested || this.processing || this.currentRunId)
+            return;
+        const waiters = this.closeWaiters.splice(0);
+        for (const waiter of waiters)
+            waiter();
+    }
+    cleanupAssetCacheRoot() {
+        if (!this.assetCacheRoot)
+            return;
+        try {
+            fs.rmSync(this.assetCacheRoot, { recursive: true, force: true });
+        }
+        finally {
+            this.send({
+                type: 'asset.materialization.cleared',
+                nodeProcessInstanceId: this.nodeProcessInstanceId,
+                hostKey: this.hostKey,
+                hostInstanceId: this.hostInstanceId,
+                clearedAt: Date.now(),
+                reason: 'host_closed',
+            });
+        }
+    }
+    writeRunContext(msg) {
+        if (!this.assetCacheRoot)
+            return;
+        try {
+            fs.mkdirSync(this.assetCacheRoot, { recursive: true });
+            fs.writeFileSync(`${this.assetCacheRoot}/run-context.json`, JSON.stringify({
+                runId: msg.runId,
+                turnId: msg.runId,
+                traceId: msg.runId,
+                conversationId: msg.conversationId,
+                updatedAt: Date.now(),
+            }), 'utf8');
+        }
+        catch (error) {
+            log.warn('[agent-host] failed to write run context for channel bridge', {
+                hostKey: this.hostKey,
+                runId: msg.runId,
+                error: String(error?.message ?? error),
+            });
+        }
+    }
+}

package/dist/appVersion.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function readAgentNodeVersion() {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const packageJsonPath = path.resolve(currentDir, '../package.json');
+    try {
+        const parsed = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        return typeof parsed.version === 'string' && parsed.version.trim() ? parsed.version.trim() : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/dist/assetCachePaths.js

@@ -0,0 +1,35 @@
+import os from 'node:os';
+import path from 'node:path';
+const ASSET_CACHE_ROOT_DIRNAME = 'bigbang-assets';
+export function buildConversationAssetCacheRoot(agentId, conversationId) {
+    return path.join(os.tmpdir(), ASSET_CACHE_ROOT_DIRNAME, sanitizeAssetCacheSegment(agentId), sanitizeAssetCacheSegment(conversationId));
+}
+export function buildHostAssetCacheRoot(agentId, conversationId, hostInstanceId) {
+    return path.join(buildConversationAssetCacheRoot(agentId, conversationId), 'hosts', sanitizeAssetCacheSegment(hostInstanceId));
+}
+export function resolveScopedAssetCachePath(params) {
+    const preferredLocalPath = normalizeRelativeAssetPath(params.preferredLocalPath);
+    const fallbackRelativePath = path.join('general', `${params.assetId}-${sanitizeLocalAssetFilename(params.filename ?? params.assetId)}`);
+    return path.join(params.cacheRoot, preferredLocalPath ?? fallbackRelativePath);
+}
+function sanitizeAssetCacheSegment(value) {
+    const normalized = value.trim() || 'unknown';
+    return encodeURIComponent(normalized).replace(/%/g, '_');
+}
+function normalizeRelativeAssetPath(value) {
+    if (!value)
+        return null;
+    const normalized = path.normalize(value.trim());
+    if (!normalized || normalized === '.' || path.isAbsolute(normalized))
+        return null;
+    if (normalized === '..' || normalized.startsWith(`..${path.sep}`))
+        return null;
+    return normalized;
+}
+function sanitizeLocalAssetFilename(filename) {
+    return filename
+        .replace(/[^A-Za-z0-9._-]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        || 'asset';
+}