@ramarivera/chofi 0.1.0

package/dist/runtime.js

@@ -0,0 +1,650 @@
+import { defaultSpawner } from "./spawn.js";
+import { AppleDriver } from "./drivers/apple.js";
+import { MaestroDriver } from "./drivers/maestro.js";
+import { ExpoDriver } from "./drivers/expo.js";
+import { IdbDriver } from "./drivers/idb.js";
+import { SimulatorStateError, AppNotInstalledError, AppNotRunningError, BuildFailedError, TestsFailedError, ToolOutputError, classifyError } from "./errors.js";
+export class RuntimeController {
+    apple;
+    maestro;
+    expo;
+    idb;
+    spawner;
+    constructor(options = {}) {
+        this.spawner = options.spawner ?? defaultSpawner;
+        this.apple = new AppleDriver(this.spawner);
+        this.maestro = new MaestroDriver(this.spawner);
+        this.expo = new ExpoDriver(this.spawner);
+        this.idb = new IdbDriver(this.spawner);
+    }
+    // === Simulator ===
+    async simList() {
+        return this.apple.listSimulators();
+    }
+    async simBoot(target) {
+        const device = await this.apple.getSimulatorState(target);
+        if (device?.state === "Booted") {
+            return; // Already booted, no-op
+        }
+        const result = await this.apple.bootSimulator(target);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to boot ${target}`);
+        }
+    }
+    async simShutdown(target) {
+        const device = await this.apple.getSimulatorState(target);
+        if (device?.state === "Shutdown") {
+            return; // Already shutdown, no-op
+        }
+        const result = await this.apple.shutdownSimulator(target);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to shutdown ${target}`);
+        }
+    }
+    async simOpen(target) {
+        const result = await this.apple.openSimulator(target);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("open", result.stderr || `Failed to open ${target}`);
+        }
+    }
+    async simErase(target) {
+        const device = await this.apple.getSimulatorState(target);
+        if (device?.state === "Booted") {
+            await this.simShutdown(target);
+        }
+        const result = await this.apple.eraseSimulator(target);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to erase ${target}`);
+        }
+    }
+    async simScreenshot(target, outputPath) {
+        const device = await this.apple.getSimulatorState(target);
+        if (!device) {
+            throw new Error(`Simulator not found: ${target}`);
+        }
+        if (device.state !== "Booted") {
+            throw new SimulatorStateError(device.udid, "Booted", device.state);
+        }
+        const result = await this.apple.screenshot(device.udid, outputPath);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Screenshot failed for ${target}`);
+        }
+    }
+    async simCreate(name, deviceType, runtime) {
+        const result = await this.apple.createSimulator(name, deviceType, runtime);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to create simulator ${name}`);
+        }
+        return result.stdout.trim();
+    }
+    async simDelete(target) {
+        const result = await this.apple.deleteSimulator(target);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to delete ${target}`);
+        }
+    }
+    async simRuntimeList() {
+        return this.apple.listRuntimes();
+    }
+    async simDeviceTypeList() {
+        return this.apple.listDeviceTypes();
+    }
+    async simClone(source, name) {
+        const result = await this.apple.cloneSimulator(source, name);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to clone ${source}`);
+        }
+        return result.stdout.trim();
+    }
+    async simClearCache(target) {
+        const result = await this.apple.clearSimulatorCache(target);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to clear cache for ${target}`);
+        }
+    }
+    async simSetAppearance(target, appearance) {
+        const result = await this.apple.setAppearance(target, appearance);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to set appearance for ${target}`);
+        }
+    }
+    async simStartRecording(udid, outputPath) {
+        const result = await this.apple.startVideoRecording(udid, outputPath);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || "Failed to start recording");
+        }
+    }
+    async simStopRecording(udid) {
+        const result = await this.apple.stopVideoRecording(udid);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || "Failed to stop recording");
+        }
+    }
+    async simAddMedia(udid, mediaPaths) {
+        const result = await this.apple.addMedia(udid, mediaPaths);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || "Failed to add media");
+        }
+    }
+    async simRunningApps(udid) {
+        return this.apple.listRunningApps(udid);
+    }
+    // === Device ===
+    async deviceList(platform) {
+        const devices = await this.apple.listDevices();
+        if (platform) {
+            return devices.filter((d) => d.status.toLowerCase() === platform.toLowerCase());
+        }
+        return devices;
+    }
+    // === App Lifecycle ===
+    async appInstall(udid, appPath) {
+        const result = await this.apple.installApp(udid, appPath);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to install ${appPath}`);
+        }
+    }
+    async appLaunch(udid, bundleId) {
+        const installed = await this.apple.isAppInstalled(udid, bundleId);
+        if (!installed) {
+            throw new AppNotInstalledError(bundleId, udid);
+        }
+        const result = await this.apple.launchApp(udid, bundleId);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to launch ${bundleId}`);
+        }
+    }
+    async appTerminate(udid, bundleId, force = false) {
+        if (force) {
+            const result = await this.spawner.run("xcrun", ["simctl", "spawn", udid, "launchctl", "kill", "9", bundleId]);
+            if (result.exitCode !== 0) {
+                throw new ToolOutputError("simctl", result.stderr || `Failed to force-terminate ${bundleId}`);
+            }
+            return;
+        }
+        const apps = await this.apple.listRunningApps(udid);
+        const running = apps.some((a) => a.bundleId === bundleId);
+        if (!running) {
+            throw new AppNotRunningError(bundleId, udid);
+        }
+        const result = await this.apple.terminateApp(udid, bundleId);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to terminate ${bundleId}`);
+        }
+    }
+    async appTerminateAll(udid, force = false) {
+        const apps = await this.apple.listRunningApps(udid);
+        for (const app of apps) {
+            await this.appTerminate(udid, app.bundleId, force);
+        }
+    }
+    async appUninstall(udid, bundleId) {
+        const result = await this.apple.uninstallApp(udid, bundleId);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || `Failed to uninstall ${bundleId}`);
+        }
+    }
+    async appListRunning(udid) {
+        return this.apple.listRunningApps(udid);
+    }
+    async simPrune() {
+        const result = await this.apple.pruneUnavailableSimulators();
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("simctl", result.stderr || "Failed to prune simulators");
+        }
+    }
+    // === Logs ===
+    async streamLogs(udid, timeoutMs = 30_000) {
+        const result = await this.apple.streamLogs(udid, timeoutMs);
+        return result.stdout;
+    }
+    // === Build / Test / Clean ===
+    async build(cwd, scheme, options = {}) {
+        const args = buildArgs(scheme, options);
+        args.push("build");
+        const result = await this.apple.xcodebuild(args, cwd);
+        if (result.exitCode !== 0) {
+            throw new BuildFailedError(result.stderr);
+        }
+    }
+    async buildWithProgress(cwd, scheme, onPhase, options = {}) {
+        const args = buildArgs(scheme, options);
+        args.push("build");
+        const result = await this.apple.xcodebuildStream(args, (line) => {
+            const phase = parseBuildPhase(line);
+            if (phase) {
+                onPhase(phase);
+            }
+        }, cwd);
+        if (result.exitCode !== 0) {
+            throw new BuildFailedError("Build failed");
+        }
+    }
+    async test(cwd, scheme, options = {}) {
+        const args = buildArgs(scheme, options);
+        args.push("test");
+        if (options.only && options.only.length > 0) {
+            for (const test of options.only) {
+                args.push("-only-testing", test);
+            }
+        }
+        if (options.skip && options.skip.length > 0) {
+            for (const test of options.skip) {
+                args.push("-skip-testing", test);
+            }
+        }
+        if (options.retry) {
+            args.push("-retry-tests-on-failure");
+        }
+        const result = await this.apple.xcodebuild(args, cwd);
+        if (result.exitCode !== 0) {
+            throw new TestsFailedError(result.stderr);
+        }
+    }
+    async testWithResults(cwd, scheme, options = {}) {
+        const args = buildArgs(scheme, options);
+        args.push("test");
+        const result = await this.apple.xcodebuild(args, cwd);
+        // Attempt to find and parse .xcresult bundle
+        const xcresultPath = findXcresultPath(result.stdout, result.stderr);
+        if (xcresultPath) {
+            try {
+                const testsResult = await this.apple.xcresultListTests(xcresultPath);
+                if (testsResult.exitCode === 0) {
+                    return parseXcresultTests(testsResult.stdout);
+                }
+            }
+            catch {
+                // Fallback to empty results if xcresulttool fails
+            }
+        }
+        if (result.exitCode !== 0) {
+            throw new TestsFailedError(result.stderr);
+        }
+        return [];
+    }
+    async getTestResults(xcresultPath) {
+        const result = await this.apple.xcresultListTests(xcresultPath);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("xcresulttool", result.stderr || "Failed to read test results");
+        }
+        return parseXcresultTests(result.stdout);
+    }
+    async clean(cwd, scheme, options = {}) {
+        if (options.derivedData || options.xcodeDerivedData || options.xcodeCache) {
+            // Custom clean operations
+            if (options.derivedData) {
+                await this.spawner.run("rm", ["-rf", "~/Library/Developer/Xcode/DerivedData"], { cwd });
+            }
+            if (options.xcodeDerivedData) {
+                await this.spawner.run("rm", ["-rf", "~/Library/Developer/Xcode/DerivedData"]);
+            }
+            if (options.xcodeCache) {
+                await this.spawner.run("rm", ["-rf", "~/Library/Caches/com.apple.dt.Xcode"]);
+            }
+            return;
+        }
+        const args = buildArgs(scheme, options);
+        args.push("clean");
+        const result = await this.apple.xcodebuild(args, cwd);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("xcodebuild", result.stderr || "Clean failed");
+        }
+    }
+    // === Expo ===
+    async prebuild(cwd, platform) {
+        const result = await this.expo.prebuild(cwd, platform);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("expo", result.stderr || "Expo prebuild failed");
+        }
+    }
+    async runExpoIos(cwd, device) {
+        const result = await this.expo.runIos(cwd, device);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("expo", result.stderr || "Expo iOS run failed");
+        }
+    }
+    async runExpoAndroid(cwd, device) {
+        const result = await this.expo.runAndroid(cwd, device);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("expo", result.stderr || "Expo Android run failed");
+        }
+    }
+    // === Maestro ===
+    async runMaestroTest(flowPath, options) {
+        const result = await this.maestro.test(flowPath, options);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("maestro", result.stderr || `Maestro test failed for ${flowPath}`);
+        }
+    }
+    async runMaestroContinuous(flowPath, options) {
+        const result = await this.maestro.testContinuous({ ...options, flowPath });
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("maestro", result.stderr || `Maestro continuous test failed for ${flowPath}`);
+        }
+    }
+    async runMaestroHierarchy(options) {
+        const result = await this.maestro.hierarchy(options);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("maestro", result.stderr || "Maestro hierarchy failed");
+        }
+        return result.stdout;
+    }
+    async runMaestroRecord(flowPath, options) {
+        const result = await this.maestro.record({ ...options, flowPath });
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("maestro", result.stderr || `Maestro record failed for ${flowPath}`);
+        }
+    }
+    async maestroDriverSetup(cwd) {
+        const result = await this.maestro.driverSetup(cwd);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("maestro", result.stderr || "Maestro driver setup failed");
+        }
+    }
+    async maestroStartDevice(options) {
+        const result = await this.maestro.startDevice(options);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("maestro", result.stderr || "Maestro start-device failed");
+        }
+    }
+    // === Test Discovery ===
+    async testWithProgress(cwd, scheme, onProgress, options = {}) {
+        const args = buildArgs(scheme, options);
+        args.push("test");
+        if (options.only && options.only.length > 0) {
+            for (const test of options.only) {
+                args.push("-only-testing", test);
+            }
+        }
+        if (options.skip && options.skip.length > 0) {
+            for (const test of options.skip) {
+                args.push("-skip-testing", test);
+            }
+        }
+        if (options.retry) {
+            args.push("-retry-tests-on-failure");
+        }
+        const result = await this.apple.xcodebuildStream(args, (line) => {
+            const progress = parseTestProgress(line);
+            if (progress) {
+                onProgress(progress);
+            }
+        }, cwd);
+        if (result.exitCode !== 0) {
+            throw new TestsFailedError("Tests failed");
+        }
+    }
+    async projectBuildConfigs(cwd, options = {}) {
+        const result = await this.apple.listBuildConfigurations(cwd, options);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("xcodebuild", result.stderr || "Failed to list build configurations");
+        }
+        return parseBuildConfigs(result.stdout);
+    }
+    async detectSchemes(cwd, options = {}) {
+        const result = await this.apple.listSchemes(cwd, options);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("xcodebuild", result.stderr || "Failed to list schemes");
+        }
+        return parseSchemes(result.stdout);
+    }
+    async discoverTests(cwd, scheme, options = {}) {
+        const args = buildArgs(scheme, options);
+        args.push("-quiet", "test-without-building", "-list-tests");
+        const result = await this.apple.xcodebuild(args, cwd);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("xcodebuild", result.stderr || "Test discovery failed");
+        }
+        return parseTestList(result.stdout);
+    }
+    // === idb: Accessibility ===
+    async idbDescribeAll(udid) {
+        const result = await this.idb.describeAll(udid);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || "Failed to describe accessibility");
+        }
+        try {
+            return JSON.parse(result.stdout);
+        }
+        catch {
+            return result.stdout;
+        }
+    }
+    async idbDescribePoint(udid, x, y) {
+        const result = await this.idb.describePoint(udid, x, y);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || "Failed to describe point");
+        }
+        try {
+            return JSON.parse(result.stdout);
+        }
+        catch {
+            return result.stdout;
+        }
+    }
+    // === idb: HID / UI ===
+    async idbTap(udid, x, y) {
+        const result = await this.idb.tap(udid, x, y);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || "Tap failed");
+        }
+    }
+    async idbSwipe(udid, x1, y1, x2, y2) {
+        const result = await this.idb.swipe(udid, x1, y1, x2, y2);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || "Swipe failed");
+        }
+    }
+    async idbPressButton(udid, button) {
+        const result = await this.idb.pressButton(udid, button);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || `Button ${button} failed`);
+        }
+    }
+    async idbInputText(udid, text) {
+        const result = await this.idb.inputText(udid, text);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || "Text input failed");
+        }
+    }
+    // === idb: Crash Logs ===
+    async idbListCrashes(udid) {
+        const result = await this.idb.listCrashes(udid);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || "Failed to list crashes");
+        }
+        try {
+            return JSON.parse(result.stdout);
+        }
+        catch {
+            return [];
+        }
+    }
+    async idbShowCrash(udid, name) {
+        const result = await this.idb.showCrash(udid, name);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || `Failed to show crash ${name}`);
+        }
+        return result.stdout;
+    }
+    async idbDeleteCrash(udid, name) {
+        const result = await this.idb.deleteCrash(udid, name);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || `Failed to delete crash ${name}`);
+        }
+    }
+    // === idb: Settings / Permissions ===
+    async idbApprove(udid, bundleId, permissions) {
+        const result = await this.idb.approve(udid, bundleId, permissions);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || "Failed to approve permissions");
+        }
+    }
+    // === idb: Location ===
+    async idbSetLocation(udid, latitude, longitude) {
+        const result = await this.idb.setLocation(udid, latitude, longitude);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || "Failed to set location");
+        }
+    }
+    // === idb: Focus ===
+    async idbFocus(udid) {
+        const result = await this.idb.focus(udid);
+        if (result.exitCode !== 0) {
+            throw new ToolOutputError("idb", result.stderr || "Failed to focus simulator");
+        }
+    }
+}
+function buildArgs(scheme, options) {
+    const args = [];
+    if (options.workspace) {
+        args.push("-workspace", options.workspace);
+    }
+    else if (options.project) {
+        args.push("-project", options.project);
+    }
+    args.push("-scheme", scheme);
+    if (options.destination) {
+        args.push("-destination", options.destination);
+    }
+    return args;
+}
+function parseTestList(stdout) {
+    const tests = [];
+    for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed && trimmed.includes("/") && !trimmed.startsWith(" ")) {
+            tests.push(trimmed);
+        }
+    }
+    return tests;
+}
+function parseBuildPhase(line) {
+    // CompileSwift / CompileC / CompileSwiftSources
+    const compileMatch = /Compile\w+\s+(?:\[.*\]\s+)?(.+)\s+\((in target '([^']+)'|in target \`([^']+)\`)/.exec(line);
+    if (compileMatch) {
+        return { phase: "compile", target: compileMatch[3] || compileMatch[4], file: compileMatch[1]?.trim() };
+    }
+    // Link
+    const linkMatch = /Ld\s+(.+)\s+\(in target '([^']+)'/.exec(line);
+    if (linkMatch) {
+        return { phase: "link", target: linkMatch[2], file: linkMatch[1]?.trim() };
+    }
+    // CodeSign
+    const signMatch = /CodeSign\s+(.+)\s+\(in target '([^']+)'/.exec(line);
+    if (signMatch) {
+        return { phase: "codesign", target: signMatch[2], file: signMatch[1]?.trim() };
+    }
+    // Copy
+    const copyMatch = /CpResource\s+(.+)\s+\(in target '([^']+)'/.exec(line);
+    if (copyMatch) {
+        return { phase: "copy", target: copyMatch[2], file: copyMatch[1]?.trim() };
+    }
+    // ProcessInfoPlist
+    const plistMatch = /ProcessInfoPlistFile\s+(.+)\s+\(in target '([^']+)'/.exec(line);
+    if (plistMatch) {
+        return { phase: "process-plist", target: plistMatch[2], file: plistMatch[1]?.trim() };
+    }
+    // Build success/failure
+    if (line.includes("** BUILD SUCCEEDED **")) {
+        return { phase: "succeeded" };
+    }
+    if (line.includes("** BUILD FAILED **")) {
+        return { phase: "failed" };
+    }
+    return undefined;
+}
+function findXcresultPath(stdout, stderr) {
+    const combined = stdout + "\n" + stderr;
+    const match = /Test results saved to:\s+(.+\.xcresult)/.exec(combined);
+    if (match && match[1]) {
+        return match[1].trim();
+    }
+    // Also check for derived data path
+    const derivedMatch = /-resultBundlePath\s+(.+\.xcresult)/.exec(combined);
+    if (derivedMatch && derivedMatch[1]) {
+        return derivedMatch[1].trim();
+    }
+    return undefined;
+}
+function parseTestProgress(line) {
+    // Test suite started
+    if (line.includes("Test Suite") && line.includes("started")) {
+        return { status: "suite-started" };
+    }
+    // Test suite finished
+    if (line.includes("Test Suite") && line.includes("finished")) {
+        return { status: "suite-finished" };
+    }
+    // Test case started
+    const startedMatch = /Test Case '-\[([^\]]+)\]' started/.exec(line);
+    if (startedMatch) {
+        return { testName: startedMatch[1], status: "started" };
+    }
+    // Test case passed
+    const passedMatch = /Test Case '-\[([^\]]+)\]' passed \(([^)]+)\)/.exec(line);
+    if (passedMatch) {
+        const durationMs = parseDuration(passedMatch[2]);
+        return { testName: passedMatch[1], status: "passed", durationMs };
+    }
+    // Test case failed
+    const failedMatch = /Test Case '-\[([^\]]+)\]' failed \(([^)]+)\)/.exec(line);
+    if (failedMatch) {
+        const durationMs = parseDuration(failedMatch[2]);
+        return { testName: failedMatch[1], status: "failed", durationMs };
+    }
+    return undefined;
+}
+function parseDuration(durationStr) {
+    const seconds = Number.parseFloat(durationStr.replace(" seconds", ""));
+    return Number.isNaN(seconds) ? undefined : Math.round(seconds * 1000);
+}
+function parseBuildConfigs(stdout) {
+    const configs = [];
+    const match = /Build Configurations:\s+(.+)/.exec(stdout);
+    if (match && match[1]) {
+        configs.push(...match[1].split(", ").map((c) => c.trim()));
+    }
+    return configs;
+}
+function parseSchemes(stdout) {
+    const schemes = [];
+    const lines = stdout.split("\n");
+    let inSchemes = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === "Schemes:") {
+            inSchemes = true;
+            continue;
+        }
+        if (inSchemes) {
+            if (trimmed === "" || trimmed.endsWith(":")) {
+                break;
+            }
+            schemes.push(trimmed);
+        }
+    }
+    return schemes;
+}
+function parseXcresultTests(stdout) {
+    const results = [];
+    try {
+        const parsed = JSON.parse(stdout);
+        for (const test of parsed.tests ?? []) {
+            const name = test.testName || test.identifier || "unknown";
+            const passed = test.testStatus === "Success" || test.testStatus === "success";
+            const failureMessage = test.failureSummaries?.[0]?.message;
+            results.push({
+                testName: name,
+                passed,
+                durationMs: test.duration ? Math.round(test.duration * 1000) : undefined,
+                failureMessage
+            });
+        }
+    }
+    catch {
+        // If xcresulttool returns non-JSON, return empty
+    }
+    return results;
+}

package/dist/safety.d.ts

@@ -0,0 +1,8 @@
+export interface SafetyGate {
+    readonly requiresConfirmation: boolean;
+    readonly description: string;
+}
+export declare const safetyGates: Record<string, SafetyGate>;
+export declare function isConfirmed(phase: string, flags: readonly string[]): boolean;
+export declare function requireConfirmation(phase: string): string;
+//# sourceMappingURL=safety.d.ts.map

package/dist/safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safety.d.ts","sourceRoot":"","sources":["../src/safety.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAuElD,CAAC;AAEF,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,OAAO,CAMT;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIzD"}