@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/observability-command.js

@@ -1,3 +1,47 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.runObservabilityCommand=a;const s=require("../shared/agent-text"),o=require("../shared/errors"),c=require("../observability/config");function a(t,n){const e=n[0]??"status";if(e==="status"){const r=(0,c.observabilityStatus)(t);return(0,s.attachAgentText)(r,u(r))}if(e==="cleanup")return(0,s.attachAgentText)({ok:!0,command:"observability",action:"cleanup",dryRun:!0,enforced:!1,note:"Cleanup policy is visible but not enforced yet."},`observability cleanup dry-run
-no files deleted`);throw new o.CliError("UNKNOWN_OBSERVABILITY_COMMAND",`Unknown aib observability command: ${e}`,{availableCommands:["status","cleanup"]})}function u(t){const n=i(t.effective)?t.effective:{},e=i(t.storage)?t.storage:{},r=i(t.counters)?t.counters:{};return["observability",`metrics: ${String(n.metrics??"unknown")}`,`mutationImpactMetrics: ${String(n.mutationImpactMetrics??"unknown")}`,`trace: ${String(n.trace??"unknown")}`,`failureSnapshots: ${String(n.failureSnapshots??"unknown")}`,`metricsRows: ${String(r.metricsRows??0)}`,`traceBytes: ${String(r.traceBytes??0)}`,`feedbackRows: ${String(r.feedbackRows??0)}`,`metricsFile: ${String(e.metricsFile??"")}`,`traceDir: ${String(e.traceDir??"")}`,`feedbackFile: ${String(e.feedbackFile??"")}`].join(`
-`)}function i(t){return!!t&&typeof t=="object"&&!Array.isArray(t)}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runObservabilityCommand = runObservabilityCommand;
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const config_1 = require("../observability/config");
+function runObservabilityCommand(cwd, args) {
+    const subcommand = args[0] ?? "status";
+    if (subcommand === "status") {
+        const result = (0, config_1.observabilityStatus)(cwd);
+        return (0, agent_text_1.attachAgentText)(result, formatStatusText(result));
+    }
+    if (subcommand === "cleanup") {
+        return (0, agent_text_1.attachAgentText)({
+            ok: true,
+            command: "observability",
+            action: "cleanup",
+            dryRun: true,
+            enforced: false,
+            note: "Cleanup policy is visible but not enforced yet."
+        }, "observability cleanup dry-run\nno files deleted");
+    }
+    throw new errors_1.CliError("UNKNOWN_OBSERVABILITY_COMMAND", `Unknown aib observability command: ${subcommand}`, {
+        availableCommands: ["status", "cleanup"]
+    });
+}
+function formatStatusText(payload) {
+    const effective = isObject(payload.effective) ? payload.effective : {};
+    const storage = isObject(payload.storage) ? payload.storage : {};
+    const counters = isObject(payload.counters) ? payload.counters : {};
+    return [
+        "observability",
+        `metrics: ${String(effective.metrics ?? "unknown")}`,
+        `mutationImpactMetrics: ${String(effective.mutationImpactMetrics ?? "unknown")}`,
+        `trace: ${String(effective.trace ?? "unknown")}`,
+        `failureSnapshots: ${String(effective.failureSnapshots ?? "unknown")}`,
+        `metricsRows: ${String(counters.metricsRows ?? 0)}`,
+        `traceBytes: ${String(counters.traceBytes ?? 0)}`,
+        `feedbackRows: ${String(counters.feedbackRows ?? 0)}`,
+        `metricsFile: ${String(storage.metricsFile ?? "")}`,
+        `traceDir: ${String(storage.traceDir ?? "")}`,
+        `feedbackFile: ${String(storage.feedbackFile ?? "")}`
+    ].join("\n");
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/commands/ota-command.js

@@ -0,0 +1,403 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOtaCommand = runOtaCommand;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const daemon_state_1 = require("../session/daemon-state");
+const product_storage_1 = require("../workers/product-storage");
+const SUPPORTED_PRODUCT_STORAGE_SCHEMA = 1;
+const STATUS_LANES = ["cli-package", "worker-bundle", "worker-registry", "launcher-pack", "policy-config", "background-schedule"];
+async function runOtaCommand(args) {
+    const options = parseArgs(args);
+    if (options.action === "status") {
+        return status(options);
+    }
+    if (options.action === "stop") {
+        return stop(options);
+    }
+    if (options.action === "run-once") {
+        return activate(options);
+    }
+    if (options.action === "rollback") {
+        return rollback(options);
+    }
+    if (options.action === "cleanup") {
+        return cleanup(options);
+    }
+    if (options.action === "watch") {
+        return watch(options);
+    }
+    return { ok: false, command: "ota", error: `Unknown ota action: ${options.action}`, availableActions: ["status", "run-once", "watch", "stop", "rollback", "cleanup"] };
+}
+function status(options) {
+    const requested = options.lane ? [options.lane] : [...STATUS_LANES];
+    const lanes = {};
+    for (const lane of requested) {
+        lanes[lane] = summarizeLane(lane, options);
+    }
+    return {
+        ok: true,
+        command: "ota",
+        action: "status",
+        lanes,
+        daemon: summarizeDaemon(options),
+        watch: summarizeWatch(readJson(options.watchPath), options)
+    };
+}
+function summarizeLane(lane, options) {
+    if (lane === "cli-package") {
+        const value = readStatus(options);
+        const blocker = activationBlocker(value, options);
+        const summary = {
+            lane,
+            status: value?.activating ? "activating" : blocker ? "pending-blocked" : value?.pending ? "pending-ready" : value?.active ? "active" : value?.lastError ? "error" : "inactive",
+            ...(value?.active?.packageVersion ? { activeVersion: value.active.packageVersion } : {}),
+            ...(value?.pending?.packageVersion ? { pendingVersion: value.pending.packageVersion } : {}),
+            ...(value?.activating?.packageVersion ? { activatingVersion: value.activating.packageVersion } : {}),
+            ...(value?.previous?.packageVersion ? { previousVersion: value.previous.packageVersion } : {}),
+            ...(blocker ? { blocker } : {})
+        };
+        return options.verbose ? { ...summary, statusPath: options.statusPath, activePointerPath: options.pointerPath, value: value ?? null } : summary;
+    }
+    const mapping = {
+        "worker-registry": node_path_1.default.join(options.root, "workers", "activation-status.json"),
+        "launcher-pack": node_path_1.default.join(options.root, "launchers", "activation-status.json"),
+        "policy-config": node_path_1.default.join(options.root, "control-plane", "policy-config.json"),
+        "background-schedule": node_path_1.default.join(options.root, "background", "schedule-config.json")
+    };
+    if (lane === "worker-bundle") {
+        const bundlesRoot = node_path_1.default.join(options.root, "workers", "bundles");
+        const workers = node_fs_1.default.existsSync(bundlesRoot)
+            ? node_fs_1.default.readdirSync(bundlesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort()
+            : [];
+        return { lane, status: workers.length > 0 ? "configured" : "inactive", workerCount: workers.length, ...(options.verbose ? { workers } : {}) };
+    }
+    const statusPath = mapping[lane];
+    if (!statusPath) {
+        return { lane, status: "unknown", error: `Unknown OTA lane: ${lane}`, availableLanes: [...STATUS_LANES] };
+    }
+    const value = readJson(statusPath);
+    return {
+        lane,
+        status: value ? "configured" : "inactive",
+        ...(typeof value?.configVersion === "string" ? { version: value.configVersion } : {}),
+        ...(typeof value?.enabled === "boolean" ? { enabled: value.enabled } : {}),
+        ...(Array.isArray(value?.routes) ? { routeCount: value.routes.length } : {}),
+        ...(options.verbose ? { statusPath, value: (value ?? null) } : {})
+    };
+}
+function activate(options) {
+    return withLock(options, () => {
+        const current = readStatus(options);
+        const blocker = activationBlocker(current, options);
+        if (blocker) {
+            return { ok: true, command: "ota", action: "run-once", blocked: true, reason: blocker, lane: "cli-package", statusPath: options.statusPath };
+        }
+        const pending = current?.pending;
+        if (!current || !pending) {
+            return { ok: true, command: "ota", action: "run-once", skipped: true, reason: "no pending OTA activation" };
+        }
+        const updatedAt = new Date().toISOString();
+        const active = { ...pending, activatedAt: updatedAt };
+        delete active.stagedAt;
+        delete active.activatingAt;
+        delete active.reason;
+        const previous = current.active ? { ...current.active, savedAt: updatedAt } : undefined;
+        const { pending: _pending, activating: _activating, lastError: _lastError, ...retained } = current;
+        const next = {
+            ...retained,
+            updatedAt,
+            activeRoot: active.packageRoot,
+            activeCliPath: active.cliPath,
+            active,
+            ...(previous ? { previous } : {})
+        };
+        writeStatus(options, next);
+        writeJson(options.pointerPath, {
+            schemaVersion: 1,
+            updatedAt,
+            packageVersion: active.packageVersion,
+            artifactVersion: active.artifactVersion,
+            activeRoot: active.packageRoot,
+            activeCliPath: active.cliPath,
+            entry: active.entry
+        });
+        return { ok: true, command: "ota", action: "run-once", activated: true, lanes: ["cli-package"], ...(active.activationGroup?.id ? { activationGroupId: active.activationGroup.id } : {}) };
+    });
+}
+function rollback(options) {
+    return withLock(options, () => {
+        const current = readStatus(options);
+        if (!current?.previous) {
+            return { ok: true, command: "ota", action: "rollback", skipped: true, reason: "no previous OTA state" };
+        }
+        const updatedAt = new Date().toISOString();
+        const active = { ...current.previous, activatedAt: updatedAt };
+        const previous = current.active ? { ...current.active, savedAt: updatedAt } : undefined;
+        const next = { ...current, updatedAt, activeRoot: active.packageRoot, activeCliPath: active.cliPath, active, ...(previous ? { previous } : {}) };
+        writeStatus(options, next);
+        writeJson(options.pointerPath, { schemaVersion: 1, updatedAt, packageVersion: active.packageVersion, artifactVersion: active.artifactVersion, activeRoot: active.packageRoot, activeCliPath: active.cliPath, entry: active.entry });
+        return { ok: true, command: "ota", action: "rollback", rolledBack: true, lanes: ["cli-package"], ...(active.activationGroup?.id ? { activationGroupId: active.activationGroup.id } : {}) };
+    });
+}
+function cleanup(options) {
+    if (policyKillSwitches(options).includes("ota-cleanup")) {
+        return { ok: true, command: "ota", action: "cleanup", skipped: true, reason: "OTA cleanup is disabled by policy kill-switch ota-cleanup" };
+    }
+    const current = readStatus(options);
+    const protectedRoots = new Set([current?.active?.packageRoot, current?.previous?.packageRoot, current?.pending?.packageRoot].filter((value) => typeof value === "string").map((value) => node_path_1.default.resolve(value)));
+    const candidates = [];
+    const versionsRoot = node_path_1.default.join(options.root, "cli-package", "versions");
+    if (node_fs_1.default.existsSync(versionsRoot)) {
+        const versions = node_fs_1.default.readdirSync(versionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => {
+            const value = node_path_1.default.join(versionsRoot, entry.name);
+            return { value, mtimeMs: node_fs_1.default.statSync(value).mtimeMs };
+        }).filter((entry) => !protectedRoots.has(node_path_1.default.resolve(entry.value))).sort((left, right) => right.mtimeMs - left.mtimeMs);
+        candidates.push(...versions.slice(options.keepRecent).map((entry) => entry.value));
+    }
+    const packageRoot = node_path_1.default.join(options.root, "cli-package");
+    if (node_fs_1.default.existsSync(packageRoot)) {
+        const now = Date.now();
+        candidates.push(...node_fs_1.default.readdirSync(packageRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && entry.name.startsWith(".package-staging-"))
+            .map((entry) => node_path_1.default.join(packageRoot, entry.name))
+            .filter((entry) => now - node_fs_1.default.statSync(entry).mtimeMs >= options.stagingMaxAgeMs));
+    }
+    const failures = [];
+    let removed = 0;
+    if (!options.dryRun) {
+        for (const candidate of candidates) {
+            try {
+                node_fs_1.default.rmSync(candidate, { recursive: true, force: true });
+                removed += 1;
+            }
+            catch (error) {
+                failures.push({ path: candidate, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+    }
+    return { ok: failures.length === 0, command: "ota", action: "cleanup", dryRun: options.dryRun, candidates: candidates.length, removed, failed: failures.length, byLane: { "cli-package": candidates.length }, ...(failures.length ? { failures } : {}) };
+}
+async function watch(options) {
+    if (policyKillSwitches(options).some((item) => item === "ota-watch" || item === "ota-activation")) {
+        return { ok: true, command: "ota", action: "watch", skipped: true, blocked: true, reason: "OTA watch is disabled by policy" };
+    }
+    const existing = readJson(options.watchPath);
+    if (existing?.status === "running" && processIsAlive(existing.pid)) {
+        return { ok: true, command: "ota", action: "watch", skipped: true, reason: "ota watch is already running", pid: existing.pid };
+    }
+    node_fs_1.default.rmSync(options.stopPath, { force: true });
+    const startedAt = Date.now();
+    for (let attempts = 1; attempts <= options.maxAttempts && Date.now() - startedAt <= options.timeoutMs; attempts += 1) {
+        writeWatch(options, { schemaVersion: 1, updatedAt: new Date().toISOString(), status: "running", pid: process.pid, startedAt: new Date(startedAt).toISOString(), attempts });
+        if (node_fs_1.default.existsSync(options.stopPath)) {
+            return finishWatch(options, "stopped", attempts, { ok: true, command: "ota", action: "watch", stopped: true, attempts });
+        }
+        const result = activate(options);
+        if (result.activated === true || result.skipped === true) {
+            return finishWatch(options, result.activated === true ? "activated" : "skipped", attempts, result);
+        }
+        await new Promise((resolve) => setTimeout(resolve, options.intervalMs));
+    }
+    return finishWatch(options, "timeout", options.maxAttempts, { ok: false, command: "ota", action: "watch", status: "timeout" });
+}
+function stop(options) {
+    const current = readJson(options.watchPath);
+    const running = current?.status === "running" && processIsAlive(current.pid);
+    writeJson(options.stopPath, { schemaVersion: 1, requestedAt: new Date().toISOString(), pid: process.pid, targetPid: running ? current.pid : null });
+    return { ok: true, command: "ota", action: "stop", stopped: running, skipped: !running, reason: running ? "stop requested" : "no running ota watch" };
+}
+function finishWatch(options, state, attempts, result) {
+    const previous = readJson(options.watchPath);
+    writeWatch(options, { schemaVersion: 1, updatedAt: new Date().toISOString(), status: state, pid: process.pid, startedAt: previous?.startedAt ?? new Date().toISOString(), finishedAt: new Date().toISOString(), attempts });
+    return { ok: result.ok !== false && state !== "timeout", command: "ota", action: "watch", status: state, attempts, result };
+}
+function activationBlocker(statusValue, options) {
+    const pending = statusValue?.pending;
+    if (!pending) {
+        return null;
+    }
+    const killSwitches = policyKillSwitches(options);
+    if (killSwitches.includes("ota-activation") || killSwitches.includes("cli-package-activation")) {
+        return "cli-package activation is disabled by policy";
+    }
+    if (pending.reason) {
+        return pending.reason;
+    }
+    if (pending.productStorageSchema !== undefined && pending.productStorageSchema > SUPPORTED_PRODUCT_STORAGE_SCHEMA) {
+        return `cli-package requires unsupported product storage schema ${pending.productStorageSchema}`;
+    }
+    if (pending.nonReversibleMigration === true) {
+        return "cli-package requires a non-reversible storage migration";
+    }
+    if (!node_fs_1.default.existsSync(pending.packageRoot) || !node_fs_1.default.existsSync(pending.cliPath)) {
+        return "pending cli-package files are missing";
+    }
+    const active = statusValue?.active;
+    if (active && pending.activationGroup?.allowDowngrade !== true) {
+        const pendingSequence = pending.activationGroup?.sequence;
+        const activeSequence = active.activationGroup?.sequence;
+        if (pendingSequence !== undefined && activeSequence !== undefined && pendingSequence <= activeSequence) {
+            return `cli-package activation sequence ${pendingSequence} is not newer than active sequence ${activeSequence}`;
+        }
+        if (pendingSequence === undefined && activeSequence === undefined && compareVersions(pending.packageVersion, active.packageVersion) <= 0) {
+            return `cli-package version ${pending.packageVersion} is not newer than active version ${active.packageVersion}`;
+        }
+    }
+    const daemon = (0, daemon_state_1.readCliDaemonIdentity)(options.root);
+    if (daemon && processIsAlive(daemon.pid) && (daemon.runningExecutions.length > 0 || daemon.activeInvokeCount > 0)) {
+        return daemon.runningExecutions.length > 0
+            ? `daemon has running executions: ${daemon.runningExecutions.slice(0, 3).map((item) => item.executionId).join(", ")}`
+            : `daemon has ${daemon.activeInvokeCount} active invoke${daemon.activeInvokeCount === 1 ? "" : "s"}`;
+    }
+    return null;
+}
+function summarizeDaemon(options) {
+    const daemon = (0, daemon_state_1.readCliDaemonIdentity)(options.root);
+    if (!daemon) {
+        return options.verbose ? { status: "unknown", identityPath: (0, daemon_state_1.cliDaemonIdentityPath)(options.root) } : { status: "unknown" };
+    }
+    const alive = processIsAlive(daemon.pid);
+    const busy = daemon.activeInvokeCount > 0 || daemon.runningExecutions.length > 0;
+    return { status: !alive ? "dead" : busy ? "busy" : "idle", pid: daemon.pid, activeInvokeCount: daemon.activeInvokeCount, runningExecutionCount: daemon.runningExecutions.length, updatedAt: daemon.updatedAt, ...(options.verbose ? { identityPath: (0, daemon_state_1.cliDaemonIdentityPath)(options.root), cliPath: daemon.cliPath } : {}) };
+}
+function summarizeWatch(value, options) {
+    if (!value) {
+        return options.verbose ? { status: "inactive", watchPath: options.watchPath } : { status: "inactive" };
+    }
+    const state = value.status === "running" && !processIsAlive(value.pid) ? "stale" : value.status;
+    return { status: state, attempts: value.attempts, ...(state === "running" ? { pid: value.pid } : {}), ...(options.verbose ? { watchPath: options.watchPath, updatedAt: value.updatedAt } : {}) };
+}
+function withLock(options, fn) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(options.lockPath), { recursive: true });
+    try {
+        node_fs_1.default.mkdirSync(options.lockPath);
+    }
+    catch (error) {
+        if (!isFileExists(error)) {
+            throw error;
+        }
+        return { ok: true, command: "ota", action: options.action, blocked: true, reason: "ota activation already locked", lockPath: options.lockPath };
+    }
+    try {
+        return fn();
+    }
+    finally {
+        node_fs_1.default.rmSync(options.lockPath, { recursive: true, force: true });
+    }
+}
+function readStatus(options) {
+    return readJson(options.statusPath);
+}
+function writeStatus(options, value) {
+    writeJson(options.statusPath, { ...value, schemaVersion: 1, statusPath: options.statusPath, activePointerPath: options.pointerPath });
+}
+function writeWatch(options, value) {
+    writeJson(options.watchPath, value);
+}
+function policyKillSwitches(options) {
+    const value = readJson(node_path_1.default.join(options.root, "control-plane", "policy-config.json"));
+    return Array.isArray(value?.killSwitches) ? value.killSwitches.filter((item) => typeof item === "string") : [];
+}
+function readJson(filePath) {
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJson(filePath, value) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+    const temp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    node_fs_1.default.writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    node_fs_1.default.renameSync(temp, filePath);
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function compareVersions(left, right) {
+    const a = left.split(/[.-]/u).map((part) => Number.parseInt(part, 10));
+    const b = right.split(/[.-]/u).map((part) => Number.parseInt(part, 10));
+    for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+        const difference = (Number.isFinite(a[index]) ? a[index] : 0) - (Number.isFinite(b[index]) ? b[index] : 0);
+        if (difference !== 0) {
+            return difference;
+        }
+    }
+    return left.localeCompare(right);
+}
+function isFileExists(error) {
+    return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+function parseArgs(args) {
+    const root = (0, product_storage_1.productStorageRoot)();
+    const otaRoot = node_path_1.default.join(root, "ota");
+    const action = args[0] === "watch" && args[1] === "stop" ? "stop" : args[0] ?? "status";
+    const options = {
+        action,
+        lane: null,
+        verbose: false,
+        dryRun: true,
+        keepRecent: 2,
+        stagingMaxAgeMs: 24 * 60 * 60 * 1000,
+        intervalMs: 1000,
+        timeoutMs: 60_000,
+        maxAttempts: 60,
+        root,
+        statusPath: node_path_1.default.join(root, "cli-package", "activation-status.json"),
+        pointerPath: node_path_1.default.join(root, "cli-package", "active-pointer.json"),
+        watchPath: node_path_1.default.join(otaRoot, "watch-status.json"),
+        stopPath: node_path_1.default.join(otaRoot, "watch-stop.json"),
+        lockPath: node_path_1.default.join(otaRoot, "activation.lock")
+    };
+    const start = args[0] === "watch" && args[1] === "stop" ? 2 : 1;
+    for (let index = start; index < args.length; index += 1) {
+        const current = args[index];
+        const next = args[index + 1];
+        if (current === "--verbose" || current === "-v")
+            options.verbose = true;
+        else if (current === "--apply")
+            options.dryRun = false;
+        else if (current === "--dry-run")
+            options.dryRun = true;
+        else if (current === "--keep-recent" && next) {
+            options.keepRecent = boundedInt(next, options.keepRecent, 0, 1000);
+            index += 1;
+        }
+        else if (current === "--staging-max-age-ms" && next) {
+            options.stagingMaxAgeMs = boundedInt(next, options.stagingMaxAgeMs, 0, 30 * 24 * 60 * 60 * 1000);
+            index += 1;
+        }
+        else if (current === "--interval-ms" && next) {
+            options.intervalMs = boundedInt(next, options.intervalMs, 50, 60_000);
+            index += 1;
+        }
+        else if (current === "--timeout-ms" && next) {
+            options.timeoutMs = boundedInt(next, options.timeoutMs, 1, 24 * 60 * 60 * 1000);
+            index += 1;
+        }
+        else if (current === "--max-attempts" && next) {
+            options.maxAttempts = boundedInt(next, options.maxAttempts, 1, 100_000);
+            index += 1;
+        }
+        else if (action === "status" && current && !current.startsWith("-") && !options.lane)
+            options.lane = current;
+        else
+            throw new Error(`Unknown ota argument: ${current}`);
+    }
+    return options;
+}
+function boundedInt(value, fallback, min, max) {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? Math.max(min, Math.min(max, parsed)) : fallback;
+}

package/dist/commands/print-config.js

@@ -1 +1,10 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.runPrintConfig=a;const n=require("./shared"),o=require("../shared/protocol");async function a(r,t={}){const e=await(0,n.resolveCompatibleTargetInstance)(r,o.CLI_COMMAND_IDS.printConfig,t),c=await(0,n.fetchEffectiveConfig)(e.entry,t);return{ok:!0,selectedInstance:{instanceId:e.entry.instanceId,reason:e.reason,matchedWorkspace:e.matchedWorkspace,port:e.entry.port},config:c}}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrintConfig = runPrintConfig;
+const resolve_1 = require("../config/resolve");
+async function runPrintConfig(_cwd, _options = {}) {
+    return {
+        ok: true,
+        config: (0, resolve_1.resolveCliConfig)(null)
+    };
+}