@skrr-ai/cli 0.1.25 → 0.1.27

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

@@ -1,11 +1,14 @@
-import { BaseCommand } from '../../../base-command';
-export default class DedicatedMachinesStop extends BaseCommand {
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+export default class DedicatedMachinesStop extends DedicatedLeaseCommand {
     static description: string;
     static examples: string[];
     static args: {
         lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        wait: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        interval: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

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

@@ -1,42 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
-const base_command_1 = require("../../../base-command");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
 const dedicated_machines_1 = require("../../../lib/dedicated-machines");
-class DedicatedMachinesStop extends base_command_1.BaseCommand {
-    static description = 'Stop a Dedicated Runtime lease';
+class DedicatedMachinesStop extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Stop a Dedicated Runtime: compute billing ends, the workspace volume and its storage billing stay. Running processes end.';
     static examples = [
         '<%= config.bin %> machines dedicated stop <lease-id>',
-        '<%= config.bin %> machines dedicated stop <lease-id> --json',
+        '<%= config.bin %> machines dedicated stop <lease-id> --wait',
+        '<%= config.bin %> machines dedicated stop <lease-id> --wait --timeout 10m --json',
     ];
     static args = {
         lease: core_1.Args.string({
-            description: 'Dedicated Runtime lease id',
+            description: dedicated_lease_command_1.DEDICATED_LEASE_ARG_DESCRIPTION,
             required: true,
             ignoreStdin: true,
         }),
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        ...dedicated_lease_command_1.dedicatedWaitFlags,
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(DedicatedMachinesStop);
-        let response;
-        try {
-            response = await (0, dedicated_machines_1.performDedicatedLeaseAction)(args.lease, 'stop');
-        }
-        catch (err) {
-            const message = (0, dedicated_machines_1.formatDedicatedRuntimeApiError)(err);
-            if (message)
-                this.error(message, { exit: 1 });
-            this.handleApiError(err);
-        }
-        if (flags.json) {
-            this.log(JSON.stringify(response, null, 2));
-            return;
-        }
-        this.log(`Dedicated Runtime ${(0, dedicated_machines_1.dedicatedLeaseId)(response?.lease)} ${(0, dedicated_machines_1.dedicatedLeaseState)(response?.lease)}.`);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const response = await this.callDedicated(() => (0, dedicated_machines_1.performDedicatedLeaseAction)(leaseId, 'stop', this.scopeFrom(flags)));
+        await this.reportLeaseAction(response, flags, { kind: 'stopped' }, 'Stopping');
     }
 }
 exports.default = DedicatedMachinesStop;

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

@@ -0,0 +1,22 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+/**
+ * `skrr machines dedicated terminal` — the web lease card's "Open terminal",
+ * from a terminal.
+ *
+ * `exec` has no TTY and cannot drive anything that prompts, which left
+ * `gh auth login`, a REPL, a dev server's interactive setup and `claude` itself
+ * reachable only from a browser. This opens the same real PTY the web does,
+ * through the same relay and the same admission.
+ */
+export default class DedicatedMachinesTerminal extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        cwd: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        command: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const dedicated_lease_command_1 = require("../../../lib/dedicated-lease-command");
+/**
+ * `skrr machines dedicated terminal` — the web lease card's "Open terminal",
+ * from a terminal.
+ *
+ * `exec` has no TTY and cannot drive anything that prompts, which left
+ * `gh auth login`, a REPL, a dev server's interactive setup and `claude` itself
+ * reachable only from a browser. This opens the same real PTY the web does,
+ * through the same relay and the same admission.
+ */
+class DedicatedMachinesTerminal extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Open an interactive shell on a Dedicated Runtime (a real PTY, as skrr-workload). Ctrl-] closes it.';
+    static examples = [
+        '<%= config.bin %> machines dedicated terminal <lease-id>',
+        '<%= config.bin %> machines dedicated terminal <lease-id> --cwd /workspace/repos/app',
+        '<%= config.bin %> machines dedicated terminal <lease-id> --command "npm run dev"',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: 'Dedicated Runtime lease id',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        cwd: core_1.Flags.string({
+            description: 'Directory to start in (defaults to HOME, /workspace/user-data)',
+        }),
+        command: core_1.Flags.string({
+            description: 'A command to type into the shell once it is ready, as if you typed it. The shell stays open after it.',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesTerminal);
+        await this.openDedicatedTerminal(args.lease, flags, flags.command);
+    }
+}
+exports.default = DedicatedMachinesTerminal;

package/dist/commands/tasks/list.js

@@ -86,6 +86,33 @@ function emptyTasksMessage(flags, bin = 'skrr') {
         lines.push('      no longer has that status. Try `--execution-state active` (running now) or');
         lines.push(`      \`--execution-state recovered\` (reaped, startable), or \`${bin} tasks active\`.`);
     }
+    else if (typeof flags.status === 'string' &&
+        flags.status.length > 0 &&
+        !flags['execution-state']) {
+        // A filter that matches nothing and a board that IS empty print the same
+        // thing, and the caller cannot tell which they are looking at. Observed:
+        // `--status todo` on a board whose open column is `backlog` said `No tasks.`
+        // while twelve were open, and it was believed.
+        //
+        // Not fixed by validating the value, for two reasons. A status is a
+        // Space-owned workflow-state id — TASK_STATUSES is a legacy default set, not
+        // a closed vocabulary — so a space may legitimately define one we have never
+        // heard of. And `todo` IS a built-in, so refusing unknown values would not
+        // have caught the case that prompted this. What distinguishes the two
+        // readings is naming the filter and how to drop it.
+        //
+        // Silent when `--execution-state` is also set, to leave the exact bare
+        // string the branch above deliberately produces for that combination. The
+        // same ambiguity exists there, but overturning a pinned decision is not
+        // this change's business.
+        lines.push('');
+        lines.push(`Note: nothing matched \`--status ${flags.status}\`. A status is a workflow-state id the`);
+        lines.push('      space owns, so a board need not use this one at all.');
+        lines.push('  → See what this scope actually holds: the same command without `--status`.');
+        if (!data_provider_1.TASK_STATUSES.includes(flags.status)) {
+            lines.push(`      (built-in ids: ${data_provider_1.TASK_STATUSES.join(', ')})`);
+        }
+    }
     return lines.join('\n');
 }
 /**

package/dist/lib/daemonBroker.d.ts

@@ -36,6 +36,7 @@
  * liveness with `process.kill(pid, 0)` to filter stale files left behind
  * by a force-killed daemon.
  */
+import { type AuthBackend } from './auth-storage';
 import { type CliConfig } from './config';
 /**
  * Wire-shape of the bootstrap file. Mirrors
@@ -86,6 +87,13 @@ export interface DaemonBrokerResult {
      * the mint/confirm split, where the mint still revoked eagerly.
      */
     familyId?: string;
+    /**
+     * Where `attemptDaemonBrokerLoginAndPersist` actually stored the credential.
+     * Callers label the token's source from this, not from the platform: Keychain
+     * only exists on macOS, and even there a failed Keychain write falls back to
+     * the file.
+     */
+    storedIn?: Exclude<AuthBackend, 'none'>;
 }
 /**
  * Explicit reasons the broker path could fail. These exist to keep the

package/dist/lib/daemonBroker.js

@@ -527,7 +527,7 @@ async function attemptDaemonBrokerLoginAndPersist(opts) {
     if (!serverOrigin) {
         throw new Error('Daemon-broker credential persistence requires a valid CLI baseURL.');
     }
-    (0, auth_storage_1.writeToBackend)({
+    const storedIn = (0, auth_storage_1.writeToBackend)({
         token: outcome.accessToken,
         refreshToken: outcome.refreshToken,
         ...(expiryToEpochMs(outcome.accessExpiresAt) !== undefined
@@ -548,7 +548,7 @@ async function attemptDaemonBrokerLoginAndPersist(opts) {
             familyId: outcome.familyId,
         });
     }
-    return outcome;
+    return storedIn === 'none' ? outcome : { ...outcome, storedIn };
 }
 // ---------------------------------------------------------------------
 // Auto-broker on first command (BaseCommand.init hook)

package/dist/lib/dedicated-copy.d.ts

@@ -0,0 +1,22 @@
+import { readDedicatedRuntimeFileChunk, writeDedicatedRuntimeFileChunk, type DedicatedRuntimeScope } from './dedicated-machines';
+/**
+ * The two copy loops behind `skrr machines dedicated cp`.
+ *
+ * One API request per 512 KiB chunk, so every chunk passes the same owner
+ * check, generation fence and daemon file policy as any other access to the
+ * machine. Neither end is replaced until the whole file has arrived: an upload
+ * stages beside its destination on the machine and the final chunk renames it;
+ * a download writes a temporary file beside its local destination and renames.
+ */
+export interface DedicatedCopyIo {
+    readChunk: typeof readDedicatedRuntimeFileChunk;
+    writeChunk: typeof writeDedicatedRuntimeFileChunk;
+    chunkBytes: number;
+    maxBytes: number;
+}
+export interface DedicatedCopyResult {
+    bytes: number;
+    destination: string;
+}
+export declare function uploadToDedicatedRuntime(localPath: string, leaseId: string, remotePath: string, scope?: DedicatedRuntimeScope, io?: Partial<DedicatedCopyIo>): Promise<DedicatedCopyResult>;
+export declare function downloadFromDedicatedRuntime(leaseId: string, remotePath: string, localPath: string, scope?: DedicatedRuntimeScope, io?: Partial<DedicatedCopyIo>): Promise<DedicatedCopyResult>;

package/dist/lib/dedicated-copy.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadToDedicatedRuntime = uploadToDedicatedRuntime;
+exports.downloadFromDedicatedRuntime = downloadFromDedicatedRuntime;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const dedicated_machines_1 = require("./dedicated-machines");
+const defaultIo = {
+    readChunk: dedicated_machines_1.readDedicatedRuntimeFileChunk,
+    writeChunk: dedicated_machines_1.writeDedicatedRuntimeFileChunk,
+    chunkBytes: dedicated_machines_1.DEDICATED_FILE_CHUNK_BYTES,
+    maxBytes: dedicated_machines_1.DEDICATED_FILE_MAX_BYTES,
+};
+function mib(bytes) {
+    return `${Math.round((bytes / (1024 * 1024)) * 10) / 10} MiB`;
+}
+async function uploadToDedicatedRuntime(localPath, leaseId, remotePath, scope = {}, io = {}) {
+    const { writeChunk, chunkBytes, maxBytes } = { ...defaultIo, ...io };
+    const info = await (0, promises_1.stat)(localPath);
+    if (!info.isFile()) {
+        throw new Error(`${localPath} is not a regular file`);
+    }
+    if (info.size > maxBytes) {
+        throw new Error(`${localPath} is ${mib(info.size)}; copy is limited to ${mib(maxBytes)}. Push it through Git or object storage instead.`);
+    }
+    const transferId = `cp-${Date.now().toString(36)}-${(0, node_crypto_1.randomBytes)(6).toString('hex')}`;
+    const handle = await (0, promises_1.open)(localPath, 'r');
+    try {
+        const buffer = Buffer.alloc(chunkBytes);
+        let offset = 0;
+        for (;;) {
+            const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, offset);
+            const final = offset + bytesRead >= info.size;
+            if (!final && bytesRead === 0) {
+                throw new Error(`${localPath} shrank while it was being copied`);
+            }
+            const result = await writeChunk(leaseId, {
+                path: remotePath,
+                transferId,
+                offset,
+                dataBase64: buffer.subarray(0, bytesRead).toString('base64'),
+                // A file that GREW is caught here: the machine refuses to commit
+                // when what it staged is not the size declared at the start.
+                ...(final ? { final: true, totalSize: info.size } : {}),
+            }, scope);
+            offset += bytesRead;
+            if (final) {
+                return { bytes: offset, destination: `${leaseId}:${result.path || remotePath}` };
+            }
+        }
+    }
+    catch (err) {
+        // Best effort: remove the staged partial so it does not sit beside the
+        // destination. The destination itself was never touched.
+        await writeChunk(leaseId, { path: remotePath, transferId, offset: 0, abort: true }, scope).catch(() => undefined);
+        throw err;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function downloadFromDedicatedRuntime(leaseId, remotePath, localPath, scope = {}, io = {}) {
+    const { readChunk, chunkBytes } = { ...defaultIo, ...io };
+    let target = localPath;
+    try {
+        if ((await (0, promises_1.stat)(localPath)).isDirectory()) {
+            target = (0, node_path_1.join)(localPath, (0, node_path_1.basename)(remotePath));
+        }
+    }
+    catch {
+        // Does not exist yet: it names the file.
+    }
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(target), { recursive: true });
+    const temporary = (0, node_path_1.join)((0, node_path_1.dirname)(target), `.${(0, node_path_1.basename)(target)}.skrr-download-${(0, node_crypto_1.randomBytes)(6).toString('hex')}`);
+    const handle = await (0, promises_1.open)(temporary, 'wx');
+    let closed = false;
+    let offset = 0;
+    let size = -1;
+    let mtimeMs = -1;
+    try {
+        for (;;) {
+            const chunk = await readChunk(leaseId, { path: remotePath, offset, length: chunkBytes }, scope);
+            if (size === -1) {
+                size = chunk.size;
+                mtimeMs = chunk.mtimeMs;
+            }
+            else if (chunk.size !== size || chunk.mtimeMs !== mtimeMs) {
+                // Chunks from two versions of a file splice into one that never existed.
+                throw new Error(`${remotePath} changed on the machine while it was being copied`);
+            }
+            const bytes = Buffer.from(chunk.dataBase64, 'base64');
+            if (bytes.byteLength !== chunk.bytesRead) {
+                throw new Error('A chunk arrived damaged; nothing was written to the destination');
+            }
+            await handle.write(bytes, 0, bytes.byteLength, offset);
+            offset += bytes.byteLength;
+            if (chunk.eof)
+                break;
+            if (bytes.byteLength === 0) {
+                throw new Error(`${remotePath} ended before its reported size`);
+            }
+        }
+        await handle.close();
+        closed = true;
+        await (0, promises_1.rename)(temporary, target);
+        return { bytes: offset, destination: target };
+    }
+    catch (err) {
+        if (!closed)
+            await handle.close().catch(() => undefined);
+        await (0, promises_1.unlink)(temporary).catch(() => undefined);
+        throw err;
+    }
+}

package/dist/lib/dedicated-exec.d.ts

@@ -0,0 +1,80 @@
+import { execDedicatedRuntime, observeDedicatedRuntimeExecution, startDedicatedRuntimeExecution, type DedicatedRuntimeExecInput, type DedicatedRuntimeExecResult, type DedicatedRuntimeScope } from './dedicated-machines';
+/**
+ * `skrr machines dedicated exec`, as a start and a series of short observations
+ * (OSK-8705).
+ *
+ * The command used to be one request held open for as long as it ran. Behind
+ * CloudFront that request died at 60 s with an HTML 504 while the command kept
+ * running, and the page's advice — try again — ran it twice. Now no request
+ * lasts longer than one bounded observation, so no proxy timeout in front of
+ * the API decides whether the caller learns the exit code:
+ *
+ *   1. START under one idempotency key. A start whose answer never arrived (a
+ *      dropped connection, a gateway page) is sent again with the SAME key, and
+ *      the server returns the execution it already started — never a second run.
+ *   2. OBSERVE, letting the server hold each answer up to 20 s, until the
+ *      command ends. A failed observation is only a failed read; it is retried.
+ *   3. PRINT exactly what the synchronous route printed: the same result, the
+ *      same refusal body, the same exit code.
+ *
+ * Against a server that predates `executions`, it falls back to the synchronous
+ * route and says what that costs — but only on the FIRST start of a request id
+ * this invocation minted. A 404 without a product code proves the task that
+ * answered has no such route, not that no other task started the command; in a
+ * mixed fleet (a rolling deploy, a rollback) only the first attempt can rely on
+ * it. Every other case retries the same id or stops with the id to repeat.
+ */
+/** How long each observation lets the server hold the answer. */
+export declare const EXEC_OBSERVE_WAIT_MS = 20000;
+/** A request id is the idempotency key; the server accepts exactly this shape. */
+export declare const EXEC_REQUEST_ID_PATTERN: RegExp;
+export declare function newExecRequestId(): string;
+/** The CLI stopped hearing about a command it started. The command may still run. */
+export declare class DedicatedExecContactLostError extends Error {
+    readonly requestId: string;
+    readonly executionId: string;
+    readonly code = "DEDICATED_RUNTIME_EXECUTION_CONTACT_LOST";
+    constructor(requestId: string, executionId: string, cause: unknown);
+}
+/** No start request got an answer from the API, so whether the command started is unknown. */
+export declare class DedicatedExecStartUnconfirmedError extends Error {
+    readonly requestId: string;
+    readonly code = "DEDICATED_RUNTIME_EXECUTION_START_UNCONFIRMED";
+    constructor(requestId: string, cause: unknown);
+}
+/**
+ * The server has no `executions` route, but this invocation carries a request id
+ * it chose: falling back to the single-request route would ignore that id, and a
+ * run it already started elsewhere would happen twice.
+ */
+export declare class DedicatedExecIdempotencyUnsupportedError extends Error {
+    readonly requestId: string;
+    readonly code = "DEDICATED_RUNTIME_EXECUTION_REQUEST_ID_UNSUPPORTED";
+    constructor(requestId: string);
+}
+export interface DedicatedExecIo {
+    start: typeof startDedicatedRuntimeExecution;
+    observe: typeof observeDedicatedRuntimeExecution;
+    legacyExec: typeof execDedicatedRuntime;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+    /** A line about the invocation (not the command's output), for stderr. */
+    notice: (message: string) => void;
+    signal: (ms: number) => AbortSignal | undefined;
+}
+/** The server answered, but has no `executions` route: nothing was started. */
+export declare function isMissingExecutionsEndpoint(err: unknown): boolean;
+export interface RunDedicatedExecOptions extends DedicatedRuntimeScope {
+    /** Idempotency key. Pass one to be able to repeat the invocation safely. */
+    requestId?: string;
+}
+export declare function runDedicatedExec(leaseId: string, input: DedicatedRuntimeExecInput, options?: RunDedicatedExecOptions, io?: Partial<DedicatedExecIo>): Promise<DedicatedRuntimeExecResult>;
+/**
+ * What was cut. A started command's stored outcome keeps at most the last
+ * 256 KiB of what the machine returned (`outputBytes` is the whole); the
+ * single-request route caps at 1 MB from the start.
+ */
+export declare function describeTruncation(result: {
+    stdout: string;
+    outputBytes?: number;
+}): string;