@tomflow/proflow-platform-cli 0.1.0

package/dist/src/apply/driver.js

@@ -0,0 +1,154 @@
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { PlatformError } from "../errors.js";
+import { readWorkspacePackageManagerSelection, systemPackageCommandRunner, } from "../install/package-manager.js";
+import { atomicWrite } from "../paths.js";
+/**
+ * Monorepo/test seam retained for source-resident planning. Production CLI must
+ * inject createWorkspacePackageManagerDriver(); it must never rely on this
+ * no-op driver to claim a product Workspace package mutation succeeded.
+ */
+export function workspaceResidentDriver() {
+    return {
+        async observeInstalledVersion(module) {
+            return module.moduleVersion;
+        },
+        async install() { },
+        async upgrade() { },
+        async remove() { },
+    };
+}
+export function createWorkspacePackageManagerDriver(options) {
+    const runner = options.runner ?? systemPackageCommandRunner();
+    return {
+        observeInstalledVersion: (module) => observeInstalledVersion(options.workspaceRoot, module.packageName),
+        install: async (module) => {
+            await ensureWorkspacePackageJson(options.workspaceRoot);
+            const manager = await requirePackageManager(options.workspaceRoot);
+            await mutatePackage(runner, manager, options.workspaceRoot, "install", `${module.packageName}@${module.moduleVersion}`);
+        },
+        upgrade: async (module) => {
+            await ensureWorkspacePackageJson(options.workspaceRoot);
+            const manager = await requirePackageManager(options.workspaceRoot);
+            await mutatePackage(runner, manager, options.workspaceRoot, "upgrade", `${module.packageName}@${module.moduleVersion}`);
+        },
+        remove: async (module) => {
+            const manager = await requirePackageManager(options.workspaceRoot);
+            await mutatePackage(runner, manager, options.workspaceRoot, "remove", module.packageName);
+        },
+    };
+}
+async function mutatePackage(runner, manager, workspaceRoot, operation, packageSpec) {
+    const args = packageManagerArgs(manager.name, operation, packageSpec);
+    try {
+        await runner.run(manager.name, args, workspaceRoot);
+    }
+    catch (error) {
+        throw new PlatformError(operation === "upgrade" ? "UPGRADE_FAILED" : "APPLY_FAILED", `${manager.name} ${operation} failed for ${packageSpec}: ${errorMessage(error)}`);
+    }
+}
+function packageManagerArgs(manager, operation, packageSpec) {
+    if (manager === "pnpm") {
+        return operation === "remove"
+            ? ["remove", "--ignore-scripts", packageSpec]
+            : ["add", "--save-exact", "--ignore-scripts", packageSpec];
+    }
+    return operation === "remove"
+        ? ["uninstall", "--ignore-scripts", packageSpec]
+        : ["install", "--save-exact", "--ignore-scripts", packageSpec];
+}
+async function requirePackageManager(workspaceRoot) {
+    const manager = await readWorkspacePackageManagerSelection(workspaceRoot);
+    if (manager === undefined) {
+        throw new PlatformError("APPLY_FAILED", "workspace packageManager is not supported; expected npm or pnpm");
+    }
+    return manager;
+}
+async function ensureWorkspacePackageJson(workspaceRoot) {
+    const path = join(workspaceRoot, "package.json");
+    try {
+        const raw = await readFile(path, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" ||
+            parsed === null ||
+            Array.isArray(parsed)) {
+            throw new Error("package.json root must be an object");
+        }
+        return;
+    }
+    catch (error) {
+        if (!isMissingFile(error)) {
+            throw new PlatformError("APPLY_FAILED", `workspace package.json is invalid: ${errorMessage(error)}`);
+        }
+    }
+    await atomicWrite(path, `${JSON.stringify({ private: true }, null, 2)}\n`);
+}
+async function observeInstalledVersion(workspaceRoot, packageName) {
+    const manifest = await readWorkspaceManifest(workspaceRoot);
+    if (manifest === undefined ||
+        (!hasOwn(manifest.dependencies, packageName) &&
+            !hasOwn(manifest.devDependencies, packageName))) {
+        return undefined;
+    }
+    const require = createRequire(pathToFileURL(join(workspaceRoot, "package.json")));
+    let entry;
+    try {
+        entry = require.resolve(packageName);
+    }
+    catch {
+        return undefined;
+    }
+    let current = dirname(entry);
+    for (;;) {
+        try {
+            const raw = await readFile(join(current, "package.json"), "utf8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed === "object" &&
+                parsed !== null &&
+                !Array.isArray(parsed) &&
+                Reflect.get(parsed, "name") === packageName &&
+                typeof Reflect.get(parsed, "version") === "string") {
+                return Reflect.get(parsed, "version");
+            }
+        }
+        catch {
+            // keep walking to the package root
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+async function readWorkspaceManifest(workspaceRoot) {
+    try {
+        const raw = await readFile(join(workspaceRoot, "package.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasOwn(record, key) {
+    return record !== undefined && Object.hasOwn(record, key);
+}
+function isMissingFile(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        Reflect.get(error, "code") === "ENOENT");
+}
+function errorMessage(error) {
+    if (typeof error === "object" && error !== null) {
+        const stderr = Reflect.get(error, "stderr");
+        if (typeof stderr === "string" && stderr.trim() !== "")
+            return stderr.trim();
+    }
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/apply/execute.d.ts

@@ -0,0 +1,36 @@
+import type { HumanAction } from "@tomflow/proflow-module-contract";
+import type { DeploymentPlan, DeploymentStep } from "../contracts.ts";
+import type { ModuleCatalog } from "../modules.ts";
+import type { WorkspacePaths } from "../paths.ts";
+import type { PackageManagerDriver } from "./driver.ts";
+export interface ExecuteDeps {
+    paths: WorkspacePaths;
+    catalog: ModuleCatalog;
+    driver: PackageManagerDriver;
+}
+/**
+ * Structured result of executing one non-human step. A lifecycle adapter's
+ * `ModuleOperationResult` is preserved verbatim: ACTION_REQUIRED / BLOCKED /
+ * FAILED are returned as values, never collapsed into a thrown APPLY_FAILED.
+ * Only genuine boundary violations (missing module, unsupported strategy,
+ * malformed adapter result) still throw.
+ */
+export type ExecuteStepOutcome = {
+    kind: "SUCCEEDED";
+} | {
+    kind: "ACTION_REQUIRED";
+    actionRequired: HumanAction;
+} | {
+    kind: "BLOCKED";
+    reason: string;
+} | {
+    kind: "FAILED";
+    reason: string;
+};
+/**
+ * Executes a single non-human step by kind + execute strategy, returning a
+ * structured outcome instead of throwing for ACTION_REQUIRED / BLOCKED / FAILED
+ * lifecycle results. Package/config mutations still throw on genuine driver or
+ * boundary errors; those are not lifecycle outcomes and must not be swallowed.
+ */
+export declare function executeStep(deps: ExecuteDeps, step: DeploymentStep, plan: DeploymentPlan): Promise<ExecuteStepOutcome>;

package/dist/src/apply/execute.js

@@ -0,0 +1,124 @@
+import { PlatformError } from "../errors.js";
+import { dispatchLifecycle } from "../lifecycle/index.js";
+import { materializeConfig } from "../persistence/index.js";
+import { ExecuteStrategy } from "../planner/index.js";
+import { cleanupRemovableFilesystemEffects } from "./cleanup.js";
+function moduleOf(plan, step) {
+    return plan.resolvedModules.find((module) => module.moduleRef === step.moduleRef);
+}
+function configForStep(plan, step, module) {
+    const target = plan.moduleTargets.find((entry) => entry.moduleRef === step.moduleRef);
+    if (target?.config === undefined)
+        return undefined;
+    const secretRefs = module.configSlots
+        .filter((slot) => slot.type === "secretRef")
+        .map((slot) => slot.key);
+    return {
+        moduleRef: step.moduleRef,
+        values: target.config,
+        secretRefs,
+    };
+}
+function lifecyclePrimitive(step) {
+    switch (step.executeStrategy) {
+        case ExecuteStrategy.lifecycleStart:
+            return "start";
+        case ExecuteStrategy.lifecycleStop:
+            return "stop";
+        case ExecuteStrategy.lifecycleRestart:
+            return "restart";
+        case ExecuteStrategy.lifecycleUninstall:
+            return "uninstall";
+        case ExecuteStrategy.lifecycleMigrate:
+            return "migrate";
+        default:
+            throw new PlatformError("APPLY_FAILED", `unsupported lifecycle strategy ${step.executeStrategy ?? "<none>"}`);
+    }
+}
+function externalResourcePrimitive(step) {
+    if (step.executeStrategy === ExecuteStrategy.externalResourceConfigure) {
+        return "start";
+    }
+    throw new PlatformError("APPLY_FAILED", `unsupported external-resource strategy ${step.executeStrategy ?? "<none>"}`);
+}
+function requiredActionRequired(result) {
+    const actionRequired = result.actionRequired;
+    if (actionRequired === undefined) {
+        throw new PlatformError("APPLY_FAILED", `module ${result.moduleRef} reported ACTION_REQUIRED without a recoverable action`);
+    }
+    return actionRequired;
+}
+function operationOutcome(result) {
+    switch (result.status) {
+        case "SUCCEEDED":
+            return { kind: "SUCCEEDED" };
+        case "ACTION_REQUIRED":
+            return {
+                kind: "ACTION_REQUIRED",
+                actionRequired: requiredActionRequired(result),
+            };
+        case "BLOCKED":
+            return {
+                kind: "BLOCKED",
+                reason: `module ${result.moduleRef} is blocked`,
+            };
+        case "FAILED":
+            return {
+                kind: "FAILED",
+                reason: result.error?.message ?? `module ${result.moduleRef} failed`,
+            };
+    }
+}
+/**
+ * Executes a single non-human step by kind + execute strategy, returning a
+ * structured outcome instead of throwing for ACTION_REQUIRED / BLOCKED / FAILED
+ * lifecycle results. Package/config mutations still throw on genuine driver or
+ * boundary errors; those are not lifecycle outcomes and must not be swallowed.
+ */
+export async function executeStep(deps, step, plan) {
+    const module = moduleOf(plan, step);
+    if (module === undefined) {
+        throw new PlatformError("APPLY_FAILED", `module ${step.moduleRef} is not in the plan`);
+    }
+    switch (step.kind) {
+        case "package": {
+            if (step.executeStrategy === ExecuteStrategy.packageRemove) {
+                await deps.driver.remove(module);
+            }
+            else if (step.executeStrategy === ExecuteStrategy.packageUpgrade) {
+                await deps.driver.upgrade(module);
+            }
+            else {
+                await deps.driver.install(module);
+            }
+            return { kind: "SUCCEEDED" };
+        }
+        case "config": {
+            const config = configForStep(plan, step, module);
+            if (config === undefined) {
+                throw new PlatformError("APPLY_FAILED", `module ${step.moduleRef} has no config target to materialize`);
+            }
+            await materializeConfig(deps.paths, config);
+            return { kind: "SUCCEEDED" };
+        }
+        case "lifecycle": {
+            const primitive = lifecyclePrimitive(step);
+            const dispatched = await dispatchLifecycle(deps.catalog, module, primitive);
+            const operation = operationOutcome(dispatched.result);
+            if (primitive === "uninstall" && operation.kind === "SUCCEEDED") {
+                await cleanupRemovableFilesystemEffects({
+                    workspaceRoot: deps.paths.root,
+                    effects: module.effects,
+                });
+            }
+            return operation;
+        }
+        case "external-resource": {
+            const primitive = externalResourcePrimitive(step);
+            const dispatched = await dispatchLifecycle(deps.catalog, module, primitive);
+            return operationOutcome(dispatched.result);
+        }
+        case "human":
+            throw new PlatformError("APPLY_FAILED", `human step ${step.stepRef} must be routed to ACTION_REQUIRED, not executed`);
+    }
+}

package/dist/src/apply/index.d.ts

@@ -0,0 +1,8 @@
+export type { ApplyContext } from "./apply.ts";
+export { applyPlan } from "./apply.ts";
+export type { PackageManagerDriver } from "./driver.ts";
+export { createWorkspacePackageManagerDriver } from "./driver.ts";
+export type { ExecuteDeps, ExecuteStepOutcome } from "./execute.ts";
+export { executeStep } from "./execute.ts";
+export type { RealityObserver, RealityObserverDeps } from "./reality.ts";
+export { createRealityObserver } from "./reality.ts";

package/dist/src/apply/index.js

@@ -0,0 +1,4 @@
+export { applyPlan } from "./apply.js";
+export { createWorkspacePackageManagerDriver } from "./driver.js";
+export { executeStep } from "./execute.js";
+export { createRealityObserver } from "./reality.js";

package/dist/src/apply/reality.d.ts

@@ -0,0 +1,20 @@
+import type { DeploymentPlan, DeploymentStep } from "../contracts.ts";
+import type { ModuleCatalog } from "../modules.ts";
+import type { WorkspacePaths } from "../paths.ts";
+import type { StepReality } from "../planner/index.ts";
+import type { PackageManagerDriver } from "./driver.ts";
+/**
+ * Observes the current reality of a single step. The apply loop consults this
+ * before every decision so that persisted history can never impersonate current
+ * reality; a step that is no longer satisfied is re-executed, never faked as
+ * skipped.
+ */
+export interface RealityObserver {
+    observe(step: DeploymentStep, plan: DeploymentPlan): Promise<StepReality | undefined>;
+}
+export interface RealityObserverDeps {
+    paths: WorkspacePaths;
+    catalog: ModuleCatalog;
+    driver: PackageManagerDriver;
+}
+export declare function createRealityObserver(deps: RealityObserverDeps): RealityObserver;

package/dist/src/apply/reality.js

@@ -0,0 +1,93 @@
+import { dispatchLifecycle } from "../lifecycle/index.js";
+import { loadConfig } from "../persistence/index.js";
+export function createRealityObserver(deps) {
+    return {
+        observe(step, plan) {
+            return observeStep(deps, step, plan);
+        },
+    };
+}
+function moduleOf(plan, step) {
+    return plan.resolvedModules.find((module) => module.moduleRef === step.moduleRef);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringMap(value) {
+    if (!isRecord(value))
+        return false;
+    return Object.values(value).every((item) => typeof item === "string");
+}
+/**
+ * Runtime-validates an adapter `status` data payload into a `StepReality` at the
+ * boundary. Only recognized fields survive; anything else is ignored so an
+ * arbitrary payload can never be mistaken for observed reality. A service
+ * `status` payload carrying `state: "RUNNING" | "STOPPED"` maps onto the
+ * boolean `processRunning` reality.
+ */
+function parseStatusReality(value) {
+    if (!isRecord(value))
+        return {};
+    const reality = {};
+    if (typeof value.processRunning === "boolean") {
+        reality.processRunning = value.processRunning;
+    }
+    else if (value.state === "RUNNING") {
+        reality.processRunning = true;
+    }
+    else if (value.state === "STOPPED") {
+        reality.processRunning = false;
+    }
+    if (typeof value.resourceConfigured === "boolean") {
+        reality.resourceConfigured = value.resourceConfigured;
+    }
+    if (typeof value.humanActionVerified === "boolean") {
+        reality.humanActionVerified = value.humanActionVerified;
+    }
+    if (typeof value.migrated === "boolean") {
+        reality.migrated = value.migrated;
+    }
+    if (typeof value.installedVersion === "string") {
+        reality.installedVersion = value.installedVersion;
+    }
+    if (isStringMap(value.configValues)) {
+        reality.configValues = value.configValues;
+    }
+    return reality;
+}
+async function observeViaStatus(catalog, module) {
+    if (!module.lifecycle.includes("status"))
+        return {};
+    try {
+        const dispatched = await dispatchLifecycle(catalog, module, "status");
+        return parseStatusReality(dispatched.result.data);
+    }
+    catch {
+        // Observation failed (transport/timeout/malformed): UNKNOWN, never a
+        // fabricated NOT_SATISFIED that would replay a lifecycle/external effect.
+        return undefined;
+    }
+}
+async function observeStep(deps, step, plan) {
+    const module = moduleOf(plan, step);
+    if (module === undefined)
+        return {};
+    switch (step.kind) {
+        case "package": {
+            const installedVersion = await deps.driver.observeInstalledVersion(module);
+            return installedVersion === undefined ? {} : { installedVersion };
+        }
+        case "config": {
+            const config = await loadConfig(deps.paths, step.moduleRef);
+            if (config === undefined)
+                return {};
+            return {
+                configValues: { ...config.publicValues, ...config.secretValues },
+            };
+        }
+        case "lifecycle":
+        case "external-resource":
+        case "human":
+            return observeViaStatus(deps.catalog, module);
+    }
+}

package/dist/src/binding/production-bindings.d.ts

@@ -0,0 +1,45 @@
+import type { ResolvedModule } from "../contracts.ts";
+type ResolvedSource = ResolvedModule["source"];
+export interface DeploymentAdapterBinding {
+    behaviorAdapter: Record<string, unknown>;
+}
+export type ProductionBindingFactory = (input: {
+    moduleRef: string;
+    config: Record<string, string>;
+    workspaceRoot: string;
+    modules: readonly ResolvedModule[];
+    configByModuleRef: ReadonlyMap<string, Record<string, string>>;
+}) => Promise<DeploymentAdapterBinding | undefined> | DeploymentAdapterBinding | undefined;
+export type ServiceProcessBindingFactory = (input: {
+    moduleRef: string;
+    config: Record<string, string>;
+    workspaceRoot: string;
+    modules: readonly ResolvedModule[];
+    configByModuleRef: ReadonlyMap<string, Record<string, string>>;
+}) => Promise<{
+    serviceProcess: unknown;
+    behaviorAdapter?: Record<string, unknown>;
+} | undefined> | {
+    serviceProcess: unknown;
+    behaviorAdapter?: Record<string, unknown>;
+} | undefined;
+export interface ProductionBindingOptions {
+    workspaceRoot: string;
+    modules: readonly ResolvedModule[];
+    configByModuleRef: ReadonlyMap<string, Record<string, string>>;
+    importAdapter: (packageName: string, source: ResolvedSource) => Promise<Record<string, unknown>>;
+}
+export declare function importRawAdapter(packageName: string, source: ResolvedSource): Promise<Record<string, unknown>>;
+/**
+ * The shipped Platform CLI production binding factory. For every discovered
+ * module it imports the module's own `deployment/adapter.ts` and, when that
+ * adapter exposes a `createProductionBinding` factory, invokes it with the
+ * module's materialized config to obtain a real bound adapter. A module without
+ * a production factory — or whose import/factory fails, or which has no
+ * materialized config the adapter accepts — is left out of the map, so the
+ * catalog falls back to the module's unbound default, which must fail-closed
+ * (ACTION_REQUIRED / NOT_READY). Platform CLI never invents a service or
+ * resource reality: it only relays the adapter's own current reality.
+ */
+export declare function buildProductionBindings(options: ProductionBindingOptions): Promise<ReadonlyMap<string, DeploymentAdapterBinding>>;
+export {};

package/dist/src/binding/production-bindings.js

@@ -0,0 +1,102 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { managedServiceStatus, restartManagedService, startManagedService, stopManagedService, } from "../lifecycle/service-process.js";
+import { workspacePaths } from "../paths.js";
+function managedServiceAdapter(workspaceRoot, module, serviceProcess, probeAdapter) {
+    const paths = workspacePaths(workspaceRoot);
+    return {
+        ...probeAdapter,
+        status: () => managedServiceStatus(paths, module),
+        start: () => startManagedService(paths, module, serviceProcess),
+        stop: () => stopManagedService(paths, module),
+        restart: () => restartManagedService(paths, module, serviceProcess),
+        uninstall: () => stopManagedService(paths, module),
+    };
+}
+export async function importRawAdapter(packageName, source) {
+    if (source.type === "workspace") {
+        if (source.path === undefined)
+            return {};
+        const url = pathToFileURL(join(source.path, "deployment", "adapter.ts"));
+        return (await /* architecture-allow-local-file-url-import */ import(__rewriteRelativeImportExtension(url.href)));
+    }
+    const resolved = import.meta.resolve(`${packageName}/deployment/adapter`);
+    const url = new URL(resolved);
+    return (await /* architecture-allow-local-file-url-import */ import(__rewriteRelativeImportExtension(url.href)));
+}
+/**
+ * The shipped Platform CLI production binding factory. For every discovered
+ * module it imports the module's own `deployment/adapter.ts` and, when that
+ * adapter exposes a `createProductionBinding` factory, invokes it with the
+ * module's materialized config to obtain a real bound adapter. A module without
+ * a production factory — or whose import/factory fails, or which has no
+ * materialized config the adapter accepts — is left out of the map, so the
+ * catalog falls back to the module's unbound default, which must fail-closed
+ * (ACTION_REQUIRED / NOT_READY). Platform CLI never invents a service or
+ * resource reality: it only relays the adapter's own current reality.
+ */
+export async function buildProductionBindings(options) {
+    const bindings = new Map();
+    for (const module of options.modules) {
+        try {
+            const namespace = await options.importAdapter(module.packageName, module.source);
+            const config = options.configByModuleRef.get(module.moduleRef) ?? {};
+            const serviceFactory = namespace.createServiceProcessBinding;
+            if (module.kind === "service" && typeof serviceFactory === "function") {
+                const processBinding = await serviceFactory({
+                    moduleRef: module.moduleRef,
+                    config,
+                    workspaceRoot: options.workspaceRoot,
+                    modules: options.modules,
+                    configByModuleRef: options.configByModuleRef,
+                });
+                if (processBinding !== undefined) {
+                    const defaultProbe = namespace
+                        .behaviorAdapter;
+                    const probeAdapter = processBinding.behaviorAdapter ??
+                        (typeof defaultProbe === "object" && defaultProbe !== null
+                            ? defaultProbe
+                            : {});
+                    bindings.set(module.packageName, {
+                        behaviorAdapter: managedServiceAdapter(options.workspaceRoot, module, processBinding.serviceProcess, probeAdapter),
+                    });
+                }
+                // A formal service package that exposes the process seam must never fall
+                // back to legacy in-memory production binding. Missing config remains
+                // unbound and therefore fails closed.
+                continue;
+            }
+            const factory = namespace
+                .createProductionBinding;
+            if (typeof factory !== "function")
+                continue;
+            const binding = await factory({
+                moduleRef: module.moduleRef,
+                config,
+                workspaceRoot: options.workspaceRoot,
+                modules: options.modules,
+                configByModuleRef: options.configByModuleRef,
+            });
+            if (binding !== undefined &&
+                typeof binding === "object" &&
+                binding !== null &&
+                typeof binding.behaviorAdapter === "object" &&
+                binding.behaviorAdapter !== null) {
+                bindings.set(module.packageName, binding);
+            }
+        }
+        catch {
+            // Import/factory failure for one module must not break the rest of the
+            // CLI; that module simply remains unbound and fails closed when used.
+        }
+    }
+    return bindings;
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+export type CliStatus = "SUCCEEDED" | "ACTION_REQUIRED" | "BLOCKED" | "FAILED";
+export interface CliOutcome {
+    command: string;
+    status: CliStatus;
+    data?: unknown;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export declare function runCli(argv: readonly string[]): Promise<string>;