gnosys 5.11.4 → 5.12.0

package/dist/lib/syncCommand.js

@@ -0,0 +1,57 @@
+import path from "path";
+import { GnosysDB } from "./db.js";
+import { readProjectIdentity } from "./projectIdentity.js";
+import { syncToTarget } from "./rulesGen.js";
+export async function runSyncCommand(opts) {
+    const projectDir = opts.directory ? path.resolve(opts.directory) : process.cwd();
+    const target = opts.global ? "global" : (opts.target || null);
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available (better-sqlite3 missing).");
+            process.exitCode = 1;
+            return;
+        }
+        if (target === "global") {
+            const results = await syncToTarget(centralDb, projectDir, "global", null);
+            for (const result of results) {
+                const action = result.created ? "Created" : "Updated";
+                console.log(`${action} global rules: ${result.filePath}`);
+                console.log(`  Preferences injected: ${result.prefCount}`);
+            }
+            console.log(`\nContent is inside <!-- GNOSYS:START --> / <!-- GNOSYS:END --> markers.`);
+            console.log(`User content outside these markers is preserved.`);
+            return;
+        }
+        const identity = await readProjectIdentity(projectDir);
+        if (!identity) {
+            console.error("No project identity found. Run 'gnosys init' first.");
+            process.exitCode = 1;
+            return;
+        }
+        const resolvedTarget = target || identity.agentRulesTarget || "all";
+        const results = await syncToTarget(centralDb, projectDir, resolvedTarget, identity.projectId);
+        if (results.length === 0) {
+            console.error("No targets found. Create a CLAUDE.md, .cursor/, or .codex/ directory first.");
+            process.exitCode = 1;
+            return;
+        }
+        for (const result of results) {
+            const action = result.created ? "Created" : "Updated";
+            console.log(`${action} rules file: ${result.filePath}`);
+            console.log(`  Preferences injected: ${result.prefCount}`);
+            console.log(`  Project conventions:  ${result.conventionCount}`);
+        }
+        console.log(`\nContent is inside <!-- GNOSYS:START --> / <!-- GNOSYS:END --> markers.`);
+        console.log(`User content outside these markers is preserved.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/syncDoctorCommand.d.ts

@@ -0,0 +1,5 @@
+export declare function runSyncDoctorCommand(opts: {
+    json?: boolean;
+    ingest?: boolean;
+    quiet?: boolean;
+}): Promise<void>;

package/dist/lib/syncDoctorCommand.js

@@ -0,0 +1,100 @@
+import { GnosysDB } from "./db.js";
+import { getConfiguredRemotePath } from "./remote.js";
+import { readMachineConfig } from "./machineConfig.js";
+import { getV13SyncStatus } from "./syncClient.js";
+import { runMasterIngestSweep } from "./syncIngest.js";
+import { getSyncIngestTimerStatus } from "./syncIngestTimer.js";
+import { quarantineStaleTmpFiles, stagingRoot } from "./syncStaging.js";
+import { existsSync, readdirSync } from "fs";
+import { readMasterMarker } from "./masterLease.js";
+import { printStatus } from "./setup/ui/status.js";
+export async function runSyncDoctorCommand(opts) {
+    let db = null;
+    try {
+        db = GnosysDB.openLocal();
+        if (!db.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const masterPath = getConfiguredRemotePath(db);
+        const mc = readMachineConfig();
+        if (!masterPath || !mc?.remote.enabled) {
+            console.log("Multi-machine sync is not configured.");
+            return;
+        }
+        const status = getV13SyncStatus(db);
+        const marker = readMasterMarker(masterPath);
+        const timerStatus = getSyncIngestTimerStatus();
+        const report = {
+            role: status.role,
+            masterPath,
+            masterReachable: status.masterReachable,
+            waitingToSync: status.waitingToSync,
+            failedToSync: status.failedToSync,
+            pendingOfflineAdds: status.pendingOfflineAdds,
+            masterEpoch: marker?.epoch ?? null,
+            snapshotAge: status.snapshotAge,
+            timerInstalled: timerStatus.installed,
+            timerPath: timerStatus.path || null,
+            timerPlatform: timerStatus.platform,
+        };
+        let ingestResult = null;
+        if (opts.ingest && mc.remote.role === "master") {
+            const root = stagingRoot(masterPath);
+            if (existsSync(root)) {
+                for (const id of readdirSync(root)) {
+                    if (!id.startsWith("."))
+                        quarantineStaleTmpFiles(masterPath, id);
+                }
+            }
+            ingestResult = runMasterIngestSweep(masterPath, {
+                quiet: opts.quiet || !!opts.json,
+            });
+            if (ingestResult.errors.length > 0) {
+                process.exitCode = 1;
+            }
+            if (opts.json) {
+                report.ingest = ingestResult;
+            }
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log("\nGnosys sync doctor (v13)\n");
+        for (const line of status.lines)
+            console.log(line);
+        if (marker) {
+            console.log(`\nMaster lease: epoch ${marker.epoch}, holder ${marker.holderMachineId}`);
+        }
+        if (timerStatus.installed) {
+            console.log(`\nIngest timer: installed (${timerStatus.path})`);
+        }
+        else if (timerStatus.platform === "unsupported") {
+            console.log("\nIngest timer: not available on this platform (Windows — use doctor --ingest manually)");
+        }
+        else {
+            console.log("\nIngest timer: not installed");
+            console.log("Install with: gnosys setup remote timer --install");
+        }
+        if (status.failedToSync > 0) {
+            printStatus("progress", "remediation", "inspect master-folder/.gnosys-staging/*/failed/");
+        }
+        if (!status.masterReachable) {
+            printStatus("warn", "mount or VPN path to master folder, then re-run doctor");
+        }
+        if (opts.ingest && mc.remote.role === "master" && ingestResult && !opts.quiet) {
+            console.log(`\nIngest sweep: +${ingestResult.ingested} ingested, ${ingestResult.skipped} skipped, ${ingestResult.quarantined} quarantined`);
+            for (const e of ingestResult.errors)
+                printStatus("fail", e);
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+    }
+    finally {
+        db?.close();
+    }
+}

package/dist/lib/syncIngest.d.ts

@@ -0,0 +1,19 @@
+/**
+ * v13 master ingest sweep — process staged JSON into gnosys.db.
+ */
+export interface IngestSweepResult {
+    ingested: number;
+    skipped: number;
+    quarantined: number;
+    errors: string[];
+}
+export interface IngestSweepOptions {
+    /** Suppress stdout (for timer / background contexts). */
+    quiet?: boolean;
+    /** Write a single JSON object to stdout with the sweep result. */
+    json?: boolean;
+}
+/**
+ * Always-on cheap ingest sweep (agent start + timer). Single-writer lock on local disk.
+ */
+export declare function runMasterIngestSweep(masterPath: string, opts?: IngestSweepOptions): IngestSweepResult;

package/dist/lib/syncIngest.js

@@ -0,0 +1,152 @@
+/**
+ * v13 master ingest sweep — process staged JSON into gnosys.db.
+ */
+import { existsSync, readdirSync, unlinkSync, writeFileSync, mkdirSync } from "fs";
+import path from "path";
+import { GnosysDB, fnv1a } from "./db.js";
+import { getGnosysHome } from "./paths.js";
+import { ensureMachineConfig } from "./machineConfig.js";
+import { listPendingStagingQueue, observeStagingFile, parseStagedFile, quarantineStagingFile, quarantineStaleTmpFiles, stagingRoot, verifyMemoryExistsInDb, } from "./syncStaging.js";
+import { assertMasterLeaseHeld, readMasterMarker, touchMasterMarkerHeartbeat, validateLeaseEpochBeforeWrite, } from "./masterLease.js";
+import { acquireWriteLockSync } from "./syncLock.js";
+const INGEST_LOCK_NAME = "master-ingest.lock";
+function payloadToMemory(p, now) {
+    const contentHash = fnv1a(`${p.title}\n${p.content}`);
+    return {
+        id: p.id,
+        title: p.title,
+        category: p.category,
+        content: p.content,
+        summary: null,
+        tags: JSON.stringify(p.tags),
+        relevance: "",
+        author: "user",
+        authority: "user",
+        confidence: 0.8,
+        reinforcement_count: 0,
+        content_hash: contentHash,
+        status: "active",
+        tier: "active",
+        supersedes: null,
+        superseded_by: null,
+        last_reinforced: null,
+        created: p.writtenAt || now,
+        modified: now,
+        source_path: null,
+        project_id: p.project_id,
+        scope: p.scope || "project",
+    };
+}
+function writeIngestReceipt(masterPath, machineId, ulid, outcome) {
+    const dir = path.join(stagingRoot(masterPath), machineId, "receipts");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path.join(dir, `${ulid}.json`), JSON.stringify({ ulid, outcome, at: new Date().toISOString() }, null, 2) + "\n");
+}
+function listMachineIds(masterPath) {
+    const root = stagingRoot(masterPath);
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root).filter((name) => {
+        if (name.startsWith("."))
+            return false;
+        try {
+            return existsSync(path.join(root, name));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * Always-on cheap ingest sweep (agent start + timer). Single-writer lock on local disk.
+ */
+export function runMasterIngestSweep(masterPath, opts) {
+    const result = { ingested: 0, skipped: 0, quarantined: 0, errors: [] };
+    const { config: mc } = ensureMachineConfig();
+    const lockPath = path.join(getGnosysHome(), INGEST_LOCK_NAME);
+    let release = null;
+    try {
+        release = acquireWriteLockSync(lockPath, "master-ingest");
+        touchMasterMarkerHeartbeat(masterPath);
+        assertMasterLeaseHeld(masterPath, mc.machineId);
+        const marker = readMasterMarker(masterPath);
+        if (!marker) {
+            result.errors.push("master.json missing");
+            return result;
+        }
+        const masterDb = new GnosysDB(masterPath);
+        if (!masterDb.isAvailable()) {
+            result.errors.push("master database unavailable");
+            masterDb.close();
+            return result;
+        }
+        try {
+            for (const machineId of listMachineIds(masterPath)) {
+                quarantineStaleTmpFiles(masterPath, machineId);
+                const queue = listPendingStagingQueue(masterPath, machineId, masterDb);
+                for (const entry of queue) {
+                    observeStagingFile(masterDb, machineId, entry.fileName, entry.memoryUlid);
+                    const parsed = parseStagedFile(entry.filePath);
+                    if (!parsed.ok) {
+                        if (parsed.quarantine) {
+                            quarantineStagingFile(entry.filePath, masterPath, machineId);
+                            result.quarantined++;
+                        }
+                        else {
+                            result.errors.push(parsed.reason);
+                        }
+                        continue;
+                    }
+                    if (masterDb.isUlidProcessed(parsed.payload.id)) {
+                        try {
+                            unlinkSync(entry.filePath);
+                        }
+                        catch {
+                            // ignore
+                        }
+                        writeIngestReceipt(masterPath, machineId, parsed.payload.id, "deduped");
+                        result.skipped++;
+                        continue;
+                    }
+                    try {
+                        validateLeaseEpochBeforeWrite(masterPath, marker.epoch, mc.machineId);
+                        const now = new Date().toISOString();
+                        masterDb.insertMemory(payloadToMemory(parsed.payload, now));
+                        if (!verifyMemoryExistsInDb(masterDb, parsed.payload.id)) {
+                            result.errors.push(`read-back failed for ${parsed.payload.id}`);
+                            continue;
+                        }
+                        masterDb.markUlidProcessed(parsed.payload.id, marker.epoch);
+                        masterDb.recordStagingLedgerEntry({
+                            stagingKey: `${machineId}/${entry.fileName}`,
+                            machineId,
+                            memoryUlid: parsed.payload.id,
+                            firstSeenAt: masterDb.getStagingLedgerFirstSeenAt(`${machineId}/${entry.fileName}`) ?? now,
+                            ingestEpoch: marker.epoch,
+                            status: "ingested",
+                        });
+                        unlinkSync(entry.filePath);
+                        writeIngestReceipt(masterPath, machineId, parsed.payload.id, "ingested");
+                        result.ingested++;
+                    }
+                    catch (err) {
+                        result.errors.push(err instanceof Error ? err.message : String(err));
+                    }
+                }
+            }
+        }
+        finally {
+            masterDb.close();
+        }
+    }
+    catch (err) {
+        result.errors.push(err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        release?.();
+    }
+    if (opts?.json) {
+        console.log(JSON.stringify(result));
+    }
+    return result;
+}

package/dist/lib/syncIngestLaunchd.d.ts

@@ -0,0 +1,8 @@
+/** Build launchd plist XML (testable without writing to disk). */
+export declare function buildSyncIngestLaunchAgentPlist(intervalMinutes: number): string;
+export declare function installSyncIngestLaunchAgent(intervalMinutes?: number): string | null;
+export declare function uninstallSyncIngestLaunchAgent(): string | null;
+export declare function getSyncIngestLaunchAgentStatus(): {
+    installed: boolean;
+    path: string;
+};

package/dist/lib/syncIngestLaunchd.js

@@ -0,0 +1,93 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execSync } from "child_process";
+const LABEL = "com.gnosys.sync-ingest";
+function plistPath() {
+    return path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+function logPath() {
+    return path.join(os.tmpdir(), "gnosys-sync-ingest.log");
+}
+function xmlEscape(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+/** Build launchd plist XML (testable without writing to disk). */
+export function buildSyncIngestLaunchAgentPlist(intervalMinutes) {
+    const nodePath = process.execPath;
+    const cliPath = process.argv[1] || "gnosys";
+    const intervalSec = Math.max(1, intervalMinutes) * 60;
+    const pathEnv = `${path.dirname(nodePath)}:/usr/local/bin:/usr/bin:/bin`;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(nodePath)}</string>
+    <string>${xmlEscape(cliPath)}</string>
+    <string>setup</string>
+    <string>remote</string>
+    <string>doctor</string>
+    <string>--ingest</string>
+    <string>--quiet</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>${intervalSec}</integer>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(logPath())}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(logPath())}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${xmlEscape(os.homedir())}</string>
+    <key>PATH</key>
+    <string>${xmlEscape(pathEnv)}</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+export function installSyncIngestLaunchAgent(intervalMinutes = 15) {
+    if (process.platform !== "darwin")
+        return null;
+    const file = plistPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, buildSyncIngestLaunchAgentPlist(intervalMinutes), "utf8");
+    try {
+        execSync(`launchctl load -w "${file}"`, { stdio: "ignore" });
+    }
+    catch (err) {
+        throw new Error(`Failed to load launch agent: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return file;
+}
+export function uninstallSyncIngestLaunchAgent() {
+    if (process.platform !== "darwin")
+        return null;
+    const file = plistPath();
+    try {
+        execSync(`launchctl unload "${file}"`, { stdio: "ignore" });
+    }
+    catch {
+        // Already unloaded or missing.
+    }
+    try {
+        fs.unlinkSync(file);
+    }
+    catch {
+        // Missing is already uninstalled.
+    }
+    return file;
+}
+export function getSyncIngestLaunchAgentStatus() {
+    const file = plistPath();
+    return { installed: fs.existsSync(file), path: file };
+}

package/dist/lib/syncIngestStartup.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Run one ingest sweep on MCP server startup (master role only).
+ * Non-blocking — callers should fire-and-forget.
+ */
+export declare function maybeRunStartupIngestSweep(): Promise<void>;

package/dist/lib/syncIngestStartup.js

@@ -0,0 +1,29 @@
+import { GnosysDB } from "./db.js";
+import { readMachineConfig } from "./machineConfig.js";
+import { getConfiguredRemotePath } from "./remote.js";
+import { runMasterIngestSweep } from "./syncIngest.js";
+/**
+ * Run one ingest sweep on MCP server startup (master role only).
+ * Non-blocking — callers should fire-and-forget.
+ */
+export async function maybeRunStartupIngestSweep() {
+    const mc = readMachineConfig();
+    if (!mc?.remote.enabled || mc.remote.role !== "master")
+        return;
+    const db = GnosysDB.openLocal();
+    let masterPath = null;
+    try {
+        if (!db.isAvailable())
+            return;
+        masterPath = getConfiguredRemotePath(db);
+    }
+    finally {
+        db.close();
+    }
+    if (!masterPath)
+        return;
+    const result = runMasterIngestSweep(masterPath, { quiet: true });
+    if (result.errors.length > 0) {
+        console.error(`[sync] Startup ingest sweep: ${result.ingested} ingested, ${result.errors.length} error(s)`);
+    }
+}

package/dist/lib/syncIngestSystemd.d.ts

@@ -0,0 +1,10 @@
+/** Build systemd service unit (testable without writing to disk). */
+export declare function buildSyncIngestSystemdService(): string;
+/** Build systemd timer unit (testable without writing to disk). */
+export declare function buildSyncIngestSystemdTimer(intervalMinutes: number): string;
+export declare function installSyncIngestSystemdTimer(intervalMinutes?: number): string | null;
+export declare function uninstallSyncIngestSystemdTimer(): string | null;
+export declare function getSyncIngestSystemdTimerStatus(): {
+    installed: boolean;
+    path: string;
+};

package/dist/lib/syncIngestSystemd.js

@@ -0,0 +1,97 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execSync } from "child_process";
+const SERVICE_NAME = "gnosys-sync-ingest";
+function systemdUserDir() {
+    return path.join(os.homedir(), ".config", "systemd", "user");
+}
+function serviceFilePath() {
+    return path.join(systemdUserDir(), `${SERVICE_NAME}.service`);
+}
+function timerFilePath() {
+    return path.join(systemdUserDir(), `${SERVICE_NAME}.timer`);
+}
+function execLine() {
+    const nodePath = process.execPath;
+    const cliPath = process.argv[1] || "gnosys";
+    return `${nodePath} ${cliPath} setup remote doctor --ingest --quiet`;
+}
+/** Build systemd service unit (testable without writing to disk). */
+export function buildSyncIngestSystemdService() {
+    return `[Unit]
+Description=Gnosys sync ingest sweep
+
+[Service]
+Type=oneshot
+ExecStart=${execLine()}
+Environment=HOME=${os.homedir()}
+`;
+}
+/** Build systemd timer unit (testable without writing to disk). */
+export function buildSyncIngestSystemdTimer(intervalMinutes) {
+    const intervalSec = Math.max(1, intervalMinutes) * 60;
+    return `[Unit]
+Description=Gnosys sync ingest timer
+
+[Timer]
+OnBootSec=5min
+OnUnitActiveSec=${intervalSec}s
+
+[Install]
+WantedBy=timers.target
+`;
+}
+export function installSyncIngestSystemdTimer(intervalMinutes = 15) {
+    if (process.platform !== "linux")
+        return null;
+    const dir = systemdUserDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const servicePath = serviceFilePath();
+    const timerPath = timerFilePath();
+    fs.writeFileSync(servicePath, buildSyncIngestSystemdService(), "utf8");
+    fs.writeFileSync(timerPath, buildSyncIngestSystemdTimer(intervalMinutes), "utf8");
+    try {
+        execSync("systemctl --user daemon-reload", { stdio: "ignore" });
+        execSync(`systemctl --user enable --now ${SERVICE_NAME}.timer`, { stdio: "ignore" });
+    }
+    catch (err) {
+        throw new Error(`Failed to enable systemd timer: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return timerPath;
+}
+export function uninstallSyncIngestSystemdTimer() {
+    if (process.platform !== "linux")
+        return null;
+    const servicePath = serviceFilePath();
+    const timerPath = timerFilePath();
+    try {
+        execSync(`systemctl --user disable --now ${SERVICE_NAME}.timer`, { stdio: "ignore" });
+    }
+    catch {
+        // Timer may already be removed.
+    }
+    for (const file of [timerPath, servicePath]) {
+        try {
+            fs.unlinkSync(file);
+        }
+        catch {
+            // Missing is already uninstalled.
+        }
+    }
+    try {
+        execSync("systemctl --user daemon-reload", { stdio: "ignore" });
+    }
+    catch {
+        // Best effort.
+    }
+    return timerPath;
+}
+export function getSyncIngestSystemdTimerStatus() {
+    const timerPath = timerFilePath();
+    const servicePath = serviceFilePath();
+    return {
+        installed: fs.existsSync(timerPath) && fs.existsSync(servicePath),
+        path: timerPath,
+    };
+}

package/dist/lib/syncIngestTimer.d.ts

@@ -0,0 +1,8 @@
+export interface SyncIngestTimerStatus {
+    installed: boolean;
+    path: string;
+    platform: "darwin" | "linux" | "unsupported";
+}
+export declare function getSyncIngestTimerStatus(): SyncIngestTimerStatus;
+export declare function installSyncIngestTimer(intervalMinutes?: number): string | null;
+export declare function uninstallSyncIngestTimer(): string | null;

package/dist/lib/syncIngestTimer.js

@@ -0,0 +1,27 @@
+import { getSyncIngestLaunchAgentStatus, installSyncIngestLaunchAgent, uninstallSyncIngestLaunchAgent, } from "./syncIngestLaunchd.js";
+import { getSyncIngestSystemdTimerStatus, installSyncIngestSystemdTimer, uninstallSyncIngestSystemdTimer, } from "./syncIngestSystemd.js";
+export function getSyncIngestTimerStatus() {
+    if (process.platform === "darwin") {
+        const status = getSyncIngestLaunchAgentStatus();
+        return { ...status, platform: "darwin" };
+    }
+    if (process.platform === "linux") {
+        const status = getSyncIngestSystemdTimerStatus();
+        return { ...status, platform: "linux" };
+    }
+    return { installed: false, path: "", platform: "unsupported" };
+}
+export function installSyncIngestTimer(intervalMinutes = 15) {
+    if (process.platform === "darwin")
+        return installSyncIngestLaunchAgent(intervalMinutes);
+    if (process.platform === "linux")
+        return installSyncIngestSystemdTimer(intervalMinutes);
+    return null;
+}
+export function uninstallSyncIngestTimer() {
+    if (process.platform === "darwin")
+        return uninstallSyncIngestLaunchAgent();
+    if (process.platform === "linux")
+        return uninstallSyncIngestSystemdTimer();
+    return null;
+}

package/dist/lib/syncIngestTimerCommand.d.ts

@@ -0,0 +1,7 @@
+export declare function runSyncIngestTimerCommand(opts: {
+    install?: boolean;
+    uninstall?: boolean;
+    status?: boolean;
+    interval?: string;
+    json?: boolean;
+}): Promise<void>;