@skrr-ai/cli 0.1.27 → 0.1.29

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

@@ -3,9 +3,10 @@ import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
  * `skrr machines dedicated sign-in` — the lease card's Sign in menu.
  *
  * Opens the machine's terminal and types the tool's sign-in command once the
- * shell is ready. The commands are the SAME fixed strings the web offers,
- * declared once in `@skrr-ai/data-provider`; each is a device-code or
- * paste-a-code flow, because the machine has no browser.
+ * shell is reading a command line, by the rule the web terminal uses
+ * (`createPendingShellCommand`). The commands are the SAME fixed strings the
+ * web offers, declared once in `@skrr-ai/data-provider`; each is a device-code
+ * or paste-a-code flow, because the machine has no browser.
  */
 export default class DedicatedMachinesSignIn extends DedicatedLeaseCommand {
     static description: string;

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

@@ -8,9 +8,10 @@ const TOOLS = data_provider_1.DEDICATED_RUNTIME_SIGN_IN_PRESETS.map((preset) =>
  * `skrr machines dedicated sign-in` — the lease card's Sign in menu.
  *
  * Opens the machine's terminal and types the tool's sign-in command once the
- * shell is ready. The commands are the SAME fixed strings the web offers,
- * declared once in `@skrr-ai/data-provider`; each is a device-code or
- * paste-a-code flow, because the machine has no browser.
+ * shell is reading a command line, by the rule the web terminal uses
+ * (`createPendingShellCommand`). The commands are the SAME fixed strings the
+ * web offers, declared once in `@skrr-ai/data-provider`; each is a device-code
+ * or paste-a-code flow, because the machine has no browser.
  */
 class DedicatedMachinesSignIn extends dedicated_lease_command_1.DedicatedLeaseCommand {
     static description = 'Sign in to GitHub CLI, Claude Code or Codex on a Dedicated Runtime, in an interactive terminal. The sign-in is shared by everything that runs on the machine, agents included.';

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

@@ -30,7 +30,7 @@ class DedicatedMachinesTerminal extends dedicated_lease_command_1.DedicatedLease
             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.',
+            description: 'A command to type into the shell once it shows its prompt, as if you typed it. Not typed if you type first. The shell stays open after it.',
         }),
     };
     async run() {

package/dist/commands/machines/dedicated/update-image.d.ts

@@ -0,0 +1,15 @@
+import { DedicatedLeaseCommand } from '../../../lib/dedicated-lease-command';
+export default class DedicatedMachinesUpdateImage 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/update-image.js

@@ -0,0 +1,38 @@
+"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_machines_1 = require("../../../lib/dedicated-machines");
+class DedicatedMachinesUpdateImage extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'Move a Dedicated Runtime onto the current root image now, instead of at its next start or restart. The machine is replaced: files under the workspace are kept; memory, shells and background jobs are not. If the new image does not come back healthy, the machine returns to its previous image. With --wait, succeeds only once the move is judged healthy.';
+    static examples = [
+        '<%= config.bin %> machines dedicated update-image <lease-id>',
+        '<%= config.bin %> machines dedicated update-image <lease-id> --wait',
+        '<%= config.bin %> machines dedicated update-image <lease-id> --wait --timeout 20m --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' }),
+        ...dedicated_lease_command_1.dedicatedWaitFlags,
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesUpdateImage);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const response = await this.callDedicated(() => (0, dedicated_machines_1.performDedicatedLeaseAction)(leaseId, 'update-image', this.scopeFrom(flags)));
+        // A machine that rolled back to its previous image is running too, so the
+        // state cannot say whether the update worked. The update's own record can:
+        // the 202 carries the previous one, and success is a newer one, judged healthy.
+        await this.reportLeaseAction(response, flags, {
+            kind: 'image_updated',
+            previousUpdateStartedAt: response?.lease?.health?.image?.lastUpdate?.startedAt ?? null,
+        }, 'Updating image of');
+    }
+}
+exports.default = DedicatedMachinesUpdateImage;

package/dist/lib/balance.d.ts

@@ -1,3 +1,4 @@
+import type { TSkyCodeUsageSnapshot } from '@skrr-ai/data-provider';
 /**
  * balance.ts — request client for `/api/balance`.
  *
@@ -77,8 +78,7 @@ export interface BalanceHistory {
 }
 /** The account's current credits, limit and period usage. */
 export declare function getBalance(): Promise<BalanceStatus>;
-/** Aggregate usage summary. Shape is owned by `getUsageSummary` server-side. */
-export declare function getBalanceUsage(): Promise<Record<string, unknown>>;
+export declare function getSkyCodeUsage(workspaceId?: string): Promise<TSkyCodeUsageSnapshot>;
 /** Recent token transactions, newest first. Cursor is an ISO createdAt. */
 export declare function getBalanceHistory(limit: number, cursor?: string): Promise<BalanceHistory>;
 /**

package/dist/lib/balance.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CREDITS_PER_USD = void 0;
 exports.getBalance = getBalance;
-exports.getBalanceUsage = getBalanceUsage;
+exports.getSkyCodeUsage = getSkyCodeUsage;
 exports.getBalanceHistory = getBalanceHistory;
 exports.formatCredits = formatCredits;
 exports.getWorkspaceBalance = getWorkspaceBalance;
@@ -21,9 +21,11 @@ const api_fetch_1 = require("./api-fetch");
 async function getBalance() {
     return (0, api_fetch_1.apiFetch)('/api/balance');
 }
-/** Aggregate usage summary. Shape is owned by `getUsageSummary` server-side. */
-async function getBalanceUsage() {
-    return (0, api_fetch_1.apiFetch)('/api/balance/usage');
+async function getSkyCodeUsage(workspaceId) {
+    const path = workspaceId
+        ? `/api/balance/usage/sky-code/workspace/${encodeURIComponent(workspaceId)}`
+        : '/api/balance/usage/sky-code';
+    return (0, api_fetch_1.apiFetch)(path);
 }
 /** Recent token transactions, newest first. Cursor is an ISO createdAt. */
 async function getBalanceHistory(limit, cursor) {

package/dist/lib/daemon-target.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Which daemon a command acts on when the caller does not name one.
+ *
+ * ── Why this is not just "the only active daemon" ──────────────────────────
+ *
+ * A daemon list is an ACCOUNT fact: every machine the owner has ever connected —
+ * a laptop, a Hosted Machine, an E2B sandbox, each Dedicated Runtime. On a
+ * laptop that is a fine basis for a default, because the machine a person is
+ * typing on is one row among the others and nothing local says which. A
+ * Dedicated Runtime guest is different: the CLI there knows, from the machine
+ * itself, that it is running on one particular daemon's machine. Choosing from
+ * the account list anyway is what OSK-8759 was — `skrr code install` typed into
+ * a guest terminal answered `AMBIGUOUS_DAEMON` and offered the owner's laptop and
+ * two sandboxes as install targets for a machine that was right there.
+ *
+ * So the default is the machine this process runs on WHEN the machine can say so,
+ * and the account list otherwise. Laptop behaviour is unchanged: nothing below
+ * reads anything on a machine that is not a guest.
+ *
+ * ── The two local signals, and why these two ───────────────────────────────
+ *
+ *  1. "This process is tenant code on a Dedicated Runtime guest" —
+ *     {@link isDedicatedRuntimeWorkload}: the workload exec wrapper stamps
+ *     `SKRR_WORKLOAD_UID` into everything it launches and the process must also
+ *     BE that uid. Every tenant lane (terminal, Bash tool, `machines dedicated
+ *     exec`, an engine session) passes through that wrapper, and it is the test
+ *     the daemon applies itself.
+ *  2. "…and this is its daemon" — the daemon's workload CLI hand-off descriptor
+ *     (`daemon/src/dedicated-cli-handoff.ts`). The daemon writes it into its own
+ *     unit RuntimeDirectory, which tenant code can read (group `skrr-workspace`)
+ *     and can neither create nor replace, and it carries the id that daemon
+ *     registered with. It disappears when the daemon stops.
+ *
+ * Not used, deliberately: `/etc/skrr-dedicated-runtime/attestation.json` is the
+ * IMAGE's record — it proves the image is a Dedicated Runtime and names engine
+ * versions, but it is identical on every machine built from that image and names
+ * no daemon. The daemon id in the unit's environment (`OVERSKY_DAEMON_ID`) never
+ * reaches tenant lanes: the spawn sanitizer strips `OVERSKY_*`, and the human
+ * terminal's environment is an allow-list.
+ *
+ * None of this authorizes anything. The server decides whether this caller may
+ * act on that daemon; a wrong answer here only changes which question is asked.
+ */
+import type { ResolvedCredential } from './credential-resolver';
+/** What this process can establish, locally, about the machine it runs on. */
+export interface LocalMachine {
+    /** True when this process is tenant code on a Dedicated Runtime guest. */
+    dedicatedRuntime: boolean;
+    /**
+     * The id this machine's daemon registered with, when the daemon has published
+     * it where this process can read it and for the deployment this CLI talks to.
+     * Null otherwise — including on every machine that is not a guest.
+     */
+    daemonId: string | null;
+}
+export interface LocalMachineOptions {
+    env?: NodeJS.ProcessEnv;
+    getuid?: (() => number) | undefined;
+    /** The CLI's own base URL. A daemon signed in to another deployment is not one of this account's rows. */
+    baseURL?: string;
+    /** Test seam only. Production reads the fixed, root-controlled path. */
+    descriptorPath?: string;
+}
+export declare function localMachine(options?: LocalMachineOptions): LocalMachine;
+export interface ActiveDaemonRow {
+    id: string;
+    name?: string;
+    isActive?: boolean;
+}
+export type DaemonTarget = 
+/**
+ * The daemon of the machine this CLI runs on. `explicit` says whether the
+ * caller named it. `daemonId` is null when the machine is known to be a guest
+ * but its daemon has not published an id this process can read — a command
+ * that needs the id must then ask for `--daemon`.
+ */
+{
+    kind: 'this-machine';
+    machine: 'dedicated-runtime';
+    daemonId: string | null;
+    explicit: boolean;
+}
+/** A daemon that is not known to be this machine's. */
+ | {
+    kind: 'daemon';
+    daemonId: string;
+    explicit: boolean;
+} | {
+    kind: 'none';
+} | {
+    kind: 'ambiguous';
+    daemons: ActiveDaemonRow[];
+};
+export interface ResolveDaemonTargetInput {
+    /** The `--daemon` value as typed, decoration and all. */
+    explicit?: string;
+    local: LocalMachine;
+    /** Only consulted when neither the caller nor the machine settles it. */
+    listActiveDaemons: () => Promise<ActiveDaemonRow[]>;
+}
+export declare function resolveDaemonTarget(input: ResolveDaemonTargetInput): Promise<DaemonTarget>;
+/** The same list `skrr list-daemons` prints, so a refusal can name values that work. */
+export declare function listActiveDaemons(credential: ResolvedCredential): Promise<ActiveDaemonRow[]>;

package/dist/lib/daemon-target.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Which daemon a command acts on when the caller does not name one.
+ *
+ * ── Why this is not just "the only active daemon" ──────────────────────────
+ *
+ * A daemon list is an ACCOUNT fact: every machine the owner has ever connected —
+ * a laptop, a Hosted Machine, an E2B sandbox, each Dedicated Runtime. On a
+ * laptop that is a fine basis for a default, because the machine a person is
+ * typing on is one row among the others and nothing local says which. A
+ * Dedicated Runtime guest is different: the CLI there knows, from the machine
+ * itself, that it is running on one particular daemon's machine. Choosing from
+ * the account list anyway is what OSK-8759 was — `skrr code install` typed into
+ * a guest terminal answered `AMBIGUOUS_DAEMON` and offered the owner's laptop and
+ * two sandboxes as install targets for a machine that was right there.
+ *
+ * So the default is the machine this process runs on WHEN the machine can say so,
+ * and the account list otherwise. Laptop behaviour is unchanged: nothing below
+ * reads anything on a machine that is not a guest.
+ *
+ * ── The two local signals, and why these two ───────────────────────────────
+ *
+ *  1. "This process is tenant code on a Dedicated Runtime guest" —
+ *     {@link isDedicatedRuntimeWorkload}: the workload exec wrapper stamps
+ *     `SKRR_WORKLOAD_UID` into everything it launches and the process must also
+ *     BE that uid. Every tenant lane (terminal, Bash tool, `machines dedicated
+ *     exec`, an engine session) passes through that wrapper, and it is the test
+ *     the daemon applies itself.
+ *  2. "…and this is its daemon" — the daemon's workload CLI hand-off descriptor
+ *     (`daemon/src/dedicated-cli-handoff.ts`). The daemon writes it into its own
+ *     unit RuntimeDirectory, which tenant code can read (group `skrr-workspace`)
+ *     and can neither create nor replace, and it carries the id that daemon
+ *     registered with. It disappears when the daemon stops.
+ *
+ * Not used, deliberately: `/etc/skrr-dedicated-runtime/attestation.json` is the
+ * IMAGE's record — it proves the image is a Dedicated Runtime and names engine
+ * versions, but it is identical on every machine built from that image and names
+ * no daemon. The daemon id in the unit's environment (`OVERSKY_DAEMON_ID`) never
+ * reaches tenant lanes: the spawn sanitizer strips `OVERSKY_*`, and the human
+ * terminal's environment is an allow-list.
+ *
+ * None of this authorizes anything. The server decides whether this caller may
+ * act on that daemon; a wrong answer here only changes which question is asked.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localMachine = localMachine;
+exports.resolveDaemonTarget = resolveDaemonTarget;
+exports.listActiveDaemons = listActiveDaemons;
+const api_fetch_1 = require("./api-fetch");
+const daemonBroker_1 = require("./daemonBroker");
+const daemon_ref_1 = require("./daemon-ref");
+const sky_code_1 = require("./sky-code");
+function localMachine(options = {}) {
+    const env = options.env ?? process.env;
+    const getuid = 'getuid' in options ? options.getuid : process.getuid?.bind(process);
+    if (!(0, sky_code_1.isDedicatedRuntimeWorkload)(env, getuid))
+        return { dedicatedRuntime: false, daemonId: null };
+    return { dedicatedRuntime: true, daemonId: publishedDaemonId(options) };
+}
+function publishedDaemonId(options) {
+    // `readBootstrap` is the parser the hand-off itself uses, so "a descriptor this
+    // CLI would broker through" and "a descriptor this CLI reads an id from" cannot
+    // disagree about what a valid one looks like — including a stale one whose
+    // daemon has exited.
+    const descriptor = (0, daemonBroker_1.readBootstrap)(options.descriptorPath ?? daemonBroker_1.DEDICATED_RUNTIME_CLI_HANDOFF_DESCRIPTOR);
+    const daemonId = typeof descriptor?.daemonId === 'string' ? descriptor.daemonId.trim() : '';
+    if (!daemonId)
+        return null;
+    const published = (0, daemonBroker_1.normalizeBaseUrl)(descriptor?.serverUrl);
+    const ours = (0, daemonBroker_1.normalizeBaseUrl)(options.baseURL);
+    if (published && ours && published !== ours)
+        return null;
+    return daemonId;
+}
+async function resolveDaemonTarget(input) {
+    const explicit = input.explicit?.trim() ? (0, daemon_ref_1.normalizeDaemonRef)(input.explicit) : '';
+    if (explicit) {
+        // Exact equality only. The display form is an 8-character prefix, and every
+        // guest daemon id begins `dedicated-runtime-`, so a prefix match would call
+        // any of the owner's guests "this machine".
+        if (input.local.dedicatedRuntime && input.local.daemonId === explicit) {
+            return {
+                kind: 'this-machine',
+                machine: 'dedicated-runtime',
+                daemonId: explicit,
+                explicit: true,
+            };
+        }
+        return { kind: 'daemon', daemonId: explicit, explicit: true };
+    }
+    if (input.local.dedicatedRuntime) {
+        return {
+            kind: 'this-machine',
+            machine: 'dedicated-runtime',
+            daemonId: input.local.daemonId,
+            explicit: false,
+        };
+    }
+    const daemons = (await input.listActiveDaemons()).filter((d) => d.isActive !== false);
+    if (daemons.length === 1)
+        return { kind: 'daemon', daemonId: daemons[0].id, explicit: false };
+    if (daemons.length === 0)
+        return { kind: 'none' };
+    return { kind: 'ambiguous', daemons };
+}
+/** The same list `skrr list-daemons` prints, so a refusal can name values that work. */
+async function listActiveDaemons(credential) {
+    const res = await (0, api_fetch_1.apiFetch)('/api/daemon-resources?status=active&limit=50', { credential });
+    return res.daemons ?? [];
+}

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

@@ -7,16 +7,106 @@ import { readDedicatedRuntimeFileChunk, writeDedicatedRuntimeFileChunk, type Ded
  * 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.
+ *
+ * And neither leaves its partial behind when it is cancelled (OSK-8708).
+ * `listenForCopyInterrupt` turns SIGINT, SIGTERM and SIGHUP into an
+ * AbortSignal the loops honour; a download also removes its temporary file from
+ * a process exit handler, for the exits nothing waits for.
  */
 export interface DedicatedCopyIo {
     readChunk: typeof readDedicatedRuntimeFileChunk;
     writeChunk: typeof writeDedicatedRuntimeFileChunk;
     chunkBytes: number;
     maxBytes: number;
+    /** Run `fn` if the process exits; returns the unregister. Injectable for tests. */
+    onProcessExit: (fn: () => void) => () => void;
+}
+export interface DedicatedCopyOptions extends Partial<DedicatedCopyIo> {
+    /** Cancels the copy, which then removes its partial file before it rejects. */
+    signal?: AbortSignal;
+    /** Called after every chunk with the bytes copied so far and the file's size. */
+    onProgress?: (copied: number, total: number) => void;
+}
+/**
+ * A refusal the CLI makes itself, with the code the server uses for the same
+ * cause. A file over the limit, a file that changed and a file that is missing
+ * each read one way and carry one code whichever side found it; the server's
+ * sentences are in `DedicatedRuntimeMachineAccess.mapFileTransferError`
+ * (OSK-8714). Before, these local refusals had no code at all.
+ */
+export declare class DedicatedCopyError extends Error {
+    readonly code: 'DEDICATED_RUNTIME_FILE_TOO_LARGE' | 'DEDICATED_RUNTIME_FILE_CHANGED' | 'DEDICATED_RUNTIME_FILE_NOT_FOUND' | 'DEDICATED_RUNTIME_PATH_NOT_A_FILE' | 'DEDICATED_RUNTIME_FILE_TRANSFER_FAILED';
+    constructor(code: 'DEDICATED_RUNTIME_FILE_TOO_LARGE' | 'DEDICATED_RUNTIME_FILE_CHANGED' | 'DEDICATED_RUNTIME_FILE_NOT_FOUND' | 'DEDICATED_RUNTIME_PATH_NOT_A_FILE' | 'DEDICATED_RUNTIME_FILE_TRANSFER_FAILED', message: string);
+}
+declare const SIGNAL_NUMBERS: {
+    readonly SIGHUP: 1;
+    readonly SIGINT: 2;
+    readonly SIGTERM: 15;
+};
+export type CopyInterruptSignal = keyof typeof SIGNAL_NUMBERS;
+/** A copy stopped by SIGINT, SIGTERM or SIGHUP. Exits 128 + the signal's number, as a shell would. */
+export declare class DedicatedCopyCancelledError extends Error {
+    readonly signalName: CopyInterruptSignal;
+    readonly code = "DEDICATED_RUNTIME_COPY_CANCELLED";
+    readonly exitCode: number;
+    constructor(signalName: CopyInterruptSignal);
 }
+export interface CopyInterruptListener {
+    /** Aborted by the first SIGINT, SIGTERM or SIGHUP, with a DedicatedCopyCancelledError as its reason. */
+    signal: AbortSignal;
+    /** The signal that cancelled the copy, if one did. */
+    interruptedBy: () => CopyInterruptSignal | null;
+    /** Stop listening. Call it once the copy has settled. */
+    dispose: () => void;
+}
+/**
+ * Listen for SIGINT, SIGTERM and SIGHUP for the length of one copy.
+ *
+ * An ordinary command-level listener, nothing more. The lock-release handler
+ * every command inherits defers to it (`installLockExitHandlers`,
+ * packages/auth-core/src/refresh.ts): the first signal reaches this listener,
+ * which aborts the copy so the loop removes its partial and rejects; a second
+ * signal, or a cleanup that hangs past auth-core's fallback, exits the process,
+ * and a download's exit handler still removes its temporary file then.
+ */
+export declare function listenForCopyInterrupt({ proc, notice, }?: {
+    proc?: Pick<NodeJS.EventEmitter, 'on' | 'removeListener'>;
+    notice?: (message: string) => void;
+}): CopyInterruptListener;
 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>;
+/**
+ * One line of progress for a terminal, redrawn in place: a 60 MiB copy takes
+ * about forty seconds, and printed nothing until it ended (OSK-8714). The
+ * caller decides whether there is a terminal to draw on.
+ */
+export declare function createCopyProgress({ label, write, now, }: {
+    label: string;
+    write: (text: string) => void;
+    now?: () => number;
+}): {
+    update: (copied: number, total: number) => void;
+    clear: () => void;
+};
+/** Whether a CI system is running this. Progress is for a person watching. */
+export declare function isContinuousIntegration(env?: NodeJS.ProcessEnv): boolean;
+/** `dir/`, `dir/.` or `.`: a machine path that names a directory to copy into. */
+export declare function namesRemoteDirectory(remotePath: string): boolean;
+/** `name` inside the machine directory `directory`, however it was spelled. */
+export declare function intoRemoteDirectory(directory: string, name: string): string;
+/**
+ * Upload one file. A destination that is a directory — spelled `dir/`, or an
+ * existing directory named without the slash — receives the file under its own
+ * name, as `cp` and `scp` do and as a download into a local directory already
+ * did. Before, `cp tiny.txt <lease>:repos/scout-a/` sent the whole file and then
+ * failed the machine's final rename with EISDIR (OSK-8713).
+ *
+ * `dir/` is resolved here, without asking. A directory named without the slash
+ * is found out by the machine, which refuses it on the first chunk before
+ * anything is staged; the copy then goes into it, once.
+ */
+export declare function uploadToDedicatedRuntime(localPath: string, leaseId: string, remotePath: string, scope?: DedicatedRuntimeScope, io?: DedicatedCopyOptions): Promise<DedicatedCopyResult>;
+export declare function downloadFromDedicatedRuntime(leaseId: string, remotePath: string, localPath: string, scope?: DedicatedRuntimeScope, io?: DedicatedCopyOptions): Promise<DedicatedCopyResult>;
+export {};