@ours.network/fleet 1.2.0-nightly.7 → 1.2.0-nightly.71

package/dist/managed-recovery.d.ts

@@ -0,0 +1,13 @@
+/** Body-free recovery cursor. Dispatching is uncertain after a crash, never
+ * permission to replay an initial task which may already have caused effects. */
+export interface ManagedRecovery {
+    version: 1;
+    session: 'pending' | 'established';
+    readiness: boolean;
+    initial: 'pending' | 'dispatching' | 'completed';
+    active: boolean;
+}
+export declare const managedRecoveryPath: (dir: string) => string;
+export declare function readManagedRecovery(dir: string): ManagedRecovery | undefined;
+export declare function writeManagedRecovery(dir: string, value: ManagedRecovery): void;
+export declare function firstManagedSessionMayStart(dir: string): boolean;

package/dist/managed-recovery.js

@@ -0,0 +1,31 @@
+import { lstatSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFileAtomically } from './atomic-file.js';
+export const managedRecoveryPath = (dir) => join(dir, '.managed-recovery.json');
+export function readManagedRecovery(dir) {
+    const path = managedRecoveryPath(dir);
+    let stat;
+    try {
+        stat = lstatSync(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 4096)
+        throw Error('MANAGED_RECOVERY_UNSAFE_PROOF');
+    const value = JSON.parse(readFileSync(path, 'utf8'));
+    if (value.version !== 1 || !['pending', 'established'].includes(value.session)
+        || !['pending', 'dispatching', 'completed'].includes(value.initial)
+        || typeof value.readiness !== 'boolean' || typeof value.active !== 'boolean')
+        throw Error('MANAGED_RECOVERY_INVALID_PROOF');
+    return value;
+}
+export function writeManagedRecovery(dir, value) {
+    replaceFileAtomically(managedRecoveryPath(dir), JSON.stringify(value) + '\n');
+}
+export function firstManagedSessionMayStart(dir) {
+    const proof = readManagedRecovery(dir);
+    return Boolean(proof?.session === 'pending' && proof.initial === 'pending' && !proof.readiness && !proof.active);
+}

package/dist/minimal-setup.d.ts

@@ -0,0 +1,2 @@
+/** Prepare only the web configuration; App onboarding chooses agents and brains later. */
+export declare function ensureMinimalSetup(configuration: string): Promise<void>;

package/dist/minimal-setup.js

@@ -0,0 +1,44 @@
+import { existsSync, linkSync, mkdirSync, mkdtempSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { withFileLock } from './atomic-file.js';
+import { loadConfig, splitRootFor } from './config.js';
+import { preflightInitPaths } from './init-wizard.js';
+import { workspaceOwnerInvite } from './paths.js';
+/** Prepare only the web configuration; App onboarding chooses agents and brains later. */
+export async function ensureMinimalSetup(configuration) {
+    const initial = preflightInitPaths(configuration);
+    await withFileLock(join(initial.parent, `.${basename(initial.splitRoot)}.init.lock`), async () => {
+        const selected = preflightInitPaths(configuration);
+        if (selected.manifestExisted) {
+            loadConfig(selected.configPath, { yamlMode: 'strict', deferredOwnerInviteFile: workspaceOwnerInvite() });
+            return;
+        }
+        if (selected.rootExisted)
+            throw new Error('Fleet split configuration exists without its manifest; retain it and recover the existing setup before setting up a tunnel');
+        const stage = mkdtempSync(join(selected.parent, '.fleet-web-setup-'));
+        const manifest = join(stage, 'fleet.yaml');
+        const root = splitRootFor(manifest);
+        let publishedRoot = false;
+        try {
+            mkdirSync(join(root, 'agents'), { recursive: true, mode: 0o700 });
+            writeFileSync(manifest, 'api_version: ours.network/fleet/v2\n', { mode: 0o600, flag: 'wx' });
+            loadConfig(manifest, { yamlMode: 'strict' });
+            if (existsSync(selected.splitRoot) || existsSync(selected.configPath))
+                throw new Error('Fleet setup targets changed; refusing replacement');
+            renameSync(root, selected.splitRoot);
+            publishedRoot = true;
+            // Same-filesystem link publishes without replacing an unexpected manifest.
+            linkSync(manifest, selected.configPath);
+            unlinkSync(manifest);
+            loadConfig(selected.configPath, { yamlMode: 'strict' });
+        }
+        catch (cause) {
+            if (publishedRoot)
+                throw new Error('Minimal Fleet setup stopped after publishing its empty split directory; existing files were retained for recovery', { cause });
+            throw cause;
+        }
+        finally {
+            rmSync(stage, { recursive: true, force: true });
+        }
+    });
+}

package/dist/monitor.d.ts

@@ -28,6 +28,10 @@ export type FetchLike = (url: string, init?: {
     signal?: AbortSignal;
 }) => Promise<FetchResponse>;
 export interface MonitorPageClient {
+    /** Body-free snapshot; never consumes messages or changes read status. */
+    unread(): Promise<{
+        identities: Array<Record<string, unknown>>;
+    }>;
     readNotificationPage(identity: string, options?: {
         since?: number | 'tip';
         signal?: AbortSignal;
@@ -88,33 +92,6 @@ export interface MonitorDeps {
  * turns they trigger keep dying.
  */
 export type StatusCause = 'connectivity' | 'delivery' | 'modal' | 'offline' | 'turns-failing' | 'safe-boundary' | 'auth';
-/** Best-effort daemon config (issue #17): the fields the MCP client reads. */
-interface DaemonConfig {
-    apiToken?: string;
-    port?: number;
-    stateDir?: string;
-}
-/**
- * Read the daemon config the way the MCP client does — best-effort. Any missing,
- * malformed, or unreadable config yields `{}` so token resolution falls through
- * (issue #17). Only the well-typed fields we consume are surfaced.
- */
-export declare function readDaemonConfig(env: NodeJS.ProcessEnv): DaemonConfig;
-/**
- * Resolve the daemon API token exactly like the MCP client (issue #17), a 3-step
- * chain: `OURS_API_TOKEN` (trimmed) → config `apiToken` (trimmed) → the 0600 owner
- * token at `<stateDir>/daemon-token`. Never generates a token; a failed read of
- * any source (missing/unreadable) silently falls through to the next.
- */
-export declare function resolveApiToken(env: NodeJS.ProcessEnv, file?: DaemonConfig): string | undefined;
-export interface DaemonEndpoint {
-    origin: string;
-    port: number;
-    configPath: string;
-    stateDir: string;
-    url(name: string): string;
-    headers: Record<string, string>;
-}
 export type IdentityPresence = {
     state: 'present';
     temporary: boolean;
@@ -125,16 +102,13 @@ export type IdentityPresence = {
     state: 'unknown';
     detail: string;
 };
-/** Resolve the daemon endpoint + auth header from env → config → defaults. */
-export declare function resolveEndpoint(env: NodeJS.ProcessEnv, includeToken?: boolean): DaemonEndpoint;
 /**
  * Ask the daemon's authoritative identity index. The notifications endpoint is
  * intentionally unsuitable for lifecycle: it serves an empty 200 page for a
  * valid but missing identity, which made a closed temp identity look healthy.
  */
 export declare function probeIdentityPresence(name: string, fetch: FetchLike, env: NodeJS.ProcessEnv, deps?: IdentityProbeDeps): Promise<IdentityPresence>;
-/** Actionable, secret-free description of every token source for this profile. */
-export declare function authResolutionHint(ep: DaemonEndpoint): string;
+export declare function classifyIdentityPresence(name: string, identities: unknown): IdentityPresence;
 /** Keep only the events whose type the role asked to wake on. */
 export declare function filterEvents(events: NotifyEvent[], wakeSources: string[]): NotifyEvent[];
 /**
@@ -196,8 +170,7 @@ export declare class Monitor {
     private readonly identity;
     private readonly cfg;
     private readonly deps;
-    private readonly ep?;
-    private readonly profile?;
+    private readonly profile;
     private readonly profileKey;
     private readonly monitorLeaseToken;
     private profileClientPromise?;
@@ -211,6 +184,7 @@ export declare class Monitor {
     private stopped;
     private bootDeadline;
     private currentAbort;
+    private initialBacklogPending;
     private apiErrorStreak;
     private readonly turnFailThreshold;
     /** Active degradations, keyed by cause. Empty means armed. */
@@ -230,6 +204,7 @@ export declare class Monitor {
     /** Gather stragglers arriving within batch_ms so a burst lands as one line. */
     private coalesce;
     private deliver;
+    private deliverLine;
     /** Update the consecutive-API-error streak and derive `.monitor-status` from it. */
     private recordTurn;
     /**
@@ -242,6 +217,7 @@ export declare class Monitor {
      */
     private doFetch;
     private profileClient;
+    private readInitialUnread;
     private disposeProfileClient;
     private advance;
     private persistCursor;
@@ -263,4 +239,3 @@ export declare class Monitor {
     private writeStatus;
 }
 export declare function createMonitor(o: MonitorOpts): Monitor;
-export {};

package/dist/monitor.js

@@ -1,6 +1,5 @@
 import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { attachOursClient } from '@ours.network/sdk/client';
 import { clientProfileKey, readClientProfile, } from './client-profile.js';
@@ -42,127 +41,31 @@ const TURN_OBSERVE_INTERVAL_MS = 1_500;
 const DEFAULT_TURN_FAIL_THRESHOLD = 3; // fallback when the resolved config omits it
 class AuthError extends Error {
 }
-/** Path to the daemon config the MCP client uses: OURS_CONFIG ?? real ~/.ours/config.json. */
-const daemonConfigPath = (env) => env.OURS_CONFIG ?? join(homedir(), '.ours', 'config.json');
-/** Preserve the daemon's legacy env integer semantics: parseInt, invalid → absent. */
-function envInt(env, name) {
-    const raw = env[name];
-    if (raw === undefined)
-        return undefined;
-    const n = parseInt(raw, 10);
-    return Number.isNaN(n) ? undefined : n;
-}
-/**
- * Read the daemon config the way the MCP client does — best-effort. Any missing,
- * malformed, or unreadable config yields `{}` so token resolution falls through
- * (issue #17). Only the well-typed fields we consume are surfaced.
- */
-export function readDaemonConfig(env) {
-    try {
-        const p = JSON.parse(readFileSync(daemonConfigPath(env), 'utf8'));
-        const o = {};
-        if (typeof p.apiToken === 'string' && p.apiToken.trim())
-            o.apiToken = p.apiToken.trim();
-        if (typeof p.port === 'number' && Number.isFinite(p.port))
-            o.port = p.port;
-        if (typeof p.stateDir === 'string')
-            o.stateDir = p.stateDir;
-        return o;
-    }
-    catch {
-        return {};
-    }
-}
-/**
- * Resolve the daemon API token exactly like the MCP client (issue #17), a 3-step
- * chain: `OURS_API_TOKEN` (trimmed) → config `apiToken` (trimmed) → the 0600 owner
- * token at `<stateDir>/daemon-token`. Never generates a token; a failed read of
- * any source (missing/unreadable) silently falls through to the next.
- */
-export function resolveApiToken(env, file = readDaemonConfig(env)) {
-    const e = env.OURS_API_TOKEN?.trim();
-    if (e)
-        return e;
-    if (file.apiToken)
-        return file.apiToken;
-    const sd = env.OURS_STATE_DIR ?? file.stateDir ?? join(homedir(), '.ours');
-    try {
-        const t = readFileSync(join(sd, 'daemon-token'), 'utf8').trim();
-        if (t)
-            return t;
-    }
-    catch { /* missing/unreadable (e.g. cross-user 0600) → fall through */ }
-    return undefined;
-}
-/** Resolve the daemon endpoint + auth header from env → config → defaults. */
-export function resolveEndpoint(env, includeToken = true) {
-    const file = readDaemonConfig(env);
-    const port = envInt(env, 'OURS_PORT') ?? file.port ?? DEFAULT_PORT;
-    const configPath = daemonConfigPath(env);
-    const stateDir = env.OURS_STATE_DIR ?? file.stateDir ?? join(homedir(), '.ours');
-    const token = includeToken ? resolveApiToken(env, file) : undefined;
-    const origin = `http://127.0.0.1:${port}`;
-    return {
-        origin,
-        port,
-        configPath,
-        stateDir,
-        url: (name) => `${origin}/identities/${encodeURIComponent(name)}/notifications`,
-        headers: token ? { 'x-ours-api-token': token } : {},
-    };
-}
 /**
  * Ask the daemon's authoritative identity index. The notifications endpoint is
  * intentionally unsuitable for lifecycle: it serves an empty 200 page for a
  * valid but missing identity, which made a closed temp identity look healthy.
  */
 export async function probeIdentityPresence(name, fetch, env, deps = {}) {
-    const profile = readClientProfile(env);
-    if (profile) {
-        let client;
-        try {
-            client = await (deps.attachClient?.({
-                endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
-                credentialPath: profile.credentialPath,
-                sessionMode: 'external', leaseToken: randomUUID(), env: {},
-            }) ?? attachOursClient({
-                endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
-                credentialPath: profile.credentialPath,
-                sessionMode: 'external', leaseToken: randomUUID(), env: {},
-            }));
-            return classifyIdentityPresence(name, await client.identities());
-        }
-        catch {
-            return { state: 'unknown', detail: 'selected identity index is unavailable' };
-        }
-        finally {
-            await client?.close().catch(() => undefined);
-        }
-    }
-    const ep = resolveEndpoint(env);
-    let response;
+    let client;
     try {
-        response = await fetch(`${ep.origin}/identities`, { headers: ep.headers });
-    }
-    catch (error) {
-        return { state: 'unknown', detail: `identity index unreachable (${msg(error)})` };
-    }
-    if (!response.ok)
-        return {
-            state: 'unknown',
-            detail: response.status === 401
-                ? `daemon rejected the API token (401) — ${authResolutionHint(ep)}`
-                : `identity index returned HTTP ${response.status}`,
+        const profile = readClientProfile(env);
+        const options = {
+            endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath,
+            sessionMode: 'external', leaseToken: randomUUID(), env: {},
         };
-    try {
-        const body = await response.json();
-        return classifyIdentityPresence(name, body.identities);
+        client = await (deps.attachClient?.(options) ?? attachOursClient(options));
+        return classifyIdentityPresence(name, await client.identities());
     }
-    catch (error) {
-        return { state: 'unknown', detail: `identity index response is unreadable (${msg(error)})` };
+    catch {
+        return { state: 'unknown', detail: 'gateway identity index unavailable; check the shared client profile and issued credential' };
+    }
+    finally {
+        await client?.close().catch(() => undefined);
     }
 }
-function classifyIdentityPresence(name, identities) {
+export function classifyIdentityPresence(name, identities) {
     if (!Array.isArray(identities))
         return { state: 'unknown', detail: 'identity index response is malformed' };
     // A healthy daemon normally has at least its Human identity. During daemon
@@ -186,12 +89,6 @@ function classifyIdentityPresence(name, identities) {
             stale: found.stale === true,
         };
 }
-/** Actionable, secret-free description of every token source for this profile. */
-export function authResolutionHint(ep) {
-    const tokenPath = join(ep.stateDir, 'daemon-token');
-    return `set OURS_API_TOKEN, set apiToken in ${JSON.stringify(ep.configPath)}, or ensure ` +
-        `${JSON.stringify(tokenPath)} is readable by the fleet supervisor`;
-}
 /** Keep only the events whose type the role asked to wake on. */
 export function filterEvents(events, wakeSources) {
     const set = new Set(wakeSources);
@@ -414,7 +311,6 @@ export class Monitor {
     identity;
     cfg;
     deps;
-    ep;
     profile;
     profileKey;
     monitorLeaseToken = `ours-fleet-monitor-${process.pid}-${randomUUID()}`;
@@ -429,6 +325,7 @@ export class Monitor {
     stopped = false;
     bootDeadline = 0;
     currentAbort = null;
+    initialBacklogPending = true;
     // Refusal-wedge detector (issue #19): consecutive delivered wakes whose turn
     // ended in an API error with no completed turn in between.
     apiErrorStreak = 0;
@@ -441,8 +338,7 @@ export class Monitor {
         this.cfg = o.cfg;
         this.deps = o.deps;
         this.profile = readClientProfile(o.deps.env);
-        this.ep = this.profile ? undefined : resolveEndpoint(o.deps.env);
-        this.profileKey = this.profile ? clientProfileKey(this.profile) : this.ep.origin;
+        this.profileKey = clientProfileKey(this.profile);
         this.statusPath = join(o.agentDir, '.monitor-status');
         this.cursorPath = join(o.agentDir, '.notify-cursor');
         this.statePath = join(o.agentDir, '.monitor-state.json');
@@ -470,14 +366,8 @@ export class Monitor {
         }
         catch (e) {
             if (e instanceof AuthError) {
-                if (this.profile) {
-                    this.cursor = null;
-                    this.degrade('auth', e.message);
-                }
-                else {
-                    this.fatal = true;
-                    this.degrade('auth', e.message, 'failed');
-                }
+                this.cursor = null;
+                this.degrade('auth', e.message);
             }
             else {
                 this.cursor = null;
@@ -500,6 +390,41 @@ export class Monitor {
                     this.degrade('offline', 'session offline');
                     return;
                 }
+                // The native SessionStart hook is disabled for managed sessions. Check
+                // existing unread work AFTER the ready turn, without a model inbox ritual
+                // or touching read status. Keep retrying a failed probe/delivery before
+                // committing stream cursors, including on supervisor restarts.
+                if (this.initialBacklogPending) {
+                    try {
+                        const body = await this.readInitialUnread();
+                        if (!Array.isArray(body.identities))
+                            throw new Error('unread summary is malformed');
+                        const row = body.identities.find(row => row.name === this.identity);
+                        if (row && (!Number.isSafeInteger(row.count) || Number(row.count) < 0
+                            || !Number.isSafeInteger(row.files) || Number(row.files) < 0))
+                            throw new Error('unread identity summary is malformed');
+                        const messages = this.cfg.wake_sources.includes('message_received') ? Number(row?.count ?? 0) : 0;
+                        const files = this.cfg.wake_sources.includes('file_received') ? Number(row?.files ?? 0) : 0;
+                        if ((messages || files) && !await this.deliverLine(`${PREFIX} unread backlog: ${messages} messages, ${files} files — run get_messages; drain remaining unread batches and authorize files before retrieving them`)) {
+                            await this.deps.sleep(BACKOFF_MAX_MS);
+                            continue;
+                        }
+                        this.initialBacklogPending = false;
+                        this.recover('connectivity', 'auth');
+                    }
+                    catch (e) {
+                        if (this.stopped)
+                            return;
+                        if (e instanceof AuthError)
+                            this.degrade('auth', e.message);
+                        else
+                            this.degrade('connectivity', 'initial unread check unavailable; retrying');
+                        await this.deps.sleep(BACKOFF_MAX_MS);
+                        continue;
+                    }
+                }
+                if (this.stopped)
+                    return;
                 let body;
                 try {
                     body = await this.doFetch(String(this.cursor ?? 0), LONGPOLL_STALL_MS, 'stall');
@@ -510,11 +435,6 @@ export class Monitor {
                 catch (e) {
                     if (this.stopped)
                         return;
-                    if (e instanceof AuthError && !this.profile) {
-                        this.fatal = true;
-                        this.degrade('auth', e.message, 'failed');
-                        return;
-                    }
                     backoff = Math.min(backoff + BACKOFF_STEP_MS, BACKOFF_MAX_MS);
                     if (e instanceof AuthError)
                         this.degrade('auth', e.message);
@@ -579,7 +499,9 @@ export class Monitor {
         catch { /* no stragglers / abort — deliver what we have */ }
     }
     async deliver(pid, batch) {
-        const line = formatNotificationLine(batch);
+        return this.deliverLine(formatNotificationLine(batch));
+    }
+    async deliverLine(line) {
         if (!this.deps.delivery) {
             this.degrade('delivery', 'structured agent-session delivery is unavailable');
             return false;
@@ -630,23 +552,19 @@ export class Monitor {
         this.currentAbort = ctrl;
         let timedOut = false;
         const timer = this.deps.timers.set(() => { timedOut = true; ctrl.abort(); }, timeoutMs);
-        let resp;
         try {
-            if (this.profile) {
-                const client = await this.profileClient();
-                const page = await client.readNotificationPage(this.identity, {
-                    since: since === 'tip' ? 'tip' : Number.parseInt(since, 10),
-                    signal: ctrl.signal,
-                    requestTimeoutMs: timeoutMs,
-                });
-                return { cursor: page.cursor, events: page.events };
-            }
-            resp = await this.deps.fetch(`${this.ep.url(this.identity)}?since=${since}`, { headers: this.ep.headers, signal: ctrl.signal });
+            const client = await this.profileClient();
+            const page = await client.readNotificationPage(this.identity, {
+                since: since === 'tip' ? 'tip' : Number.parseInt(since, 10),
+                signal: ctrl.signal,
+                requestTimeoutMs: timeoutMs,
+            });
+            return { cursor: page.cursor, events: page.events };
         }
         catch (error) {
             if (timedOut && timeoutKind === 'stall')
                 throw new Error(`notification stream stalled for ${Math.round(timeoutMs / 1000)}s`);
-            if (this.profile && /(?:HTTP\s*401|unauthori[sz]ed|API token)/i.test(msg(error)))
+            if (/(?:HTTP\s*401|unauthori[sz]ed|API token)/i.test(msg(error)))
                 throw new AuthError(`daemon rejected the API token (401) — verify the credential file `
                     + `${JSON.stringify(this.profile.credentialPath)} selected by `
                     + `${JSON.stringify(this.profile.configPath)}`);
@@ -656,15 +574,8 @@ export class Monitor {
             this.deps.timers.clear(timer);
             this.currentAbort = null;
         }
-        if (resp.status === 401)
-            throw new AuthError(`daemon rejected the API token (401) — ${authResolutionHint(this.ep)}`);
-        if (!resp.ok)
-            throw new Error(`daemon returned HTTP ${resp.status}`);
-        return resp.json();
     }
     profileClient() {
-        if (!this.profile)
-            throw new Error('explicit client profile is not selected');
         if (!this.profileClientPromise) {
             const { endpoint, expectedInstanceId, credentialPath } = this.profile;
             const options = {
@@ -678,6 +589,32 @@ export class Monitor {
         }
         return this.profileClientPromise;
     }
+    async readInitialUnread() {
+        const ctrl = new AbortController();
+        this.currentAbort = ctrl;
+        const timer = this.deps.timers.set(() => ctrl.abort(), 5_000);
+        let client;
+        try {
+            const { endpoint, expectedInstanceId, credentialPath } = this.profile;
+            const options = {
+                endpoint, expectedInstanceId, credentialPath,
+                sessionMode: 'external', leaseToken: this.monitorLeaseToken, env: {},
+                requestSignal: ctrl.signal,
+            };
+            client = await (this.deps.attachClient?.(options) ?? attachOursClient(options));
+            return await client.unread();
+        }
+        catch (error) {
+            if (/(?:HTTP\s*401|unauthori[sz]ed|API token)/i.test(msg(error)))
+                throw new AuthError('daemon rejected the API token (401); initial unread check unavailable; retrying');
+            throw error;
+        }
+        finally {
+            this.deps.timers.clear(timer);
+            this.currentAbort = null;
+            await client?.close().catch(() => undefined);
+        }
+    }
     async disposeProfileClient() {
         const pending = this.profileClientPromise;
         this.profileClientPromise = undefined;

package/dist/notifications/fleet-producer.d.ts

@@ -0,0 +1,22 @@
+import { type ProducerConfig } from './outbox.js';
+/** Read durable supervisor ledgers without restarting agents or attaching a
+ * conversation controller. Each tick reads at most 256 KiB per role, from its
+ * checkpoint; it never loads a complete transcript or requests model history. */
+export declare class FleetNotificationProducer {
+    private readonly roots;
+    private readonly stateDir;
+    private readonly config;
+    private readonly warn;
+    private readonly queues;
+    private readonly observation;
+    private continuation?;
+    private stopped;
+    private readonly existing;
+    private cleanup?;
+    constructor(roots: string[], stateDir: string, config: ProducerConfig, warn?: (line: string) => void);
+    private names;
+    poll(): void;
+    private resume;
+    drain(): Promise<void>;
+    close(): Promise<void>;
+}