@rynx-ai/daemon 0.1.10 → 0.1.11-beta.10

package/dist/db.js

@@ -1,11 +1,11 @@
 /**
  * `~/.rynx/rynx.db` — the daemon's SQLite store. Concerns kept apart:
- *  - `channels`  — a chat type + its plugin-owned config/credentials.
- *  - `instances` — a runnable binding: a chat channel + an agent (1:1 with a channel,
- *    enforced by a UNIQUE channel_id). This is what the daemon mounts.
- *  - `plugins`   — static manifests, grants and immutable install locations.
+ *  - `plugin_installations` — source-qualified manifests and immutable packages.
+ *  - `plugin_marketplaces` — catalog registrations; catalog data is never executable.
  *  - `plugin_session_launch_operations` — durable idempotency/tombstones.
  *  - `control_links` — generic, one-use links to the local session console.
+ *  - `session_portal_tickets` / `session_portal_grants` — hashed, scoped,
+ *    browser Session Portal authorization.
  *  - `runtime_pairing_claims` / `runtime_client_grants` — one-use enrollment
  *    claims and the durable client identities they issue for direct runtimes.
  *  - `runtime_targets` / `runtime_direct_routes` / `runtime_pending_enrollments`
@@ -16,15 +16,18 @@
  * Connections are cached per resolved path so tests can point `RYNX_DB` /
  * `RYNX_HOME` at a temp dir. Override with `RYNX_DB` (full path) or `RYNX_HOME`.
  */
-import { randomUUID } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { chmodSync, mkdirSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { rynxHome } from "@rynx-ai/core";
 import Database from "better-sqlite3";
 const connections = new Map();
 /** Absolute path to the SQLite file (override via `RYNX_DB`, else `~/.rynx/rynx.db`). */
 export function dbPath() {
-    return process.env.RYNX_DB?.trim() || join(daemonHome(), "rynx.db");
+    const configured = process.env.RYNX_DB?.trim();
+    if (configured && !isAbsolute(configured)) {
+        throw new Error("RYNX_DB must be an absolute path");
+    }
+    return configured ? resolve(configured) : join(rynxHome(), "rynx.db");
 }
 /** Open (or reuse) the database at the current path, migrating + importing on first open. */
 export function db() {
@@ -37,7 +40,7 @@ export function db() {
     conn.pragma("busy_timeout = 5000");
     conn.pragma("foreign_keys = ON");
     migrate(conn);
-    // The store may hold channel secrets (e.g. LARK_APP_SECRET) — keep it private.
+    // Plugin state and daemon credentials are private.
     try {
         chmodSync(path, 0o600);
     }
@@ -49,34 +52,45 @@ export function db() {
 }
 function migrate(conn) {
     conn.exec(`
-    CREATE TABLE IF NOT EXISTS plugins (
-      name         TEXT PRIMARY KEY,
-      spec         TEXT NOT NULL,
-      source       TEXT NOT NULL,
-      version      TEXT,
-      enabled      INTEGER NOT NULL DEFAULT 1,
-      installed_at TEXT NOT NULL,
-      updated_at   TEXT,
-      install_path TEXT,
-      manifest     TEXT,
-      integrity    TEXT,
-      grants       TEXT
+    CREATE TABLE IF NOT EXISTS plugin_marketplaces (
+      marketplace_id TEXT PRIMARY KEY,
+      source_type    TEXT NOT NULL CHECK(source_type IN ('git', 'local')),
+      requested_source TEXT NOT NULL,
+      resolved_revision TEXT NOT NULL,
+      source_fingerprint TEXT NOT NULL,
+      built_in      INTEGER NOT NULL DEFAULT 0,
+      catalog        TEXT NOT NULL,
+      created_at     TEXT NOT NULL,
+      refreshed_at   TEXT NOT NULL
     );
-    CREATE TABLE IF NOT EXISTS channels (
-      id         TEXT PRIMARY KEY,
-      name       TEXT NOT NULL UNIQUE,
-      type       TEXT NOT NULL,
-      options    TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
+    CREATE TABLE IF NOT EXISTS plugin_marketplace_bindings (
+      marketplace_id    TEXT PRIMARY KEY,
+      source_fingerprint TEXT NOT NULL,
+      created_at         TEXT NOT NULL
     );
-    CREATE TABLE IF NOT EXISTS instances (
-      id         TEXT PRIMARY KEY,
-      channel_id TEXT NOT NULL UNIQUE REFERENCES channels(id) ON DELETE CASCADE,
-      agent      TEXT,
-      enabled    INTEGER NOT NULL DEFAULT 1,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
+    INSERT OR IGNORE INTO plugin_marketplace_bindings (
+      marketplace_id, source_fingerprint, created_at
+    )
+    SELECT marketplace_id, source_fingerprint, created_at
+    FROM plugin_marketplaces;
+    CREATE TABLE IF NOT EXISTS plugin_installations (
+      canonical_id   TEXT PRIMARY KEY,
+      marketplace_id TEXT NOT NULL,
+      plugin_id      TEXT NOT NULL,
+      source_type    TEXT NOT NULL CHECK(source_type IN ('git', 'local')),
+      requested_source TEXT NOT NULL,
+      resolved_revision TEXT NOT NULL,
+      source_fingerprint TEXT NOT NULL,
+      version        TEXT NOT NULL,
+      enabled        INTEGER NOT NULL DEFAULT 1,
+      installed_at   TEXT NOT NULL,
+      updated_at     TEXT NOT NULL,
+      install_path   TEXT NOT NULL,
+      manifest       TEXT NOT NULL,
+      integrity      TEXT NOT NULL,
+      runtime_state  TEXT,
+      runtime_error  TEXT,
+      UNIQUE(marketplace_id, plugin_id)
     );
     CREATE TABLE IF NOT EXISTS session_items (
       id          TEXT PRIMARY KEY,
@@ -142,16 +156,25 @@ function migrate(conn) {
         ON DELETE CASCADE
     );
     CREATE TABLE IF NOT EXISTS sessions (
+      id         TEXT PRIMARY KEY,
+      workspace  TEXT NOT NULL,
+      execution  TEXT NOT NULL,
+      title      TEXT,
+      forked_from_session_id TEXT,
+      source     TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT
+    );
+    CREATE TABLE IF NOT EXISTS session_snapshot_cleanup (
+      session_id TEXT PRIMARY KEY
+    );
+    CREATE TABLE IF NOT EXISTS runtime_projects (
       id               TEXT PRIMARY KEY,
-      provider         TEXT,
-      agent            TEXT,
-      config           TEXT,
-      model            TEXT,
-      reasoning_effort TEXT,
-      title            TEXT,
-      source           TEXT,
+      name             TEXT NOT NULL,
+      directories_json TEXT NOT NULL,
+      primary_dir      TEXT NOT NULL,
       created_at       TEXT NOT NULL,
-      updated_at       TEXT
+      updated_at       TEXT NOT NULL
     );
     CREATE TABLE IF NOT EXISTS session_pending_messages (
       session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
@@ -173,6 +196,7 @@ function migrate(conn) {
       scope_id       TEXT NOT NULL,
       operation_id   TEXT NOT NULL,
       request_hash   TEXT NOT NULL,
+      raw_request_hash TEXT,
       session_id     TEXT NOT NULL,
       state          TEXT NOT NULL DEFAULT 'active' CHECK(state IN ('active', 'deleted')),
       created_at     TEXT NOT NULL,
@@ -187,6 +211,31 @@ function migrate(conn) {
     );
     CREATE INDEX IF NOT EXISTS idx_plugin_session_launch_operations_session
       ON plugin_session_launch_operations(session_id);
+    CREATE TABLE IF NOT EXISTS session_fork_operations (
+      operation_id     TEXT PRIMARY KEY,
+      request_hash     TEXT NOT NULL,
+      source_session_id TEXT NOT NULL,
+      target_session_id TEXT NOT NULL UNIQUE,
+      title            TEXT,
+      fork_position    INTEGER,
+      state            TEXT NOT NULL DEFAULT 'reserved'
+        CHECK(state IN ('reserved', 'completed', 'target_deleted')),
+      error            TEXT,
+      created_at       TEXT NOT NULL,
+      updated_at       TEXT NOT NULL,
+      completed_at     TEXT,
+      deleted_at       TEXT,
+      CHECK(
+        (state = 'reserved' AND completed_at IS NULL AND deleted_at IS NULL)
+        OR (state = 'completed' AND completed_at IS NOT NULL AND deleted_at IS NULL)
+        OR (state = 'target_deleted' AND deleted_at IS NOT NULL)
+      )
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_fork_operations_source
+      ON session_fork_operations(source_session_id, state);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_session_fork_operations_reserved_source
+      ON session_fork_operations(source_session_id)
+      WHERE state = 'reserved';
     CREATE TABLE IF NOT EXISTS control_links (
       token      TEXT PRIMARY KEY,
       plugin_id  TEXT NOT NULL,
@@ -197,6 +246,39 @@ function migrate(conn) {
     );
     CREATE INDEX IF NOT EXISTS idx_control_links_expires
       ON control_links(expires_at);
+    CREATE TABLE IF NOT EXISTS session_portal_tickets (
+      ticket_hash TEXT PRIMARY KEY,
+      plugin_id   TEXT NOT NULL,
+      scope       TEXT NOT NULL CHECK(scope IN ('plugin_sessions', 'single_session')),
+      access      TEXT NOT NULL CHECK(access IN ('read_only', 'read_write')),
+      session_id  TEXT,
+      created_at  TEXT NOT NULL,
+      expires_at  TEXT NOT NULL,
+      used_at     TEXT,
+      CHECK(
+        (scope = 'plugin_sessions' AND session_id IS NULL)
+        OR (scope = 'single_session' AND session_id IS NOT NULL)
+      )
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_portal_tickets_expires
+      ON session_portal_tickets(expires_at);
+    CREATE TABLE IF NOT EXISTS session_portal_grants (
+      portal_id   TEXT PRIMARY KEY,
+      secret_hash TEXT NOT NULL,
+      plugin_id   TEXT NOT NULL,
+      scope       TEXT NOT NULL CHECK(scope IN ('plugin_sessions', 'single_session')),
+      access      TEXT NOT NULL CHECK(access IN ('read_only', 'read_write')),
+      session_id  TEXT,
+      created_at  TEXT NOT NULL,
+      expires_at  TEXT NOT NULL,
+      revoked_at  TEXT,
+      CHECK(
+        (scope = 'plugin_sessions' AND session_id IS NULL)
+        OR (scope = 'single_session' AND session_id IS NOT NULL)
+      )
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_portal_grants_expires
+      ON session_portal_grants(expires_at);
     CREATE TABLE IF NOT EXISTS runtime_pairing_claims (
       claim_id                   TEXT PRIMARY KEY,
       secret_hash                TEXT NOT NULL,
@@ -260,30 +342,67 @@ function migrate(conn) {
     CREATE INDEX IF NOT EXISTS idx_runtime_pending_enrollments_expires
       ON runtime_pending_enrollments(expires_at);
   `);
+    migratePluginCapabilityDeclarations(conn);
+    migrateSessionSnapshots(conn);
     // Breaking plugin-runtime cutover: remove obsolete core-owned state.
     conn.exec(`
     DROP TABLE IF EXISTS control_sessions;
     DROP TABLE IF EXISTS plugin_daemon_worker_settings;
   `);
-    // `sessions` is the unified machine-session record (console + every channel).
-    // Add the identity columns to a pre-existing table (SQLite has no
-    // ADD COLUMN IF NOT EXISTS) and backfill the origin of rows written before
-    // this change — they were all console sessions.
-    addColumnIfMissing(conn, "sessions", "source", "TEXT");
-    addColumnIfMissing(conn, "sessions", "updated_at", "TEXT");
-    addColumnIfMissing(conn, "sessions", "provider", "TEXT");
-    const sessionColumns = conn.prepare("PRAGMA table_info(sessions)").all();
-    if (sessionColumns.some((column) => column.name === "executor")) {
-        conn.exec("UPDATE sessions SET provider = executor WHERE provider IS NULL AND executor IS NOT NULL");
+    addColumnIfMissing(conn, "plugin_marketplaces", "built_in", "INTEGER NOT NULL DEFAULT 0");
+    addColumnIfMissing(conn, "sessions", "forked_from_session_id", "TEXT");
+    addColumnIfMissing(conn, "plugin_session_launch_operations", "raw_request_hash", "TEXT");
+}
+/** Remove the inert permission-declaration columns left by older installations. */
+function migratePluginCapabilityDeclarations(conn) {
+    const columns = conn
+        .prepare("PRAGMA table_info(plugin_installations)")
+        .all();
+    const names = new Set(columns.map((column) => column.name));
+    for (const legacyColumn of ["capabilities", "grants"]) {
+        if (names.has(legacyColumn)) {
+            conn.exec(`ALTER TABLE plugin_installations DROP COLUMN ${legacyColumn}`);
+        }
     }
-    addColumnIfMissing(conn, "plugins", "updated_at", "TEXT");
-    addColumnIfMissing(conn, "plugins", "install_path", "TEXT");
-    addColumnIfMissing(conn, "plugins", "manifest", "TEXT");
-    addColumnIfMissing(conn, "plugins", "integrity", "TEXT");
-    addColumnIfMissing(conn, "plugins", "grants", "TEXT");
-    conn.exec("UPDATE sessions SET source = 'console' WHERE source IS NULL");
-    conn.exec("UPDATE plugins SET updated_at = installed_at WHERE updated_at IS NULL");
-    importLegacyConfig(conn);
+}
+/**
+ * Breaking Session cutover: the previous rows contain mutable Agent/Provider
+ * references and no immutable workspace/execution snapshots, so they cannot be
+ * migrated faithfully. Remove every database-owned Session artifact and create
+ * the new snapshot-only table. User workspace directories are never touched.
+ */
+function migrateSessionSnapshots(conn) {
+    const columns = conn.prepare("PRAGMA table_info(sessions)").all();
+    const names = new Set(columns.map((column) => column.name));
+    if (names.has("workspace") && names.has("execution"))
+        return;
+    conn.transaction(() => {
+        conn.exec(`
+      INSERT OR IGNORE INTO session_snapshot_cleanup (session_id)
+      SELECT id FROM sessions;
+      DELETE FROM session_message_operation_resources;
+      DELETE FROM session_message_operations;
+      DELETE FROM session_resources;
+      DELETE FROM session_items;
+      DELETE FROM session_pending_messages;
+      DELETE FROM session_emulator_bindings;
+      DELETE FROM plugin_session_launch_operations;
+      DELETE FROM session_fork_operations;
+      DELETE FROM control_links;
+      DELETE FROM sessions;
+      DROP TABLE sessions;
+      CREATE TABLE sessions (
+        id         TEXT PRIMARY KEY,
+        workspace  TEXT NOT NULL,
+        execution  TEXT NOT NULL,
+        title      TEXT,
+        forked_from_session_id TEXT,
+        source     TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT
+      );
+    `);
+    }).immediate();
 }
 /** Idempotently add a column to an existing table (no-op if already present). */
 function addColumnIfMissing(conn, table, column, ddl) {
@@ -292,65 +411,3 @@ function addColumnIfMissing(conn, table, column, ddl) {
         return;
     conn.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${ddl}`);
 }
-/**
- * One-time import of a pre-existing `~/.rynx/config.json` (the old hand-edited
- * format, where each entry mixed channel config + agent binding). Each entry
- * becomes a `channels` row (the config) plus an `instances` row (the binding).
- * The instance keeps the entry's key as its `id` so per-instance on-disk state
- * (keyed by instanceId) stays intact. Runs only when empty; the file is renamed
- * afterwards so it's never read — or hand-edited — again.
- */
-function importLegacyConfig(conn) {
-    const { n } = conn.prepare("SELECT COUNT(*) AS n FROM channels").get();
-    if (n > 0)
-        return;
-    const legacy = process.env.RYNX_CONFIG?.trim() || join(daemonHome(), "config.json");
-    if (!existsSync(legacy))
-        return;
-    let channels;
-    try {
-        const parsed = JSON.parse(readFileSync(legacy, "utf8"));
-        if (parsed.channels && typeof parsed.channels === "object") {
-            channels = parsed.channels;
-        }
-    }
-    catch {
-        return; // malformed legacy file — leave it alone, start empty
-    }
-    if (!channels)
-        return;
-    const now = new Date().toISOString();
-    const insertChannel = conn.prepare(`INSERT OR IGNORE INTO channels (id, name, type, options, created_at, updated_at)
-     VALUES (@id, @name, @type, @options, @now, @now)`);
-    const insertInstance = conn.prepare(`INSERT OR IGNORE INTO instances (id, channel_id, agent, enabled, created_at, updated_at)
-     VALUES (@id, @channelId, @agent, @enabled, @now, @now)`);
-    const tx = conn.transaction(() => {
-        for (const [key, entry] of Object.entries(channels)) {
-            const channelId = randomUUID();
-            insertChannel.run({
-                id: channelId,
-                name: key,
-                type: entry.type ?? key,
-                options: entry.options ? JSON.stringify(entry.options) : null,
-                now,
-            });
-            insertInstance.run({
-                id: key, // preserve the old key as the runtime instanceId
-                channelId,
-                agent: entry.agent ?? null,
-                enabled: entry.enabled === false ? 0 : 1,
-                now,
-            });
-        }
-    });
-    tx();
-    try {
-        renameSync(legacy, `${legacy}.imported`);
-    }
-    catch {
-        /* leave the source in place if it can't be renamed */
-    }
-}
-function daemonHome() {
-    return process.env.RYNX_HOME?.trim() || join(homedir(), ".rynx");
-}

package/dist/entry-path.d.ts

@@ -0,0 +1,3 @@
+/** Resolve the executable daemon module without importing its side-effectful entry. */
+export declare function resolveDaemonEntry(moduleUrl?: string): string;
+export declare function installedDaemonVersion(): string;

package/dist/entry-path.js

@@ -0,0 +1,12 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const require = createRequire(import.meta.url);
+/** Resolve the executable daemon module without importing its side-effectful entry. */
+export function resolveDaemonEntry(moduleUrl = import.meta.url) {
+    return join(dirname(fileURLToPath(moduleUrl)), "index-daemon.js");
+}
+export function installedDaemonVersion() {
+    const manifest = require("../package.json");
+    return typeof manifest.version === "string" ? manifest.version : "0.0.0";
+}

package/dist/index-daemon.js

@@ -1,70 +1,7 @@
 #!/usr/bin/env node
-/**
- * The resident daemon entry — this is what pm2 keeps alive.
- *
- * Boot order matters: install the EPIPE guard first (we're a pm2 child).
- * The composition root reads static plugin manifests, projects chat instances
- * onto remote runner handles, and supervises non-chat plugin workers. Installed
- * plugin code is loaded only in child processes.
- */
-import { startRynxDaemonServer } from "./daemon-server.js";
-import { installStdioEpipeGuard } from "./stdio-epipe-guard.js";
-installStdioEpipeGuard();
-async function main() {
-    const followsApp = process.env.RYNX_DAEMON_LIFECYCLE === "follow-app";
-    let parentDisconnected = followsApp && !process.connected;
-    const recordParentDisconnect = () => {
-        parentDisconnected = true;
-    };
-    if (followsApp)
-        process.once("disconnect", recordParentDisconnect);
-    let server;
-    try {
-        server = await startRynxDaemonServer();
-    }
-    catch (error) {
-        process.off("disconnect", recordParentDisconnect);
-        throw error;
-    }
-    let shutdownPromise;
-    const shutdown = (signal) => {
-        if (shutdownPromise)
-            return shutdownPromise;
-        process.off("SIGINT", onSigint);
-        process.off("SIGTERM", onSigterm);
-        process.off("disconnect", onDisconnect);
-        shutdownPromise = (async () => {
-            console.log(JSON.stringify({ level: "info", type: "shutdown", signal }));
-            await server.shutdown();
-        })();
-        shutdownPromise.catch((error) => {
-            process.exitCode = 1;
-            console.error(`Shutdown failed: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
-        });
-        return shutdownPromise;
-    };
-    const onSigint = () => {
-        void shutdown("SIGINT");
-    };
-    const onSigterm = () => {
-        void shutdown("SIGTERM");
-    };
-    const onDisconnect = () => {
-        if (process.env.RYNX_DAEMON_LIFECYCLE === "follow-app") {
-            void shutdown("APP_DISCONNECT");
-        }
-    };
-    process.once("SIGINT", onSigint);
-    process.once("SIGTERM", onSigterm);
-    if (followsApp) {
-        process.once("disconnect", onDisconnect);
-        process.off("disconnect", recordParentDisconnect);
-        if (parentDisconnected || !process.connected) {
-            void shutdown("APP_DISCONNECT");
-        }
-    }
-}
-main().catch((err) => {
+/** Direct daemon executable retained only for standalone PM2 supervision. */
+import { runDaemonProcess } from "./process.js";
+runDaemonProcess().catch((err) => {
     console.error(`Fatal error: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
     process.exit(1);
 });

package/dist/lifecycle.d.ts

@@ -0,0 +1,12 @@
+export { formatControlUrl, isPm2DaemonOnline, statusDaemon, stopDaemon, streamLogs, } from "./pm2.js";
+export { resolveDaemonEntry } from "./entry-path.js";
+export interface StandaloneDaemonLaunchContext {
+    builtinSkillsDir: string;
+    cliVersion: string;
+    productVersion: string;
+}
+export declare function startDaemon(options: {
+    force: boolean;
+    quiet?: boolean;
+    context: StandaloneDaemonLaunchContext;
+}): number;

package/dist/lifecycle.js

@@ -0,0 +1,16 @@
+import { startDaemon as startPm2Daemon, } from "./pm2.js";
+export { formatControlUrl, isPm2DaemonOnline, statusDaemon, stopDaemon, streamLogs, } from "./pm2.js";
+export { resolveDaemonEntry } from "./entry-path.js";
+export function startDaemon(options) {
+    return startPm2Daemon({
+        force: options.force,
+        quiet: options.quiet,
+        launchEnvironment: {
+            RYNX_BUILTIN_SKILLS_DIR: options.context.builtinSkillsDir,
+            RYNX_CLI_VERSION: options.context.cliVersion,
+            RYNX_DISTRIBUTION: "standalone",
+            RYNX_PRODUCT_VERSION: options.context.productVersion,
+            RYNX_DAEMON_LIFECYCLE: "standalone",
+        },
+    });
+}

package/dist/maintenance-lease.d.ts

@@ -0,0 +1,39 @@
+export type MaintenanceLeaseReleaseOutcome = "released" | "not_active" | "denied";
+export interface MaintenanceLeaseStoreOptions {
+    filePath?: string;
+    now?: () => number;
+    ttlMs?: number;
+    /** Test seam; production fsyncs the lease directory after rename/remove. */
+    syncDirectory?: (directory: string) => void;
+    /** Process-local recovery hook, invoked once when a live lease is observed expired. */
+    onExpired?: () => void;
+}
+export declare function maintenanceLeaseFile(env?: NodeJS.ProcessEnv): string;
+/**
+ * Cross-process admission fence used only during daemon replacement.
+ *
+ * The raw bearer token is never persisted. The bounded expiry means a crashed
+ * upgrader cannot leave the daemon permanently unavailable, while atomic rename
+ * ensures a replacement daemon sees either the complete lease or no lease.
+ */
+export declare class MaintenanceLeaseStore {
+    private readonly filePath;
+    private readonly now;
+    private readonly ttlMs;
+    private readonly syncDirectory;
+    private readonly onExpired;
+    private lease;
+    private expiryTimer;
+    constructor(options?: MaintenanceLeaseStoreOptions);
+    isActive(): boolean;
+    isHeldBy(token: string): boolean;
+    acquire(token: string): boolean;
+    release(token: string): MaintenanceLeaseReleaseOutcome;
+    private readPersistedLease;
+    private writePersistedLease;
+    private clear;
+    private clearFile;
+    private expire;
+    private scheduleExpiry;
+    private cancelExpiry;
+}