@reticlehq/server 2.8.0 → 2.10.0

package/dist/journal/workspace-gitignore.js

@@ -0,0 +1,59 @@
+import { join } from 'node:path';
+import { ReticleDir } from '@reticlehq/core';
+/**
+ * The `.reticle/` entries that are LOCAL state, and must never be committed by accident.
+ *
+ * Split from the durable half deliberately, and the split is the whole design: `contract.json`,
+ * `flows/`, `baselines/` and `capsules/` are meant to be checked in — a flow that cannot be shared
+ * is not a regression check anybody else can run — while everything below is per-machine churn.
+ *
+ * The reason this matters beyond tidiness: a session journal carries URLs, request and response
+ * bodies, and DOM text from the app under test. `.reticle/` is created by the daemon rather than by
+ * the user, so it arrives untracked and unexplained, and one `git add -A` puts an app's traffic into
+ * a shared repository. Reticle created the directory; the ignore for it is Reticle's to write.
+ */
+const TRANSIENT = [
+    `${ReticleDir.SESSIONS_SUBDIR}/`,
+    `${ReticleDir.RUNS_SUBDIR}/`,
+    `${ReticleDir.VISUAL_SUBDIR}/`,
+    ReticleDir.PROJECT_FILE,
+    ReticleDir.AMBIENT_FILE,
+    ReticleDir.ENVELOPES_FILE,
+    ReticleDir.FLAKE_FILE,
+    ReticleDir.TIERS_FILE,
+    '*.log',
+    '*.tmp',
+];
+const HEADER = [
+    '# Written by Reticle, and only about the directory Reticle owns.',
+    '#',
+    '# The entries below are per-machine state — session journals, run artifacts, learned envelopes.',
+    '# Journals contain URLs, request and response bodies and page text from the app under test, so',
+    '# they are worth keeping out of a shared repository on their own account.',
+    '#',
+    `# Deliberately NOT ignored: ${ReticleDir.CONTRACT_FILE}, ${ReticleDir.FLOWS_SUBDIR}/, ${ReticleDir.BASELINES_SUBDIR}/ and`,
+    `# ${ReticleDir.CAPSULES_SUBDIR}/. Those are meant to be committed — a saved flow only earns its keep`,
+    '# when a teammate or CI can replay it.',
+    '#',
+    '# Edit freely: Reticle writes this once and never rewrites it.',
+];
+/**
+ * Write `.reticle/.gitignore` if it is not already there.
+ *
+ * Never overwrites — once the file exists it belongs to whoever edited it last, and silently
+ * reverting somebody's change to a file we placed in their repository is worse than not having
+ * written it. Best-effort throughout: this runs on the daemon's start path, and a workspace that
+ * cannot be written must not stop a daemon coming up. Nothing about verification depends on it.
+ */
+export async function ensureWorkspaceGitignore(fs, root) {
+    const path = join(root, '.gitignore');
+    try {
+        if (await fs.exists(path))
+            return;
+        await fs.mkdir(root);
+        await fs.writeFile(path, `${[...HEADER, '', ...TRANSIENT].join('\n')}\n`);
+    }
+    catch {
+        /* a workspace we cannot write is not a reason to fail a session */
+    }
+}

package/dist/license/license.d.ts

@@ -12,6 +12,7 @@
  */
 import { type KeyObject } from 'node:crypto';
 import { z } from 'zod';
+import { LicenseActivation } from '@reticlehq/core';
 /** Outcome of verifying a license key. */
 export declare const LicenseStatus: {
     readonly VALID: "valid";
@@ -21,18 +22,31 @@ export declare const LicenseStatus: {
     readonly EXPIRED: "expired";
 };
 export type LicenseStatus = (typeof LicenseStatus)[keyof typeof LicenseStatus];
-/** The signed claims inside a key. `exp` is epoch ms; `features` (optional) scopes which ee features unlock. */
+/**
+ * The signed claims inside a key. `exp` is epoch ms; `features` (optional) scopes which ee features
+ * unlock.
+ *
+ * `lid` is the STABLE LICENSE ID and the only safe join key for per-customer usage: `org` is a display
+ * name a human typed at signing time, so two customers called "Acme" merge into one and a customer who
+ * renames splits into two. Every key carries one (minted by the issuer, `scripts/issue-license.mjs`),
+ * which is why it is required rather than optional — an optional id is one that goes missing on exactly
+ * the keys somebody later needs to attribute, and a key without it should be re-issued, not silently
+ * counted as nobody.
+ */
 declare const LicensePayloadSchema: z.ZodObject<{
+    lid: z.ZodString;
     org: z.ZodString;
     plan: z.ZodString;
     exp: z.ZodNumber;
     features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
+    lid: string;
     org: string;
     plan: string;
     exp: number;
     features?: string[] | undefined;
 }, {
+    lid: string;
     org: string;
     plan: string;
     exp: number;
@@ -42,13 +56,44 @@ export type LicensePayload = z.infer<typeof LicensePayloadSchema>;
 type LicenseCheck = {
     status: typeof LicenseStatus.VALID;
     payload: LicensePayload;
+}
+/**
+ * EXPIRED carries the payload; the other failures cannot. The line is the SIGNATURE, not the
+ * clock: an expired key was genuinely issued by us and its claims are exactly as trustworthy as
+ * they were yesterday, so the licence id is safe to use. A malformed or wrongly-signed key has no
+ * verified claims at all, and naming a customer from one would mean trusting whatever was pasted.
+ */
+ | {
+    status: typeof LicenseStatus.EXPIRED;
+    payload: LicensePayload;
 } | {
-    status: Exclude<LicenseStatus, typeof LicenseStatus.VALID>;
+    status: Exclude<LicenseStatus, typeof LicenseStatus.VALID | typeof LicenseStatus.EXPIRED>;
 };
 /** Sign a payload into a license key — the ISSUER side (Reticle's private key). Exposed for the issuer tool + tests. */
 export declare function signLicenseKey(payload: LicensePayload, privateKey: KeyObject): string;
 /** Verify a key against the issuer public key. Never throws — returns a structured status. */
 export declare function verifyLicenseKey(key: string | undefined, publicKey: KeyObject, now: number): LicenseCheck;
+/**
+ * Where to get a key. A named constant because it appears in the gate's error AND in what
+ * `reticle license` prints, and a contact address that drifts between the two is a support request
+ * that reaches nobody.
+ */
+export declare const LICENSE_CONTACT = "hey@reticle.sh";
+/**
+ * The features a licence gates in THIS build. The single source: `assertEnterprise` callers name a
+ * member rather than a string literal, and `reticle license` reports the list, so what the CLI claims
+ * is gated is derived from what is actually gated rather than a second list somebody maintains.
+ *
+ * It is deliberately short. Reticle's roadmap for enterprise is longer (SSO, SCIM, RBAC, multi-org,
+ * policy gates), and none of it is here yet — printing a roadmap as though it were shipped is how a
+ * buyer discovers on day two that the thing they paid for does not exist. What is listed is what the
+ * running build will actually refuse without a key.
+ */
+export declare const EnterpriseFeature: {
+    /** Recording an audit event. */
+    readonly AUDIT_LOG: "audit-log";
+};
+export type EnterpriseFeature = (typeof EnterpriseFeature)[keyof typeof EnterpriseFeature];
 /** Thrown when a production-mode enterprise feature is used without a valid license. */
 export declare class EnterpriseLicenseError extends Error {
     readonly feature: string;
@@ -71,8 +116,28 @@ export declare function assertEnterprise(feature: string, ctx: GateContext): voi
 export declare const LICENSE_KEY_ENV = "RETICLE_LICENSE_KEY";
 export declare const LICENSE_PUBLIC_KEY_ENV = "RETICLE_LICENSE_PUBLIC_KEY";
 /** The human-facing state of enterprise activation on this machine (what `reticle license status` shows). */
-interface LicenseReport {
-    status: 'active' | 'missing' | 'invalid' | 'expired' | 'eval';
+export interface LicenseReport {
+    /**
+     * Typed against core's closed list rather than re-listing the strings here: this status is reported
+     * on every telemetry event, so a member added in one place and not the other is a silently
+     * miscounted column (telemetry contract, rule 4).
+     */
+    status: LicenseActivation;
+    /** The stable license id — what usage is attributed to. Present only when `status` is `active`. */
+    licenseId?: string;
+    /**
+     * What a licence unlocks in THIS build, and where to get one. Always reported, including on an
+     * unlicensed install: `reticle license` was the one command that talks about licensing and it named
+     * neither, so it told an interested reader to set a variable without saying what it would unlock or
+     * how to obtain it. A dead end at exactly the moment somebody is asking.
+     */
+    gated: readonly string[];
+    contact: string;
+    /**
+     * The key is valid, and scoped to features this build does not gate, so it unlocks nothing here.
+     * Present only when true: a `false` on every healthy licence is noise on the common case.
+     */
+    coversNothingHere?: boolean;
     org?: string;
     plan?: string;
     expiresAt?: number;

package/dist/license/license.js

@@ -12,6 +12,7 @@
  */
 import { createPublicKey, sign as edSign, verify as edVerify } from 'node:crypto';
 import { z } from 'zod';
+import { LicenseActivation } from '@reticlehq/core';
 /** Outcome of verifying a license key. */
 export const LicenseStatus = {
     VALID: 'valid',
@@ -20,8 +21,19 @@ export const LicenseStatus = {
     BAD_SIGNATURE: 'bad-signature',
     EXPIRED: 'expired',
 };
-/** The signed claims inside a key. `exp` is epoch ms; `features` (optional) scopes which ee features unlock. */
+/**
+ * The signed claims inside a key. `exp` is epoch ms; `features` (optional) scopes which ee features
+ * unlock.
+ *
+ * `lid` is the STABLE LICENSE ID and the only safe join key for per-customer usage: `org` is a display
+ * name a human typed at signing time, so two customers called "Acme" merge into one and a customer who
+ * renames splits into two. Every key carries one (minted by the issuer, `scripts/issue-license.mjs`),
+ * which is why it is required rather than optional — an optional id is one that goes missing on exactly
+ * the keys somebody later needs to attribute, and a key without it should be re-issued, not silently
+ * counted as nobody.
+ */
 const LicensePayloadSchema = z.object({
+    lid: z.string().min(1),
     org: z.string(),
     plan: z.string(),
     exp: z.number(),
@@ -68,15 +80,35 @@ export function verifyLicenseKey(key, publicKey, now) {
     if (!signatureOk)
         return { status: LicenseStatus.BAD_SIGNATURE };
     if (payload.exp <= now)
-        return { status: LicenseStatus.EXPIRED };
+        return { status: LicenseStatus.EXPIRED, payload };
     return { status: LicenseStatus.VALID, payload };
 }
+/**
+ * Where to get a key. A named constant because it appears in the gate's error AND in what
+ * `reticle license` prints, and a contact address that drifts between the two is a support request
+ * that reaches nobody.
+ */
+export const LICENSE_CONTACT = 'hey@reticle.sh';
+/**
+ * The features a licence gates in THIS build. The single source: `assertEnterprise` callers name a
+ * member rather than a string literal, and `reticle license` reports the list, so what the CLI claims
+ * is gated is derived from what is actually gated rather than a second list somebody maintains.
+ *
+ * It is deliberately short. Reticle's roadmap for enterprise is longer (SSO, SCIM, RBAC, multi-org,
+ * policy gates), and none of it is here yet — printing a roadmap as though it were shipped is how a
+ * buyer discovers on day two that the thing they paid for does not exist. What is listed is what the
+ * running build will actually refuse without a key.
+ */
+export const EnterpriseFeature = {
+    /** Recording an audit event. */
+    AUDIT_LOG: 'audit-log',
+};
 /** Thrown when a production-mode enterprise feature is used without a valid license. */
 export class EnterpriseLicenseError extends Error {
     feature;
     reason;
     constructor(feature, reason) {
-        super(`Reticle Enterprise feature "${feature}" requires a valid license (${reason}). Contact hey@reticle.sh.`);
+        super(`Reticle Enterprise feature "${feature}" requires a valid license (${reason}). Contact ${LICENSE_CONTACT}.`);
         this.name = 'EnterpriseLicenseError';
         this.feature = feature;
         this.reason = reason;
@@ -122,7 +154,7 @@ export const LICENSE_PUBLIC_KEY_ENV = 'RETICLE_LICENSE_PUBLIC_KEY';
  * never setting RETICLE_LICENSE_PUBLIC_KEY, because the baked key takes precedence. The public key is
  * safe to ship openly — it can only verify licenses, never mint them (that needs the private key).
  */
-const BAKED_ISSUER_PUBLIC_KEY_PEM = '';
+const BAKED_ISSUER_PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAcg+u61Fs5pwDHcYxFGhaxVaQoUbAdyl+RUdSViZyxDY=\n-----END PUBLIC KEY-----";
 /**
  * Resolve the issuer public-key PEM enforcement uses: the baked-in release key wins, so it can't be
  * turned off from the environment. Only when nothing is baked (dev/repo) does the env var apply — that
@@ -134,6 +166,15 @@ function resolveIssuerPublicKeyPem(env, baked = BAKED_ISSUER_PUBLIC_KEY_PEM) {
     const envPem = env[LICENSE_PUBLIC_KEY_ENV];
     return envPem !== undefined && envPem.length > 0 ? envPem : undefined;
 }
+/**
+ * The two fields every report carries, spread into each branch. One object rather than a field on each
+ * return, because the value that must never go missing is the one on the branch nobody was thinking
+ * about — and the branch an unlicensed reader lands on is exactly that branch.
+ */
+const LICENSE_OFFER = {
+    gated: Object.values(EnterpriseFeature),
+    contact: LICENSE_CONTACT,
+};
 function loadPublicKey(pem) {
     if (pem === undefined || 0 === pem.length)
         return undefined;
@@ -156,42 +197,70 @@ export function describeLicense(now, env = process.env, baked = BAKED_ISSUER_PUB
         // is off, and assertEnterpriseFromEnv now denies rather than unlocking. Say so loudly here too.
         return isProductionEnv(env)
             ? {
-                status: 'invalid',
+                ...LICENSE_OFFER,
+                status: LicenseActivation.INVALID,
                 detail: 'MISCONFIGURED — running in production with no issuer key baked; enterprise features are DENIED (rebuild with BAKED_ISSUER_PUBLIC_KEY_PEM stamped in)',
             }
             : {
-                status: 'eval',
+                ...LICENSE_OFFER,
+                status: LicenseActivation.EVAL,
                 detail: 'evaluation mode: enterprise features run free (no issuer key configured)',
             };
     }
     const publicKey = loadPublicKey(pem);
     if (publicKey === undefined)
-        return { status: 'invalid', detail: `${LICENSE_PUBLIC_KEY_ENV} is not a valid public key` };
+        return {
+            ...LICENSE_OFFER,
+            status: LicenseActivation.INVALID,
+            detail: `${LICENSE_PUBLIC_KEY_ENV} is not a valid public key`,
+        };
     const check = verifyLicenseKey(env[LICENSE_KEY_ENV], publicKey, now);
     if (check.status === LicenseStatus.VALID) {
-        const { org, plan, exp, features } = check.payload;
+        const { lid, org, plan, exp, features } = check.payload;
+        // A key scoped to features this build does not gate is `active` and unlocks nothing. Both halves
+        // were already on screen (`features` against `gated`) and nothing joined them, so the one word a
+        // customer actually reads told them they were fine while every gated call refused them.
+        const coversNothingHere = features !== undefined && !features.some((f) => LICENSE_OFFER.gated.includes(f));
+        const detail = coversNothingHere
+            ? `licensed to ${org} (${plan}), expires ${new Date(exp).toISOString()}. This key covers ${features?.join(', ')}, and nothing this build gates (${LICENSE_OFFER.gated.join(', ')}) is included. Contact ${LICENSE_CONTACT}`
+            : `licensed to ${org} (${plan}), expires ${new Date(exp).toISOString()}`;
         return {
-            status: 'active',
+            ...LICENSE_OFFER,
+            status: LicenseActivation.ACTIVE,
+            licenseId: lid,
             org,
             plan,
             expiresAt: exp,
             ...(features !== undefined ? { features } : {}),
-            detail: `licensed to ${org} (${plan}), expires ${new Date(exp).toISOString()}`,
+            ...(coversNothingHere ? { coversNothingHere } : {}),
+            detail,
         };
     }
     if (check.status === LicenseStatus.MISSING) {
         return {
-            status: 'missing',
-            detail: `set ${LICENSE_KEY_ENV} to activate enterprise features in production`,
+            ...LICENSE_OFFER,
+            status: LicenseActivation.MISSING,
+            detail: `set ${LICENSE_KEY_ENV} to activate enterprise features in production. ` +
+                `Request a key from ${LICENSE_CONTACT}`,
         };
     }
     if (check.status === LicenseStatus.EXPIRED) {
+        // The id rides an expired key so a lapse can be attributed to a CUSTOMER. Without it, telemetry
+        // reports that somebody's licence ran out and cannot say whose, which is not a renewal signal.
         return {
-            status: 'expired',
-            detail: 'license expired — renew to keep using enterprise features',
+            ...LICENSE_OFFER,
+            status: LicenseActivation.EXPIRED,
+            licenseId: check.payload.lid,
+            org: check.payload.org,
+            expiresAt: check.payload.exp,
+            detail: `license expired. Renew with ${LICENSE_CONTACT} to keep using enterprise features`,
         };
     }
-    return { status: 'invalid', detail: `license key rejected (${check.status})` };
+    return {
+        ...LICENSE_OFFER,
+        status: LicenseActivation.INVALID,
+        detail: `license key rejected (${check.status}). ${LICENSE_CONTACT} can re-issue it`,
+    };
 }
 /** True in a production runtime (NODE_ENV=production) — where a missing issuer key is a mis-built
  *  release, not an eval session, so the gate must fail CLOSED rather than run features free. */

package/dist/mcp/mcp-proxy.d.ts

@@ -1,3 +1,10 @@
+export { SseFrameParser, type SseFrame } from './sse-frame-parser.js';
+export { probeDaemon, waitForDaemon } from './proxy-daemon-probe.js';
+/**
+ * Re-exported so every existing caller (and every spec) keeps importing the proxy's log from the
+ * proxy. Where the code lives is a file-size decision; where it is imported from is an API.
+ */
+export { accountProxyLogWrite, proxyLog, proxyLogPath, PROXY_LOG_CHECK_BYTES, recoverOversizedProxyLog, setProxyLogPort, } from './proxy-log.js';
 /**
  * Overridable so the survival spec can reach exhaustion in seconds instead of minutes — the same
  * reason the idle windows take an env override. A positive integer only; anything else falls back,
@@ -7,62 +14,6 @@ export declare const MAX_RECONNECT_ATTEMPTS: number;
 export declare function reconnectDelayMs(attempt: number): number;
 /** JSON-RPC id the proxy uses for its own replayed `initialize` — never one the client could send. */
 export declare const RECONNECT_INITIALIZE_ID = "__reticle_proxy_reinit";
-/**
- * How much the proxy may append between size checks.
- *
- * Statting the file on every line would be a syscall per log line on a process that logs from a
- * reconnect loop. Counting what we wrote costs nothing and is exact enough, because this process is
- * the only writer of its own log. Well under the cap, so the cap is a cap rather than a suggestion.
- */
-export declare const PROXY_LOG_CHECK_BYTES: number;
-/**
- * Keep the proxy log under the same cap as the daemon log, without a stat per write.
- *
- * Returns the new "bytes since the last check" counter, so the accounting is testable without a
- * filesystem. Rotation itself is `rotateDaemonLog` — the proxy log had no cap at all while the
- * daemon log on the SAME machine stayed small, which is the whole of this defect.
- */
-export declare function accountProxyLogWrite(bytesSinceCheck: number, written: number, path: string, deps: {
-    fileSize(p: string): number;
-    renameFile(from: string, to: string): void;
-}): number;
-/**
- * Reclaim a proxy log that a previous process already let run away. Returns the bytes reclaimed.
- *
- * Reported from the field: one machine's `proxy-4400.log` reached a third of a 460GB disk and broke
- * builds, Docker and ordinary shell commands with ENOSPC. Nothing in Reticle degraded first, so the
- * failure surfaced as the operating system refusing to write files. Files like that exist on real
- * machines now, and the cap alone does not help them: the user should not have to find one with `du`.
- *
- * TRUNCATED IN PLACE, never renamed or unlinked. A rename moves the bytes without reclaiming a byte,
- * and a file that a running process still holds open keeps its blocks allocated after an unlink
- * until that handle closes — which is why the reporter recovered with `: > ~/.reticle/proxy-4400.log`
- * and why that is the operation to copy here.
- *
- * Best-effort, in the same spirit as `rotateDaemonLog`: refusing to start the MCP server over
- * housekeeping is strictly worse than a large file.
- */
-export declare function recoverOversizedProxyLog(path: string, deps: {
-    fileSize(p: string): number;
-    truncateFile(p: string): void;
-}, max?: number): number;
-/** Name the proxy log after the port it serves. Called before anything can log. */
-export declare function setProxyLogPort(port: number): void;
-/** The proxy's own log file, so a silent drop leaves a readable trace the agent can go read. */
-export declare function proxyLogPath(port?: number | undefined): string;
-/**
- * Log to stderr (which the agent host usually swallows) AND to ~/.reticle/proxy-<port>.log, which it
- * does not. A dropped MCP connection is invisible from the agent's side — no message, no exit code —
- * so the one thing that makes it diagnosable at all is a file somebody can read afterwards.
- *
- * EXPORTED because the crash handlers need it. `installProxyResilience` was wired to the bare stderr
- * logger, so the proxy's own uncaught exceptions and unhandled rejections — the exact events that
- * present to a human as "the MCP server disconnected" — were written to a stream the editor throws
- * away. The handler ran, the process kept serving, and the reason went nowhere. Reported as "the
- * proxy has no log file… when it dies the diagnostic dies with it", which was half right: the file
- * existed, and the one path that most needed it was not using it.
- */
-export declare function proxyLog(event: string, fields?: Record<string, unknown>): void;
 /**
  * JSON-RPC requests forwarded on behalf of the client that have not been answered yet.
  *
@@ -143,33 +94,6 @@ export declare class HandshakeReplay {
     /** True when this inbound daemon line is the echo of our replayed handshake and must not be forwarded. */
     shouldSuppressInbound(line: string): boolean;
 }
-/** One parsed Server-Sent-Events frame: the event name (defaulted to "message") and its data. */
-interface SseFrame {
-    event: string;
-    data: string;
-}
-/**
- * Incremental SSE frame parser for the MCP front door.
- *
- * A single SSE field can split across TCP reads (`da` in one chunk, `ta: {...}` in the next), and a
- * server may send CRLF or bare CR line endings — so the framing is stateful and edge-case-prone, yet it
- * carried every MCP message the agent sends and was only ever exercised end-to-end. Pulled out of the
- * socket handler as a pure, chunk-fed parser so those boundaries are unit-testable: feed raw chunks,
- * get back each complete frame (a blank line terminates a frame; `event:` names it, `data:` lines
- * accumulate newline-joined; `id:`/`retry:`/comments are ignored — not needed for the bridge).
- */
-export declare class SseFrameParser {
-    #private;
-    push(chunk: string): SseFrame[];
-}
-/**
- * Returns true if something is already listening on the reticle port.
- * Uses a plain TCP probe so we don't create a side-effectful SSE session
- * inside the daemon just to check reachability.
- */
-export declare function probeDaemon(port: number): Promise<boolean>;
-/** Poll until the daemon's HTTP port accepts connections or the deadline is reached. */
-export declare function waitForDaemon(port: number): Promise<void>;
 /**
  * Turn an `endpoint` frame's data into a POST target, or null when there is nothing usable in it.
  *
@@ -181,15 +105,6 @@ export declare function waitForDaemon(port: number): Promise<void>;
  * to reconnect and how to answer what it cannot send.
  */
 export declare function buildSessionUrl(rawData: string, port: number): string | null;
-/**
- * Bridge stdio ↔ SSE: connects to the running daemon's MCP endpoint and forwards
- * Claude Code's stdin/stdout JSON-RPC through it. Never resolves — runs until stdin closes.
- *
- * A dropped SSE stream used to exit the process, which is what made the agent's `reticle_*` tools
- * vanish mid-session with no message and no way for the agent to get them back — only a human running
- * `/mcp` could. The daemon demonstrably stays up across these drops, so the stream ending is a
- * transport event, not a shutdown: reconnect to it and replay the handshake instead of dying.
- */
 export declare function startMcpProxy(port: number, 
 /**
  * Bring a daemon back before reconnecting. Without it the proxy retried a DEAD port until the
@@ -197,4 +112,3 @@ export declare function startMcpProxy(port: number,
  * failure mode for a daemon that crashed, was stopped, or shut itself down as idle.
  */
 ensureDaemon?: () => Promise<void>): Promise<never>;
-export {};