summer-engine 2.6.5 → 2.7.0

package/dist/lib/debug-report.js

@@ -0,0 +1,308 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { hostname, platform, release } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { EngineApiClient } from "./api-client.js";
+import { shapeEngineLogResponse } from "./log-filters.js";
+import { tildeify } from "./format.js";
+import { getMcpLogPath, readRecentMcpLogLines } from "./mcp-log.js";
+import { runDoctor } from "../commands/doctor.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../../package.json");
+function sleep(ms) {
+    return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function timestampForFile(date) {
+    return date.toISOString().replace(/[:.]/g, "-");
+}
+export function defaultDebugReportFilename(date = new Date()) {
+    return `summer-debug-report-${timestampForFile(date)}.md`;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function pickString(value, keys) {
+    const record = asRecord(value);
+    if (!record)
+        return null;
+    for (const key of keys) {
+        const candidate = record[key];
+        if (typeof candidate === "string" && candidate.length > 0)
+            return candidate;
+    }
+    return null;
+}
+function projectPathFromReport(report) {
+    return pickString(report.engine.health, ["project_path", "projectPath", "projectRoot", "project_root"]);
+}
+function resolveOutputPath(report, options) {
+    if (options.outputPath) {
+        return isAbsolute(options.outputPath)
+            ? options.outputPath
+            : resolve(process.cwd(), options.outputPath);
+    }
+    const baseDir = options.baseDir ?? projectPathFromReport(report) ?? process.cwd();
+    return join(baseDir, defaultDebugReportFilename(new Date(report.generatedAt)));
+}
+async function writeMarkdown(path, markdown) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, markdown, "utf-8");
+}
+async function safeCollect(label, fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        return {
+            ok: false,
+            label,
+            error: errorMessage(error),
+        };
+    }
+}
+function firstOpsResult(value) {
+    const root = asRecord(value);
+    const results = root?.results;
+    if (Array.isArray(results) && results.length > 0) {
+        return asRecord(results[0]);
+    }
+    return root;
+}
+function isGamePlaying(value) {
+    return firstOpsResult(value)?.playing === true;
+}
+async function collectConsole(client, maxConsoleLines) {
+    const raw = await client.executeOps([
+        { op: "GetConsoleOutput", max_lines: maxConsoleLines },
+    ]);
+    return shapeEngineLogResponse(raw, {
+        errorsOnly: false,
+        maxEntries: maxConsoleLines,
+    }).result;
+}
+async function collectDebugger(client, type, maxEntries) {
+    const op = {
+        op: "GetDebuggerErrors",
+        max_errors: maxEntries,
+        include_stack: true,
+    };
+    if (type === "warning")
+        op.type = "warning";
+    const raw = await client.executeOps([op]);
+    return shapeEngineLogResponse(raw, { maxEntries }).result;
+}
+async function collectPlaySession(client, options) {
+    const session = {
+        requested: true,
+        waitMs: options.playWaitMs,
+    };
+    session.before = await safeCollect("is-running-before", () => client.executeOps([{ op: "IsGameRunning" }]));
+    const wasPlaying = isGamePlaying(session.before);
+    session.wasPlayingBefore = wasPlaying;
+    if (wasPlaying) {
+        session.note =
+            "Game was already running. Collected current runtime diagnostics without clearing console, launching, or stopping.";
+    }
+    else {
+        session.clearConsole = await safeCollect("clear-console", () => client.executeOps([{ op: "ClearConsoleOutput" }]));
+        session.play = await safeCollect("play", () => client.play());
+    }
+    await sleep(options.playWaitMs);
+    session.diagnostics = await safeCollect("diagnostics-after-play", () => client.getDiagnostics());
+    session.console = await safeCollect("console-after-play", () => collectConsole(client, options.maxConsoleLines));
+    session.debuggerErrors = await safeCollect("debugger-errors-after-play", () => collectDebugger(client, "error", options.maxDebuggerEntries));
+    session.debuggerWarnings = await safeCollect("debugger-warnings-after-play", () => collectDebugger(client, "warning", options.maxDebuggerEntries));
+    if (!wasPlaying) {
+        session.stop = await safeCollect("stop", () => client.stop());
+    }
+    return session;
+}
+function redact(value) {
+    if (Array.isArray(value))
+        return value.map((item) => redact(item));
+    if (!value || typeof value !== "object")
+        return value;
+    const out = {};
+    for (const [key, nested] of Object.entries(value)) {
+        if (/token|secret|password|authorization|cookie|api[-_]?key|hostname/i.test(key)) {
+            out[key] = "[REDACTED]";
+        }
+        else {
+            out[key] = redact(nested);
+        }
+    }
+    return out;
+}
+export function redactDebugReport(report) {
+    return redact(report);
+}
+function jsonBlock(value) {
+    return `\`\`\`json\n${JSON.stringify(redact(value), null, 2)}\n\`\`\``;
+}
+function doctorSummary(doctor) {
+    if (!doctor)
+        return "Doctor was skipped.";
+    return `${doctor.summary.failures} failures, ${doctor.summary.warnings} warnings, ${doctor.summary.ok} OK.`;
+}
+function issueText(issue) {
+    return issue && issue.trim().length > 0 ? issue.trim() : "No issue text provided.";
+}
+export function renderDebugReportMarkdown(report) {
+    const health = asRecord(report.engine.health);
+    const projectName = pickString(health, ["project_name", "projectName"]) ?? "unknown";
+    const projectPath = pickString(health, ["project_path", "projectPath"]) ?? "unknown";
+    const scene = pickString(health, ["scene", "scenePath", "scene_path"]) ?? "unknown";
+    return `# Summer Debug Report
+
+Generated: ${report.generatedAt}
+
+## Before Sending
+
+This report is meant for Summer Engine support or an assisting AI agent. It does not include auth tokens or project file contents, but it may include local paths, project names, console output, and stack traces. Review it before sending.
+
+## User Issue
+
+${issueText(report.issue)}
+
+## Quick Summary
+
+- Doctor: ${doctorSummary(report.doctor)}
+- Engine connected: ${report.engine.connected ? "yes" : "no"}
+- Project: ${projectName}
+- Project path: ${tildeify(projectPath)}
+- Scene: ${scene}
+
+## Environment
+
+${jsonBlock({
+        ...report.environment,
+        cwd: tildeify(report.environment.cwd),
+        hostname: report.environment.hostname ? "[local-hostname-present]" : "",
+    })}
+
+## Doctor Checks
+
+${report.doctor ? jsonBlock(report.doctor) : "Doctor was skipped."}
+
+## MCP Lifecycle Log
+
+Log path: ${tildeify(report.mcp.logPath)}
+
+${report.mcp.recentLog.length > 0 ? `\`\`\`jsonl\n${report.mcp.recentLog.join("\n")}\n\`\`\`` : "No MCP lifecycle log entries found."}
+
+## Engine Health
+
+${report.engine.health ? jsonBlock(report.engine.health) : report.engine.error ?? "Engine was not reachable."}
+
+## Project State
+
+${report.engine.project ? jsonBlock(report.engine.project) : "No project state collected."}
+
+## Scene State
+
+${report.engine.scene ? jsonBlock(report.engine.scene) : "No scene state collected."}
+
+## Diagnostics
+
+${report.engine.diagnostics ? jsonBlock(report.engine.diagnostics) : "No diagnostics collected."}
+
+## Console
+
+${report.engine.console ? jsonBlock(report.engine.console) : "No console output collected."}
+
+## Debugger Errors
+
+${report.engine.debuggerErrors ? jsonBlock(report.engine.debuggerErrors) : "No debugger errors collected."}
+
+## Debugger Warnings
+
+${report.engine.debuggerWarnings ? jsonBlock(report.engine.debuggerWarnings) : "No debugger warnings collected."}
+
+## Play Session
+
+${report.engine.playSession ? jsonBlock(report.engine.playSession) : "No play session requested. Re-run with --play if the issue only appears while the game is running."}
+
+## Agent Handoff Prompt
+
+\`\`\`text
+You are debugging a Summer Engine project. Use the Summer debug skill and this report as the starting evidence.
+
+User issue:
+${issueText(report.issue)}
+
+Process:
+1. Start with the collected diagnostics, console output, and debugger errors in this report.
+2. Form one specific hypothesis before editing.
+3. Ask before making project changes.
+4. After a fix, re-run the diagnostic that found the issue and update the report or final answer with the exact evidence.
+\`\`\`
+`;
+}
+export async function collectDebugReport(options = {}) {
+    const generatedAt = new Date().toISOString();
+    const includeDoctor = options.includeDoctor ?? true;
+    const report = {
+        generatedAt,
+        issue: options.issue?.trim() || null,
+        environment: {
+            cliVersion: version,
+            nodeVersion: process.version,
+            platform: platform(),
+            release: release(),
+            cwd: process.cwd(),
+            hostname: hostname(),
+        },
+        doctor: null,
+        mcp: {
+            logPath: getMcpLogPath(),
+            recentLog: [],
+        },
+        engine: {
+            connected: false,
+        },
+    };
+    if (includeDoctor) {
+        report.doctor = await runDoctor({ quiet: true });
+    }
+    report.mcp.recentLog = await readRecentMcpLogLines();
+    let client;
+    try {
+        client = await EngineApiClient.connect();
+        report.engine.connected = true;
+    }
+    catch (error) {
+        report.engine.error = errorMessage(error);
+        report.mcp.recentLog = await readRecentMcpLogLines();
+        return report;
+    }
+    const maxConsoleLines = options.maxConsoleLines ?? 200;
+    const maxDebuggerEntries = options.maxDebuggerEntries ?? 100;
+    report.engine.health = await safeCollect("health", () => client.health());
+    report.engine.project = await safeCollect("project-state", () => client.getProjectState());
+    report.engine.scene = await safeCollect("scene-state", () => client.getSceneState());
+    report.engine.diagnostics = await safeCollect("diagnostics", () => client.getDiagnostics());
+    report.engine.console = await safeCollect("console", () => collectConsole(client, maxConsoleLines));
+    report.engine.debuggerErrors = await safeCollect("debugger-errors", () => collectDebugger(client, "error", maxDebuggerEntries));
+    report.engine.debuggerWarnings = await safeCollect("debugger-warnings", () => collectDebugger(client, "warning", maxDebuggerEntries));
+    if (options.includePlaySession) {
+        report.engine.playSession = await collectPlaySession(client, {
+            playWaitMs: options.playWaitMs ?? 2500,
+            maxConsoleLines,
+            maxDebuggerEntries,
+        });
+    }
+    report.mcp.recentLog = await readRecentMcpLogLines();
+    return report;
+}
+export async function createDebugReportArtifact(options = {}) {
+    const report = await collectDebugReport(options);
+    const markdown = renderDebugReportMarkdown(report);
+    const path = resolveOutputPath(report, options);
+    await writeMarkdown(path, markdown);
+    return { path, markdown, report };
+}

package/dist/lib/game-task-plan.js

@@ -249,7 +249,7 @@ function inferSkills(mode, target, goal) {
         addSkill(routes, "design-mechanic", "Implement the core shooting/combat loop.", 230);
         addSkill(routes, "design-level", "Shape the arena, spawn space, cover, and pacing.", 210);
     }
-    addSkill(routes, "gdscript-patterns", "Use direct host file edits for scripts, then verify through MCP.", 90);
+    addSkill(routes, "gdscript-patterns", "Use guarded Summer file tools for scripts, then verify through MCP.", 90);
     addSkill(routes, "verification-before-completion", "Do not finish without a clean verification story.", 80);
     return routes
         .sort((a, b) => b.weight - a.weight)
@@ -350,7 +350,7 @@ export function buildGameTaskPlan(options) {
         verification,
         principles: [
             "The agent should build a playable game slice, not a static demo.",
-            "Use host file edits for code/data/docs; use MCP for live scene state, imports, inspector values, play, and diagnostics.",
+            "Use identity-bound Summer file tools for code/data/docs and Summer scene tools for live hierarchy/inspector changes.",
             "Reuse/import assets before paid generation unless the user explicitly wants custom output.",
             "Prefer exact IDs and structured tool results over search guesses after asset creation.",
             "Verify through the engine before claiming completion.",
@@ -358,8 +358,8 @@ export function buildGameTaskPlan(options) {
         recommendedSkills: inferSkills(mode, target, goal),
         mcpToolPlan: buildMcpToolPlan(mode, target, assetPolicy, verification, goal),
         hostFileWork: [
-            "Write and edit .gd/.cs scripts directly with host file tools.",
-            "Use direct file edits for JSON, markdown, project notes, and simple resources.",
+            "Read and mutate project text through summer_read_file, summer_replace_text, and guarded summer_write_file.",
+            "Use create_only:true for new files and an engine sha256 receipt for overwrites.",
             "Read relevant .summer memory files when project context reports them.",
         ],
         userGates: buildUserGates(mode, assetPolicy),

package/dist/lib/mcp-boot-notice.d.ts

@@ -0,0 +1,3 @@
+import type { BootDriftNotice } from "./version-check.js";
+export declare function getCachedBootDriftNotice(): BootDriftNotice | null;
+export declare function setCachedBootDriftNotice(notice: BootDriftNotice | null): void;

package/dist/lib/mcp-boot-notice.js

@@ -0,0 +1,7 @@
+let cachedBootDriftNotice = null;
+export function getCachedBootDriftNotice() {
+    return cachedBootDriftNotice;
+}
+export function setCachedBootDriftNotice(notice) {
+    cachedBootDriftNotice = notice;
+}

package/dist/lib/mcp-log.d.ts

@@ -0,0 +1,3 @@
+export declare function getMcpLogPath(): string;
+export declare function appendMcpLogEvent(event: string, details?: Record<string, unknown>): void;
+export declare function readRecentMcpLogLines(maxLines?: number): Promise<string[]>;

package/dist/lib/mcp-log.js

@@ -0,0 +1,72 @@
+import { appendFileSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getSummerDir } from "./auth.js";
+const MAX_LOG_BYTES = 512 * 1024;
+const RETAIN_LOG_BYTES = 256 * 1024;
+export function getMcpLogPath() {
+    return join(getSummerDir(), "mcp.log");
+}
+function redact(value) {
+    if (Array.isArray(value))
+        return value.map((item) => redact(item));
+    if (!value || typeof value !== "object")
+        return value;
+    const out = {};
+    for (const [key, nested] of Object.entries(value)) {
+        if (/token|secret|password|authorization|cookie|api[-_]?key/i.test(key)) {
+            out[key] = "[REDACTED]";
+        }
+        else {
+            out[key] = redact(nested);
+        }
+    }
+    return out;
+}
+function rotateIfNeeded(path) {
+    try {
+        if (statSync(path).size < MAX_LOG_BYTES)
+            return;
+        const text = readFileSync(path, "utf-8");
+        const retained = text.slice(-RETAIN_LOG_BYTES);
+        writeFileSync(path, `{"event":"mcp:log_rotated"}\n${retained}`, {
+            encoding: "utf-8",
+            mode: 0o600,
+        });
+    }
+    catch {
+        // No existing log, or not readable. The next append will recreate it.
+    }
+}
+export function appendMcpLogEvent(event, details = {}) {
+    try {
+        const dir = getSummerDir();
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const path = getMcpLogPath();
+        rotateIfNeeded(path);
+        const safeDetails = redact(details);
+        const payload = {
+            ts: new Date().toISOString(),
+            event,
+            ...safeDetails,
+        };
+        appendFileSync(path, `${JSON.stringify(payload)}\n`, {
+            encoding: "utf-8",
+            mode: 0o600,
+        });
+    }
+    catch {
+        // Logging must never affect MCP behavior.
+    }
+}
+export async function readRecentMcpLogLines(maxLines = 120) {
+    try {
+        const text = await readFile(getMcpLogPath(), "utf-8");
+        if (!text.trim())
+            return [];
+        return text.trimEnd().split(/\r?\n/).slice(-maxLines);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/lib/skills-registry.d.ts

@@ -23,7 +23,7 @@ export declare const SKILL_REGISTRY: readonly [{
     readonly public: true;
     readonly clients: readonly ["summer", "codex", "claude-code", "cursor", "windsurf", "cline", "roo-code", "kilo-code", "gemini", "github-copilot", "vscode-copilot", "opencode"];
     readonly recommended: true;
-    readonly requiresMcpTools: readonly ["summer_get_console", "summer_get_debugger_errors", "summer_get_script_errors", "summer_get_diagnostics", "summer_clear_console", "summer_play", "summer_stop", "summer_inspect_node"];
+    readonly requiresMcpTools: readonly ["summer_create_debug_report", "summer_get_console", "summer_get_debugger_errors", "summer_get_script_errors", "summer_get_diagnostics", "summer_clear_console", "summer_play", "summer_stop", "summer_inspect_node"];
     readonly testScenario: "Triage a runtime crash end-to-end: read errors, locate code, propose fix, apply on approval, verify.";
 }, {
     readonly name: "play";
@@ -49,6 +49,14 @@ export declare const SKILL_REGISTRY: readonly [{
     readonly recommended: true;
     readonly requiresMcpTools: readonly ["summer_create_scene", "summer_open_scene", "summer_get_scene_tree", "summer_add_node", "summer_instantiate_scene", "summer_save_scene"];
     readonly testScenario: "Build a small reusable player scene, instantiate it in a main scene, and save both scenes through Summer tools.";
+}, {
+    readonly name: "summer-cloud";
+    readonly category: "scene-and-project";
+    readonly public: true;
+    readonly clients: readonly ["summer", "codex", "claude-code", "cursor", "windsurf", "cline", "roo-code", "kilo-code", "gemini", "github-copilot", "vscode-copilot", "opencode"];
+    readonly recommended: true;
+    readonly requiresMcpTools: readonly ["summer_cloud_init", "summer_cloud_status", "summer_cloud_push", "summer_cloud_pull", "summer_cloud_restore", "summer_cloud_checkpoints", "summer_cloud_conflicts"];
+    readonly testScenario: "Enable Cloud for a project, push it, then pull it onto a second machine, taking the bootstrap choice and surfacing the delete count before any guarded deletion.";
 }, {
     readonly name: "fps-controller";
     readonly category: "character-controllers";
@@ -201,6 +209,14 @@ export declare const SKILL_REGISTRY: readonly [{
     readonly recommended: true;
     readonly requiresMcpTools: readonly ["summer_get_scene_tree", "summer_inspect_node", "summer_project_setting", "summer_get_console", "summer_get_diagnostics"];
     readonly testScenario: "Run the Steam pre-flight checklist (Windows + Mac + Linux), validate icons/banners/screenshots/build config, and produce a release build only when green.";
+}, {
+    readonly name: "remote-deploy";
+    readonly category: "deployment";
+    readonly public: true;
+    readonly clients: readonly ["summer", "codex", "claude-code", "cursor", "windsurf", "cline", "roo-code", "kilo-code", "gemini", "github-copilot", "vscode-copilot", "opencode"];
+    readonly recommended: true;
+    readonly requiresMcpTools: readonly ["summer_project_setting", "summer_get_diagnostics", "summer_get_console", "summer_get_script_errors"];
+    readonly testScenario: "User says \"deploy the game to my Android phone\" — skill walks the prerequisites (runnable export preset, installed export templates, USB-debugging device), checks diagnostics are clean, and points them at the topnav Remote Deploy button to deploy a debug build with on-device remote debugging.";
 }, {
     readonly name: "concept-art";
     readonly category: "2d-assets";
@@ -249,6 +265,14 @@ export declare const SKILL_REGISTRY: readonly [{
     readonly recommended: false;
     readonly requiresMcpTools: readonly ["summer_generate_image", "summer_import_from_url", "summer_set_resource_property", "summer_add_node", "summer_set_prop"];
     readonly testScenario: "User requests a '4-frame walk cycle for the goblin' — skill generates per-frame at locked anchor, builds SpriteFrames resource, wires AnimatedSprite2D.";
+}, {
+    readonly name: "create-asset-sheet";
+    readonly category: "2d-assets";
+    readonly public: true;
+    readonly clients: readonly ["summer", "codex", "claude-code", "cursor", "windsurf", "cline", "roo-code", "kilo-code", "gemini", "github-copilot", "vscode-copilot", "opencode"];
+    readonly recommended: false;
+    readonly requiresMcpTools: readonly ["summer_get_studio_workflow", "summer_generate_image", "summer_slice_asset_sheet", "summer_import_asset_by_id"];
+    readonly testScenario: "User requests a Japanese village asset pack — skill loads the Guided asset-pack recipe, generates one coherent sheet, slices it through the shared cloud pipeline, and imports selected results.";
 }, {
     readonly name: "skybox-panorama";
     readonly category: "2d-assets";

package/dist/lib/skills-registry.js

@@ -53,6 +53,7 @@ export const SKILL_REGISTRY = [
         clients: ALL_CLIENTS,
         recommended: true,
         requiresMcpTools: [
+            "summer_create_debug_report",
             "summer_get_console",
             "summer_get_debugger_errors",
             "summer_get_script_errors",
@@ -108,6 +109,23 @@ export const SKILL_REGISTRY = [
         ],
         testScenario: "Build a small reusable player scene, instantiate it in a main scene, and save both scenes through Summer tools.",
     },
+    {
+        name: "summer-cloud",
+        category: "scene-and-project",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: true,
+        requiresMcpTools: [
+            "summer_cloud_init",
+            "summer_cloud_status",
+            "summer_cloud_push",
+            "summer_cloud_pull",
+            "summer_cloud_restore",
+            "summer_cloud_checkpoints",
+            "summer_cloud_conflicts",
+        ],
+        testScenario: "Enable Cloud for a project, push it, then pull it onto a second machine, taking the bootstrap choice and surfacing the delete count before any guarded deletion.",
+    },
     {
         name: "fps-controller",
         category: "character-controllers",
@@ -413,6 +431,20 @@ export const SKILL_REGISTRY = [
         ],
         testScenario: "Run the Steam pre-flight checklist (Windows + Mac + Linux), validate icons/banners/screenshots/build config, and produce a release build only when green.",
     },
+    {
+        name: "remote-deploy",
+        category: "deployment",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: true,
+        requiresMcpTools: [
+            "summer_project_setting",
+            "summer_get_diagnostics",
+            "summer_get_console",
+            "summer_get_script_errors",
+        ],
+        testScenario: "User says \"deploy the game to my Android phone\" — skill walks the prerequisites (runnable export preset, installed export templates, USB-debugging device), checks diagnostics are clean, and points them at the topnav Remote Deploy button to deploy a debug build with on-device remote debugging.",
+    },
     {
         name: "concept-art",
         category: "2d-assets",
@@ -494,6 +526,20 @@ export const SKILL_REGISTRY = [
         ],
         testScenario: "User requests a '4-frame walk cycle for the goblin' — skill generates per-frame at locked anchor, builds SpriteFrames resource, wires AnimatedSprite2D.",
     },
+    {
+        name: "create-asset-sheet",
+        category: "2d-assets",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: false,
+        requiresMcpTools: [
+            "summer_get_studio_workflow",
+            "summer_generate_image",
+            "summer_slice_asset_sheet",
+            "summer_import_asset_by_id",
+        ],
+        testScenario: "User requests a Japanese village asset pack — skill loads the Guided asset-pack recipe, generates one coherent sheet, slices it through the shared cloud pipeline, and imports selected results.",
+    },
     {
         name: "skybox-panorama",
         category: "2d-assets",

package/dist/mcp/server.d.ts

@@ -1,6 +1,6 @@
 import { EngineApiClient } from "../lib/api-client.js";
-import { type BootDriftNotice } from "../lib/version-check.js";
-export declare function getCachedBootDriftNotice(): BootDriftNotice | null;
+import { getCachedBootDriftNotice as getCachedNotice } from "../lib/mcp-boot-notice.js";
+export declare const getCachedBootDriftNotice: typeof getCachedNotice;
 export declare function getClient(): Promise<EngineApiClient>;
 export declare function resetClient(): void;
 export declare function startMcpServer(): Promise<void>;