@skrr-ai/cli 0.1.47 → 0.1.48

package/dist/commands/machines/dedicated/sign-in-status.d.ts

@@ -0,0 +1,22 @@
+import type { DedicatedRuntimeSignInStatus } from '@skrr-ai/data-provider';
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated sign-in-status` — the read half of `sign-in`.
+ *
+ * Deliberately a separate command, not a flag on `sign-in`: the whole reason
+ * the endpoint exists is to answer the question WITHOUT starting a sign-in,
+ * and folding it into the verb that signs in would make the distinction a
+ * matter of remembering a flag.
+ */
+export default class DedicatedMachinesSignInStatus extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+export declare function describeSignInStatus(status: DedicatedRuntimeSignInStatus): string;

package/dist/commands/machines/dedicated/sign-in-status.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeSignInStatus = describeSignInStatus;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+const dedicated_machines_1 = require("../../../lib/dedicated-machines");
+const LABELS = new Map(data_provider_1.DEDICATED_RUNTIME_SIGN_IN_PRESETS.map((preset) => [preset.tool, preset.label]));
+/**
+ * `skrr machines dedicated sign-in-status` — the read half of `sign-in`.
+ *
+ * Deliberately a separate command, not a flag on `sign-in`: the whole reason
+ * the endpoint exists is to answer the question WITHOUT starting a sign-in,
+ * and folding it into the verb that signs in would make the distinction a
+ * matter of remembering a flag.
+ */
+class DedicatedMachinesSignInStatus extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Report whether a Dedicated Runtime is signed in to GitHub CLI, Claude Code and Codex, without starting a sign-in. Read-only on the machine.';
+    static examples = [
+        '<%= config.bin %> machines dedicated sign-in-status <lease-id>',
+        '<%= config.bin %> machines dedicated sign-in-status <lease-id> --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_lease_command_1.DEDICATED_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesSignInStatus);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const response = await this.callDedicated(() => (0, dedicated_machines_1.getDedicatedRuntimeSignInStatus)(leaseId, this.scopeFrom(flags)));
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const statuses = response?.statuses ?? [];
+        if (!statuses.length) {
+            this.log('The machine reported no sign-in status.');
+            return;
+        }
+        for (const status of statuses)
+            this.log(describeSignInStatus(status));
+        // `unknown` is not `signed_out`, and the difference decides whether anyone
+        // should go and re-authenticate. Saying it once, at the end, rather than
+        // on every row, keeps the common all-signed-in case one line per tool.
+        if (statuses.every((status) => status.state === 'unknown')) {
+            this.log('\nNothing could be read. The probe may have timed out or the machine may be unreachable — ' +
+                'that is not evidence the credentials are gone. Check again shortly.');
+        }
+        else if (statuses.some((status) => status.state === 'unknown')) {
+            this.log('\n`unknown` means the check could not answer, not that the tool is signed out — ' +
+                'it may not be installed on this image.');
+        }
+        if (response.checkedAt)
+            this.log(`\nChecked ${response.checkedAt}.`);
+        // No state-derived exit code, on purpose. The one a script would reach for
+        // — non-zero when "not signed in" — has no honest definition here, because
+        // it would have to put `unknown` on one side or the other and both are
+        // wrong. `--json` carries the three states; let the caller decide which of
+        // them it cares about.
+    }
+}
+exports.default = DedicatedMachinesSignInStatus;
+const STATE_LABEL = {
+    signed_in: 'signed in',
+    signed_out: 'signed out',
+    unknown: 'unknown',
+};
+function describeSignInStatus(status) {
+    const label = LABELS.get(status.tool) ?? status.tool;
+    const account = status.account ? ` (${status.account})` : '';
+    return `${label.padEnd(12)} ${STATE_LABEL[status.state] ?? status.state}${account}`;
+}

package/dist/commands/machines/dedicated/ssh-config.d.ts

@@ -0,0 +1,28 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated ssh-config` — the OpenSSH stanza for every lease.
+ *
+ * The block is a wildcard `Host rtl_*.skrr`: installing it once makes
+ * `ssh rtl_<id>.skrr` (and therefore `scp`, `rsync`, `git`, VS Code
+ * Remote-SSH, JetBrains Gateway) work for every Dedicated Runtime the user
+ * ever leases — one device identity and one pin file under ~/.skrr/ssh/,
+ * nothing of the user's own ~/.ssh shared with it.
+ *
+ * By default the block is installed into ~/.ssh/config as a managed region
+ * between the skrr markers, and refuses — rather than edits — a config whose
+ * markers cannot bound a region. `--print` writes the block to stdout for
+ * people who keep their ssh config by hand.
+ */
+export default class DedicatedMachinesSshConfig extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        workspace: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        print: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+const dedicated_ssh_1 = require("../../../lib/dedicated-ssh");
+/**
+ * `skrr machines dedicated ssh-config` — the OpenSSH stanza for every lease.
+ *
+ * The block is a wildcard `Host rtl_*.skrr`: installing it once makes
+ * `ssh rtl_<id>.skrr` (and therefore `scp`, `rsync`, `git`, VS Code
+ * Remote-SSH, JetBrains Gateway) work for every Dedicated Runtime the user
+ * ever leases — one device identity and one pin file under ~/.skrr/ssh/,
+ * nothing of the user's own ~/.ssh shared with it.
+ *
+ * By default the block is installed into ~/.ssh/config as a managed region
+ * between the skrr markers, and refuses — rather than edits — a config whose
+ * markers cannot bound a region. `--print` writes the block to stdout for
+ * people who keep their ssh config by hand.
+ */
+class DedicatedMachinesSshConfig extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Install (or --print) the ~/.ssh/config block that lets plain ssh/scp/rsync/Remote-SSH reach any Dedicated Runtime.';
+    static examples = [
+        '<%= config.bin %> machines dedicated ssh-config <lease-id>',
+        '<%= config.bin %> machines dedicated ssh-config <lease-id> --print',
+        '<%= config.bin %> machines dedicated ssh-config <lease-id> --json',
+    ];
+    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' }),
+        print: core_1.Flags.boolean({ description: 'Print the block instead of installing it' }),
+        json: core_1.Flags.boolean({ description: 'Output the block as JSON' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(DedicatedMachinesSshConfig);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        // First use creates the device identity so the block names a file that
+        // exists; its admission still happens per-connection, by the daemon.
+        (0, dedicated_ssh_1.ensureSshIdentity)();
+        const block = (0, dedicated_ssh_1.sshConfigBlock)();
+        if (flags.json) {
+            this.log(JSON.stringify({ leaseId, config: block }, null, 2));
+            return;
+        }
+        if (flags.print) {
+            this.log(`${block}\n`);
+            return;
+        }
+        try {
+            const { configPath } = (0, dedicated_ssh_1.installSshConfigBlock)();
+            process.stderr.write(`Installed the skrr block in ${configPath}. \`ssh ${leaseId}.skrr\` (and scp, rsync, Remote-SSH) just work.\n`);
+        }
+        catch (error) {
+            if (error instanceof dedicated_ssh_1.DedicatedSshError) {
+                this.error(error.message, { exit: 1 });
+            }
+            throw error;
+        }
+    }
+}
+exports.default = DedicatedMachinesSshConfig;

package/dist/commands/machines/dedicated/ssh-proxy.d.ts

@@ -0,0 +1,22 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated ssh-proxy` — the ProxyCommand half of owner SSH.
+ *
+ * OpenSSH runs this with stdin/stdout wired to the SSH protocol: whatever the
+ * client writes arrives on the machine's sshd, whatever sshd writes is read
+ * back here. Everything else — admission, generation fencing, the ephemeral
+ * key's admission, host-key delivery — is carried by the channel, so this
+ * command's only job is to move bytes honestly and say why it cannot.
+ *
+ * Not for typing into: it writes protocol bytes to stdout and diagnostics to
+ * stderr, exactly like `ssh -W`. Humans want `ssh` (the next command) or the
+ * `ssh-config` block it can print.
+ */
+export default class DedicatedMachinesSshProxy extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        host: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+const dedicated_ssh_1 = require("../../../lib/dedicated-ssh");
+/**
+ * `skrr machines dedicated ssh-proxy` — the ProxyCommand half of owner SSH.
+ *
+ * OpenSSH runs this with stdin/stdout wired to the SSH protocol: whatever the
+ * client writes arrives on the machine's sshd, whatever sshd writes is read
+ * back here. Everything else — admission, generation fencing, the ephemeral
+ * key's admission, host-key delivery — is carried by the channel, so this
+ * command's only job is to move bytes honestly and say why it cannot.
+ *
+ * Not for typing into: it writes protocol bytes to stdout and diagnostics to
+ * stderr, exactly like `ssh -W`. Humans want `ssh` (the next command) or the
+ * `ssh-config` block it can print.
+ */
+class DedicatedMachinesSshProxy extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Bridge stdio to a Dedicated Runtime’s SSH server — the ProxyCommand ssh/scp/rsync/Remote-SSH use. Not an interactive command.';
+    static examples = [
+        "ssh -o ProxyCommand='skrr machines dedicated ssh-proxy %h' rtl_abc123.skrr",
+        '<%= config.bin %> machines dedicated ssh-proxy rtl_abc123.skrr',
+    ];
+    static args = {
+        host: core_1.Args.string({
+            description: 'The ssh host alias (rtl_<id>.skrr) or a bare lease id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args } = await this.parse(DedicatedMachinesSshProxy);
+        // `%h` arrives as the Host alias (`rtl_<id>.skrr`); a bare id or `self`
+        // work too, so the command is callable by hand.
+        const lease = (0, dedicated_ssh_1.leaseIdForSshHost)(args.host) ??
+            (args.host === 'self' ? await this.resolveLeaseArg('self') : null);
+        if (!lease) {
+            this.error(`Cannot read a lease id from '${args.host}'. Expected rtl_<id> or rtl_<id>.skrr.`, { exit: 2 });
+        }
+        let code;
+        try {
+            code = await (0, dedicated_ssh_1.runSshProxy)({
+                baseURL: this.cliConfig.baseURL,
+                token: this.resolvedCredential.token,
+                leaseId: lease,
+                input: process.stdin,
+                output: process.stdout,
+                errorOutput: process.stderr,
+            });
+        }
+        catch (err) {
+            if (err instanceof dedicated_ssh_1.DedicatedSshError)
+                this.error(err.message, { exit: 1 });
+            throw err;
+        }
+        if (code !== 0)
+            this.exit(code);
+    }
+}
+exports.default = DedicatedMachinesSshProxy;

package/dist/commands/machines/dedicated/ssh.d.ts

@@ -0,0 +1,29 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `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.
+ */
+export default class DedicatedMachinesSsh extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static usage: string;
+    static strict: boolean;
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        workspace: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

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>;
+}