@bbigbang/agent-node 0.1.0

package/dist/skillFs.js

@@ -0,0 +1,229 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { normalizeSkillRootsWithBuiltins } from './builtinSkillRoots.js';
+import { WorkspaceFsError } from './workspaceFs.js';
+const MAX_PREVIEW_BYTES = 256 * 1024;
+export function listSkills(skillRoots, requestedPath) {
+    const roots = normalizeRoots(skillRoots);
+    if (roots.length === 0) {
+        return { path: null, roots: [], skills: [], entries: [] };
+    }
+    if (requestedPath?.trim()) {
+        const resolvedPath = resolveSkillPath(roots, requestedPath);
+        const stat = resolvedPath.configuredRootSymlink
+            ? fs.statSync(resolvedPath.path, { throwIfNoEntry: false })
+            : fs.lstatSync(resolvedPath.path, { throwIfNoEntry: false });
+        if (!stat)
+            throw new WorkspaceFsError('not_found', 'Path not found.');
+        if (stat.isSymbolicLink()) {
+            throw new WorkspaceFsError('path_outside_workspace', 'Symlink paths are not allowed in skill roots.');
+        }
+        if (!stat.isDirectory())
+            throw new WorkspaceFsError('not_directory', 'Path is not a directory.');
+        return {
+            path: resolvedPath.path,
+            roots: roots.map((root) => root.path),
+            skills: [],
+            entries: listDirectoryEntries(resolvedPath.path),
+        };
+    }
+    const seen = new Set();
+    const skills = [];
+    for (const root of roots) {
+        for (const skill of scanSkillRoot(root)) {
+            if (seen.has(skill.path))
+                continue;
+            seen.add(skill.path);
+            skills.push(skill);
+        }
+    }
+    skills.sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        path: null,
+        roots: roots.map((root) => root.path),
+        skills,
+        entries: [],
+    };
+}
+export function readSkillFile(skillRoots, skillPath) {
+    const roots = normalizeRoots(skillRoots);
+    const resolvedPath = resolveSkillPath(roots, skillPath);
+    const stat = fs.lstatSync(resolvedPath.path, { throwIfNoEntry: false });
+    if (!stat)
+        throw new WorkspaceFsError('not_found', 'Path not found.');
+    if (stat.isSymbolicLink()) {
+        throw new WorkspaceFsError('path_outside_workspace', 'Symlink files are not allowed in skill roots.');
+    }
+    if (!stat.isFile())
+        throw new WorkspaceFsError('not_file', 'Path is not a file.');
+    if (stat.size > MAX_PREVIEW_BYTES) {
+        throw new WorkspaceFsError('file_too_large', `File exceeds preview limit (${MAX_PREVIEW_BYTES} bytes).`);
+    }
+    const contentBuffer = fs.readFileSync(resolvedPath.path);
+    if (looksBinary(contentBuffer)) {
+        throw new WorkspaceFsError('binary_file', 'Binary files are not supported for preview.');
+    }
+    return {
+        path: resolvedPath.path,
+        content: contentBuffer.toString('utf8'),
+        mimeType: resolvedPath.path.toLowerCase().endsWith('.md') ? 'text/markdown' : 'text/plain',
+        size: stat.size,
+        modifiedAt: Math.floor(stat.mtimeMs),
+    };
+}
+function normalizeRoots(skillRoots) {
+    const roots = [];
+    const seen = new Set();
+    for (const value of normalizeSkillRootsWithBuiltins(skillRoots)) {
+        if (!value || !path.isAbsolute(value))
+            continue;
+        const resolved = path.resolve(value);
+        if (seen.has(resolved))
+            continue;
+        const stat = fs.statSync(resolved, { throwIfNoEntry: false });
+        if (!stat?.isDirectory())
+            continue;
+        roots.push({ path: resolved, realPath: fs.realpathSync(resolved) });
+        seen.add(resolved);
+    }
+    return roots;
+}
+function resolveSkillPath(roots, candidatePath) {
+    if (!path.isAbsolute(candidatePath)) {
+        throw new WorkspaceFsError('path_outside_workspace', 'Skill path must be absolute.');
+    }
+    const resolved = path.resolve(candidatePath);
+    const allowed = roots.some((root) => {
+        const relative = path.relative(root.path, resolved);
+        return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+    });
+    let realPathAllowed = false;
+    const stat = fs.lstatSync(resolved, { throwIfNoEntry: false });
+    if (stat && !stat.isSymbolicLink()) {
+        const realPath = fs.realpathSync(resolved);
+        realPathAllowed = roots.some((root) => {
+            const relative = path.relative(root.realPath, realPath);
+            return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+        });
+    }
+    if (!allowed && !realPathAllowed) {
+        throw new WorkspaceFsError('path_outside_workspace', 'Path escapes configured skill roots.');
+    }
+    if (!stat)
+        return { path: resolved, configuredRootSymlink: false };
+    if (stat.isSymbolicLink()) {
+        const realPath = fs.realpathSync(resolved);
+        const configuredRootSymlink = roots.some((root) => root.path === resolved && root.realPath === realPath);
+        if (configuredRootSymlink) {
+            return { path: resolved, configuredRootSymlink: true };
+        }
+        throw new WorkspaceFsError('path_outside_workspace', 'Symlink paths are not allowed in skill roots.');
+    }
+    if (!realPathAllowed) {
+        throw new WorkspaceFsError('path_outside_workspace', 'Path escapes configured skill roots.');
+    }
+    const hasSymlinkDescendant = roots.some((root) => pathIsInsideOrEqual(root.path, resolved) && pathHasSymlinkDescendant(root.path, resolved));
+    if (hasSymlinkDescendant) {
+        throw new WorkspaceFsError('path_outside_workspace', 'Symlink paths are not allowed in skill roots.');
+    }
+    return { path: resolved, configuredRootSymlink: false };
+}
+function pathIsInsideOrEqual(rootPath, candidatePath) {
+    const relative = path.relative(rootPath, candidatePath);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function pathHasSymlinkDescendant(rootPath, candidatePath) {
+    const relative = path.relative(rootPath, candidatePath);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+        return false;
+    const parts = relative.split(path.sep).filter(Boolean);
+    let current = rootPath;
+    for (const part of parts.slice(0, -1)) {
+        current = path.join(current, part);
+        const stat = fs.lstatSync(current, { throwIfNoEntry: false });
+        if (stat?.isSymbolicLink())
+            return true;
+    }
+    return false;
+}
+function listDirectoryEntries(directoryPath) {
+    return fs.readdirSync(directoryPath, { withFileTypes: true }).flatMap((entry) => {
+        if (entry.isSymbolicLink())
+            return [];
+        const absoluteEntry = path.join(directoryPath, entry.name);
+        const entryStat = fs.lstatSync(absoluteEntry, { throwIfNoEntry: false });
+        if (!entryStat || entryStat.isSymbolicLink())
+            return [];
+        return {
+            name: entry.name,
+            path: absoluteEntry,
+            kind: entry.isDirectory() ? 'directory' : 'file',
+            size: entry.isDirectory() ? null : (entryStat?.size ?? null),
+            modifiedAt: entryStat?.mtimeMs ? Math.floor(entryStat.mtimeMs) : null,
+        };
+    }).sort((a, b) => {
+        if (a.kind !== b.kind)
+            return a.kind === 'directory' ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+}
+function scanSkillRoot(root) {
+    let entries = [];
+    try {
+        entries = fs.readdirSync(root.path, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const skills = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const skillPath = path.join(root.path, entry.name, 'SKILL.md');
+            const stat = fs.lstatSync(skillPath, { throwIfNoEntry: false });
+            if (!stat?.isFile())
+                continue;
+            const realPath = fs.realpathSync(skillPath);
+            const relative = path.relative(root.realPath, realPath);
+            if (relative.startsWith('..') || path.isAbsolute(relative))
+                continue;
+            skills.push(parseSkillSummary(entry.name, skillPath, root.path));
+        }
+    }
+    return skills;
+}
+function parseSkillSummary(defaultName, skillPath, sourceRoot) {
+    const summary = {
+        name: defaultName,
+        path: skillPath,
+        sourceRoot,
+    };
+    try {
+        const content = fs.readFileSync(skillPath, 'utf8');
+        const frontmatter = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!frontmatter)
+            return summary;
+        for (const line of frontmatter[1].split('\n')) {
+            const colonIndex = line.indexOf(':');
+            if (colonIndex === -1)
+                continue;
+            const key = line.slice(0, colonIndex).trim();
+            const value = line.slice(colonIndex + 1).trim();
+            if (key === 'name' && value)
+                summary.name = value;
+            if (key === 'description' && value)
+                summary.description = value;
+        }
+    }
+    catch {
+        // Ignore malformed or unreadable frontmatter and fall back to basename metadata.
+    }
+    return summary;
+}
+function looksBinary(content) {
+    const limit = Math.min(content.length, 8_000);
+    for (let index = 0; index < limit; index += 1) {
+        if (content[index] === 0)
+            return true;
+    }
+    return false;
+}

package/dist/soloHost.js

@@ -0,0 +1,165 @@
+import { randomUUID } from 'node:crypto';
+import { clearAcpSessionId, log, } from '@bbigbang/runtime-acp';
+import { getRuntimeDriver } from '@bbigbang/protocol';
+import { CodexAppServerRuntime } from './codexAppServerRuntime.js';
+import { ensureWorkspaceScaffold, migrateWorkspaceLegacyFiles } from './workspaceFs.js';
+import { SoloNodeSink } from './soloNodeSink.js';
+const SOLO_IDLE_TIMEOUT_MS = 30_000;
+/** Remove transient solo runtime session rows from the node-local DB. */
+export function purgeSoloRuntimeSession(db, sessionKey) {
+    clearAcpSessionId(db, sessionKey);
+    db.prepare('DELETE FROM sessions WHERE session_key = ?').run(sessionKey);
+    db.prepare('DELETE FROM bindings WHERE session_key = ?').run(sessionKey);
+}
+export class SoloHost {
+    db;
+    soloSessionId;
+    workspaceRoot;
+    sessionKey;
+    runtime;
+    send;
+    activeRunId = null;
+    running = false;
+    lastActivityAt = Date.now();
+    idleTimer = null;
+    closed = false;
+    constructor(params) {
+        const { msg, db, config, toolAuth, workspaceLockManager, send, spawnImpl } = params;
+        this.db = db;
+        this.soloSessionId = msg.soloSessionId;
+        this.workspaceRoot = msg.workspacePath;
+        this.sessionKey = `solo:${msg.soloSessionId}`;
+        this.send = send;
+        ensureWorkspaceScaffold(this.workspaceRoot, msg.agentName);
+        migrateWorkspaceLegacyFiles(this.workspaceRoot);
+        const driver = getRuntimeDriver(msg.agentType);
+        const runtimeEnv = {
+            ...(driver.defaultEnv ?? {}),
+            ...(msg.envVars ?? {}),
+        };
+        const agentArgs = [...driver.args];
+        purgeSoloRuntimeSession(db, this.sessionKey);
+        this.runtime = new CodexAppServerRuntime({
+            db,
+            sessionKey: this.sessionKey,
+            bindingKey: `solo:${msg.soloSessionId}`,
+            toolAuth,
+            workspaceRoot: this.workspaceRoot,
+            agentCommand: driver.command,
+            agentArgs,
+            env: runtimeEnv,
+            model: msg.model,
+            reasoningEffort: msg.reasoningEffort,
+            codexMode: msg.codexMode,
+            serviceTier: msg.codexServiceTier,
+            disabledToolKinds: msg.disabledToolKinds,
+            agentSurfaceMode: config.agentSurfaceMode,
+            workspaceLockManager,
+            soloMode: true,
+            ...(spawnImpl ? { spawnImpl } : {}),
+        });
+        this.resetIdleTimer();
+    }
+    getSoloSessionId() {
+        return this.soloSessionId;
+    }
+    isRunning() {
+        return this.running;
+    }
+    isClosed() {
+        return this.closed;
+    }
+    touch() {
+        this.lastActivityAt = Date.now();
+        this.resetIdleTimer();
+    }
+    async prompt(instruction, systemPromptText) {
+        if (this.closed) {
+            throw new Error('Solo host is closed.');
+        }
+        if (this.running) {
+            throw new Error('Solo host already has an active run.');
+        }
+        this.touch();
+        const runId = randomUUID();
+        this.activeRunId = runId;
+        this.running = true;
+        const sink = new SoloNodeSink(this.soloSessionId, this.send);
+        try {
+            const result = await this.runtime.prompt({
+                runId,
+                promptText: instruction,
+                sink,
+                uiMode: 'summary',
+                systemPromptText,
+                actorUserId: 'solo_user',
+            });
+            this.send({
+                type: 'solo.run.end',
+                soloSessionId: this.soloSessionId,
+                stopReason: result.stopReason,
+                ...(result.stopReason === 'failed' ? { error: result.error ?? 'Solo run failed.' } : {}),
+            });
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            log.warn('[solo-host] prompt error', { soloSessionId: this.soloSessionId, error: message });
+            this.send({
+                type: 'solo.run.end',
+                soloSessionId: this.soloSessionId,
+                stopReason: 'failed',
+                error: message,
+            });
+        }
+        finally {
+            this.running = false;
+            this.activeRunId = null;
+            purgeSoloRuntimeSession(this.db, this.sessionKey);
+            this.touch();
+        }
+    }
+    async steer(text) {
+        if (this.closed || !this.running || !this.activeRunId)
+            return false;
+        this.touch();
+        if (!this.runtime.steerCurrentRun)
+            return false;
+        return this.runtime.steerCurrentRun(this.activeRunId, text);
+    }
+    async cancel() {
+        this.touch();
+        if (this.running && this.activeRunId) {
+            await this.runtime.cancelCurrentRun(this.activeRunId);
+        }
+    }
+    async respondToPermission(requestId, decision, selectedActionId, responseText, answers) {
+        this.touch();
+        return this.runtime.respondToPermission(requestId, decision, selectedActionId, responseText, answers);
+    }
+    isIdleExpired() {
+        return !this.running && Date.now() - this.lastActivityAt >= SOLO_IDLE_TIMEOUT_MS;
+    }
+    async close() {
+        this.closed = true;
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+        if (this.running && this.activeRunId) {
+            await this.runtime.cancelCurrentRun(this.activeRunId);
+        }
+        await this.runtime.close?.();
+        purgeSoloRuntimeSession(this.db, this.sessionKey);
+    }
+    resetIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+        }
+        this.idleTimer = setTimeout(() => {
+            if (!this.running && this.isIdleExpired()) {
+                void this.close();
+            }
+        }, SOLO_IDLE_TIMEOUT_MS);
+        this.idleTimer.unref?.();
+    }
+}

package/dist/soloNodeSink.js

@@ -0,0 +1,138 @@
+/**
+ * OutboundSink that forwards solo runtime output to core as solo.run.event messages.
+ */
+export class SoloNodeSink {
+    soloSessionId;
+    send;
+    hooks;
+    constructor(soloSessionId, send, hooks) {
+        this.soloSessionId = soloSessionId;
+        this.send = send;
+        this.hooks = hooks;
+    }
+    async sendAgentText(text) {
+        this.emitEvent({ type: 'content.delta', text });
+    }
+    async sendActivityText(text) {
+        this.emitEvent({ type: 'activity.delta', text });
+    }
+    async sendText(text) {
+        this.emitEvent({ type: 'content.delta', text });
+    }
+    async sendThinkingText(text) {
+        this.emitEvent({ type: 'thinking.delta', text });
+    }
+    async requestPermission(req) {
+        this.hooks?.onPermissionRequest?.();
+        this.send({
+            type: 'solo.permission.request',
+            soloSessionId: this.soloSessionId,
+            requestId: req.requestId,
+            toolName: req.toolName ?? req.toolTitle,
+            toolArgs: req.toolArgs ?? null,
+            toolKind: req.toolKind,
+            ...(req.approvalKind ? { approvalKind: req.approvalKind } : {}),
+            ...(req.title ? { title: req.title } : {}),
+            ...(req.description ? { description: req.description } : {}),
+            ...(req.input !== undefined ? { input: req.input } : {}),
+            ...(req.actions?.length ? { actions: req.actions } : {}),
+        });
+    }
+    async sendUi(event) {
+        if (event.kind === 'tool') {
+            const toolEvent = event;
+            if (event.stage === 'complete') {
+                const normalizedStatus = event.status === 'cancelled'
+                    ? 'cancelled'
+                    : event.status === 'error' || event.status === 'failed' || event.status === 'declined'
+                        ? 'failed'
+                        : 'completed';
+                const isError = normalizedStatus === 'failed';
+                this.emitEvent({
+                    type: 'tool.result',
+                    toolCallId: event.toolCallId ?? '',
+                    output: toolEvent.output ?? event.detail ?? event.status ?? 'done',
+                    detail: event.detail,
+                    error: isError,
+                    status: normalizedStatus,
+                    metadata: event.metadata,
+                });
+            }
+            else {
+                const normalizedStatus = event.status === 'cancelled'
+                    ? 'cancelled'
+                    : event.status === 'error' || event.status === 'failed' || event.status === 'declined'
+                        ? 'failed'
+                        : event.status === 'completed'
+                            ? 'completed'
+                            : 'running';
+                this.emitEvent({
+                    type: 'tool.call',
+                    toolCallId: event.toolCallId ?? '',
+                    name: event.title,
+                    input: toolEvent.input ?? event.detail ?? null,
+                    detail: event.detail,
+                    status: normalizedStatus,
+                    metadata: event.metadata,
+                });
+            }
+        }
+        if (event.kind === 'usage') {
+            this.emitEvent({
+                type: 'run.usage',
+                inputTokens: event.inputTokens,
+                cachedInputTokens: event.cachedInputTokens,
+                outputTokens: event.outputTokens,
+                reasoningOutputTokens: event.reasoningOutputTokens,
+                totalTokens: event.totalTokens,
+                currentInputTokens: event.currentInputTokens,
+                currentCachedInputTokens: event.currentCachedInputTokens,
+                modelContextWindow: event.modelContextWindow,
+                createdAt: Date.now(),
+                metadata: event.metadata,
+            });
+        }
+        if (event.kind === 'compact') {
+            this.emitEvent({
+                type: 'runtime.compact',
+                threadId: event.threadId,
+                turnId: event.turnId,
+                itemId: event.itemId,
+                source: event.source,
+                eventKey: event.eventKey,
+                createdAt: Date.now(),
+            });
+        }
+        if (event.kind === 'plan_phase') {
+            this.emitEvent({
+                type: 'plan.phase',
+                phase: event.phase,
+                createdAt: Date.now(),
+            });
+        }
+        if (event.kind === 'plan' || event.kind === 'task') {
+            const createdAt = Date.now();
+            this.emitEvent({
+                type: event.kind === 'plan' ? 'plan.update' : 'task.update',
+                title: event.title,
+                detail: event.detail,
+                createdAt,
+            });
+            if (event.silent)
+                return;
+            const text = event.detail
+                ? `\n[${event.kind}] ${event.title}\n${event.detail}\n`
+                : `\n[${event.kind}] ${event.title}\n`;
+            this.emitEvent({ type: 'content.delta', text });
+        }
+    }
+    async breakTextStream() { }
+    async flush() { }
+    emitEvent(event) {
+        this.send({
+            type: 'solo.run.event',
+            soloSessionId: this.soloSessionId,
+            event,
+        });
+    }
+}