@skrr-ai/cli 0.1.47 → 0.1.48

package/dist/commands/machines/dedicated/service/apply.d.ts

@@ -0,0 +1,23 @@
+import { DedicatedServiceCommand } from '../../../../lib/dedicated-service-command';
+/**
+ * `skrr machines dedicated service apply` — the git-ops verb: make the
+ * machine's declaration match the file.
+ *
+ * `create` refuses a name that exists; `apply` is idempotent — it reads the
+ * current spec (for its CAS `revision`), then updates or creates so a
+ * checked-in `service.json` can be re-applied any number of times. There is
+ * deliberately no watcher: the file is input, not a live mirror.
+ */
+export default class DedicatedServiceApply extends DedicatedServiceCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/dedicated/service/apply.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const core_1 = require("@oclif/core");
+const prompt_1 = require("../../../../lib/prompt");
+const dedicated_service_command_1 = require("../../../../lib/dedicated-service-command");
+const dedicated_service_1 = require("../../../../lib/dedicated-service");
+/**
+ * `skrr machines dedicated service apply` — the git-ops verb: make the
+ * machine's declaration match the file.
+ *
+ * `create` refuses a name that exists; `apply` is idempotent — it reads the
+ * current spec (for its CAS `revision`), then updates or creates so a
+ * checked-in `service.json` can be re-applied any number of times. There is
+ * deliberately no watcher: the file is input, not a live mirror.
+ */
+class DedicatedServiceApply extends dedicated_service_command_1.DedicatedServiceCommand {
+    static summary = 'Create or update a service from a spec file, idempotently';
+    static description = 'Applies service.json to the machine: creates the service when absent, updates it ' +
+        'against the stored spec’s revision when present (CAS — a spec that changed since the ' +
+        'read is reported as a conflict, never silently merged). Re-running it is safe.';
+    static examples = [
+        '<%= config.bin %> machines dedicated service apply <lease-id> --file service.json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_service_command_1.SERVICE_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        file: core_1.Flags.string({
+            description: 'The service.json to apply',
+            required: true,
+        }),
+        json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedServiceApply);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        let raw;
+        try {
+            raw = flags.file === '-' ? await (0, prompt_1.readStdin)() : (0, node_fs_1.readFileSync)(flags.file, 'utf8');
+        }
+        catch (err) {
+            this.error(`Cannot read ${flags.file}: ${err instanceof Error ? err.message : err}`, {
+                exit: 2,
+            });
+        }
+        let spec;
+        try {
+            spec = (0, dedicated_service_1.parseServiceSpecDocument)(raw, flags.file);
+        }
+        catch (err) {
+            this.reportServiceError(err);
+        }
+        // Upsert: read the current spec for its revision, then choose create or
+        // CAS update. `get` failing with not_found is the create path — read the
+        // raw ack here rather than through callService, which exits on refusals.
+        let verb = 'create';
+        let baseRevision;
+        try {
+            const channel = await this.serviceChannel();
+            const { result } = await channel.call('get', {
+                leaseId,
+                name: spec.name,
+                ...this.scopeFrom(flags),
+            });
+            if (result?.spec) {
+                verb = 'update';
+                baseRevision = typeof result.spec.revision === 'number' ? result.spec.revision : undefined;
+            }
+        }
+        catch (err) {
+            if (!(err instanceof dedicated_service_1.DedicatedServiceError && err.code === 'not_found')) {
+                this.reportServiceError(err);
+            }
+        }
+        const payload = verb === 'update'
+            ? {
+                leaseId,
+                name: spec.name,
+                patch: (0, dedicated_service_1.specPayload)(spec),
+                baseRevision,
+                ...this.scopeFrom(flags),
+            }
+            : { leaseId, spec: (0, dedicated_service_1.specPayload)(spec), ...this.scopeFrom(flags) };
+        const result = await this.callService(verb, payload);
+        this.closeServiceChannel();
+        if (flags.json) {
+            this.log(JSON.stringify(result ?? { name: spec.name, applied: verb }, null, 2));
+            return;
+        }
+        this.log(`Service ${spec.name} ${verb === 'create' ? 'created' : 'updated'} on ${leaseId}.`);
+    }
+}
+exports.default = DedicatedServiceApply;

package/dist/commands/machines/dedicated/service/approve.d.ts

@@ -0,0 +1,23 @@
+import { DedicatedServiceCommand } from '../../../../lib/dedicated-service-command';
+/**
+ * `skrr machines dedicated service approve` — the owner's answer to an
+ * agent-proposed service.
+ *
+ * Agents on the machine propose services through `skrr service propose`; a
+ * proposal is inert — nothing runs — until the owner answers it here.
+ * Approving turns the proposal into a live declaration with the agent's
+ * provenance preserved; rejecting drops it.
+ */
+export default class DedicatedServiceApprove extends DedicatedServiceCommand {
+    static summary: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        reject: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/dedicated/service/approve.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const dedicated_service_command_1 = require("../../../../lib/dedicated-service-command");
+/**
+ * `skrr machines dedicated service approve` — the owner's answer to an
+ * agent-proposed service.
+ *
+ * Agents on the machine propose services through `skrr service propose`; a
+ * proposal is inert — nothing runs — until the owner answers it here.
+ * Approving turns the proposal into a live declaration with the agent's
+ * provenance preserved; rejecting drops it.
+ */
+class DedicatedServiceApprove extends dedicated_service_command_1.DedicatedServiceCommand {
+    static summary = 'Approve or reject an agent-proposed service';
+    static examples = [
+        '<%= config.bin %> machines dedicated service approve <lease-id> <name>',
+        '<%= config.bin %> machines dedicated service approve <lease-id> <name> --reject',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_service_command_1.SERVICE_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+        name: core_1.Args.string({ description: 'Proposed service name', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        reject: core_1.Flags.boolean({ description: 'Reject the proposal instead of approving it' }),
+        json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedServiceApprove);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const result = await this.callService('approve', {
+            leaseId,
+            name: args.name,
+            approve: !flags.reject,
+            ...this.scopeFrom(flags),
+        });
+        this.closeServiceChannel();
+        if (flags.json) {
+            this.log(JSON.stringify(result ?? { name: args.name, approved: !flags.reject }, null, 2));
+            return;
+        }
+        this.log(flags.reject
+            ? `Proposal ${args.name} rejected — nothing runs.`
+            : `Proposal ${args.name} approved — the service is now declared and starts.`);
+    }
+}
+exports.default = DedicatedServiceApprove;

package/dist/commands/machines/dedicated/service/create.d.ts

@@ -0,0 +1,55 @@
+import { DedicatedServiceCommand } from '../../../../lib/dedicated-service-command';
+/**
+ * `skrr machines dedicated service create` — declare a workload the machine
+ * keeps running.
+ *
+ * The spec arrives one of three ways, never mixed:
+ *
+ *   argv        `service create <lease> --name devin -- <argv…>`
+ *   file        `service create <lease> --file service.json`
+ *   template    `service create <lease> --template worker --param repo=x`
+ *
+ * A template is a spec with `${param}` holes resolved locally
+ * (`~/.skrr/templates/<name>.json`, then the API gallery) — what reaches the
+ * daemon is always a concrete spec, so nothing downstream ever learns that
+ * templates exist. `--print` shows that merged spec instead of creating.
+ */
+export default class DedicatedServiceCreate extends DedicatedServiceCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static usage: string;
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        command: import("@oclif/core/lib/interfaces").Arg<string[] | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        template: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        param: 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>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        cwd: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        env: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        restart: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        notify: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'stop-timeout': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'limit-memory': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'limit-cpu': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'limit-pids': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /**
+     * The one spec this invocation means — flags+argv, --file, or --template.
+     * Mixing sources is refused rather than merged: "which spec won" is a
+     * question only the caller can answer.
+     */
+    private resolveSpec;
+    /**
+     * `~/.skrr/templates/<name>.json` first, then the API gallery. A missing
+     * local file is a fall-through, a broken one is an error; a gallery miss
+     * names both places looked.
+     */
+    private resolveTemplate;
+}

package/dist/commands/machines/dedicated/service/create.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const core_1 = require("@oclif/core");
+const prompt_1 = require("../../../../lib/prompt");
+const dedicated_service_command_1 = require("../../../../lib/dedicated-service-command");
+const dedicated_service_1 = require("../../../../lib/dedicated-service");
+const exec_1 = require("../../hosted/exec");
+/**
+ * `skrr machines dedicated service create` — declare a workload the machine
+ * keeps running.
+ *
+ * The spec arrives one of three ways, never mixed:
+ *
+ *   argv        `service create <lease> --name devin -- <argv…>`
+ *   file        `service create <lease> --file service.json`
+ *   template    `service create <lease> --template worker --param repo=x`
+ *
+ * A template is a spec with `${param}` holes resolved locally
+ * (`~/.skrr/templates/<name>.json`, then the API gallery) — what reaches the
+ * daemon is always a concrete spec, so nothing downstream ever learns that
+ * templates exist. `--print` shows that merged spec instead of creating.
+ */
+class DedicatedServiceCreate extends dedicated_service_command_1.DedicatedServiceCommand {
+    static summary = 'Declare an always-on service on a Dedicated Runtime';
+    static description = 'Declares a service the machine keeps running: it restarts on crash, on daemon restart, ' +
+        'after a checkpoint, and on a replacement machine. Give the command after -- as argv, ' +
+        'or a spec with --file service.json, or a --template with --param values. ' +
+        'Combine none of the three — each is a complete spec.';
+    static examples = [
+        '<%= config.bin %> machines dedicated service create <lease-id> --name devin --cwd /workspace/repos/devin -- node dist/worker.js',
+        '<%= config.bin %> machines dedicated service create <lease-id> --file service.json',
+        '<%= config.bin %> machines dedicated service create <lease-id> --name worker --restart on-failure --limit-memory 2G -- node dist/worker.js',
+        '<%= config.bin %> machines dedicated service create <lease-id> --template devin-worker --param repo=/workspace/repos/app',
+        '<%= config.bin %> machines dedicated service create <lease-id> --template devin-worker --param repo=x --print',
+    ];
+    static usage = 'machines dedicated service create <lease-id> [flags] -- <command...>';
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_service_command_1.SERVICE_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+        command: core_1.Args.string({
+            description: 'The service command and its arguments, after --',
+            multiple: true,
+            required: false,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        ...dedicated_service_command_1.serviceSpecFlags,
+        file: core_1.Flags.string({ description: 'Read the spec from a service.json file instead of flags' }),
+        template: core_1.Flags.string({
+            description: 'Build the spec from a template (~/.skrr/templates/<name>.json, then the API gallery)',
+        }),
+        param: core_1.Flags.string({
+            description: 'Template parameter as name=value; repeat for several',
+            multiple: true,
+        }),
+        print: core_1.Flags.boolean({
+            description: 'Print the spec that would be created without creating it',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output the created service as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { head, tail } = (0, exec_1.splitExecArgv)(this.argv);
+        const { args, flags } = await this.parse(DedicatedServiceCreate, head);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        let spec;
+        try {
+            spec = await this.resolveSpec(flags, tail ?? args.command ?? []);
+        }
+        catch (err) {
+            this.reportServiceError(err);
+        }
+        const errors = (0, dedicated_service_1.validateServiceSpec)(spec);
+        if (errors.length > 0) {
+            this.error(`The service spec is not valid:\n${errors.map((e) => `  - ${e}`).join('\n')}`, {
+                exit: 2,
+            });
+        }
+        if (flags.print) {
+            this.log(JSON.stringify((0, dedicated_service_1.specPayload)(spec), null, 2));
+            return;
+        }
+        const result = await this.callService('create', {
+            leaseId,
+            spec: (0, dedicated_service_1.specPayload)(spec),
+            ...this.scopeFrom(flags),
+        });
+        this.closeServiceChannel();
+        if (flags.json) {
+            this.log(JSON.stringify(result ?? { name: spec.name }, null, 2));
+            return;
+        }
+        const name = spec.name ?? result?.name ?? 'service';
+        this.log(`Service ${name} declared on ${leaseId}. It starts now and restarts across crashes, ` +
+            `daemon updates, checkpoints and machine replacement.`);
+        this.log(`Watch it: \`${this.config.bin} machines dedicated service status ${leaseId} ${name}\`, ` +
+            `logs: \`${this.config.bin} machines dedicated service logs ${leaseId} ${name} -f\`.`);
+    }
+    /**
+     * The one spec this invocation means — flags+argv, --file, or --template.
+     * Mixing sources is refused rather than merged: "which spec won" is a
+     * question only the caller can answer.
+     */
+    async resolveSpec(flags, argv) {
+        const file = flags.file;
+        const templateName = flags.template;
+        const flagSpecUsed = Boolean(flags.name ||
+            flags.cwd ||
+            flags.env?.length ||
+            flags.restart ||
+            flags.notify !== undefined ||
+            flags['stop-timeout'] !== undefined ||
+            flags['limit-memory'] ||
+            flags['limit-cpu'] !== undefined ||
+            flags['limit-pids'] !== undefined);
+        if (file && (templateName || flagSpecUsed || argv.length > 0)) {
+            this.error('--file is the whole spec — it cannot be combined with --template, spec flags, or a command after --.', { exit: 2 });
+        }
+        if (templateName && argv.length > 0) {
+            this.error('--template already carries the command — nothing may follow --.', { exit: 2 });
+        }
+        if (file) {
+            // `-` is the repo's stdin convention — a spec is small enough to pipe.
+            let raw;
+            try {
+                raw = file === '-' ? await (0, prompt_1.readStdin)() : (0, node_fs_1.readFileSync)(file, 'utf8');
+            }
+            catch (err) {
+                this.error(`Cannot read ${file}: ${err instanceof Error ? err.message : err}`, {
+                    exit: 2,
+                });
+            }
+            return (0, dedicated_service_1.parseServiceSpecDocument)(raw, file === '-' ? '<stdin>' : file);
+        }
+        if (templateName) {
+            const given = (0, dedicated_service_1.parseParamEntries)(flags.param);
+            const template = await this.resolveTemplate(templateName, flags);
+            const spec = (0, dedicated_service_1.mergeServiceTemplate)(template, given, `template ${templateName}`);
+            // Flag overrides sit over the merged spec — a template sets defaults,
+            // the invocation decides.
+            const fromFlags = (0, dedicated_service_1.specFromFlags)({
+                name: flags.name,
+                cwd: flags.cwd,
+                env: (0, dedicated_service_1.parseEnvEntries)(flags.env),
+                restart: flags.restart,
+                notify: flags.notify,
+                stopTimeoutSeconds: flags['stop-timeout'],
+                limits: {
+                    memoryMax: flags['limit-memory'],
+                    cpuQuotaPercent: flags['limit-cpu'],
+                    pidsMax: flags['limit-pids'],
+                },
+            });
+            return { ...spec, ...stripUndefined(fromFlags) };
+        }
+        return (0, dedicated_service_1.specFromFlags)({
+            name: flags.name,
+            argv,
+            cwd: flags.cwd,
+            env: (0, dedicated_service_1.parseEnvEntries)(flags.env),
+            restart: flags.restart,
+            notify: flags.notify,
+            stopTimeoutSeconds: flags['stop-timeout'],
+            limits: {
+                memoryMax: flags['limit-memory'],
+                cpuQuotaPercent: flags['limit-cpu'],
+                pidsMax: flags['limit-pids'],
+            },
+        });
+    }
+    /**
+     * `~/.skrr/templates/<name>.json` first, then the API gallery. A missing
+     * local file is a fall-through, a broken one is an error; a gallery miss
+     * names both places looked.
+     */
+    async resolveTemplate(name, flags) {
+        const local = (0, dedicated_service_1.loadLocalServiceTemplate)(name);
+        if (local)
+            return local;
+        try {
+            const channel = await this.serviceChannel();
+            const { result } = await channel.callTemplates('get', {
+                name,
+                ...this.scopeFrom(flags),
+            });
+            const template = result?.template ?? result;
+            if (template && typeof template === 'object' && template.spec) {
+                return template;
+            }
+            this.error(`Template ${name} was not found in ~/.skrr/templates/ or the gallery.`, {
+                exit: 1,
+            });
+        }
+        catch (err) {
+            // A timeout here is the API not answering `dedicated:templates:*` at
+            // all — the gallery is not served yet; name THAT, not "daemon offline".
+            if (err instanceof dedicated_service_1.DedicatedServiceError && err.code === 'SERVICE_CALL_TIMEOUT') {
+                this.error(`The template gallery is not available — ${name} was not in ~/.skrr/templates/ and this API does not serve dedicated:templates yet.`, { exit: 1 });
+            }
+            if (err instanceof dedicated_service_1.DedicatedServiceError)
+                this.reportServiceError(err);
+            this.handleApiError(err);
+        }
+    }
+}
+exports.default = DedicatedServiceCreate;
+function stripUndefined(spec) {
+    const out = {};
+    for (const [key, value] of Object.entries(spec)) {
+        if (value === undefined)
+            continue;
+        if (key === 'limits' && value && typeof value === 'object' && Object.keys(value).length === 0)
+            continue;
+        out[key] = value;
+    }
+    return out;
+}

package/dist/commands/machines/dedicated/service/edit.d.ts

@@ -0,0 +1,30 @@
+import { DedicatedServiceCommand } from '../../../../lib/dedicated-service-command';
+/**
+ * `skrr machines dedicated service edit` — change a running declaration in
+ * $EDITOR, applied as a compare-and-swap update.
+ *
+ * The round-trip is honest about the race it cannot hide: the daemon owns the
+ * spec and increments `revision` on every write, so an edit made against a
+ * stale read is refused `conflict`, never merged. When that happens your edit
+ * is saved to a named file, the editor re-opens on the CURRENT spec, and you
+ * re-apply — three rounds, then the command gives up with the file named.
+ */
+export default class DedicatedServiceEdit extends DedicatedServiceCommand {
+    static summary: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        editor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Run the editor over the temp file. Returns the new contents, or null when
+     * the file is byte-identical — an unopened or untouched edit applies
+     * nothing, which is the honest answer to "I looked and left".
+     */
+    private editFile;
+}

package/dist/commands/machines/dedicated/service/edit.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const core_1 = require("@oclif/core");
+const dedicated_service_command_1 = require("../../../../lib/dedicated-service-command");
+const dedicated_service_1 = require("../../../../lib/dedicated-service");
+/** How many times a CAS conflict re-seeds the editor before giving up. */
+const EDIT_CONFLICT_ROUNDS = 3;
+/**
+ * `skrr machines dedicated service edit` — change a running declaration in
+ * $EDITOR, applied as a compare-and-swap update.
+ *
+ * The round-trip is honest about the race it cannot hide: the daemon owns the
+ * spec and increments `revision` on every write, so an edit made against a
+ * stale read is refused `conflict`, never merged. When that happens your edit
+ * is saved to a named file, the editor re-opens on the CURRENT spec, and you
+ * re-apply — three rounds, then the command gives up with the file named.
+ */
+class DedicatedServiceEdit extends dedicated_service_command_1.DedicatedServiceCommand {
+    static summary = 'Edit a service spec in $EDITOR and apply it (CAS update)';
+    static examples = [
+        '<%= config.bin %> machines dedicated service edit <lease-id> <name>',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_service_command_1.SERVICE_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+        name: core_1.Args.string({ description: 'Service name', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        editor: core_1.Flags.string({ description: 'Editor to use (default $VISUAL, $EDITOR, then vi)' }),
+        json: core_1.Flags.boolean({ description: 'Output the updated spec as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedServiceEdit);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const editor = flags.editor ?? process.env.VISUAL ?? process.env.EDITOR ?? 'vi';
+        const channel = await this.serviceChannel();
+        const dir = (0, node_fs_1.mkdtempSync)(node_path_1.default.join((0, node_os_1.tmpdir)(), 'skrr-svc-edit-'));
+        const file = node_path_1.default.join(dir, `${args.name}.json`);
+        // Set on every path that NAMES the temp file for the user — an error that
+        // says "your edit is at <file>" must leave the file standing.
+        let keepDir = false;
+        try {
+            for (let round = 1; round <= EDIT_CONFLICT_ROUNDS; round += 1) {
+                const { result } = await channel.call('get', {
+                    leaseId,
+                    name: args.name,
+                    ...this.scopeFrom(flags),
+                });
+                const spec = result?.spec;
+                if (!spec) {
+                    this.error(`No service named ${args.name} on ${leaseId}.`, { exit: 1 });
+                }
+                const baseRevision = typeof spec.revision === 'number' ? spec.revision : undefined;
+                (0, node_fs_1.writeFileSync)(file, `${JSON.stringify(spec, null, 2)}\n`);
+                const edited = await this.editFile(file, editor);
+                if (edited === null) {
+                    this.log('Unchanged — nothing applied.');
+                    return;
+                }
+                let next;
+                try {
+                    next = (0, dedicated_service_1.parseServiceSpecDocument)(edited, file);
+                }
+                catch (err) {
+                    keepDir = true;
+                    // Keep the file so the person can fix it by hand and apply it.
+                    this.error(`${err instanceof Error ? err.message : err}\nYour edit is still at ${file} — fix it and run \`${this.config.bin} machines dedicated service apply ${leaseId} --file ${file}\`, or re-run edit.`, { exit: 2 });
+                }
+                try {
+                    const { result: updated } = await channel.call('update', {
+                        leaseId,
+                        name: args.name,
+                        patch: (0, dedicated_service_1.specPayload)(next),
+                        baseRevision,
+                        ...this.scopeFrom(flags),
+                    });
+                    this.closeServiceChannel();
+                    if (flags.json) {
+                        this.log(JSON.stringify(updated ?? (0, dedicated_service_1.specPayload)(next), null, 2));
+                        return;
+                    }
+                    this.log(`Service ${args.name} updated on ${leaseId}.`);
+                    return;
+                }
+                catch (err) {
+                    if (!(err instanceof dedicated_service_1.DedicatedServiceError && err.code === 'conflict')) {
+                        this.reportServiceError(err);
+                    }
+                    // CAS lost: preserve the edit, say where, and re-seed the editor
+                    // with the spec as it actually is now.
+                    const rejected = `${file}.rejected-${round}.json`;
+                    (0, node_fs_1.writeFileSync)(rejected, edited);
+                    if (round === EDIT_CONFLICT_ROUNDS) {
+                        keepDir = true;
+                        this.error(`The spec changed underneath the edit ${EDIT_CONFLICT_ROUNDS} times in a row. ` +
+                            `Your last edit is at ${rejected} — apply it by hand with \`${this.config.bin} machines dedicated service apply ${leaseId} --file ${rejected}\` once the machine settles.`, { exit: 1 });
+                    }
+                    keepDir = true;
+                    process.stderr.write(`[edit] the spec changed since you opened it; your edit is saved at ${rejected} and the editor re-opens on the current spec.\n`);
+                }
+            }
+        }
+        finally {
+            if (!keepDir) {
+                try {
+                    (0, node_fs_1.rmSync)(dir, { recursive: true, force: true });
+                }
+                catch {
+                    /* a file the user still needs is worth more than a clean tmpdir */
+                }
+            }
+        }
+    }
+    /**
+     * Run the editor over the temp file. Returns the new contents, or null when
+     * the file is byte-identical — an unopened or untouched edit applies
+     * nothing, which is the honest answer to "I looked and left".
+     */
+    async editFile(file, editor) {
+        const before = (0, node_fs_1.readFileSync)(file, 'utf8');
+        // sh -c so "code --wait" and friends work as one flag value.
+        const spawned = (0, node_child_process_1.spawnSync)('sh', ['-c', `${editor} "$1"`, 'sh', file], {
+            stdio: 'inherit',
+        });
+        if (spawned.error) {
+            this.error(`Could not run ${editor}: ${spawned.error.message}`, { exit: 1 });
+        }
+        if (spawned.status !== 0) {
+            this.error(`${editor} exited ${spawned.status}; nothing was applied.`, { exit: 1 });
+        }
+        const after = (0, node_fs_1.readFileSync)(file, 'utf8');
+        return after === before ? null : after;
+    }
+}
+exports.default = DedicatedServiceEdit;