@skrr-ai/cli 0.1.47 → 0.1.49

package/dist/commands/machines/dedicated/ssh.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const core_1 = require("@oclif/core");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+const harnesses_1 = require("../../../lib/harnesses");
+const dedicated_ssh_1 = require("../../../lib/dedicated-ssh");
+const exec_1 = require("../hosted/exec");
+const SSH_READY_STATES = new Set(['ready', 'active', 'idle']);
+/**
+ * `skrr machines dedicated ssh` — a real OpenSSH session on a Dedicated
+ * Runtime, as skrr-workload.
+ *
+ * The client on this machine is ordinary `ssh`: this command builds the
+ * options (`-o ProxyCommand=… ssh-proxy %h`, the lease's identity file and
+ * known_hosts) and execs it, so tab-completion, `-L`, agent forwarding and
+ * every other OpenSSH feature behave the way `man ssh` says they do.
+ * `ssh-proxy` carries the protocol over the admitted relay; there is no port
+ * on the machine for the session to have arrived on.
+ *
+ * `scp`, `rsync`, `git` over SSH, VS Code Remote-SSH and JetBrains Gateway
+ * take the same path — they just need the Host block, which `ssh-config`
+ * prints.
+ */
+class DedicatedMachinesSsh extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'SSH into a Dedicated Runtime as skrr-workload — a real OpenSSH session. For port forwards and other ssh options use the `ssh-config` block plus plain `ssh`, which takes them before the host.';
+    static examples = [
+        '<%= config.bin %> machines dedicated ssh <lease-id>',
+        '<%= config.bin %> machines dedicated ssh <lease-id> -- ls -la',
+        '<%= config.bin %> machines dedicated ssh-config <lease-id> >> ~/.ssh/config  # then: ssh -L 3000:localhost:3000 rtl_<id>.skrr',
+    ];
+    static usage = 'machines dedicated ssh <lease-id> -- [command...]';
+    static strict = false;
+    static args = {
+        lease: core_1.Args.string({
+            description: 'Dedicated Runtime lease id, or `self`',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        workspace: core_1.Flags.string({ description: 'Workspace scope' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { head, tail } = (0, exec_1.splitExecArgv)(this.argv);
+        let parsed;
+        try {
+            parsed = await this.parse(DedicatedMachinesSsh, head);
+        }
+        catch {
+            // An ssh-looking flag before -- (say `-L`) is not this command's flag —
+            // and cannot be: ssh options must precede the destination on ssh's own
+            // argv, so there is no honest place to forward it to. Say where it goes.
+            this.error('ssh options cannot be forwarded here. Put a remote command after --, or add the option to the Host block from `skrr machines dedicated ssh-config <lease-id>` and run ssh directly.', { exit: 2 });
+        }
+        const { args, flags, argv } = parsed;
+        if (argv.length > 1) {
+            this.error(`Extra arguments before -- are not forwarded to ssh. Put a remote command after --, or add ssh options to the block from \`${this.config.bin} machines dedicated ssh-config ${args.lease}\`.`, { exit: 2 });
+        }
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const remoteCommand = tail ?? [];
+        // Refuse BEFORE ssh starts where the answer is already knowable — a
+        // stopped machine or an absent daemon — so the error is a sentence, not a
+        // ProxyCommand failure buried in ssh's own diagnostics.
+        const response = await this.callDedicated(() => (0, dedicated_machines_1.getDedicatedRuntime)(leaseId, this.scopeFrom(flags)));
+        const lease = response?.lease;
+        if (!lease)
+            this.error('Dedicated Runtime lease not found.', { exit: 1 });
+        const state = (0, dedicated_machines_1.dedicatedLeaseState)(lease);
+        if (!SSH_READY_STATES.has(state)) {
+            this.error(state === 'stopped'
+                ? `${leaseId} is stopped. Start it first: \`${this.config.bin} machines dedicated start ${leaseId} --wait\`.`
+                : `${leaseId} is ${state}; SSH connects once it is ready.`, { exit: 1 });
+        }
+        const listed = await this.callDedicated(() => (0, harnesses_1.listHarnesses)());
+        const harness = (0, dedicated_machines_1.dedicatedTerminalHarness)(lease, listed?.harnesses ?? []);
+        if (!harness?.daemonId) {
+            this.error(`${leaseId} is ${state}, but its daemon is not connected yet. Wait a moment, or run \`${this.config.bin} machines dedicated health-check ${leaseId}\`.`, { exit: 1 });
+        }
+        const identity = (0, dedicated_ssh_1.ensureSshIdentity)();
+        const host = `${leaseId}${dedicated_ssh_1.SSH_HOST_SUFFIX}`;
+        const sshArgv = [
+            '-o',
+            `ProxyCommand=${(0, dedicated_ssh_1.sshProxyCommand)()}`,
+            '-o',
+            `UserKnownHostsFile=${(0, dedicated_ssh_1.knownHostsPath)()}`,
+            '-o',
+            'StrictHostKeyChecking=yes',
+            '-o',
+            'IdentitiesOnly=yes',
+            '-o',
+            'ServerAliveInterval=30',
+            '-i',
+            identity.privateKey,
+            `${dedicated_ssh_1.SSH_USER}@${host}`,
+            ...remoteCommand,
+        ];
+        const code = await new Promise((resolve) => {
+            const child = (0, node_child_process_1.spawn)('ssh', sshArgv, { stdio: 'inherit' });
+            child.on('error', (err) => {
+                process.stderr.write(`${err.message}\n`);
+                resolve(1);
+            });
+            child.on('close', (exitCode, signal) => {
+                if (exitCode !== null) {
+                    resolve(exitCode);
+                    return;
+                }
+                // A signal means ssh was killed, not that it finished; give the shell
+                // reading this command's status the conventional 128+signal.
+                const SIGNAL_CODES = { SIGINT: 130, SIGTERM: 143 };
+                resolve((signal && SIGNAL_CODES[signal]) ?? 1);
+            });
+        });
+        if (code !== 0)
+            this.exit(code);
+    }
+}
+exports.default = DedicatedMachinesSsh;

package/dist/commands/native/allow-all.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+/**
+ * Remove the application restriction. Blocked applications stay blocked, and
+ * password managers are never included either way.
+ */
+export default class NativeAllowAll extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/native/allow-all.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const native_1 = require("../native");
+/**
+ * Remove the application restriction. Blocked applications stay blocked, and
+ * password managers are never included either way.
+ */
+class NativeAllowAll extends core_1.Command {
+    static description = 'Remove the application restriction (blocked apps stay blocked)';
+    static examples = ['<%= config.bin %> native allow-all'];
+    static flags = {
+        ...native_1.nativeProfileFlag,
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        const { flags } = await this.parse(NativeAllowAll);
+        await (0, native_1.forwardNativeCommand)(this, [
+            'allow-all',
+            ...(0, native_1.profilePassthrough)(flags.profile),
+            ...(flags.json ? ['--json'] : []),
+        ]);
+    }
+}
+exports.default = NativeAllowAll;

package/dist/commands/native/allow.d.ts

@@ -0,0 +1,24 @@
+import { Command } from '@oclif/core';
+/**
+ * Make sure one application is in scope.
+ *
+ * It unblocks an app that `native deny` blocked, and adds one to a restriction
+ * if a restriction exists. With no restriction set it reports that the app was
+ * already in scope — because every application is, by default.
+ *
+ * It deliberately does NOT create a restriction out of an empty list. Doing so
+ * would silently narrow scope from "every app" to "this one app", which is the
+ * opposite of what the word promises. Use `native restrict-to` to narrow.
+ */
+export default class NativeAllow extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        app: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/native/allow.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const native_1 = require("../native");
+/**
+ * Make sure one application is in scope.
+ *
+ * It unblocks an app that `native deny` blocked, and adds one to a restriction
+ * if a restriction exists. With no restriction set it reports that the app was
+ * already in scope — because every application is, by default.
+ *
+ * It deliberately does NOT create a restriction out of an empty list. Doing so
+ * would silently narrow scope from "every app" to "this one app", which is the
+ * opposite of what the word promises. Use `native restrict-to` to narrow.
+ */
+class NativeAllow extends core_1.Command {
+    static description = 'Make sure an application is in scope (unblocks it, or adds it to a restriction)';
+    static examples = [
+        '<%= config.bin %> native allow "Slack"',
+        '<%= config.bin %> native allow com.apple.Notes',
+    ];
+    static args = {
+        app: core_1.Args.string({
+            description: 'Application name or bundle id',
+            required: true,
+            // Without this oclif reads stdin for a missing positional, so the command
+            // hangs from a pipe instead of refusing.
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        ...native_1.nativeProfileFlag,
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(NativeAllow);
+        await (0, native_1.forwardNativeCommand)(this, [
+            'allow',
+            args.app,
+            ...(0, native_1.profilePassthrough)(flags.profile),
+            ...(flags.json ? ['--json'] : []),
+        ]);
+    }
+}
+exports.default = NativeAllow;

package/dist/commands/native/deny.d.ts

@@ -0,0 +1,24 @@
+import { Command } from '@oclif/core';
+/**
+ * Block one application from ever being driven on this computer.
+ *
+ * The counterpart of the allow-everything default: it lets someone keep the
+ * default and carve out the two or three apps they do not want touched, which
+ * is a far smaller thing to write down than enumerating every app they do.
+ *
+ * Takes effect on the NEXT call, not the next restart — revocation is the
+ * user's only stop button, and one that waited for a restart would fail at
+ * exactly the moment they wanted it.
+ */
+export default class NativeDeny extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        app: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/native/deny.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const native_1 = require("../native");
+/**
+ * Block one application from ever being driven on this computer.
+ *
+ * The counterpart of the allow-everything default: it lets someone keep the
+ * default and carve out the two or three apps they do not want touched, which
+ * is a far smaller thing to write down than enumerating every app they do.
+ *
+ * Takes effect on the NEXT call, not the next restart — revocation is the
+ * user's only stop button, and one that waited for a restart would fail at
+ * exactly the moment they wanted it.
+ */
+class NativeDeny extends core_1.Command {
+    static description = 'Block an application from ever being driven on this computer';
+    static examples = [
+        '<%= config.bin %> native deny "Slack"',
+        '<%= config.bin %> native deny "*"',
+    ];
+    static args = {
+        app: core_1.Args.string({
+            description: 'Application name or bundle id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        ...native_1.nativeProfileFlag,
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(NativeDeny);
+        await (0, native_1.forwardNativeCommand)(this, [
+            'deny',
+            args.app,
+            ...(0, native_1.profilePassthrough)(flags.profile),
+            ...(flags.json ? ['--json'] : []),
+        ]);
+    }
+}
+exports.default = NativeDeny;

package/dist/commands/native/disable.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+/**
+ * Turn native application control off.
+ *
+ * Both flags go off together: leaving `allowCloudAgents` true under
+ * `enabled: false` is a state that reads like a grant, is not one, and would
+ * come back the moment someone re-enabled.
+ */
+export default class NativeDisable extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/native/disable.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const native_1 = require("../native");
+/**
+ * Turn native application control off.
+ *
+ * Both flags go off together: leaving `allowCloudAgents` true under
+ * `enabled: false` is a state that reads like a grant, is not one, and would
+ * come back the moment someone re-enabled.
+ */
+class NativeDisable extends core_1.Command {
+    static description = 'Turn native application control off for this computer';
+    static examples = ['<%= config.bin %> native disable'];
+    static flags = {
+        ...native_1.nativeProfileFlag,
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        const { flags } = await this.parse(NativeDisable);
+        await (0, native_1.forwardNativeCommand)(this, [
+            'disable',
+            ...(0, native_1.profilePassthrough)(flags.profile),
+            ...(flags.json ? ['--json'] : []),
+        ]);
+    }
+}
+exports.default = NativeDisable;

package/dist/commands/native/enable.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+/** Turn native application control on for this computer. */
+export default class NativeEnable extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'cloud-agents': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/native/enable.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const native_1 = require("../native");
+/** Turn native application control on for this computer. */
+class NativeEnable extends core_1.Command {
+    static description = 'Turn native application control on for this computer';
+    static examples = [
+        '<%= config.bin %> native enable',
+        '<%= config.bin %> native enable --cloud-agents',
+    ];
+    static flags = {
+        ...native_1.nativeProfileFlag,
+        'cloud-agents': core_1.Flags.boolean({
+            description: 'Also allow cloud agents to drive native apps on this computer',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        const { flags } = await this.parse(NativeEnable);
+        await (0, native_1.forwardNativeCommand)(this, [
+            'enable',
+            ...(0, native_1.profilePassthrough)(flags.profile),
+            ...(flags['cloud-agents'] ? ['--cloud-agents'] : []),
+            ...(flags.json ? ['--json'] : []),
+        ]);
+    }
+}
+exports.default = NativeEnable;

package/dist/commands/native/list-apps.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+/**
+ * List the applications running on this computer, marking which may take
+ * irreversible actions.
+ *
+ * This is how the scope gets CHOSEN, so it works before anything is in scope —
+ * the same reason `list_apps` is one of two verbs the policy exempts from the
+ * app check. Without it a user had to guess an application's exact name and
+ * hope the comparison matched.
+ */
+export default class NativeListApps extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/native/list-apps.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const native_1 = require("../native");
+/**
+ * List the applications running on this computer, marking which may take
+ * irreversible actions.
+ *
+ * This is how the scope gets CHOSEN, so it works before anything is in scope —
+ * the same reason `list_apps` is one of two verbs the policy exempts from the
+ * app check. Without it a user had to guess an application's exact name and
+ * hope the comparison matched.
+ */
+class NativeListApps extends core_1.Command {
+    static description = 'List running applications and which may take irreversible actions';
+    static examples = ['<%= config.bin %> native list-apps'];
+    static flags = {
+        ...native_1.nativeProfileFlag,
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        const { flags } = await this.parse(NativeListApps);
+        await (0, native_1.forwardNativeCommand)(this, [
+            'list-apps',
+            ...(0, native_1.profilePassthrough)(flags.profile),
+            ...(flags.json ? ['--json'] : []),
+        ]);
+    }
+}
+exports.default = NativeListApps;

package/dist/commands/native/restrict-to.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+/**
+ * Narrow native control to a specific set of applications.
+ *
+ * The default is every application — enabling native control IS the consent,
+ * and this is for someone who wants less than that. It used to be the other
+ * way round: an allow-list that authorized nothing when empty, so the shipped
+ * default was a session that could do nothing and the escape was `"*"`.
+ */
+export default class NativeRestrictTo extends Command {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static args: {
+        apps: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/native/restrict-to.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const native_1 = require("../native");
+/**
+ * Narrow native control to a specific set of applications.
+ *
+ * The default is every application — enabling native control IS the consent,
+ * and this is for someone who wants less than that. It used to be the other
+ * way round: an allow-list that authorized nothing when empty, so the shipped
+ * default was a session that could do nothing and the escape was `"*"`.
+ */
+class NativeRestrictTo extends core_1.Command {
+    static description = 'Narrow native control to a specific set of applications';
+    static examples = [
+        '<%= config.bin %> native restrict-to "Slack" "Notes"',
+        '<%= config.bin %> native restrict-to com.apple.Notes',
+    ];
+    static strict = false;
+    static args = {
+        apps: core_1.Args.string({
+            description: 'Application names or bundle ids',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        ...native_1.nativeProfileFlag,
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        const { argv, flags } = await this.parse(NativeRestrictTo);
+        await (0, native_1.forwardNativeCommand)(this, [
+            'restrict-to',
+            ...(0, native_1.profilePassthrough)(flags.profile),
+            ...argv.filter((a) => a !== '--json'),
+            ...(flags.json ? ['--json'] : []),
+        ]);
+    }
+}
+exports.default = NativeRestrictTo;

package/dist/commands/native/status.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+/**
+ * Whether native control is on, which apps may take irreversible actions, and
+ * whether the helper can actually run.
+ *
+ * The last part is the one that had nowhere to appear. `/health` has carried
+ * seven `nativeUi` diagnostic fields since OSK-11016 and NOTHING read them, so
+ * a user could not tell "turned off" from "helper not installed" from "TCC not
+ * granted" — three different repairs behind one silence.
+ */
+export default class NativeStatus extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/native/status.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const native_1 = require("../native");
+/**
+ * Whether native control is on, which apps may take irreversible actions, and
+ * whether the helper can actually run.
+ *
+ * The last part is the one that had nowhere to appear. `/health` has carried
+ * seven `nativeUi` diagnostic fields since OSK-11016 and NOTHING read them, so
+ * a user could not tell "turned off" from "helper not installed" from "TCC not
+ * granted" — three different repairs behind one silence.
+ */
+class NativeStatus extends core_1.Command {
+    static description = 'Show whether native control is on, which apps may send or delete, and helper health';
+    static examples = [
+        '<%= config.bin %> native status',
+        '<%= config.bin %> native status --json',
+    ];
+    static flags = {
+        ...native_1.nativeProfileFlag,
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        const { flags } = await this.parse(NativeStatus);
+        await (0, native_1.forwardNativeCommand)(this, [
+            'status',
+            ...(0, native_1.profilePassthrough)(flags.profile),
+            ...(flags.json ? ['--json'] : []),
+        ]);
+    }
+}
+exports.default = NativeStatus;

package/dist/commands/native.d.ts

@@ -0,0 +1,39 @@
+import { Command } from '@oclif/core';
+/**
+ * `--profile` is a GLOBAL flag on the runtime binary, so every `skrr native`
+ * subcommand has to declare it to be reachable — `native status` itself tells
+ * users "use --profile to target one" when sibling profiles have live daemons,
+ * and without this declaration that advice could not be followed (OSK-11100).
+ */
+export declare const nativeProfileFlag: {
+    profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+/** The passthrough form of the parsed profile flag, or nothing. */
+export declare function profilePassthrough(profile: string | undefined): string[];
+export declare function buildNativeArgs(passthrough: readonly string[]): string[];
+/**
+ * Forward one `skrr native` command to the daemon.
+ *
+ * Native application control is consent that belongs to the person at the
+ * machine, so the setting lives in that machine's `daemon.json` and a cloud
+ * request can never write it (OSK-11018). The CLI is a bridge for the same
+ * reason `skrr browser` is: the capability is the daemon's, and a second
+ * implementation here would be a second place for the policy to drift.
+ *
+ * Until this existed the setting had NO command at all. The executor's own
+ * refusal told users to "set `nativeUi.enabled` and `nativeUi.allowCloudAgents`
+ * in the local daemon configuration" — a file it did not name — so the product's
+ * answer to "how do I turn this on" was to open a JSON file.
+ */
+export declare function forwardNativeCommand(command: Command, passthrough: readonly string[]): Promise<void>;
+/**
+ * `skrr native` is the stable user-facing entry point for native application
+ * control. Keeping it a thin bridge is what stops the REST CLI acquiring its
+ * own copy of the app-scope rules.
+ */
+export default class Native extends Command {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    run(): Promise<void>;
+}