@ory/argus 0.1.0

package/dist/local/health.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Health-checking utilities for the local Ory development environment.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAllServices = checkAllServices;
+exports.waitForGateway = waitForGateway;
+const configs_js_1 = require("./configs.js");
+async function checkEndpoint(name, url) {
+    try {
+        const res = await fetch(url, { signal: AbortSignal.timeout(3000) });
+        if (res.ok) {
+            return { name, url, healthy: true };
+        }
+        return { name, url, healthy: false, error: `HTTP ${res.status}` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { name, url, healthy: false, error: msg };
+    }
+}
+/**
+ * Check the health of all local Ory services.
+ *
+ * `gatewayUrl` overrides the gateway probe URL (used by the manager after
+ * a runtime gateway-mode fallback, where re-resolving via env var would
+ * give a stale path). When omitted, falls back to env-var resolution
+ * anchored at `projectRoot`.
+ */
+async function checkAllServices(options = {}) {
+    const gateway = options.gatewayUrl ?? (0, configs_js_1.gatewayHealthUrl)();
+    const checks = [
+        checkEndpoint("Gateway", gateway),
+        checkEndpoint("Kratos", `http://localhost:${configs_js_1.KRATOS_PUBLIC_PORT}/health/ready`),
+        checkEndpoint("Keto", `http://localhost:${configs_js_1.KETO_READ_PORT}/health/ready`),
+        checkEndpoint("Hydra", `http://localhost:${configs_js_1.HYDRA_PUBLIC_PORT}/health/ready`),
+        checkEndpoint("Jaeger", `http://localhost:${configs_js_1.JAEGER_UI_PORT}/`),
+    ];
+    return Promise.all(checks);
+}
+/**
+ * Wait for the gateway to become healthy, polling at the given interval.
+ * Returns true if healthy within the timeout, false otherwise.
+ *
+ * `gatewayUrl` overrides the probe URL (see `checkAllServices`). Otherwise
+ * the URL is computed from env-var resolution anchored at `projectRoot`.
+ */
+async function waitForGateway(timeoutMs = 120_000, intervalMs = 2000, options = {}) {
+    const deadline = Date.now() + timeoutMs;
+    const url = options.gatewayUrl ?? (0, configs_js_1.gatewayHealthUrl)();
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(url, {
+                signal: AbortSignal.timeout(2000),
+            });
+            if (res.ok)
+                return true;
+        }
+        catch {
+            // Not ready yet
+        }
+        await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    return false;
+}

package/dist/local/index.d.ts

@@ -0,0 +1,6 @@
+export { runLocalCommand } from "./cli.js";
+export { localUp, localDown, localStatus, localSeed, localLogs, localReset, localEnv, localConfigure, ensureLocalOryStack, type EnsureLocalOryStackResult, } from "./manager.js";
+export { checkAllServices, waitForGateway, type ServiceHealth } from "./health.js";
+export { seedLocalEnvironment, type SeedResult } from "./seed.js";
+export { GATEWAY_URL, GATEWAY_PORT, KRATOS_PUBLIC_PORT, KRATOS_ADMIN_PORT, KETO_READ_PORT, KETO_WRITE_PORT, HYDRA_PUBLIC_PORT, HYDRA_ADMIN_PORT, JAEGER_UI_PORT, JAEGER_OTLP_HTTP_PORT, JAEGER_UI_URL, JAEGER_OTLP_HTTP_URL, } from "./configs.js";
+export { ensureDevJaeger, stopDevJaeger, DEV_JAEGER_CONTAINER, DEV_JAEGER_IMAGE, type EnsureDevJaegerResult, type StopDevJaegerResult, } from "./jaeger.js";

package/dist/local/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_JAEGER_IMAGE = exports.DEV_JAEGER_CONTAINER = exports.stopDevJaeger = exports.ensureDevJaeger = exports.JAEGER_OTLP_HTTP_URL = exports.JAEGER_UI_URL = exports.JAEGER_OTLP_HTTP_PORT = exports.JAEGER_UI_PORT = exports.HYDRA_ADMIN_PORT = exports.HYDRA_PUBLIC_PORT = exports.KETO_WRITE_PORT = exports.KETO_READ_PORT = exports.KRATOS_ADMIN_PORT = exports.KRATOS_PUBLIC_PORT = exports.GATEWAY_PORT = exports.GATEWAY_URL = exports.seedLocalEnvironment = exports.waitForGateway = exports.checkAllServices = exports.ensureLocalOryStack = exports.localConfigure = exports.localEnv = exports.localReset = exports.localLogs = exports.localSeed = exports.localStatus = exports.localDown = exports.localUp = exports.runLocalCommand = void 0;
+var cli_js_1 = require("./cli.js");
+Object.defineProperty(exports, "runLocalCommand", { enumerable: true, get: function () { return cli_js_1.runLocalCommand; } });
+var manager_js_1 = require("./manager.js");
+Object.defineProperty(exports, "localUp", { enumerable: true, get: function () { return manager_js_1.localUp; } });
+Object.defineProperty(exports, "localDown", { enumerable: true, get: function () { return manager_js_1.localDown; } });
+Object.defineProperty(exports, "localStatus", { enumerable: true, get: function () { return manager_js_1.localStatus; } });
+Object.defineProperty(exports, "localSeed", { enumerable: true, get: function () { return manager_js_1.localSeed; } });
+Object.defineProperty(exports, "localLogs", { enumerable: true, get: function () { return manager_js_1.localLogs; } });
+Object.defineProperty(exports, "localReset", { enumerable: true, get: function () { return manager_js_1.localReset; } });
+Object.defineProperty(exports, "localEnv", { enumerable: true, get: function () { return manager_js_1.localEnv; } });
+Object.defineProperty(exports, "localConfigure", { enumerable: true, get: function () { return manager_js_1.localConfigure; } });
+Object.defineProperty(exports, "ensureLocalOryStack", { enumerable: true, get: function () { return manager_js_1.ensureLocalOryStack; } });
+var health_js_1 = require("./health.js");
+Object.defineProperty(exports, "checkAllServices", { enumerable: true, get: function () { return health_js_1.checkAllServices; } });
+Object.defineProperty(exports, "waitForGateway", { enumerable: true, get: function () { return health_js_1.waitForGateway; } });
+var seed_js_1 = require("./seed.js");
+Object.defineProperty(exports, "seedLocalEnvironment", { enumerable: true, get: function () { return seed_js_1.seedLocalEnvironment; } });
+var configs_js_1 = require("./configs.js");
+Object.defineProperty(exports, "GATEWAY_URL", { enumerable: true, get: function () { return configs_js_1.GATEWAY_URL; } });
+Object.defineProperty(exports, "GATEWAY_PORT", { enumerable: true, get: function () { return configs_js_1.GATEWAY_PORT; } });
+Object.defineProperty(exports, "KRATOS_PUBLIC_PORT", { enumerable: true, get: function () { return configs_js_1.KRATOS_PUBLIC_PORT; } });
+Object.defineProperty(exports, "KRATOS_ADMIN_PORT", { enumerable: true, get: function () { return configs_js_1.KRATOS_ADMIN_PORT; } });
+Object.defineProperty(exports, "KETO_READ_PORT", { enumerable: true, get: function () { return configs_js_1.KETO_READ_PORT; } });
+Object.defineProperty(exports, "KETO_WRITE_PORT", { enumerable: true, get: function () { return configs_js_1.KETO_WRITE_PORT; } });
+Object.defineProperty(exports, "HYDRA_PUBLIC_PORT", { enumerable: true, get: function () { return configs_js_1.HYDRA_PUBLIC_PORT; } });
+Object.defineProperty(exports, "HYDRA_ADMIN_PORT", { enumerable: true, get: function () { return configs_js_1.HYDRA_ADMIN_PORT; } });
+Object.defineProperty(exports, "JAEGER_UI_PORT", { enumerable: true, get: function () { return configs_js_1.JAEGER_UI_PORT; } });
+Object.defineProperty(exports, "JAEGER_OTLP_HTTP_PORT", { enumerable: true, get: function () { return configs_js_1.JAEGER_OTLP_HTTP_PORT; } });
+Object.defineProperty(exports, "JAEGER_UI_URL", { enumerable: true, get: function () { return configs_js_1.JAEGER_UI_URL; } });
+Object.defineProperty(exports, "JAEGER_OTLP_HTTP_URL", { enumerable: true, get: function () { return configs_js_1.JAEGER_OTLP_HTTP_URL; } });
+var jaeger_js_1 = require("./jaeger.js");
+Object.defineProperty(exports, "ensureDevJaeger", { enumerable: true, get: function () { return jaeger_js_1.ensureDevJaeger; } });
+Object.defineProperty(exports, "stopDevJaeger", { enumerable: true, get: function () { return jaeger_js_1.stopDevJaeger; } });
+Object.defineProperty(exports, "DEV_JAEGER_CONTAINER", { enumerable: true, get: function () { return jaeger_js_1.DEV_JAEGER_CONTAINER; } });
+Object.defineProperty(exports, "DEV_JAEGER_IMAGE", { enumerable: true, get: function () { return jaeger_js_1.DEV_JAEGER_IMAGE; } });

package/dist/local/jaeger-main.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Standalone entry point for managing the dev-launcher Jaeger container.
+ *
+ * Used by root package.json scripts:
+ *   pnpm jaeger:up   → node packages/core/dist/local/jaeger-main.js up
+ *   pnpm jaeger:down → node packages/core/dist/local/jaeger-main.js down
+ *
+ * The container started here (`ory-jaeger-dev`) is independent of the
+ * Compose-managed Jaeger that ships with `pnpm local:up` (`ory-jaeger`),
+ * so they cannot collide.
+ */
+export {};

package/dist/local/jaeger-main.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Standalone entry point for managing the dev-launcher Jaeger container.
+ *
+ * Used by root package.json scripts:
+ *   pnpm jaeger:up   → node packages/core/dist/local/jaeger-main.js up
+ *   pnpm jaeger:down → node packages/core/dist/local/jaeger-main.js down
+ *
+ * The container started here (`ory-jaeger-dev`) is independent of the
+ * Compose-managed Jaeger that ships with `pnpm local:up` (`ory-jaeger`),
+ * so they cannot collide.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const jaeger_js_1 = require("./jaeger.js");
+async function main() {
+    const subcommand = process.argv[2];
+    switch (subcommand) {
+        case "up": {
+            const result = await (0, jaeger_js_1.ensureDevJaeger)();
+            switch (result.status) {
+                case "already-running":
+                    console.log(`Jaeger is already reachable at ${result.endpoint} (UI: ${result.uiUrl}).`);
+                    break;
+                case "started":
+                    console.log(`Jaeger started in Docker. OTLP endpoint: ${result.endpoint}, UI: ${result.uiUrl}.`);
+                    console.log("Use 'pnpm jaeger:down' to stop it.");
+                    break;
+                case "skipped:no-docker":
+                    console.error(`Could not start Jaeger: ${result.detail}`);
+                    process.exit(1);
+                case "skipped:probe-failed":
+                    console.error(`Jaeger did not become healthy: ${result.detail}`);
+                    process.exit(1);
+                case "error":
+                    console.error(`Jaeger failed to start: ${result.detail}`);
+                    process.exit(1);
+            }
+            break;
+        }
+        case "down": {
+            const result = (0, jaeger_js_1.stopDevJaeger)();
+            switch (result.status) {
+                case "stopped":
+                    console.log("Stopped the dev Jaeger container.");
+                    break;
+                case "not-running":
+                    console.log("No dev Jaeger container is running.");
+                    break;
+                case "skipped:no-docker":
+                    console.error(`Cannot stop Jaeger: ${result.detail}`);
+                    process.exit(1);
+                case "error":
+                    console.error(`Failed to stop Jaeger: ${result.detail}`);
+                    process.exit(1);
+            }
+            break;
+        }
+        case "help":
+        case "--help":
+        case "-h":
+        case undefined:
+            console.log(`
+ory-jaeger — Manage the standalone Jaeger container used by dev launchers
+
+Usage:
+  pnpm jaeger:up      Start a local Jaeger all-in-one container (UI on :16686, OTLP HTTP on :4318)
+  pnpm jaeger:down    Stop and remove the dev Jaeger container
+
+Dev launchers (pnpm dev:<harness>) call 'jaeger up' automatically when no
+OTEL_EXPORTER_OTLP_ENDPOINT is set in the parent shell. Run these manually
+if you want to inspect traces without launching a harness.
+
+Requires Docker.
+`);
+            break;
+        default:
+            console.error(`Unknown subcommand: ${subcommand}`);
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error(err.message ?? err);
+    process.exit(1);
+});

package/dist/local/jaeger.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Standalone Jaeger lifecycle for the dev launcher.
+ *
+ * Runs Jaeger all-in-one as a single Docker container (no Compose project)
+ * so `pnpm dev:<harness>` can ship traces to a local Jaeger UI without
+ * spinning up the rest of the local Ory stack.
+ *
+ * The container is named distinctly from the `local up` Jaeger container
+ * (`ory-jaeger`) so the two cannot collide. If `local up` is already running
+ * its Jaeger, the OTLP port is bound and `ensureDevJaeger` short-circuits via
+ * the reachability probe.
+ */
+export declare const DEV_JAEGER_CONTAINER = "jaeger";
+export declare const DEV_JAEGER_IMAGE = "jaegertracing/all-in-one:1";
+export interface EnsureDevJaegerResult {
+    /** OTLP HTTP endpoint to use, or undefined when Jaeger is unavailable. */
+    endpoint?: string;
+    /** UI URL when Jaeger is available. */
+    uiUrl?: string;
+    /** Human-readable status — "running", "started", "skipped:no-docker", "skipped:port-in-use", "error". */
+    status: "already-running" | "started" | "skipped:no-docker" | "skipped:probe-failed" | "error";
+    /** Detail / error message for logging. */
+    detail?: string;
+}
+export interface StopDevJaegerResult {
+    status: "stopped" | "not-running" | "skipped:no-docker" | "error";
+    detail?: string;
+}
+/**
+ * Ensure a local Jaeger is reachable on the OTLP HTTP port.
+ *
+ * Order of operations:
+ *   1. Probe `localhost:4318` — return `already-running` when something
+ *      already serves it (the `local up` Jaeger, a previous dev-launcher
+ *      Jaeger, or any other OTLP collector the user has running).
+ *   2. If Docker is unavailable, return `skipped:no-docker`.
+ *   3. If our standalone container exists but is stopped, remove it so the
+ *      `--rm` flag stays meaningful, then re-run.
+ *   4. `docker run` Jaeger all-in-one and wait for the OTLP port to come up.
+ */
+export declare function ensureDevJaeger(opts?: {
+    startupTimeoutMs?: number;
+}): Promise<EnsureDevJaegerResult>;
+/**
+ * Stop the standalone dev Jaeger container.
+ *
+ * Idempotent: returns `not-running` when nothing matching is up. Does not
+ * touch the `local up` Jaeger (different container name).
+ */
+export declare function stopDevJaeger(): StopDevJaegerResult;

package/dist/local/jaeger.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Standalone Jaeger lifecycle for the dev launcher.
+ *
+ * Runs Jaeger all-in-one as a single Docker container (no Compose project)
+ * so `pnpm dev:<harness>` can ship traces to a local Jaeger UI without
+ * spinning up the rest of the local Ory stack.
+ *
+ * The container is named distinctly from the `local up` Jaeger container
+ * (`ory-jaeger`) so the two cannot collide. If `local up` is already running
+ * its Jaeger, the OTLP port is bound and `ensureDevJaeger` short-circuits via
+ * the reachability probe.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_JAEGER_IMAGE = exports.DEV_JAEGER_CONTAINER = void 0;
+exports.ensureDevJaeger = ensureDevJaeger;
+exports.stopDevJaeger = stopDevJaeger;
+const node_child_process_1 = require("node:child_process");
+const configs_js_1 = require("./configs.js");
+exports.DEV_JAEGER_CONTAINER = "jaeger";
+exports.DEV_JAEGER_IMAGE = "jaegertracing/all-in-one:1";
+function dockerAvailable() {
+    const result = (0, node_child_process_1.spawnSync)("docker", ["info"], { stdio: "ignore" });
+    return result.status === 0;
+}
+async function isOtlpReachable(timeoutMs = 800) {
+    try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+        try {
+            const res = await fetch(`${configs_js_1.JAEGER_OTLP_HTTP_URL}/v1/traces`, {
+                method: "GET",
+                signal: ctrl.signal,
+            });
+            return res.status >= 200 && res.status < 600;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    catch {
+        return false;
+    }
+}
+function inspectContainer(name) {
+    const result = (0, node_child_process_1.spawnSync)("docker", ["inspect", "--format", "{{.State.Running}}", name], { stdio: ["ignore", "pipe", "ignore"] });
+    if (result.status !== 0) {
+        return { exists: false, running: false };
+    }
+    const out = (result.stdout?.toString() ?? "").trim();
+    return { exists: true, running: out === "true" };
+}
+function startContainer() {
+    // Use --rm so the container is wiped on stop — no stale state between runs.
+    const args = [
+        "run",
+        "-d",
+        "--rm",
+        "--name",
+        exports.DEV_JAEGER_CONTAINER,
+        "-p",
+        `${configs_js_1.JAEGER_UI_PORT}:${configs_js_1.JAEGER_UI_PORT}`,
+        "-p",
+        `${configs_js_1.JAEGER_OTLP_HTTP_PORT}:${configs_js_1.JAEGER_OTLP_HTTP_PORT}`,
+        "-e",
+        "COLLECTOR_OTLP_ENABLED=true",
+        "-e",
+        "LOG_LEVEL=warn",
+        exports.DEV_JAEGER_IMAGE,
+    ];
+    const result = (0, node_child_process_1.spawnSync)("docker", args, { stdio: ["ignore", "ignore", "pipe"] });
+    if (result.status === 0)
+        return { ok: true };
+    const stderr = (result.stderr?.toString() ?? "").trim();
+    return { ok: false, detail: stderr || `docker run exited ${result.status}` };
+}
+async function waitUntilReachable(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await isOtlpReachable(500))
+            return true;
+        await new Promise((r) => setTimeout(r, 250));
+    }
+    return false;
+}
+/**
+ * Ensure a local Jaeger is reachable on the OTLP HTTP port.
+ *
+ * Order of operations:
+ *   1. Probe `localhost:4318` — return `already-running` when something
+ *      already serves it (the `local up` Jaeger, a previous dev-launcher
+ *      Jaeger, or any other OTLP collector the user has running).
+ *   2. If Docker is unavailable, return `skipped:no-docker`.
+ *   3. If our standalone container exists but is stopped, remove it so the
+ *      `--rm` flag stays meaningful, then re-run.
+ *   4. `docker run` Jaeger all-in-one and wait for the OTLP port to come up.
+ */
+async function ensureDevJaeger(opts = {}) {
+    if (await isOtlpReachable()) {
+        return {
+            status: "already-running",
+            endpoint: configs_js_1.JAEGER_OTLP_HTTP_URL,
+            uiUrl: configs_js_1.JAEGER_UI_URL,
+        };
+    }
+    if (!dockerAvailable()) {
+        return {
+            status: "skipped:no-docker",
+            detail: "Docker is not running. Start Docker Desktop to auto-launch Jaeger.",
+        };
+    }
+    const state = inspectContainer(exports.DEV_JAEGER_CONTAINER);
+    if (state.exists && !state.running) {
+        // Stale --rm container could only exist if Docker died mid-run; clean it up.
+        (0, node_child_process_1.spawnSync)("docker", ["rm", "-f", exports.DEV_JAEGER_CONTAINER], { stdio: "ignore" });
+    }
+    const start = startContainer();
+    if (!start.ok) {
+        return { status: "error", detail: start.detail };
+    }
+    const ready = await waitUntilReachable(opts.startupTimeoutMs ?? 15_000);
+    if (!ready) {
+        return {
+            status: "skipped:probe-failed",
+            detail: "Jaeger container started but OTLP port did not respond in time.",
+        };
+    }
+    return {
+        status: "started",
+        endpoint: configs_js_1.JAEGER_OTLP_HTTP_URL,
+        uiUrl: configs_js_1.JAEGER_UI_URL,
+    };
+}
+/**
+ * Stop the standalone dev Jaeger container.
+ *
+ * Idempotent: returns `not-running` when nothing matching is up. Does not
+ * touch the `local up` Jaeger (different container name).
+ */
+function stopDevJaeger() {
+    if (!dockerAvailable()) {
+        return {
+            status: "skipped:no-docker",
+            detail: "Docker is not running.",
+        };
+    }
+    const state = inspectContainer(exports.DEV_JAEGER_CONTAINER);
+    if (!state.exists) {
+        return { status: "not-running" };
+    }
+    const result = (0, node_child_process_1.spawnSync)("docker", ["rm", "-f", exports.DEV_JAEGER_CONTAINER], {
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    if (result.status === 0) {
+        return { status: "stopped" };
+    }
+    const stderr = (result.stderr?.toString() ?? "").trim();
+    return {
+        status: "error",
+        detail: stderr || `docker rm exited ${result.status}`,
+    };
+}

package/dist/local/main.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Standalone entry point for `local` commands.
+ *
+ * Used by root package.json scripts: node packages/core/dist/local/main.js <subcommand>
+ */
+export {};

package/dist/local/main.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Standalone entry point for `local` commands.
+ *
+ * Used by root package.json scripts: node packages/core/dist/local/main.js <subcommand>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_js_1 = require("./cli.js");
+const args = process.argv.slice(2);
+(0, cli_js_1.runLocalCommand)("ory-local", args).catch((err) => {
+    console.error(err.message ?? err);
+    process.exit(1);
+});

package/dist/local/manager.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Local Ory environment manager.
+ *
+ * Manages the Docker Compose lifecycle for running Kratos, Keto, Hydra,
+ * and an API gateway locally. The gateway defaults to Ory Console Lite when
+ * its source tree is present at `<projectRoot>/../cloud/console/console`,
+ * and falls back to the bundled nginx routing layer otherwise.
+ * `ORY_CONSOLE_LITE_PATH` overrides the path explicitly.
+ *
+ * Runtime directory: .ory-dev/ory/ (relative to where the command is run,
+ * or the project root when invoked from a plugin CLI). Sibling of
+ * .ory-dev/registry/ owned by the local npm registry manager.
+ */
+export interface EnsureLocalOryStackResult {
+    status: "already-running" | "started" | "skipped:no-docker" | "compose-failed" | "gateway-unhealthy" | "console-misconfigured";
+    /** Local Ory gateway URL. Set when status is `already-running` or `started`. */
+    gatewayUrl?: string;
+    /** Filesystem path to the compose project (for log hints). */
+    localDir: string;
+    /** Human-readable detail / error message for logging. */
+    detail?: string;
+}
+/**
+ * Bring up the local Ory stack and wait for the gateway to be healthy.
+ *
+ * Idempotent and fail-graceful: returns a typed result instead of exiting.
+ * If the gateway is already healthy the function short-circuits without
+ * touching Docker. When `quiet` is set, progress is logged to stderr only
+ * (suitable for the dev launcher); otherwise it prints to stdout in the
+ * format `localUp` historically used.
+ */
+export declare function ensureLocalOryStack(opts?: {
+    quiet?: boolean;
+    localDir?: string;
+}): Promise<EnsureLocalOryStackResult>;
+export declare function localUp(opts?: {
+    seed?: boolean;
+}): Promise<void>;
+export declare function localDown(): Promise<void>;
+export declare function localStatus(): Promise<void>;
+export declare function localSeed(): Promise<void>;
+export declare function localLogs(args: string[]): void;
+export declare function localReset(): Promise<void>;
+export declare function localEnv(): void;
+export declare function localConfigure(): void;