@myagentroam/node 0.1.3 → 0.1.6

package/dist/service/terminal-service.js

@@ -0,0 +1,52 @@
+import { parseSecretEnvironment } from '../util/secret-environment.js';
+export class TerminalService {
+    database;
+    terminalManager;
+    constructor(database, terminalManager) {
+        this.database = database;
+        this.terminalManager = terminalManager;
+    }
+    operations() {
+        return {
+            'terminal.open': (data) => this.open(data),
+            'terminal.list': () => ({ terminals: this.database().listTerminalSessions() }),
+            'terminal.close': (data) => this.close(data),
+            'terminal.attach.authorize': (data) => this.authorizeAttach(data)
+        };
+    }
+    open(data) {
+        if (data === null || typeof data !== 'object')
+            throw new Error('TERMINAL_OPEN_INVALID');
+        const input = data;
+        const secretEnvironment = parseSecretEnvironment(input.secretEnvironment);
+        let cwd;
+        if (input.workspaceId !== undefined) {
+            if (typeof input.workspaceId !== 'string')
+                throw new Error('TERMINAL_OPEN_INVALID');
+            const workspace = this.database().getWorkspace(input.workspaceId);
+            if (workspace === undefined)
+                throw new Error('WORKSPACE_NOT_FOUND');
+            cwd = workspace.path;
+        }
+        return {
+            terminal: this.terminalManager.open({
+                ...input,
+                workspaceId: typeof input.workspaceId === 'string' ? input.workspaceId : null,
+                environment: secretEnvironment,
+                ...(cwd === undefined ? {} : { cwd })
+            })
+        };
+    }
+    async close(data) {
+        const input = data;
+        if (typeof input.terminalId !== 'string')
+            throw new Error('TERMINAL_NOT_FOUND');
+        return { terminal: await this.terminalManager.close(input.terminalId) };
+    }
+    authorizeAttach(data) {
+        if (data === null || typeof data !== 'object')
+            throw new Error('TERMINAL_ATTACH_INVALID');
+        const attachment = this.terminalManager.authorizeAttach(data);
+        return { attachment, terminal: this.terminalManager.get(attachment.terminalId) };
+    }
+}

package/dist/service/workbench-event-service.d.ts

@@ -0,0 +1,21 @@
+import type { NodeEnvelope, WorkbenchEvent, WorkbenchEventCategory } from '@myagentroam/protocol';
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+export declare class WorkbenchEventService {
+    private readonly send;
+    private readonly accepts;
+    private readonly buffer;
+    private sequence;
+    private readonly history;
+    constructor(send: (envelope: NodeEnvelope) => void, accepts: (category: WorkbenchEventCategory, payload: unknown) => boolean);
+    emit(category: WorkbenchEventCategory, payload: unknown): void;
+    read(after: number): {
+        readonly events: readonly WorkbenchEvent[];
+        readonly latestSequence: number;
+        readonly resyncRequired: boolean;
+    };
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    snapshotSequence(): number;
+    acknowledge(replyTo: string | undefined): boolean;
+    replay(): void;
+    get pendingCount(): number;
+}

package/dist/service/workbench-event-service.js

@@ -0,0 +1,53 @@
+import { ReliableWorkbenchEventBuffer } from '../event-buffer.js';
+export class WorkbenchEventService {
+    send;
+    accepts;
+    buffer = new ReliableWorkbenchEventBuffer();
+    sequence = 0;
+    history = [];
+    constructor(send, accepts) {
+        this.send = send;
+        this.accepts = accepts;
+    }
+    emit(category, payload) {
+        if (!this.accepts(category, payload))
+            return;
+        const event = { sequence: ++this.sequence, category, payload };
+        this.history.push(event);
+        if (this.history.length > 1_000)
+            this.history.shift();
+        this.send(this.buffer.queue(event));
+    }
+    read(after) {
+        const first = this.history[0]?.sequence;
+        const reset = after > this.sequence || (first !== undefined && after < first - 1);
+        return {
+            events: reset ? [] : this.history.filter((event) => event.sequence > after),
+            latestSequence: this.sequence,
+            resyncRequired: reset
+        };
+    }
+    operations() {
+        return {
+            'workbench.events.read': (data) => {
+                const afterValue = data?.after;
+                const after = typeof afterValue === 'number' && Number.isInteger(afterValue) && afterValue >= 0
+                    ? afterValue
+                    : 0;
+                return this.read(after);
+            }
+        };
+    }
+    snapshotSequence() {
+        return this.sequence;
+    }
+    acknowledge(replyTo) {
+        return this.buffer.acknowledge(replyTo);
+    }
+    replay() {
+        this.buffer.replay(this.send);
+    }
+    get pendingCount() {
+        return this.buffer.size;
+    }
+}

package/dist/service/workbench-manifest-service.d.ts

@@ -0,0 +1,89 @@
+import type { NodeCapabilities } from '@myagentroam/protocol';
+import type { TerminalManager } from '../terminal.js';
+import type { RunnerService } from './runner-service.js';
+interface WorkbenchManifestServiceOptions {
+    readonly capabilities: () => NodeCapabilities;
+    readonly runners: RunnerService;
+    readonly terminals: TerminalManager;
+}
+/** Builds the capability-driven Workbench contract exposed by this Node. */
+export declare class WorkbenchManifestService {
+    private readonly options;
+    constructor(options: WorkbenchManifestServiceOptions);
+    read(): Promise<{
+        manifestVersion: 1;
+        revision: number;
+        observedAt: number;
+        platform: "linux" | "windows";
+        architecture: string;
+        conversation: {
+            available: boolean;
+            reasonCode: null;
+            itemVersions: number[];
+            supportsSessionCursor: boolean;
+            supportsWorkspaceActivityCursor: boolean;
+            supportsHistoryPaging: boolean;
+            supportsItemFinalSnapshots: boolean;
+            maxPageSize: number;
+        };
+        runners: readonly {
+            runner: "codex" | "claude-code" | "opencode";
+            capabilities: string[];
+            models: {
+                id: string;
+                label: string;
+                supportedEfforts: string[];
+            }[];
+            accessOptions: {
+                id: string;
+                label: string;
+                description: string;
+            }[];
+            commands: {
+                id: string;
+                available: boolean;
+                runner: "codex" | "claude-code" | "opencode";
+                reasonCode: string | null;
+                label: string;
+                description: string;
+                inputHint: string;
+                source: "CODEX_APP_SERVER" | "CLAUDE_AGENT_SDK" | "OPENCODE_SERVER";
+                interaction: "RUNNER_TEXT" | "IMMEDIATE_ACTION" | "TOGGLE" | "VALUE";
+                stateLabel?: string | undefined;
+            }[];
+        }[];
+        files: {
+            available: boolean;
+            reasonCode: null;
+            supportsList: boolean;
+            supportsReadRange: boolean;
+            supportsSearch: boolean;
+            maxDirectoryPageSize: number;
+            maxReadBytes: number;
+            maxSearchResults: number;
+        };
+        git: {
+            available: boolean;
+            reasonCode: null;
+            supportsCurrentChanges: boolean;
+            supportsTurnChanges: boolean;
+            supportsHistory: boolean;
+            maxDiffBytes: number;
+        };
+        terminal: {
+            profiles: readonly Pick<import("../terminal.js").TerminalProfile, "id" | "label" | "isDefault">[];
+            maxTerminals: number;
+            maxTerminalsPerWorkspace: number;
+            maxReplayBytes: number;
+            reconnectWindowMs: number;
+            available: boolean;
+            reasonCode: null;
+            supportsPty: boolean;
+            supportsConPty: boolean;
+            supportsReplay: boolean;
+            supportsReadonlyAttach: boolean;
+            supportsTakeover: boolean;
+        };
+    }>;
+}
+export {};

package/dist/service/workbench-manifest-service.js

@@ -0,0 +1,70 @@
+function revisionFor(capabilities) {
+    const source = JSON.stringify({
+        platform: capabilities.platform,
+        architecture: capabilities.architecture,
+        codex: capabilities.codex,
+        claudeCode: capabilities.claudeCode,
+        openCode: capabilities.openCode
+    });
+    let hash = 2_166_136_261;
+    for (const character of source)
+        hash = Math.imul(hash ^ character.charCodeAt(0), 16_777_619);
+    return hash >>> 0;
+}
+/** Builds the capability-driven Workbench contract exposed by this Node. */
+export class WorkbenchManifestService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async read() {
+        const capabilities = this.options.capabilities();
+        return {
+            manifestVersion: 1,
+            revision: revisionFor(capabilities),
+            observedAt: Date.now(),
+            platform: capabilities.platform,
+            architecture: capabilities.architecture,
+            conversation: {
+                available: true,
+                reasonCode: null,
+                itemVersions: [1],
+                supportsSessionCursor: true,
+                supportsWorkspaceActivityCursor: true,
+                supportsHistoryPaging: true,
+                supportsItemFinalSnapshots: true,
+                maxPageSize: 500
+            },
+            runners: await this.options.runners.profiles(),
+            files: {
+                available: true,
+                reasonCode: null,
+                supportsList: true,
+                supportsReadRange: true,
+                supportsSearch: true,
+                maxDirectoryPageSize: 200,
+                maxReadBytes: 512 * 1024,
+                maxSearchResults: 200
+            },
+            git: {
+                available: true,
+                reasonCode: null,
+                supportsCurrentChanges: true,
+                supportsTurnChanges: true,
+                supportsHistory: true,
+                maxDiffBytes: 512 * 1024
+            },
+            terminal: {
+                available: true,
+                reasonCode: null,
+                supportsPty: capabilities.platform === 'linux',
+                supportsConPty: capabilities.platform === 'windows',
+                supportsReplay: true,
+                supportsReadonlyAttach: true,
+                supportsTakeover: true,
+                ...this.options.terminals.limits(),
+                profiles: this.options.terminals.availableProfiles()
+            }
+        };
+    }
+}

package/dist/service/workspace-change-service.d.ts

@@ -0,0 +1,9 @@
+import type { NodeWorkspace } from '../database.js';
+import { WorkspaceDomainState } from './workspace-domain-state.js';
+export declare class WorkspaceChangeService {
+    private readonly state;
+    constructor(state: WorkspaceDomainState);
+    invalidate(workspaceId: string): void;
+    clear(): void;
+    current(workspace: NodeWorkspace): Promise<unknown>;
+}

package/dist/service/workspace-change-service.js

@@ -0,0 +1,86 @@
+import { basename, posix } from 'node:path';
+import { isWorkspaceChangeVisible, listInitializedSubmodulePaths, readCurrentChangesSummary, resolveGitRepository } from '../workspace.js';
+const CACHE_TTL_MS = 5_000;
+export class WorkspaceChangeService {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    invalidate(workspaceId) {
+        this.state.changesReads.delete(workspaceId);
+        this.state.changesCache.delete(workspaceId);
+        this.state.changesVersions.set(workspaceId, (this.state.changesVersions.get(workspaceId) ?? 0) + 1);
+    }
+    clear() {
+        this.state.changesReads.clear();
+        this.state.changesCache.clear();
+        this.state.changesVersions.clear();
+    }
+    async current(workspace) {
+        if (workspace.kind !== 'GIT_WORKSPACE')
+            throw new Error('WORKSPACE_NOT_GIT');
+        const cached = this.state.changesCache.get(workspace.id);
+        if (cached !== undefined && cached.expiresAt > Date.now())
+            return cached.value;
+        const existing = this.state.changesReads.get(workspace.id);
+        if (existing !== undefined)
+            return existing;
+        const version = this.state.changesVersions.get(workspace.id) ?? 0;
+        const request = this.state.changesLimiter.run(async () => {
+            const paths = ['', ...(await listInitializedSubmodulePaths(workspace.path))];
+            const readRepository = async (repositoryPath) => {
+                const repository = repositoryPath === ''
+                    ? workspace.path
+                    : await resolveGitRepository(workspace.path, repositoryPath);
+                const summary = await readCurrentChangesSummary(repository);
+                const changes = (await Promise.all(summary.changes.map(async (change) => ({
+                    change,
+                    visible: await isWorkspaceChangeVisible(repository, change.path)
+                }))))
+                    .filter(({ visible }) => visible)
+                    .map(({ change }) => change);
+                return {
+                    repositoryPath,
+                    repositoryName: repositoryPath === '' ? basename(repository) : posix.basename(repositoryPath),
+                    branch: summary.branch,
+                    changes
+                };
+            };
+            const root = await readRepository('');
+            const children = (await Promise.all(paths.slice(1).map(async (path) => {
+                try {
+                    return await readRepository(path);
+                }
+                catch {
+                    return undefined;
+                }
+            }))).filter((value) => value !== undefined);
+            const decorate = (change) => ({
+                ...change,
+                additions: null,
+                deletions: null,
+                binary: false,
+                diffAvailable: change.state !== 'UNTRACKED'
+            });
+            const value = {
+                branch: root.branch,
+                changes: root.changes.map(decorate),
+                repositories: [root, ...children].map((repository) => ({
+                    ...repository,
+                    changes: repository.changes.map(decorate)
+                }))
+            };
+            if ((this.state.changesVersions.get(workspace.id) ?? 0) === version)
+                this.state.changesCache.set(workspace.id, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+            return value;
+        });
+        this.state.changesReads.set(workspace.id, request);
+        try {
+            return await request;
+        }
+        finally {
+            if (this.state.changesReads.get(workspace.id) === request)
+                this.state.changesReads.delete(workspace.id);
+        }
+    }
+}

package/dist/service/workspace-content-search-service.d.ts

@@ -0,0 +1,14 @@
+import type { WorkspaceContentSearch } from '@myagentroam/protocol';
+import type { NodeWorkspace } from '../database.js';
+import type { WorkspaceFileService } from './workspace-file-service.js';
+export declare class WorkspaceContentSearchService {
+    private readonly files;
+    private readonly platform;
+    private readonly pending;
+    constructor(files: WorkspaceFileService, platform?: NodeJS.Platform);
+    search(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<WorkspaceContentSearch>;
+    private perform;
+    private engines;
+    private candidates;
+    private nativeSearch;
+}