@roamcode.ai/server 1.0.22 → 1.1.0

package/dist/start.d.ts

@@ -18,7 +18,26 @@ interface AttachSpawnOptions {
     dataDir: string;
 }
 
-type ProviderId = "claude" | "codex";
+declare const ADAPTER_CONTRACT_VERSION: 1;
+declare const adapterCapabilityNames: readonly ["probe", "launch", "resume", "state", "identity", "metadata", "usage", "login", "attachments", "cleanup"];
+type AdapterCapabilityName = (typeof adapterCapabilityNames)[number];
+type AdapterStateAuthority = "native-events" | "runtime-signals" | "pane-heuristics";
+interface AdapterManifestV1 {
+    schemaVersion: typeof ADAPTER_CONTRACT_VERSION;
+    id: string;
+    version: string;
+    displayName: string;
+    platforms: Array<"darwin" | "linux">;
+    resumeIdentity: "optional" | "required" | "unsupported";
+    capabilities: Record<AdapterCapabilityName, boolean>;
+    stateAuthority: AdapterStateAuthority[];
+    /** JSON Schema for the adapter-owned launch options. */
+    optionSchema: Record<string, unknown>;
+}
+
+/** Public adapter identity. Built-ins are ordinary ids under the same contract; third parties are not
+ * forced through a source-code union update. Runtime validation is owned by ProviderRegistry. */
+type ProviderId = string;
 interface ProviderAvailability {
     terminalAvailable: boolean;
     metadataAvailable: boolean;
@@ -45,7 +64,22 @@ type CodexSessionOptions = {
     dangerouslyBypassApprovalsAndSandbox?: boolean;
     addDirs?: string[];
 };
-type ProviderSessionOptions = ClaudeSessionOptions | CodexSessionOptions;
+interface ProviderSessionOptions {
+    provider: ProviderId;
+    model?: string;
+    effort?: string;
+    reasoningEffort?: string;
+    permissionMode?: ClaudeSessionOptions["permissionMode"];
+    dangerouslySkip?: boolean;
+    sandbox?: CodexSessionOptions["sandbox"];
+    approvalPolicy?: CodexSessionOptions["approvalPolicy"];
+    profile?: string;
+    webSearch?: boolean;
+    dangerouslyBypassApprovalsAndSandbox?: boolean;
+    addDirs?: string[];
+    legacyArgs?: string[];
+    [key: string]: unknown;
+}
 type LaunchIntent = "fresh" | "resume";
 interface ProcessSpec {
     executable: string;
@@ -89,9 +123,11 @@ interface ProviderRuntimeMetadata {
     effort?: string;
 }
 interface AgentProvider {
+    /** Exact public, versioned adapter contract. Optional only for legacy in-process test doubles. */
+    readonly manifest?: Readonly<AdapterManifestV1>;
     readonly id: ProviderId;
     readonly displayName: string;
-    readonly resumeIdentity: "optional" | "required";
+    readonly resumeIdentity: "optional" | "required" | "unsupported";
     probe(): Promise<ProviderAvailability>;
     buildProcess(context: ProviderProcessContext): Promise<ProcessSpec>;
     /** Stateful parsers must be created per spawned process; providers are registry singletons. */
@@ -116,6 +152,12 @@ interface ClaudeVersionProbe {
 
 interface AuthGateOptions {
     token?: string;
+    /**
+     * Optional verifier for independently revocable credentials (for example per-device tokens). It
+     * receives the presented plaintext once; implementations should persist only a digest. A verifier
+     * failure is treated as an invalid credential and can never take the server down.
+     */
+    verifyCredential?: (token: string) => boolean;
     /** Consecutive failures from one client before it is locked out. Default 10. */
     maxFailures?: number;
     /** Lockout duration in ms. Default 60000. */
@@ -159,6 +201,7 @@ declare class AuthGate {
     private readonly lockoutMs;
     private readonly graceMs;
     private readonly now;
+    private readonly verifyCredential?;
     private readonly clients;
     constructor(opts: AuthGateOptions);
     check(presentedToken: string | undefined, clientKey: string): AuthCheckResult;
@@ -171,6 +214,10 @@ declare class AuthGate {
      * slate is correct (and avoids leaving a client locked out against a token that no longer exists).
      */
     rotateToken(newToken: string): void;
+    /** True only for the current host recovery credential (never a device key or grace token). */
+    isCurrentHostToken(presentedToken: string | undefined): boolean;
+    /** Security reset: replace the host credential immediately, with no previous-token grace window. */
+    resetToken(newToken: string): void;
     /** Drop entries whose lockout has expired and whose failure count is 0 — keeps the map bounded. */
     private sweepExpired;
     /** TEST ONLY: number of tracked clients currently locked (lockedUntil in the future). */
@@ -178,10 +225,13 @@ declare class AuthGate {
 }
 
 interface SessionDefaults {
+    /** The provider used by the most recently created session. Absent only for legacy saved documents. */
+    provider?: ProviderId;
     effort: string;
     model?: string;
     dangerouslySkip: boolean;
     permissionMode?: string;
+    addDirs?: string[];
     codex?: {
         model?: string;
         reasoningEffort?: string;
@@ -235,6 +285,7 @@ interface StoredSessionBase {
 }
 interface StoredClaudeSession extends StoredSessionBase {
     provider: "claude";
+    externalAdapter?: never;
     dangerouslySkip: boolean;
     /** The USER-chosen spawn flags the session was created with (`--model`/`--effort`/`--permission-mode`/
      *  `--dangerously-skip-permissions`/`--add-dir …`) — everything EXCEPT the ephemeral per-session
@@ -252,13 +303,24 @@ interface StoredIntegrationStatus {
 }
 interface StoredCodexSession extends StoredSessionBase {
     provider: "codex";
+    externalAdapter?: never;
     launchOptions: CodexSessionOptions;
     providerSessionId?: string;
     integrationStatus?: StoredIntegrationStatus;
     dangerouslySkip?: never;
     spawnArgs?: never;
 }
-type StoredSession = StoredClaudeSession | StoredCodexSession;
+interface StoredExternalSession extends StoredSessionBase {
+    provider: ProviderId;
+    /** Discriminator that keeps additive third-party rows separate from rollback-readable built-in tables. */
+    externalAdapter: true;
+    launchOptions: ProviderSessionOptions;
+    providerSessionId?: string;
+    integrationStatus?: StoredIntegrationStatus;
+    dangerouslySkip?: never;
+    spawnArgs?: never;
+}
+type StoredSession = StoredClaudeSession | StoredCodexSession | StoredExternalSession;
 /** How a store is actually backed: "sqlite" (durable) or "memory-fallback" (the native module failed to
  *  load — NOT durable across restarts). Surfaced so start.ts can warn loudly + /diag can report it. */
 type StoreMode = "sqlite" | "memory-fallback";
@@ -284,6 +346,8 @@ interface SessionStore {
     commitProvisionalProviderSessionId(id: string, value: string): void;
     getSessionDefaults(): StoredSessionDefaults | undefined;
     putSessionDefaults(defaults: SessionDefaults, expectedRevision: number, updatedAt: number): StoredSessionDefaults;
+    /** Server-owned last-launch write. Replaces the remembered choices and advances the revision atomically. */
+    rememberSessionDefaults(defaults: SessionDefaults, updatedAt: number): StoredSessionDefaults;
     putFile(file: StoredSessionFile): void;
     getFile(sessionId: string, id: string): StoredSessionFile | undefined;
     listFiles(sessionId: string, includeHidden?: boolean): StoredSessionFile[];
@@ -296,6 +360,15 @@ interface SessionStore {
     readonly mode: StoreMode;
 }
 
+type DeviceScope = "direct" | "relay";
+interface PairingTicket {
+    /** One-time capability carried by the pairing URL. Never persisted in plaintext. */
+    secret: string;
+    expiresAt: number;
+    /** Exact product surfaces the resulting device credential can reach. */
+    scopes: DeviceScope[];
+}
+
 declare global {
     /** Stable package version injected by tsup. Source/test builds fall back to package.json. */
     const __SERVER_VERSION__: string | undefined;
@@ -322,9 +395,43 @@ type PaneStatus = "working" | "blocked" | "idle";
 
 declare class ProviderRegistry {
     private readonly byId;
+    private readonly manifests;
+    private readonly sources;
+    private readonly enabled;
     constructor(providers: readonly AgentProvider[]);
+    register(provider: AgentProvider, source?: "built-in" | "installed", enabled?: boolean): void;
+    setEnabled(id: ProviderId, enabled: boolean): void;
+    isEnabled(id: ProviderId): boolean;
+    source(id: ProviderId): "built-in" | "installed" | undefined;
+    unregisterInstalled(id: ProviderId): void;
     get(id: ProviderId): AgentProvider;
     list(): AgentProvider[];
+    listEnabled(): AgentProvider[];
+    manifest(id: ProviderId): Readonly<AdapterManifestV1>;
+    descriptors(): {
+        enabled: boolean;
+        id: string;
+        displayName: string;
+        version: string;
+        schemaVersion: 1;
+        source: "built-in" | "installed";
+        platforms: ("darwin" | "linux")[];
+        resumeIdentity: "optional" | "required" | "unsupported";
+        capabilities: {
+            usage: boolean;
+            state: boolean;
+            probe: boolean;
+            launch: boolean;
+            resume: boolean;
+            identity: boolean;
+            metadata: boolean;
+            login: boolean;
+            attachments: boolean;
+            cleanup: boolean;
+        };
+        stateAuthority: AdapterStateAuthority[];
+        optionSchema: Record<string, unknown>;
+    }[];
 }
 
 interface CodexSpawnLease {
@@ -454,6 +561,11 @@ interface TerminalManagerDeps {
      * are). Same never-throw contract.
      */
     onFinished?: (id: string, wasAttached: boolean) => void;
+    /** Every semantic state transition, including ones observed while a browser is attached. Used by the
+     * command-center event/attention layer; a failure is isolated from terminal state. */
+    onActivityChanged?: (id: string, previous: PaneStatus, current: PaneStatus, attached: boolean) => void;
+    /** A client focused/attached this terminal. Done-unseen attention can become seen; blocked attention stays. */
+    onViewed?: (id: string) => void;
     /**
      * Capture a tmux session's CURRENT rendered pane as plain text (READ-ONLY). Injected for tests; in
      * production it defaults to a real `capture-pane -p` on {@link TMUX_SOCKET}. Drives {@link refreshActivity},
@@ -466,15 +578,8 @@ interface TerminalManagerDeps {
 type CreateTerminalOptions = {
     id: string;
     cwd: string;
-    provider: "claude";
-    options: ClaudeSessionOptions;
-    cols?: number;
-    rows?: number;
-} | {
-    id: string;
-    cwd: string;
-    provider: "codex";
-    options: CodexSessionOptions;
+    provider: ProviderId;
+    options: ProviderSessionOptions;
     cols?: number;
     rows?: number;
 };
@@ -491,6 +596,7 @@ declare class TerminalManager {
     private readonly providers;
     private attachConfig?;
     constructor(deps: TerminalManagerDeps);
+    private notifyActivityChanged;
     /** Late-bound (after listen(), which resolves the loopback port) — same config the chat SessionManager
      *  gets. When set, each terminal's claude is spawned with `--mcp-config` so send_image/send_file work. */
     setAttachConfig(attach: AttachSpawnOptions | undefined): void;
@@ -599,16 +705,404 @@ declare class TerminalManager {
     private killTmux;
 }
 
+type InputLeaseActorType = "device" | "host" | "local" | "relay";
+interface InputLeasePrincipal {
+    actorType: InputLeaseActorType;
+    actorId: string;
+    label: string;
+}
+interface InputLease {
+    id: string;
+    sessionId: string;
+    holderId: string;
+    actorType: InputLeaseActorType;
+    actorId: string;
+    label: string;
+    acquiredAt: number;
+    renewedAt: number;
+    expiresAt: number;
+    revision: number;
+}
+type InputLeaseEvent = {
+    type: "granted";
+    lease: InputLease;
+} | {
+    type: "renewed";
+    lease: InputLease;
+} | {
+    type: "released" | "expired" | "revoked";
+    lease: InputLease;
+} | {
+    type: "taken-over";
+    lease: InputLease;
+    previous: InputLease;
+};
+type InputLeaseAcquireResult = {
+    status: "granted" | "owned";
+    lease: InputLease;
+} | {
+    status: "denied";
+    current: InputLease;
+};
+interface InputLeaseCoordinatorOptions {
+    ttlMs?: number;
+    now?: () => number;
+    generateId?: () => string;
+    scheduleExpiry?: boolean;
+    onEvent?: (event: InputLeaseEvent) => void;
+}
+/**
+ * Coordinates the one mutable terminal input stream shared by many read-only observers.
+ *
+ * Leases intentionally live in memory: a host restart invalidates every connection and therefore every holder.
+ * Durable audit is supplied by the caller through onEvent. Expiry, release, and confirmed takeover are explicit;
+ * merely sending input can never acquire or steal ownership.
+ */
+declare class InputLeaseCoordinator {
+    private readonly leases;
+    private readonly listeners;
+    private readonly timers;
+    private readonly ttlMs;
+    private readonly now;
+    private readonly generateId;
+    private readonly scheduleExpiry;
+    private readonly onEvent?;
+    private revision;
+    constructor(options?: InputLeaseCoordinatorOptions);
+    acquire(sessionId: string, holderId: string, principal: InputLeasePrincipal): InputLeaseAcquireResult;
+    takeover(sessionId: string, holderId: string, principal: InputLeasePrincipal, confirmed: boolean, authorized?: boolean): InputLeaseAcquireResult;
+    renew(sessionId: string, holderId: string, leaseId: string): InputLease | undefined;
+    canWrite(sessionId: string, holderId: string, leaseId?: string): boolean;
+    release(sessionId: string, holderId: string, leaseId?: string): boolean;
+    releaseHolder(holderId: string): number;
+    revoke(sessionId: string): boolean;
+    revokeActor(actorType: InputLeaseActorType, actorId: string): number;
+    get(sessionId: string): InputLease | undefined;
+    subscribe(sessionId: string, listener: (event: InputLeaseEvent) => void): () => void;
+    close(): void;
+    private validate;
+    private current;
+    private renewExisting;
+    private remove;
+    private schedule;
+    private emit;
+}
+
+type TeamStoreMode = "sqlite" | "memory-fallback";
+type TeamMemberKind = "person" | "service";
+type TeamMemberStatus = "active" | "suspended" | "removed";
+type TeamRole = "viewer" | "operator" | "workspace-manager" | "extension-manager" | "policy-admin" | "organization-admin";
+type TeamScopeType = "team" | "host" | "workspace";
+type TeamPrincipalType = "device" | "host" | "local" | "relay";
+type TeamPermission = "team:read" | "sessions:read" | "sessions:operate" | "attention:read" | "attention:manage" | "presence:read" | "presence:write" | "workspaces:manage" | "extensions:manage" | "policy:manage" | "members:manage" | "audit:read" | "fleet:read";
+interface TeamRecord {
+    id: string;
+    name: string;
+    authorizationEnabled: boolean;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface TeamMember {
+    id: string;
+    displayName: string;
+    kind: TeamMemberKind;
+    status: TeamMemberStatus;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface TeamRoleBinding {
+    id: string;
+    memberId: string;
+    role: TeamRole;
+    scopeType: TeamScopeType;
+    scopeId?: string;
+    createdAt: number;
+}
+interface TeamPrincipalBinding {
+    actorType: TeamPrincipalType;
+    actorId: string;
+    memberId: string;
+    createdAt: number;
+}
+interface TeamAuthorizationResource {
+    hostId?: string;
+    workspaceId?: string;
+}
+interface TeamAuthorizationDecision {
+    allowed: boolean;
+    reason: "local-break-glass" | "not-enforced" | "unbound" | "inactive" | "role" | "missing-permission";
+    member?: TeamMember;
+    roles: TeamRole[];
+}
+interface TeamStore {
+    readonly mode: TeamStoreMode;
+    getTeam(): TeamRecord | null;
+    createTeam(input: {
+        name: string;
+        ownerName: string;
+        ownerPrincipal: {
+            actorType: TeamPrincipalType;
+            actorId: string;
+        };
+    }, now?: number): {
+        team: TeamRecord;
+        owner: TeamMember;
+    };
+    updateTeam(input: {
+        name?: string;
+        authorizationEnabled?: boolean;
+    }, expectedRevision: number, now?: number): TeamRecord;
+    listMembers(opts?: {
+        includeRemoved?: boolean;
+    }): TeamMember[];
+    getMember(id: string): TeamMember | undefined;
+    createMember(input: {
+        displayName: string;
+        kind?: TeamMemberKind;
+    }, now?: number): TeamMember;
+    updateMember(id: string, input: {
+        displayName?: string;
+        status?: TeamMemberStatus;
+    }, expectedRevision: number, now?: number): TeamMember | undefined;
+    listRoleBindings(memberId?: string): TeamRoleBinding[];
+    grantRole(input: {
+        memberId: string;
+        role: TeamRole;
+        scopeType?: TeamScopeType;
+        scopeId?: string;
+    }, now?: number): TeamRoleBinding;
+    revokeRole(id: string, now?: number): boolean;
+    listPrincipalBindings(memberId?: string): TeamPrincipalBinding[];
+    bindPrincipal(input: {
+        memberId: string;
+        actorType: TeamPrincipalType;
+        actorId: string;
+    }, now?: number): TeamPrincipalBinding;
+    unbindPrincipal(actorType: TeamPrincipalType, actorId: string, now?: number): boolean;
+    memberForPrincipal(actorType: TeamPrincipalType, actorId: string): TeamMember | undefined;
+    authorize(actorType: TeamPrincipalType, actorId: string, permission: TeamPermission, resource?: TeamAuthorizationResource): TeamAuthorizationDecision;
+    close(): void;
+}
+
+type PolicyStoreMode = "sqlite" | "memory-fallback";
+type ExtensionPolicyMode = "allow-integrity" | "signed-only" | "deny";
+type UpdatePolicyMode = "stable-only" | "deny";
+interface EnterprisePolicy {
+    enforcementEnabled: boolean;
+    allowedHostIds: string[] | null;
+    allowedWorkspaceIds: string[] | null;
+    allowedProviderIds: string[] | null;
+    allowDangerousProviderModes: boolean;
+    allowFileTransfer: boolean;
+    extensionMode: ExtensionPolicyMode;
+    allowRelay: boolean;
+    updateMode: UpdatePolicyMode;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface EnterprisePolicyUpdate {
+    enforcementEnabled?: boolean;
+    allowedHostIds?: string[] | null;
+    allowedWorkspaceIds?: string[] | null;
+    allowedProviderIds?: string[] | null;
+    allowDangerousProviderModes?: boolean;
+    allowFileTransfer?: boolean;
+    extensionMode?: ExtensionPolicyMode;
+    allowRelay?: boolean;
+    updateMode?: UpdatePolicyMode;
+}
+interface PolicyStore {
+    readonly mode: PolicyStoreMode;
+    get(): EnterprisePolicy;
+    update(input: EnterprisePolicyUpdate, expectedRevision: number, now?: number): EnterprisePolicy;
+    close(): void;
+}
+
+type PeerStoreMode = "sqlite" | "memory-fallback";
+type PeerAction = "read" | "send" | "wait" | "start" | "focus";
+type PeerStatus = "active" | "suspended";
+interface PeerRecord {
+    id: string;
+    label: string;
+    remoteHostId: string;
+    remoteVersion: string;
+    actions: PeerAction[];
+    allowedWorkspaceIds: string[] | null;
+    status: PeerStatus;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+    lastVerifiedAt: number;
+}
+interface PeerConnection extends PeerRecord {
+    baseUrl: string;
+    credential: string;
+}
+interface CreatePeerInput {
+    label: string;
+    baseUrl: string;
+    credential: string;
+    remoteHostId: string;
+    remoteVersion: string;
+    actions?: PeerAction[];
+    allowedWorkspaceIds?: string[] | null;
+}
+interface UpdatePeerInput {
+    label?: string;
+    actions?: PeerAction[];
+    allowedWorkspaceIds?: string[] | null;
+    status?: PeerStatus;
+    remoteVersion?: string;
+    lastVerifiedAt?: number;
+}
+interface PeerStore {
+    readonly mode: PeerStoreMode;
+    list(): PeerRecord[];
+    get(id: string): PeerRecord | undefined;
+    connection(id: string): PeerConnection | undefined;
+    create(input: CreatePeerInput, now?: number): PeerRecord;
+    update(id: string, input: UpdatePeerInput, expectedRevision: number, now?: number): PeerRecord | undefined;
+    rotateCredential(id: string, input: {
+        credential: string;
+        remoteVersion: string;
+        lastVerifiedAt?: number;
+    }, expectedRevision: number, now?: number): PeerRecord | undefined;
+    remove(id: string): boolean;
+    close(): void;
+}
+
+type PresenceMode = "viewing" | "operating";
+interface PresenceTarget {
+    hostId: string;
+    workspaceId?: string;
+    sessionId?: string;
+    agentId?: string;
+}
+interface PresenceRecord extends PresenceTarget {
+    id: string;
+    memberId?: string;
+    label: string;
+    mode: PresenceMode;
+    connectedAt: number;
+    lastSeenAt: number;
+    expiresAt: number;
+    revision: number;
+}
+type PresenceEvent = {
+    type: "joined" | "updated" | "left" | "expired";
+    presence: PresenceRecord;
+};
+interface PresenceHeartbeatInput extends PresenceTarget {
+    clientId: string;
+    mode: PresenceMode;
+    memberId?: string;
+}
+interface PresenceCoordinatorOptions {
+    ttlMs?: number;
+    now?: () => number;
+    generateId?: () => string;
+    maxRecords?: number;
+    maxPerActor?: number;
+    scheduleExpiry?: boolean;
+}
+/**
+ * Ephemeral, privacy-bounded presence. No IP, bearer credential, path, prompt, or terminal data is retained.
+ * Heartbeats expire cleanly after disconnect and are capped both globally and per authenticated actor.
+ */
+declare class PresenceCoordinator {
+    private readonly records;
+    private readonly listeners;
+    private readonly ttlMs;
+    private readonly now;
+    private readonly generateId;
+    private readonly maxRecords;
+    private readonly maxPerActor;
+    private readonly timer?;
+    private revision;
+    constructor(options?: PresenceCoordinatorOptions);
+    heartbeat(principal: InputLeasePrincipal, input: PresenceHeartbeatInput): PresenceRecord;
+    list(filter?: Partial<PresenceTarget>): PresenceRecord[];
+    release(principal: Pick<InputLeasePrincipal, "actorType" | "actorId">, clientId: string): boolean;
+    releaseActor(principal: Pick<InputLeasePrincipal, "actorType" | "actorId">): number;
+    /**
+     * Input ownership is authoritative for the public "operating" label. When a lease ends or moves, keep the
+     * connected observer visible but immediately downgrade stale operating heartbeats instead of waiting for TTL.
+     */
+    downgradeOperating(principal: Pick<InputLeasePrincipal, "actorType" | "actorId">, sessionId: string): number;
+    subscribe(listener: (event: PresenceEvent) => void): () => void;
+    sweep(): number;
+    close(): void;
+    private enforceBounds;
+    private evict;
+    private publicRecord;
+    private emit;
+}
+
+type RelayRpcMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface RelayRpcRequest {
+    id: string;
+    method: RelayRpcMethod;
+    path: string;
+    headers: Record<string, string>;
+    body?: Buffer;
+}
+interface RelayRpcResponse {
+    id: string;
+    status: number;
+    headers: Record<string, string>;
+    body?: string;
+}
+
 interface CreateServerResult {
     app: FastifyInstance;
     authGate: AuthGate;
+    /** Issue a five-minute, one-use pairing capability without exposing the host's master token. */
+    issuePairing(): PairingTicket;
+    /** Internal E2E-relay bridge. It authenticates relay-scoped devices through the exact normal route hooks. */
+    dispatchRelayRequest(token: string, request: RelayRpcRequest): Promise<RelayRpcResponse>;
+    /** Issues a relay-principal terminal ticket without exposing the bridge's process-local capability. */
+    issueRelayTerminalTicket(token: string): Promise<string>;
+    /** Process-local loopback headers for streamed relay HTTP. Never expose these outside this server process. */
+    relayLoopbackHeaders(token: string, headers?: Record<string, string>): Record<string, string>;
     /** Exposed so startServer can late-bind the MCP attach config (after listen() resolves the port) —
      *  this is what gives the terminal's claude send_image/send_file. */
     terminalManager: TerminalManager;
+    /** Exposed for relay/team composition and isolated ownership tests. */
+    inputLeases: InputLeaseCoordinator;
+    teamStore: TeamStore;
+    policyStore: PolicyStore;
+    peerStore: PeerStore;
+    presence: PresenceCoordinator;
     /** False when tmux/node-pty is unavailable → terminal sessions are disabled (startServer warns loudly). */
     terminalAvailable: boolean;
 }
 
+type RelayHostStatus = "idle" | "connecting" | "online" | "reconnecting" | "stopped";
+interface RelayHostMetrics {
+    status: RelayHostStatus;
+    activeChannels: number;
+    acceptedChannels: number;
+    rejectedChannels: number;
+    completedRequests: number;
+    failedRequests: number;
+    reconnects: number;
+    activeTransfers: number;
+    completedTransfers: number;
+    failedTransfers: number;
+    streamedRequestBytes: number;
+    streamedResponseBytes: number;
+}
+interface RelayHostConnector {
+    start(): void;
+    stop(): Promise<void>;
+    waitUntilReady(timeoutMs?: number): Promise<void>;
+    closeDevice(deviceId: string): void;
+    metrics(): RelayHostMetrics;
+}
+
 declare function providerPreflightWarning(name: string, availability: ProviderAvailability): string | undefined;
 declare function runProviderPreflight(providers: ReadonlyArray<{
     name: string;
@@ -631,11 +1125,7 @@ declare function startServer(env?: NodeJS.ProcessEnv): Promise<CreateServerResul
     url: string;
     token?: string;
     tokenGenerated: boolean;
+    relayHost?: RelayHostConnector;
 }>;
-/** Install process-wide crash guards so a stray unhandled rejection or a listener-less EventEmitter
- *  `error` (e.g. a write-after-teardown on a dying claude child, or a detached updater spawn failure)
- *  LOGS instead of taking the whole server down — for an always-on self-hosted server, staying up beats
- *  crashing. Install ONCE at a process entry (never in startServer, which tests call repeatedly). */
-declare function installCrashGuards(): void;
 
-export { claudePreflightWarning, installCrashGuards, providerPreflightWarning, runClaudePreflight, runProviderPreflight, startServer };
+export { claudePreflightWarning, providerPreflightWarning, runClaudePreflight, runProviderPreflight, startServer };