@alphafox/cli 0.2.0 → 0.3.2

package/README.md

@@ -2,16 +2,43 @@
 
 Alphafox CLI (`alphafox`) — Agent and human entry for the versioned Public Application API on alphafox-web.
 
+Homepage: https://alphafoxai.github.io/alphafox-cli/
+
 ## Install
 
+Pick **one** of the following. Both install the CLI **and** register Agent
+Skills. `npm install -g @alphafox/cli` alone does **not** install Skills.
+
+### Method 1 — Manual wizard
+
 ```bash
-npm install -g @alphafox/cli
-# or
-npx alphafox-cli version
+npx @alphafox/cli@latest install
 ```
 
+This installs `@alphafox/cli` globally, runs `npx skills add` into detected
+agents (Cursor, Claude Code, Codex, …), and may prompt for
+`alphafox auth login --browser`. **Restart the AI tool** afterwards so Skills
+load.
+
+### Method 2 — Install via Agent
+
+Copy and send this to Cursor / Claude Code / Codex / Trae:
+
+```
+帮我安装 Alphafox CLI：https://github.com/alphafoxai/alphafox-cli/blob/main/docs/alphafox-cli-installation-guide.md
+```
+
+```
+Help me install Alphafox CLI: https://github.com/alphafoxai/alphafox-cli/blob/main/docs/alphafox-cli-installation-guide.md
+```
+
+The Agent follows that guide (`npm install -g`, `npx skills add`, login,
+`doctor`). **Restart the AI tool** when it finishes.
+
 ## Quick start
 
+After Method 1 or 2:
+
 ```bash
 alphafox version
 alphafox doctor
@@ -28,14 +55,25 @@ alphafox api GET /api/v1/me
 - Profiles: `production` (default), `staging`, `local` — isolated issuer/audience/client (ADR 0003).
 - High-risk writes require `--yes`. Automation tokens are **deferred** (ADR 0004).
 - Raw `api` only hits allowlisted `/api/v1/*` facade paths.
+- Writes validate `--body` / `--config @file` against the catalog schema
+  before HTTP. Agents must `alphafox schema <operationId>` first and must
+  not invent fields. Large objects use `--config @file`, not argv.
 
 ## Skills
 
-Co-versioned Agent Skills live under `skills/`. They route intent to public `operationId`s only.
+Co-versioned Agent Skills live under `skills/`. API-oriented skills route public
+`operationId`s; an explicit local-execution skill may call its co-versioned
+built-in command.
+
+`alphafox install` (and the [Agent install guide](docs/alphafox-cli-installation-guide.md))
+run `npx skills add` so those files land in Agent skill directories
+(`.cursor/skills`, `.claude/skills`, `~/.agents/skills`, …).
 
 ## Docs
 
+- [Homepage](https://alphafoxai.github.io/alphafox-cli/)
 - [Release / supply chain](docs/release-supply-chain.md)
+- [Agent install guide](docs/alphafox-cli-installation-guide.md)
 - [Staging E2E checklist](docs/e2e-staging.md)
 - Related ADRs and parity matrix live in the alphafox-web repository
 

package/dist/catalog/command-tree.d.ts

@@ -31,4 +31,5 @@ export declare function resolveTypedCommand(tokens: readonly string[]): TypedRes
 export declare function typedCommandExample(op: CatalogOperation): {
     readonly typed: string;
     readonly api: string;
+    readonly config?: string;
 };

package/dist/catalog/command-tree.js

@@ -104,14 +104,16 @@ function typedCommandExample(op) {
     const schemaNames = op.path.match(/\{([a-zA-Z0-9_]+)\}/g)?.map((s) => s.slice(1, -1)) ?? [];
     const pathFlags = schemaNames.map((name) => `--${name} <${name}>`).join(" ");
     const riskFlag = op.risk === "high-risk-write" || op.risk === "unknown" ? " --yes" : "";
-    const bodyFlag = op.method !== "GET" && op.method !== "HEAD" && op.method !== "DELETE"
-        ? " --body '{}'"
-        : "";
+    const writesBody = op.method !== "GET" && op.method !== "HEAD" && op.method !== "DELETE";
+    const bodyFlag = writesBody ? " --body '{…}'" : "";
     const typedFlags = [pathFlags, bodyFlag.trim(), riskFlag.trim()]
         .filter(Boolean)
         .join(" ");
     return {
         typed: `alphafox ${segments.join(" ")}${typedFlags ? ` ${typedFlags}` : ""}`,
         api: `alphafox api ${op.method} ${op.path}${bodyFlag}${riskFlag}`,
+        config: writesBody
+            ? `alphafox ${segments.join(" ")} --config @./${op.operationId}.json${riskFlag}`
+            : undefined,
     };
 }

package/dist/catalog/validate-body.d.ts

@@ -0,0 +1,22 @@
+import { type ErrorObject } from "ajv/dist/2020";
+import type { ErrorBody } from "../envelope";
+export declare function isWriteMethod(method: string): boolean;
+export declare function isEmptyObject(value: unknown): boolean;
+export type BodyValidationResult = {
+    readonly ok: true;
+    readonly body: unknown;
+} | {
+    readonly ok: false;
+    readonly error: ErrorBody;
+};
+export declare function validateCatalogWriteBody(input: {
+    readonly method: string;
+    readonly operationId?: string;
+    readonly body: unknown;
+}): BodyValidationResult;
+export declare function formatAjvErrors(errors: readonly ErrorObject[]): readonly {
+    readonly instancePath: string;
+    readonly keyword: string;
+    readonly message: string;
+    readonly params: Record<string, unknown>;
+}[];

package/dist/catalog/validate-body.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWriteMethod = isWriteMethod;
+exports.isEmptyObject = isEmptyObject;
+exports.validateCatalogWriteBody = validateCatalogWriteBody;
+exports.formatAjvErrors = formatAjvErrors;
+const _2020_1 = __importDefault(require("ajv/dist/2020"));
+const operations_1 = require("./operations");
+const ajv = new _2020_1.default({
+    allErrors: true,
+    strict: false,
+    validateSchema: false,
+});
+const compiled = new Map();
+function isWriteMethod(method) {
+    const verb = method.toUpperCase();
+    return verb !== "GET" && verb !== "HEAD";
+}
+function isEmptyObject(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === 0);
+}
+function validateCatalogWriteBody(input) {
+    if (!isWriteMethod(input.method)) {
+        return { ok: true, body: input.body };
+    }
+    const payload = input.body === undefined ? {} : input.body;
+    const operationId = input.operationId;
+    if (!operationId) {
+        if (payload === undefined || isEmptyObject(payload)) {
+            return { ok: true, body: payload };
+        }
+        return {
+            ok: false,
+            error: {
+                type: "usage",
+                subtype: "body_schema_missing",
+                message: "Uncataloged write cannot send a non-empty body. Find the operationId first.",
+                hint: "Run alphafox catalog / alphafox schema <operationId>, then resend only documented fields.",
+            },
+        };
+    }
+    const doc = (0, operations_1.getOperationSchemaDocument)(operationId);
+    const schema = doc?.request.body ?? null;
+    if (!schema) {
+        if (payload === undefined || isEmptyObject(payload)) {
+            return { ok: true, body: payload };
+        }
+        return {
+            ok: false,
+            error: {
+                type: "usage",
+                subtype: "body_schema_missing",
+                message: `Operation ${operationId} has no catalog request body; do not invent fields.`,
+                hint: `Run alphafox schema ${operationId}. Omit --body/--config or send {}.`,
+            },
+        };
+    }
+    const validate = compileBodySchema(operationId, schema);
+    const ok = validate(payload);
+    if (ok) {
+        return { ok: true, body: payload };
+    }
+    return {
+        ok: false,
+        error: {
+            type: "usage",
+            subtype: "body_schema",
+            message: `Request body does not match catalog schema for ${operationId}`,
+            hint: `Run alphafox schema ${operationId} and resend only documented fields via --body or --config @file.`,
+            details: {
+                operationId,
+                errors: formatAjvErrors(validate.errors ?? []),
+            },
+        },
+    };
+}
+function compileBodySchema(operationId, schema) {
+    const cached = compiled.get(operationId);
+    if (cached)
+        return cached;
+    const validate = ajv.compile(schema);
+    compiled.set(operationId, validate);
+    return validate;
+}
+function formatAjvErrors(errors) {
+    return errors.map((err) => ({
+        instancePath: err.instancePath,
+        keyword: err.keyword,
+        message: err.message ?? "invalid",
+        params: (err.params ?? {}),
+    }));
+}

package/dist/commands/request-body.d.ts

@@ -0,0 +1,21 @@
+export declare class RequestBodyError extends Error {
+    readonly type = "usage";
+    readonly subtype: string;
+    readonly hint?: string;
+    constructor(input: {
+        readonly message: string;
+        readonly subtype: string;
+        readonly hint?: string;
+    });
+}
+export declare function isRequestBodyError(value: unknown): value is RequestBodyError;
+export interface LoadJsonOptions {
+    readonly cwd?: string;
+    readonly readFile?: (path: string) => string;
+}
+export declare function loadJsonArg(raw: string, options?: LoadJsonOptions): unknown;
+export type RequestBodySource = "body" | "config" | "none";
+export declare function parseRequestBodyFlags(args: readonly string[], options?: LoadJsonOptions): {
+    readonly body: unknown;
+    readonly source: RequestBodySource;
+};

package/dist/commands/request-body.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestBodyError = void 0;
+exports.isRequestBodyError = isRequestBodyError;
+exports.loadJsonArg = loadJsonArg;
+exports.parseRequestBodyFlags = parseRequestBodyFlags;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+class RequestBodyError extends Error {
+    type = "usage";
+    subtype;
+    hint;
+    constructor(input) {
+        super(input.message);
+        this.name = "RequestBodyError";
+        this.subtype = input.subtype;
+        this.hint = input.hint;
+    }
+}
+exports.RequestBodyError = RequestBodyError;
+function isRequestBodyError(value) {
+    return value instanceof RequestBodyError;
+}
+function loadJsonArg(raw, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const read = options.readFile ?? ((p) => (0, node_fs_1.readFileSync)(p, "utf8"));
+    if (raw.startsWith("@")) {
+        const rel = raw.slice(1);
+        if (!rel) {
+            throw new RequestBodyError({
+                subtype: "missing_config",
+                message: "@path is empty",
+                hint: "Use --config @./payload.json",
+            });
+        }
+        const abs = (0, node_path_1.isAbsolute)(rel) ? rel : (0, node_path_1.resolve)(cwd, rel);
+        try {
+            return JSON.parse(read(abs));
+        }
+        catch (err) {
+            throw new RequestBodyError({
+                subtype: "invalid_config",
+                message: `Cannot read JSON file ${abs}: ${err instanceof Error ? err.message : String(err)}`,
+                hint: "Pass a JSON object file via --config @path",
+            });
+        }
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new RequestBodyError({
+            subtype: "invalid_body",
+            message: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+            hint: "Small payloads: --body '{...}'. Large objects: --config @./payload.json",
+        });
+    }
+}
+function parseRequestBodyFlags(args, options = {}) {
+    const bodyIdx = args.indexOf("--body");
+    const configIdx = args.indexOf("--config");
+    if (bodyIdx >= 0 && configIdx >= 0) {
+        throw new RequestBodyError({
+            subtype: "body_and_config",
+            message: "Use either --body or --config, not both",
+            hint: "Prefer --config @file for nested / large objects",
+        });
+    }
+    if (configIdx >= 0) {
+        const raw = args[configIdx + 1];
+        if (!raw || raw.startsWith("--")) {
+            throw new RequestBodyError({
+                subtype: "missing_config",
+                message: "--config requires @path or inline JSON",
+                hint: "alphafox <command> --config @./payload.json",
+            });
+        }
+        return { body: loadJsonArg(raw, options), source: "config" };
+    }
+    if (bodyIdx >= 0) {
+        const raw = args[bodyIdx + 1];
+        if (!raw || raw.startsWith("--")) {
+            throw new RequestBodyError({
+                subtype: "missing_body",
+                message: "--body requires JSON or @path",
+                hint: "Small payloads: --body '{...}'. Large objects: --config @./payload.json",
+            });
+        }
+        return { body: loadJsonArg(raw, options), source: "body" };
+    }
+    return { body: undefined, source: "none" };
+}

package/dist/commands/run.js

@@ -13,6 +13,11 @@ const client_1 = require("../http/client");
 const store_1 = require("../keychain/store");
 const confirmation_1 = require("../safety/confirmation");
 const version_1 = require("../version");
+const run_command_1 = require("../engine-backtest/run-command");
+const validate_body_1 = require("../catalog/validate-body");
+const types_1 = require("../install/types");
+const wizard_1 = require("../install/wizard");
+const request_body_1 = require("./request-body");
 function parseGlobalFlags(argv) {
     const flags = {
         format: "json",
@@ -79,6 +84,7 @@ async function runCli(argv, env = process.env) {
             usage: [
                 "alphafox version",
                 "alphafox doctor",
+                "alphafox install [--no-auth|--dry-run]",
                 "alphafox auth login [--no-wait|--device-code CODE|--browser]",
                 "alphafox auth status [--verify]",
                 "alphafox auth logout",
@@ -86,19 +92,22 @@ async function runCli(argv, env = process.env) {
                 "alphafox profile list|use <name>",
                 "alphafox schema [operationId]",
                 "alphafox catalog",
-                "alphafox api METHOD PATH [--body JSON]",
+                "alphafox api METHOD PATH [--body JSON|--config @file]",
+                "alphafox engine-backtest run --experiment <uuid> --definition <id> --config @file --exchange <id> --range FROM..TO --initial-equity N",
                 "alphafox <domain> <resource> <action> [flags]",
             ],
         }, { format: flags.format, jq: flags.jq });
         return 0;
     }
     try {
-        if (cmd !== "version") {
+        if (cmd !== "version" && cmd !== "install") {
             assertCatalogCompatible();
         }
         switch (cmd) {
             case "version":
                 return cmdVersion(flags);
+            case "install":
+                return await cmdInstall(args, flags, env);
             case "doctor":
                 return cmdDoctor(flags, env);
             case "whoami":
@@ -113,6 +122,19 @@ async function runCli(argv, env = process.env) {
                 return await cmdApi(args, flags, env);
             case "catalog":
                 return cmdCatalog(flags);
+            case "engine-backtest": {
+                const sub = args[0];
+                if (!sub ||
+                    sub === "run" ||
+                    sub === "help" ||
+                    sub === "--help" ||
+                    sub === "-h") {
+                    return await (0, run_command_1.cmdEngineBacktest)(args, flags, env);
+                }
+                // Hyphen built-in only owns `run`. Underscore/hyphen catalog CRUD
+                // (engine_backtest.experiments.*) still goes through the typed tree.
+                return await cmdTyped(cmd, args, flags, env);
+            }
             default:
                 return await cmdTyped(cmd, args, flags, env);
         }
@@ -146,6 +168,46 @@ function assertCatalogCompatible() {
         hint: "Upgrade or pin @alphafox/cli to the catalog minCliVersion/maxCliVersion range.",
     });
 }
+async function cmdInstall(args, flags, env) {
+    const parsed = (0, wizard_1.parseInstallArgs)(args);
+    if (parsed.unknown.length > 0) {
+        (0, envelope_1.writeError)({
+            type: "usage",
+            subtype: "unknown_install_flag",
+            message: `Unknown install flag: ${parsed.unknown.join(" ")}`,
+            hint: "Usage: alphafox install [--no-auth] [--dry-run]",
+        });
+    }
+    if (parsed.help) {
+        (0, envelope_1.writeSuccess)((0, wizard_1.installHelpData)(), { format: flags.format, jq: flags.jq });
+        return 0;
+    }
+    try {
+        const data = await (0, wizard_1.runInstallWizard)({
+            format: flags.format,
+            yes: flags.yes,
+            dryRun: flags.dryRun,
+            noInput: flags.noInput,
+            jq: flags.jq,
+            noAuth: parsed.noAuth,
+            help: false,
+        }, env);
+        (0, envelope_1.writeSuccess)(data, { format: flags.format, jq: flags.jq });
+        return data.auth.action === "failed" ? 1 : 0;
+    }
+    catch (err) {
+        if ((0, types_1.isInstallError)(err)) {
+            (0, envelope_1.writeError)({
+                type: err.type,
+                subtype: err.subtype,
+                message: err.message,
+                hint: err.hint,
+                details: err.details,
+            });
+        }
+        throw err;
+    }
+}
 function cmdVersion(flags) {
     const compatibility = (0, operations_1.checkGeneratedCatalogCompatibility)(version_1.CLI_VERSION);
     (0, envelope_1.writeSuccess)({
@@ -626,7 +688,7 @@ async function cmdApi(args, flags, env) {
     if (!method || !path) {
         (0, envelope_1.writeError)({
             type: "usage",
-            message: "Usage: alphafox api METHOD PATH [--body JSON]",
+            message: "Usage: alphafox api METHOD PATH [--body JSON|--config @file]",
         });
     }
     if ((0, allowlist_1.isInternalDisallowedPath)(path) || !(0, allowlist_1.isFacadeAllowlistedPath)(path)) {
@@ -638,15 +700,34 @@ async function cmdApi(args, flags, env) {
         }, { exitCode: 77 });
     }
     let body;
-    const bodyIdx = args.indexOf("--body");
-    if (bodyIdx >= 0) {
-        body = JSON.parse(args[bodyIdx + 1] ?? "{}");
+    try {
+        body = (0, request_body_1.parseRequestBodyFlags)(args).body;
+    }
+    catch (err) {
+        if ((0, request_body_1.isRequestBodyError)(err)) {
+            (0, envelope_1.writeError)({
+                type: err.type,
+                subtype: err.subtype,
+                message: err.message,
+                hint: err.hint,
+            });
+        }
+        throw err;
     }
     const profile = (0, profiles_1.resolveProfile)(flags.profile, env, {
         unsafeCustomEndpoint: flags.unsafeCustomEndpoint,
     });
     // Infer risk from catalog; uncataloged mutations are treated as high-risk.
     const catalogHit = (0, operations_1.findCatalogOperationByRoute)(method, (0, allowlist_1.normalizeApiPath)(path));
+    const validated = (0, validate_body_1.validateCatalogWriteBody)({
+        method,
+        operationId: catalogHit?.operationId,
+        body,
+    });
+    if (!validated.ok) {
+        (0, envelope_1.writeError)(validated.error);
+    }
+    body = validated.body;
     const risk = (0, confirmation_1.inferRawApiRisk)(method, catalogHit?.risk);
     const gate = (0, confirmation_1.assertHighRiskConfirmation)({
         risk,
@@ -665,6 +746,8 @@ async function cmdApi(args, flags, env) {
             path,
             profile: profile.name,
             risk,
+            operationId: catalogHit?.operationId,
+            body,
         }, { format: flags.format, jq: flags.jq });
         return 0;
     }
@@ -750,7 +833,7 @@ async function invokeOperation(operationId, args, flags, env) {
         (0, operations_1.extractPathParamNames)(op.path));
     for (let i = 0; i < args.length; i += 1) {
         const a = args[i];
-        if (a.startsWith("--") && a !== "--body") {
+        if (a.startsWith("--") && a !== "--body" && a !== "--config") {
             const key = a.slice(2);
             const value = args[++i] ?? "";
             if (pathParamNames.has(key)) {
@@ -762,10 +845,29 @@ async function invokeOperation(operationId, args, flags, env) {
         }
     }
     let body;
-    const bodyIdx = args.indexOf("--body");
-    if (bodyIdx >= 0) {
-        body = JSON.parse(args[bodyIdx + 1] ?? "{}");
+    try {
+        body = (0, request_body_1.parseRequestBodyFlags)(args).body;
+    }
+    catch (err) {
+        if ((0, request_body_1.isRequestBodyError)(err)) {
+            (0, envelope_1.writeError)({
+                type: err.type,
+                subtype: err.subtype,
+                message: err.message,
+                hint: err.hint,
+            });
+        }
+        throw err;
+    }
+    const validated = (0, validate_body_1.validateCatalogWriteBody)({
+        method: op.method,
+        operationId,
+        body,
+    });
+    if (!validated.ok) {
+        (0, envelope_1.writeError)(validated.error);
     }
+    body = validated.body;
     let path = (0, operations_1.resolveOperationPath)(op.path, params);
     if ((op.method === "GET" || op.method === "HEAD") &&
         Object.keys(extra).length > 0) {
@@ -783,6 +885,7 @@ async function invokeOperation(operationId, args, flags, env) {
             path,
             risk: op.risk,
             profile: profile.name,
+            body: op.method === "GET" || op.method === "HEAD" ? undefined : body,
         }, { format: flags.format, jq: flags.jq });
         return 0;
     }

package/dist/engine-backtest/errors.d.ts

@@ -0,0 +1,18 @@
+export declare class EngineBacktestError extends Error {
+    readonly type: string;
+    readonly subtype?: string;
+    readonly status?: number;
+    readonly code?: string | number;
+    readonly hint?: string;
+    readonly details?: unknown;
+    constructor(input: {
+        readonly message: string;
+        readonly type?: string;
+        readonly subtype?: string;
+        readonly status?: number;
+        readonly code?: string | number;
+        readonly hint?: string;
+        readonly details?: unknown;
+    });
+}
+export declare function isEngineBacktestError(value: unknown): value is EngineBacktestError;

package/dist/engine-backtest/errors.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EngineBacktestError = void 0;
+exports.isEngineBacktestError = isEngineBacktestError;
+class EngineBacktestError extends Error {
+    type;
+    subtype;
+    status;
+    code;
+    hint;
+    details;
+    constructor(input) {
+        super(input.message);
+        this.name = "EngineBacktestError";
+        this.type = input.type ?? "runtime";
+        this.subtype = input.subtype;
+        this.status = input.status;
+        this.code = input.code;
+        this.hint = input.hint;
+        this.details = input.details;
+    }
+}
+exports.EngineBacktestError = EngineBacktestError;
+function isEngineBacktestError(value) {
+    return value instanceof EngineBacktestError;
+}

package/dist/engine-backtest/fetch-runtime.d.ts

@@ -0,0 +1,38 @@
+export declare const BACKTEST_RUNTIME_PROTOCOL = 1;
+export declare const DEFAULT_BACKTEST_WASM_MANIFEST_URL = "https://zwggllrrna54e2d6.public.blob.vercel-storage.com/engine-backtest/latest.json";
+export declare const BLOB_RUNTIME_FILES: {
+    readonly wasm: "tradingfox-backtest.wasm";
+    readonly wasmExec: "wasm_exec.js";
+    readonly worker: "worker.mjs";
+    readonly client: "index.mjs";
+    readonly node: "node.mjs";
+    readonly nodeWorker: "worker-node.mjs";
+    readonly nodeWorkerPath: "worker-node-path.mjs";
+};
+export type BlobRuntimeFileKey = keyof typeof BLOB_RUNTIME_FILES;
+export interface EngineBacktestBlobManifest {
+    readonly version: string;
+    readonly hash: string;
+    readonly protocol: number;
+    readonly engineSha?: string;
+    readonly packageVersion?: string;
+    readonly wasm: string;
+    readonly wasmExec: string;
+    readonly worker: string;
+    readonly client: string;
+    readonly node: string;
+    readonly nodeWorker: string;
+    readonly nodeWorkerPath: string;
+}
+export interface FetchRuntimeHooks {
+    readonly fetch?: typeof fetch;
+    readonly cacheDir?: string;
+}
+export declare function resolveBacktestWasmManifestUrl(env?: NodeJS.ProcessEnv): string;
+export declare function resolveRuntimeCacheDir(hash: string, env?: NodeJS.ProcessEnv): string;
+export declare function parseEngineBacktestBlobManifest(value: unknown): EngineBacktestBlobManifest;
+export declare function ensureBlobRuntime(env?: NodeJS.ProcessEnv, hooks?: FetchRuntimeHooks): Promise<{
+    readonly manifest: EngineBacktestBlobManifest;
+    readonly directory: string;
+    readonly nodeEntry: string;
+}>;