@myagentroam/node 0.9.9 → 0.9.11

package/dist/service/session-context-service.d.ts

@@ -1,35 +0,0 @@
-import type { NodeAgentSession } from '../database.js';
-import type { RunnerRegistry } from '../runner/runner-registry.js';
-export interface SessionContextUsage {
-    readonly model: string | null;
-    readonly usedTokens: number;
-    readonly maxTokens: number;
-    readonly percentage: number;
-}
-export interface SessionContextReadResult {
-    readonly context: SessionContextUsage | null;
-    readonly pending: boolean;
-}
-export interface SessionContextServiceOptions {
-    readonly runners: RunnerRegistry;
-    readonly session: (sessionId: string) => NodeAgentSession | undefined;
-    readonly stopped: () => boolean;
-    readonly publish: (input: {
-        sessionId: string;
-        workspaceId: string;
-        context: SessionContextUsage;
-        pending: false;
-    }) => void;
-}
-export declare class SessionContextService {
-    private readonly options;
-    private readonly snapshots;
-    private readonly snapshotTimers;
-    private readonly timers;
-    private readonly versions;
-    constructor(options: SessionContextServiceOptions);
-    read(session: NodeAgentSession): Promise<SessionContextReadResult>;
-    schedule(sessionId: string): void;
-    dispose(): void;
-    private current;
-}

package/dist/service/session-domain-state.d.ts

@@ -1,9 +0,0 @@
-export declare class SessionDomainState<TSession, TActivity> {
-    readonly directNative: Map<string, TSession>;
-    readonly externalActivity: Map<string, TActivity>;
-    readonly resumedByDirectId: Map<string, string>;
-    readonly resumeFailures: Map<string, string>;
-    readonly messageResumeFailures: Map<string, string>;
-    readonly resumeFailureDetails: Map<string, string>;
-    readonly failureTimers: Map<string, NodeJS.Timeout>;
-}

package/dist/service/session-identity-service.d.ts

@@ -1,24 +0,0 @@
-import type { NodeAgentSession } from '../database.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
-export interface SessionIdentityServiceOptions {
-    readonly runtime: NodeRuntimeState;
-    readonly persist: (session: NodeAgentSession, nativeSessionId: string) => void;
-    readonly migrateCommands: (previousId: string, nextId: string) => void;
-    readonly migrateQueue: (previousId: string, nextId: string) => void;
-    readonly migrateRunnerState: (previousId: string, nextId: string) => void;
-    readonly emitSession: (session: NodeAgentSession) => void;
-    readonly emitRun: (run: unknown) => void;
-    readonly emitQueue: (sessionId: string) => void;
-    readonly emitTurn: (turn: unknown) => void;
-}
-export declare class SessionIdentityService {
-    private readonly options;
-    readonly bootstrapIds: Set<string>;
-    private readonly waiters;
-    constructor(options: SessionIdentityServiceOptions);
-    markBootstrap(sessionId: string): void;
-    promote(sessionId: string, nativeSessionId: string): void;
-    wait(bootstrapSessionId: string): Promise<string>;
-    reject(sessionId: string, code: string): void;
-    dispose(): void;
-}

package/dist/service/session-lifecycle-service.d.ts

@@ -1,31 +0,0 @@
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
-import type { NodeAgentSession, NodeDatabase } from '../database.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
-import type { RunnerRegistry } from '../runner/runner-registry.js';
-import type { NativeSessionProjectionService } from './native-session-projection-service.js';
-import type { SessionIdentityService } from './session-identity-service.js';
-interface SessionLifecycleServiceOptions {
-    readonly database: () => NodeDatabase;
-    readonly runtime: NodeRuntimeState;
-    readonly runners: RunnerRegistry;
-    readonly projection: NativeSessionProjectionService;
-    readonly identity: SessionIdentityService;
-    readonly present: (session: NodeAgentSession) => unknown;
-    readonly emitSession: (session: NodeAgentSession) => void;
-    readonly execute: (operation: string, data: Record<string, unknown>) => Promise<unknown>;
-    readonly interceptedSessionId: (clientMessageId: string) => string | undefined;
-}
-export declare class SessionLifecycleService {
-    private readonly options;
-    private readonly starts;
-    constructor(options: SessionLifecycleServiceOptions);
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
-    clear(): void;
-    private updateMetadata;
-    private movePin;
-    private create;
-    private updateConfiguration;
-    private start;
-    private startFresh;
-}
-export {};

package/dist/service/session-message-service.d.ts

@@ -1,33 +0,0 @@
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
-import type { NodeAgentSession } from '../database.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
-import type { CommandStateStore } from '../runner-command-engine.js';
-import type { RunnerRegistry } from '../runner/runner-registry.js';
-import type { WorkspaceUploadService } from './workspace-upload-service.js';
-import type { RunnerImageAttachment, RunAttachmentService } from './run-attachment-service.js';
-import type { RunnerInteractionService } from './runner-interaction-service.js';
-import type { WorkspaceQueueWorkbenchService } from './workspace-queue-workbench-service.js';
-interface SessionMessageServiceOptions {
-    readonly runtime: NodeRuntimeState;
-    readonly uploads: WorkspaceUploadService;
-    readonly attachments: RunAttachmentService;
-    readonly commands: CommandStateStore;
-    readonly queue: WorkspaceQueueWorkbenchService<RunnerImageAttachment>;
-    readonly interaction: RunnerInteractionService;
-    readonly runners: RunnerRegistry;
-    readonly resolve: (sessionId: string) => Promise<NodeAgentSession>;
-    readonly present: (session: NodeAgentSession) => unknown;
-    readonly emitSession: (session: NodeAgentSession) => void;
-    readonly channelToken: (sessionId: string) => string | undefined;
-}
-export declare class SessionMessageService {
-    private readonly options;
-    private readonly pendingMessages;
-    constructor(options: SessionMessageServiceOptions);
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private message;
-    private persistAttachments;
-    private channelMessage;
-    private channelToken;
-}
-export {};

package/dist/service/session-presentation-service.d.ts

@@ -1,34 +0,0 @@
-import type { NodeCapabilities, SessionActivityState, RunnerCommandState } from '@myagentroam/protocol';
-import type { CodexSessionControl } from '../codex-app-server.js';
-import type { NodeAgentSession, NodeDatabase } from '../database.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
-import type { CommandStateStore } from '../runner-command-engine.js';
-import type { RunnerRegistry } from '../runner/runner-registry.js';
-export type PresentedSession = NodeAgentSession & {
-    readonly control: CodexSessionControl;
-    readonly activity: SessionActivityState;
-    readonly runtime: {
-        readonly level: CodexSessionControl['level'];
-        readonly capabilities: readonly string[];
-        readonly reasonCode: string | null;
-    };
-    readonly commandStates: readonly RunnerCommandState[];
-};
-interface SessionPresentationServiceOptions {
-    readonly database: () => NodeDatabase | undefined;
-    readonly runtime: NodeRuntimeState;
-    readonly commands: CommandStateStore;
-    readonly runners: RunnerRegistry;
-    readonly capabilities: () => NodeCapabilities;
-    readonly hasManagedActiveRun: (session: NodeAgentSession) => boolean;
-    readonly externalActivity: (sessionId: string) => SessionActivityState | undefined;
-    readonly projectionForNative: (session: NodeAgentSession) => NodeAgentSession | undefined;
-}
-export declare class SessionPresentationService {
-    private readonly options;
-    constructor(options: SessionPresentationServiceOptions);
-    present(session: NodeAgentSession): PresentedSession;
-    presentDiscovered(sessions: readonly NodeAgentSession[]): readonly PresentedSession[];
-}
-export declare function latestSessionActivityAt(current: number, discovered: number): number;
-export {};

package/dist/service/session-query-service.d.ts

@@ -1,35 +0,0 @@
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
-import type { NodeAgentSession } from '../database.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
-import type { RunnerRegistry } from '../runner/runner-registry.js';
-import type { SessionContextService } from './session-context-service.js';
-import type { RunnerName } from '@myagentroam/protocol';
-export interface SessionQueryServiceOptions {
-    readonly runtime: NodeRuntimeState;
-    readonly runners: RunnerRegistry;
-    readonly resolve: (sessionId: string) => Promise<NodeAgentSession | undefined>;
-    readonly present: (session: NodeAgentSession) => unknown;
-    readonly history: (session: NodeAgentSession, input: {
-        readonly cursor?: string;
-        readonly limit?: number;
-    }) => Promise<unknown>;
-    readonly segments: (session: NodeAgentSession, input: {
-        readonly cursor?: string;
-        readonly limit?: number;
-    }) => Promise<unknown>;
-    readonly context: SessionContextService;
-    readonly discover: (runner: RunnerName, workspaceId?: string) => Promise<readonly NodeAgentSession[]>;
-    readonly workspaceIdForCwd: (cwd: string) => string | undefined;
-}
-export declare class SessionQueryService {
-    private readonly options;
-    constructor(options: SessionQueryServiceOptions);
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private get;
-    private runs;
-    private turns;
-    private events;
-    private readContext;
-    private discover;
-    private requireSession;
-}

package/dist/service/skill-directory-service.d.ts

@@ -1,20 +0,0 @@
-import { type SkillInstallMetadata } from '@myagentroam/protocol';
-export type LocalSkillStatus = 'VALID' | 'UNKNOWN_VERSION' | 'PARTIAL' | 'INVALID' | 'INVALID_LINK' | 'GIT_EXCLUDE_BROKEN';
-export interface LocalSkillInspection {
-    readonly name: string;
-    readonly description: string;
-    readonly localStatus: LocalSkillStatus;
-    readonly skillFilePath: string;
-    readonly install?: SkillInstallMetadata;
-}
-export interface LocalSkillTargetInspection {
-    readonly targetKind: 'NODE' | 'WORKSPACE';
-    readonly compatibilityMode: 'SYMLINK' | 'JUNCTION' | 'MANAGED_COPY' | 'UNAVAILABLE';
-    readonly skills: readonly LocalSkillInspection[];
-}
-export declare class SkillDirectoryService {
-    inspectNodeHome(home: string, options?: {
-        readonly includeClaudeCompatibility?: boolean;
-    }): Promise<LocalSkillTargetInspection>;
-    inspectWorkspace(workspace: string): Promise<LocalSkillTargetInspection>;
-}

package/dist/service/skill-install-service.d.ts

@@ -1,21 +0,0 @@
-import { type SkillInstallMetadata } from '@myagentroam/protocol';
-export interface SkillBundleFile {
-    readonly path: string;
-    readonly contentBase64: string;
-}
-export interface InstallableSkillBundle {
-    readonly schemaVersion: 1;
-    readonly files: readonly SkillBundleFile[];
-}
-export declare class SkillInstallService {
-    recoverNodeHome(home: string): Promise<void>;
-    recoverWorkspace(workspace: string): Promise<void>;
-    installNodeHome(home: string, name: string, bundle: InstallableSkillBundle, metadata: SkillInstallMetadata): Promise<void>;
-    installWorkspace(workspace: string, name: string, bundle: InstallableSkillBundle, metadata: SkillInstallMetadata, options?: {
-        readonly confirmTracked?: boolean;
-    }): Promise<void>;
-    removeWorkspace(workspace: string, name: string): Promise<void>;
-    removeNodeHome(home: string, name: string): Promise<void>;
-    repairWorkspaceGitExclude(workspace: string): Promise<void>;
-}
-export declare function workspaceSkillTracked(workspace: string, name: string): Promise<boolean>;

package/dist/service/skill-node-operation-service.d.ts

@@ -1,44 +0,0 @@
-import type { NodeConfig } from '../config.js';
-import type { NodeDatabase } from '../database.js';
-export declare class SkillNodeOperationService {
-    private readonly database;
-    private readonly config;
-    private readonly directories;
-    private readonly installer;
-    private readonly activeTargets;
-    private readonly jobs;
-    constructor(database: () => NodeDatabase, config: () => NodeConfig);
-    operations(): {
-        'node.skills.inspect': (data: unknown) => Promise<import("./skill-directory-service.js").LocalSkillTargetInspection>;
-        'node.skills.install': (data: unknown) => Promise<{
-            accepted: boolean;
-            installJobId: `${string}-${string}-${string}-${string}-${string}`;
-        }>;
-        'node.skills.remove': (data: unknown) => Promise<{
-            removed: boolean;
-        }>;
-        'workspace.skills.inspect': (data: unknown) => Promise<import("./skill-directory-service.js").LocalSkillTargetInspection>;
-        'workspace.skills.install': (data: unknown) => Promise<{
-            accepted: boolean;
-            installJobId: `${string}-${string}-${string}-${string}-${string}`;
-        }>;
-        'workspace.skills.remove': (data: unknown) => Promise<{
-            removed: boolean;
-        }>;
-        'workspace.skills.git-exclude-repair': (data: unknown) => Promise<{
-            repaired: boolean;
-        }>;
-        'skill.install.job.get': (data: unknown) => {
-            errorCode?: string;
-            installJobId: string;
-            status: "RUNNING" | "SUCCEEDED" | "FAILED";
-        };
-    };
-    private install;
-    private job;
-    private cleanupJobs;
-    private performInstall;
-    private remove;
-    private workspacePath;
-    private download;
-}

package/dist/service/terminal-relay-state.d.ts

@@ -1,6 +0,0 @@
-export declare class TerminalRelayState {
-    readonly attachments: Map<string, {
-        readonly attachmentId: string;
-        readonly terminalId: string;
-    }>;
-}

package/dist/service/terminal-service.d.ts

@@ -1,12 +0,0 @@
-import type { NodeDatabase } from '../database.js';
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
-import type { TerminalManager } from '../terminal.js';
-export declare class TerminalService {
-    private readonly database;
-    private readonly terminalManager;
-    constructor(database: () => NodeDatabase, terminalManager: TerminalManager);
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private open;
-    private close;
-    private authorizeAttach;
-}

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

@@ -1,9 +0,0 @@
-import { type NodeEnvelope, type WorkbenchEventCategory } from '@myagentroam/protocol';
-export declare class WorkbenchEventService {
-    private readonly send;
-    private readonly accepts;
-    private sequence;
-    constructor(send: (envelope: NodeEnvelope) => void, accepts: (category: WorkbenchEventCategory, payload: unknown) => boolean);
-    emit(category: WorkbenchEventCategory, payload: unknown): void;
-    snapshotSequence(): number;
-}

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

@@ -1,90 +0,0 @@
-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;
-            supportsHistoryPaging: boolean;
-            supportsItemFinalSnapshots: boolean;
-            maxPageSize: number;
-        };
-        runners: readonly {
-            runner: "codex" | "claude-code" | "opencode";
-            capabilities: string[];
-            models: {
-                id: string;
-                label: string;
-                supportedEfforts: string[];
-                isDefault?: boolean | undefined;
-                defaultEffort?: string | undefined;
-            }[];
-            accessOptions: {
-                id: string;
-                description: string;
-                label: string;
-            }[];
-            commands: {
-                id: string;
-                description: string;
-                available: boolean;
-                runner: "codex" | "claude-code" | "opencode";
-                reasonCode: string | null;
-                label: 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/workspace-change-service.d.ts

@@ -1,9 +0,0 @@
-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-content-search-service.d.ts

@@ -1,14 +0,0 @@
-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;
-}

package/dist/service/workspace-domain-state.d.ts

@@ -1,79 +0,0 @@
-import type { FileHandle } from 'node:fs/promises';
-import type { NodeAgentSession } from '../database.js';
-import type { WorkspaceFileIndex } from '../workspace.js';
-export interface WorkspaceWatch {
-    readonly workspaceId: string;
-    readonly watchId: string;
-    readonly sessionHash: string;
-    readonly workbenchConnectionId: string;
-    readonly nodeGeneration: string;
-    expiresAt: number;
-    readonly topics: {
-        readonly sessions: boolean;
-        readonly changes: boolean;
-        readonly files: {
-            readonly path: string;
-            readonly cursor?: string;
-            readonly limit?: number;
-        } | undefined;
-    };
-    timer: NodeJS.Timeout;
-}
-export interface ActiveWorkspaceUpload {
-    readonly id: string;
-    readonly workspaceId: string;
-    readonly path: string;
-    readonly targetPath: string;
-    readonly temporaryPath: string;
-    readonly size: number;
-    readonly overwrite: boolean;
-    readonly composerAttachment?: {
-        readonly id: string;
-        readonly name: string;
-        readonly mime: string;
-    };
-    readonly handle: FileHandle;
-    receivedBytes: number;
-    readonly timer: NodeJS.Timeout;
-}
-export interface CompletedComposerAttachment {
-    readonly id: string;
-    readonly workspaceId: string;
-    readonly path: string;
-    readonly targetPath: string;
-    readonly name: string;
-    readonly mime: string;
-    readonly size: number;
-    readonly timer: NodeJS.Timeout;
-}
-export declare class WorkspaceDomainState {
-    readonly uploads: Map<string, ActiveWorkspaceUpload>;
-    readonly composerAttachments: Map<string, CompletedComposerAttachment>;
-    readonly changesReads: Map<string, Promise<unknown>>;
-    readonly changesCache: Map<string, {
-        readonly value: unknown;
-        readonly expiresAt: number;
-    }>;
-    readonly changesVersions: Map<string, number>;
-    readonly fileIndexes: Map<string, WorkspaceFileIndex>;
-    readonly watches: Map<string, Map<string, WorkspaceWatch>>;
-    readonly watchRevisions: Map<string, number>;
-    watchSnapshotSequence: number;
-    readonly sessionWatchTimers: Map<string, NodeJS.Timeout>;
-    readonly sessionWatchSignatures: Map<string, string>;
-    readonly sessionWatchReads: Map<string, Promise<void>>;
-    readonly sessionCache: Map<string, {
-        readonly sessions: readonly NodeAgentSession[];
-        readonly expiresAt: number;
-    }>;
-    readonly sessionCacheReads: Map<string, Promise<readonly NodeAgentSession[]>>;
-    readonly changesLimiter: AsyncLimiter;
-}
-declare class AsyncLimiter {
-    private readonly limit;
-    private active;
-    private readonly waiters;
-    constructor(limit: number);
-    run<T>(task: () => Promise<T>): Promise<T>;
-}
-export {};

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

@@ -1,18 +0,0 @@
-import type { NodeWorkspace } from '../database.js';
-import { WorkspaceFileIndex } from '../workspace.js';
-import { WorkspaceDomainState } from './workspace-domain-state.js';
-export declare class WorkspaceFileService {
-    private readonly state;
-    private readonly allowedRoots;
-    private readonly onInvalidated;
-    private readonly mutationTails;
-    constructor(state: WorkspaceDomainState, allowedRoots: () => readonly string[], onInvalidated: (workspaceId: string) => void);
-    list(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<unknown>;
-    read(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<unknown>;
-    readContent(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<unknown>;
-    search(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<unknown>;
-    mutate(workspace: NodeWorkspace, input: Record<string, unknown>): Promise<unknown>;
-    private serializeMutation;
-    index(workspace: NodeWorkspace): WorkspaceFileIndex;
-    dispose(workspaceId?: string): void;
-}

package/dist/service/workspace-git-exclude-service.d.ts

@@ -1,4 +0,0 @@
-export declare function ensureWorkspaceGitExclude(workspace: string): Promise<void>;
-export declare function updateWorkspaceSkillGitExclude(workspace: string, name: string, add: boolean): Promise<void>;
-export declare function rewriteWorkspaceGitExclude(workspace: string, names: ReadonlySet<string>): Promise<void>;
-export declare function hasBrokenWorkspaceSkillGitExclude(workspace: string, names: readonly string[]): Promise<boolean>;

package/dist/service/workspace-queue-workbench-service.d.ts

@@ -1,86 +0,0 @@
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
-import type { RunnerName } from '@myagentroam/protocol';
-import type { NodeAgentRun, NodeMcpInstallation, NodeMessageAttachmentInput } from '../database.js';
-export interface QueuedRunStart<TAttachment = unknown> {
-    readonly runId: string;
-    readonly sessionId: string;
-    readonly workspaceId: string;
-    readonly runner: RunnerName;
-    readonly input: string;
-    readonly attachments: readonly TAttachment[];
-    readonly attachmentPaths: readonly string[];
-    readonly cwd: string;
-    readonly externalSessionId: string | null;
-    readonly model: string | null;
-    readonly effort: string | null;
-    readonly access: string | null;
-    readonly collaborationMode: 'default' | 'plan';
-    readonly serviceTier?: 'fast';
-    readonly secretEnvironment: Readonly<Record<string, string>>;
-    readonly personalInstructions?: string;
-}
-interface EnqueuedRunDisposition {
-    readonly runId: string;
-    readonly intent: 'SEND' | 'QUEUE' | 'REPLACE_CURRENT';
-    readonly queueBefore: {
-        readonly paused: boolean;
-        readonly runIds: readonly string[];
-    };
-    readonly leaseWasActive: boolean;
-    readonly activeRunId?: string;
-}
-export interface WorkspaceQueueWorkbenchServiceOptions {
-    readonly runtime: NodeRuntimeState;
-    readonly emit: (workspaceId: string, sessionId: string) => void;
-    readonly clearImages: (runId: string) => void;
-    readonly cleanupAttachments: (runId: string) => void;
-    readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'FAILED' | 'CANCELLED') => void;
-    readonly emitConversation: (turn: unknown) => void;
-    readonly control: (operation: string, payload: Record<string, unknown>) => void;
-    readonly stopped: () => boolean;
-    readonly markInterrupted: (runId: string) => void;
-    readonly prepareInput: (runner: RunnerName, input: string, collaborationMode: 'default' | 'plan') => string;
-    readonly mcps: (workspaceId: string) => readonly NodeMcpInstallation[];
-}
-export declare class WorkspaceQueueWorkbenchService<TAttachment> {
-    private readonly options;
-    private readonly starts;
-    private readonly scheduledSessions;
-    constructor(options: WorkspaceQueueWorkbenchServiceOptions);
-    enqueue(start: QueuedRunStart<TAttachment>, message: {
-        readonly runId: string;
-        readonly sessionId: string;
-        readonly clientMessageId: string;
-        readonly content: string;
-        readonly initiatedByUserId?: number;
-        readonly attachments?: readonly NodeMessageAttachmentInput[];
-    }): {
-        readonly run: NodeAgentRun;
-        readonly created: boolean;
-    };
-    pending(runId: string): QueuedRunStart<TAttachment> | undefined;
-    remove(runId: string): void;
-    clear(): void;
-    publish(sessionId: string): void;
-    migrateSession(previousId: string, nextId: string): void;
-    cancelQueued(runId: string): void;
-    pauseForInterrupt(sessionId: string): void;
-    resumeAfterCommandRun(sessionId: string): void;
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private get;
-    private pauseOrResume;
-    private reorder;
-    private update;
-    private delete;
-    private execute;
-    private requireSession;
-    private requireRun;
-    replace(queuedRunId: string, activeRunId: string, prioritize?: boolean): void;
-    schedule(sessionId: string): void;
-    settleEnqueue(input: EnqueuedRunDisposition): 'STARTED' | 'QUEUED' | 'RESTARTING';
-    dispatch(sessionId: string): Promise<void>;
-    present(workspaceId: string, sessionId: string): unknown;
-    private updatePending;
-}
-export {};

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

@@ -1,15 +0,0 @@
-import type { NodeConfig } from '../config.js';
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
-import type { NodeDatabase } from '../database.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
-export declare class WorkspaceService {
-    private readonly database;
-    private readonly config;
-    private readonly runtime;
-    private readonly onRemoved;
-    constructor(database: () => NodeDatabase, config: () => NodeConfig, runtime: NodeRuntimeState, onRemoved: (workspaceId: string) => void);
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private register;
-    private listDirectories;
-    private remove;
-}