@skrr-ai/cli 0.1.28 → 0.1.29

package/dist/lib/dedicated-machines.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEDICATED_FILE_MAX_BYTES = exports.DEDICATED_FILE_CHUNK_BYTES = exports.DEDICATED_EXEC_DEFAULT_TIMEOUT_MS = exports.DEDICATED_EXEC_MAX_TIMEOUT_MS = exports.DEDICATED_MACHINE_PRODUCT = exports.DEDICATED_LEASE_ACTIONS = void 0;
+exports.describeDedicatedImageStanding = describeDedicatedImageStanding;
 exports.dedicatedRuntimeCreateInput = dedicatedRuntimeCreateInput;
 exports.isDedicatedRepositoryRef = isDedicatedRepositoryRef;
 exports.createDedicatedRuntime = createDedicatedRuntime;
@@ -25,23 +26,59 @@ exports.formatUsdCents = formatUsdCents;
 exports.dedicatedSpendSummary = dedicatedSpendSummary;
 exports.describeDedicatedDeletion = describeDedicatedDeletion;
 exports.describeDedicatedLease = describeDedicatedLease;
+exports.formatDedicatedDeadline = formatDedicatedDeadline;
+exports.dedicatedDeletionLines = dedicatedDeletionLines;
 exports.dedicatedLeaseHarnesses = dedicatedLeaseHarnesses;
 exports.dedicatedLeaseIdForDaemon = dedicatedLeaseIdForDaemon;
 exports.dedicatedTerminalHarness = dedicatedTerminalHarness;
 exports.selectDedicatedAttachHarness = selectDedicatedAttachHarness;
 exports.dedicatedCatalogFromProducts = dedicatedCatalogFromProducts;
 exports.dedicatedRuntimeApiErrorCode = dedicatedRuntimeApiErrorCode;
+exports.dedicatedRuntimeApiErrorDetails = dedicatedRuntimeApiErrorDetails;
 exports.formatDedicatedRuntimeApiError = formatDedicatedRuntimeApiError;
 const api_fetch_1 = require("./api-fetch");
 const edge_error_page_1 = require("./edge-error-page");
+const harnesses_1 = require("./harnesses");
 exports.DEDICATED_LEASE_ACTIONS = [
     'start',
     'stop',
     'restart',
+    'update-image',
     'snapshot',
     'health-check',
 ];
 exports.DEDICATED_MACHINE_PRODUCT = 'dedicated-machine';
+/** One line saying where a machine's image stands and what the owner can do. */
+function describeDedicatedImageStanding(image, leaseId) {
+    const last = image.lastUpdate;
+    if (last?.status === 'applying') {
+        return `moving onto the current image${last.startedAt ? ` since ${last.startedAt}` : ''}; files are kept`;
+    }
+    if (last?.status === 'rolling_back') {
+        return 'the current image did not come back healthy; returning to the previous image, files kept';
+    }
+    const parts = [];
+    if (image.updateAvailable) {
+        parts.push(`update available${image.updateBy ? `, required by ${image.updateBy}` : ''} — \`skrr machines dedicated update-image ${leaseId || '<lease-id>'}\``);
+    }
+    else if (last?.status === 'rolled_back') {
+        parts.push('on the previous image: the current one did not come back healthy here');
+    }
+    else if (last?.status === 'failed') {
+        parts.push('the last image update did not complete on either image; files are kept');
+    }
+    else {
+        parts.push('current');
+    }
+    if (last?.status === 'succeeded' && last.settledAt)
+        parts.push(`updated ${last.settledAt}`);
+    if (last?.status === 'rolled_back' && last.settledAt) {
+        parts.push(`rolled back ${last.settledAt}`);
+    }
+    if (last?.status === 'failed' && last.settledAt)
+        parts.push(`update failed ${last.settledAt}`);
+    return parts.join(' · ');
+}
 /**
  * Flags in, request body out — and the point of it being a function is the
  * OMISSION.
@@ -61,7 +98,9 @@ function dedicatedRuntimeCreateInput(input) {
         requestId: input.requestId,
         displayName: input.displayName,
         sizePreset: input.sizePreset,
-        monthlySpendingLimitCents: input.monthlySpendingLimitCents,
+        ...(input.monthlySpendingLimitCents !== undefined
+            ? { monthlySpendingLimitCents: input.monthlySpendingLimitCents }
+            : {}),
         ...(input.regionClass ? { regionClass: input.regionClass } : {}),
         ...(input.storageGb !== undefined ? { storageGb: input.storageGb } : {}),
         ...(input.retentionClass ? { retentionClass: input.retentionClass } : {}),
@@ -226,8 +265,8 @@ async function observeDedicatedRuntimeExecution(leaseId, executionId, options) {
 /** Mirrors the daemon's bounds (daemon/src/tools/file-transfer.ts). */
 exports.DEDICATED_FILE_CHUNK_BYTES = 512 * 1024;
 exports.DEDICATED_FILE_MAX_BYTES = 64 * 1024 * 1024;
-async function readDedicatedRuntimeFileChunk(leaseId, input, scope = {}) {
-    return (0, api_fetch_1.apiFetch)(withDedicatedScope(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/files/read`, scope), { method: 'POST', body: input });
+async function readDedicatedRuntimeFileChunk(leaseId, input, scope = {}, signal) {
+    return (0, api_fetch_1.apiFetch)(withDedicatedScope(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/files/read`, scope), { method: 'POST', body: input, ...(signal ? { signal } : {}) });
 }
 async function writeDedicatedRuntimeFileChunk(leaseId, input, scope = {}) {
     return (0, api_fetch_1.apiFetch)(withDedicatedScope(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/files/write`, scope), { method: 'POST', body: input });
@@ -308,6 +347,14 @@ function describeDedicatedDeletion(deletion, leaseId) {
     if (deletion.status === 'purging') {
         return 'recovery window closed; every copy is being deleted';
     }
+    if (deletion.status === 'withheld') {
+        return deletion.restorable
+            ? `deletion stopped after the machine was shut down; files kept — \`skrr machines dedicated restore ${leaseId || '<lease-id>'}\``
+            : 'deletion stopped after the machine was shut down; files kept';
+    }
+    if (deletion.restorable && deletion.supersededByLeaseId) {
+        return `previous copy kept until ${deletion.recoverableUntil} (restored into ${deletion.supersededByLeaseId}); restorable until then — \`skrr machines dedicated restore ${leaseId || '<lease-id>'}\``;
+    }
     if (deletion.restorable) {
         return `restorable until ${deletion.recoverableUntil} — \`skrr machines dedicated restore ${leaseId || '<lease-id>'}\``;
     }
@@ -348,6 +395,9 @@ function describeDedicatedLease(lease, harnesses = []) {
     row('last backup', storage.lastBackupAt);
     const image = [resources.imageVersion || lease.daemon?.imageVersion].filter(Boolean).join('');
     row('image', image);
+    if (lease.health?.image) {
+        row('image update', describeDedicatedImageStanding(lease.health.image, dedicatedLeaseId(lease)));
+    }
     if (lease.daemon?.version || lease.daemon?.lastHeartbeatAt) {
         row('daemon', [
             lease.daemon.version ? `skrrd ${lease.daemon.version}` : '',
@@ -358,19 +408,18 @@ function describeDedicatedLease(lease, harnesses = []) {
     }
     const health = lease.health;
     if (health && typeof health.assignable === 'boolean') {
-        row('health', health.assignable
-            ? 'can take work'
-            : `not assignable${health.reasons?.length ? `: ${[...new Set(health.reasons)].join(', ')}` : ''}`);
+        const why = health.assignable
+            ? ''
+            : (0, harnesses_1.describeHealthReasonSentences)(health.reasons, dedicatedLeaseState(lease));
+        row('health', health.assignable ? 'can take work' : `not assignable${why ? `: ${why}` : ''}`);
     }
     row('spend', lease.billing ? dedicatedSpendSummary(lease) : undefined);
-    if (storage.deleteAfter || storage.unpaidSince) {
-        row('deletion', [
-            storage.unpaidSince ? `unpaid since ${storage.unpaidSince}` : '',
-            storage.deletionNoticeAt ? `notice ${storage.deletionNoticeAt}` : '',
-            storage.deleteAfter ? `workspace deleted after ${storage.deleteAfter}` : '',
-        ]
-            .filter(Boolean)
-            .join(' · '));
+    const deletionPlan = dedicatedDeletionLines(lease);
+    if (deletionPlan.length > 0) {
+        row('deletion', deletionPlan[0]);
+        for (const line of deletionPlan.slice(1)) {
+            lines.push(`  ${''.padEnd(13)}${line}`);
+        }
     }
     const deletion = storage.deletion;
     if (deletion?.status) {
@@ -394,6 +443,178 @@ function describeDedicatedLease(lease, harnesses = []) {
     row('support ref', lease.supportReference);
     return lines;
 }
+/** "2026-09-30 14:00 UTC (in 17 days)" — a deadline readable without converting it. */
+function formatDedicatedDeadline(value, now = new Date()) {
+    const at = value ? new Date(value) : null;
+    if (!at || Number.isNaN(at.getTime()))
+        return 'unknown';
+    const stamp = `${at.toISOString().slice(0, 16).replace('T', ' ')} UTC`;
+    const days = Math.round((at.getTime() - now.getTime()) / 86_400_000);
+    const relative = days === 0
+        ? 'today'
+        : days > 0
+            ? `in ${days} day${days === 1 ? '' : 's'}`
+            : `${-days} day${days === -1 ? '' : 's'} ago`;
+    return `${stamp} (${relative})`;
+}
+/** Why, by the remedy when the plan names one; by the reason for an older plan. */
+const DELETION_REASON_BY_REMEDY = {
+    pay_invoice: 'an invoice for its usage is unpaid',
+    subscribe: 'the plan it needs has ended',
+};
+const DELETION_REASON_TEXT = {
+    plan_inactive: DELETION_REASON_BY_REMEDY.subscribe,
+    subscription_canceled: 'subscription cancelled',
+    payment_failed: 'payment failed and retries finished',
+    unknown: 'billing account not in good standing',
+};
+const LEGACY_DELETION_REMEDY_TEXT = {
+    subscription_canceled: 'unless you subscribe again',
+    payment_failed: 'unless the outstanding invoice is paid',
+    unknown: 'unless billing is restored',
+};
+/** An invoice's amount in its own currency, from Stripe's minor units. */
+function formatInvoiceAmount(amountDue, currency) {
+    const code = String(currency || '').toUpperCase();
+    if (!/^[A-Z]{3}$/.test(code) || !Number.isSafeInteger(amountDue))
+        return null;
+    try {
+        const format = new Intl.NumberFormat('en-US', { style: 'currency', currency: code });
+        return format.format(amountDue / 10 ** (format.resolvedOptions().maximumFractionDigits ?? 2));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Exactly the remedy that clears the cause, as the tail of "workspace deleted
+ * after …", and the pages it is carried out at: each unpaid invoice's (for an
+ * owner who pays it), or Billing in the app to subscribe again.
+ */
+function dedicatedDeletionRemedy(plan, lease) {
+    const remedy = plan.remedy;
+    if (remedy?.kind === 'pay_invoice') {
+        if (!remedy.paidByOwner || remedy.invoices.length === 0) {
+            return {
+                clause: "unless the unpaid invoice is paid (it was sent to your workspace's billing contact)",
+                lines: [],
+            };
+        }
+        return {
+            clause: `unless the unpaid invoice${remedy.invoices.length === 1 ? ' is' : 's are'} paid`,
+            lines: [
+                ...remedy.invoices.map((invoice) => {
+                    const amount = formatInvoiceAmount(invoice.amountDue, invoice.currency);
+                    return `pay: ${amount ? `${amount} ` : ''}${invoice.hostedInvoiceUrl}`;
+                }),
+                // Read again from Stripe with the plan, like the machine's page; a link in
+                // an email can expire.
+                "a payment link in an email can expire; this one, and the machine's page on the web, stay current",
+            ],
+        };
+    }
+    if (remedy?.kind === 'subscribe') {
+        return {
+            clause: lease.workspaceId
+                ? "unless the workspace subscribes again (the workspace's Settings → Billing in the app)"
+                : 'unless you subscribe again (Billing in the app)',
+            lines: [],
+        };
+    }
+    return {
+        clause: LEGACY_DELETION_REMEDY_TEXT[plan.reason || 'unknown'] || LEGACY_DELETION_REMEDY_TEXT.unknown,
+        lines: [],
+    };
+}
+const DELETION_BLOCKER_TEXT = {
+    billing_status_unavailable: 'billing status could not be read',
+    paused: 'deletions are paused by an operator',
+    hold: 'a hold is open on this workspace',
+    other_operation_running: 'another operation on this machine is running',
+    invoice_added: 'another invoice became unpaid; a notice naming it is being sent',
+    not_stopped: 'the machine is not stopped',
+    notice_not_delivered: 'no deletion notice has reached your email yet',
+    final_notice_not_delivered: 'the final notice has not reached your email yet',
+    final_notice_resent: 'the final notice is being sent again',
+    notice_undeliverable: 'the deletion notice could not be delivered to your email',
+    email_unverified: 'your email address is not verified',
+    email_changed: 'your email address changed; the notice is being sent to the new one',
+    cause_changed: 'the billing state changed; a new notice is being sent',
+    billing_contact_unavailable: "the billing account's contact could not be read",
+    changed_concurrently: 'the lease changed while deleting',
+};
+const NOTICE_TEXT = {
+    compute_stopped: 'stopped',
+    deletion_notice: 'deletion notice',
+    early_reminder: '30-day reminder',
+    reminder: '7-day reminder',
+    final_notice: '1-day notice',
+    deletion_cancelled: 'cancellation',
+    archive_reminder: '7-day reminder',
+    archive_final_reminder: '1-day reminder',
+};
+/**
+ * The deletion plan as lines for `show`: what will happen and when first, then
+ * why, which notices reached the owner, and what is holding it back.
+ */
+function dedicatedDeletionLines(lease, now = new Date()) {
+    // ONE source: the server's plan. `storage.deleteAfter` and `unpaidSince` are
+    // its compatibility fields, and a stopped lease's stored date is a deadline only
+    // once a delivered notice started it — so they are not read here.
+    const plan = lease.storage?.deletionPlan;
+    if (!plan)
+        return [];
+    const lines = [];
+    const remedy = dedicatedDeletionRemedy(plan, lease);
+    let remedyApplies = false;
+    if (plan.kind === 'retention_period') {
+        lines.push(`workspace deleted after ${formatDedicatedDeadline(plan.deleteAfter, now)}`);
+    }
+    else if (plan.status === 'cancelled') {
+        const kept = plan.workspaceWithheld
+            ? ' — the machine had been shut down; files kept, restore them into a new machine'
+            : ' — workspace kept';
+        lines.push(`deletion cancelled ${formatDedicatedDeadline(plan.cancelledAt, now)}${plan.cancelReason === 'billing_resolved' ? ` — billing in good standing${kept}` : plan.workspaceWithheld ? kept : ''}`);
+    }
+    else if (plan.status === 'deleting') {
+        // Until its files are about to be deleted, clearing the cause still stops it.
+        remedyApplies = plan.cancellable === true;
+        lines.push(remedyApplies
+            ? `workspace is being deleted — not too late: it stops, with every file kept, ${remedy.clause.replace(/^unless /, 'if ')}`
+            : 'workspace is being deleted');
+    }
+    else if (plan.status === 'scheduled') {
+        remedyApplies = true;
+        lines.push(`workspace deleted after ${formatDedicatedDeadline(plan.deleteAfter, now)} ${remedy.clause}`);
+    }
+    else {
+        remedyApplies = true;
+        lines.push(`files kept until at least ${formatDedicatedDeadline(plan.retentionEndsAt, now)}; no deletion date until a deletion notice reaches your email, then at least ${plan.noticeFloorDays || 30} days; no deletion at all ${remedy.clause.replace(/^unless /, 'if ')}`);
+    }
+    if (remedyApplies)
+        lines.push(...remedy.lines);
+    if (plan.kind === 'unpaid' && plan.status !== 'cancelled') {
+        const unpaid = plan.remedy?.kind === 'pay_invoice';
+        const why = [
+            plan.entitlementEndedAt
+                ? `${unpaid ? 'unpaid since' : 'billing ended'} ${formatDedicatedDeadline(plan.entitlementEndedAt, now)}`
+                : '',
+            (plan.remedy && DELETION_REASON_BY_REMEDY[plan.remedy.kind]) ||
+                (plan.reason ? DELETION_REASON_TEXT[plan.reason] || plan.reason : ''),
+        ].filter(Boolean);
+        if (why.length > 0)
+            lines.push(why.join(' · '));
+    }
+    const delivered = (plan.notices || [])
+        .filter((notice) => notice.deliveredAt)
+        .map((notice) => `${NOTICE_TEXT[notice.notice] || notice.notice} ${formatDedicatedDeadline(notice.deliveredAt, now)} (${(notice.channels || []).join(', ')})`);
+    if (delivered.length > 0)
+        lines.push(`notices: ${delivered.join(' · ')}`);
+    if (plan.blockedBy) {
+        lines.push(`held back: ${DELETION_BLOCKER_TEXT[plan.blockedBy] || plan.blockedBy}`);
+    }
+    return lines;
+}
 /**
  * Every harness row a Dedicated Runtime lease's daemon registered, freshest
  * first.
@@ -609,6 +830,43 @@ function dedicatedRuntimeApiErrorCode(err) {
     }
     return err.status ? `HTTP_${err.status}` : undefined;
 }
+/**
+ * The public `details` object a refusal carried — `state`, `action` and the
+ * health `reasons` of a failed health check — for the `--json` envelope.
+ *
+ * The server builds it from an allow-list of safe values (reason codes, lease
+ * states), so it is passed through whole rather than re-filtered here, where a
+ * second list would only drift from the first.
+ */
+function dedicatedRuntimeApiErrorDetails(err) {
+    if (!(err instanceof api_fetch_1.ApiFetchError) || !err.body) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(err.body);
+        const details = parsed?.details;
+        return details && typeof details === 'object' && !Array.isArray(details)
+            ? details
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The health reasons a refusal named, deduplicated, as the sentence's tail.
+ *
+ * A failed `health-check` exists to say WHY a machine cannot take work, and the
+ * sentence alone never did: it printed "did not pass health checks." and kept
+ * `image_version_missing` to itself (OSK-8687). It then printed the codes, which
+ * say nothing to the person running it (OSK-8768); `--json` keeps them in
+ * `error.details.reasons`.
+ */
+function describeRefusalReasons(err) {
+    const details = dedicatedRuntimeApiErrorDetails(err);
+    const sentences = (0, harnesses_1.describeHealthReasonSentences)(details?.reasons, details?.state);
+    return sentences ? ` Reasons: ${sentences}` : '';
+}
 function formatDedicatedRuntimeApiError(err) {
     if (!(err instanceof api_fetch_1.ApiFetchError) || !err.body) {
         return null;
@@ -632,7 +890,8 @@ function formatDedicatedRuntimeApiError(err) {
     }
     try {
         const parsed = JSON.parse(err.body);
-        return parsed.message || parsed.error || parsed.code || null;
+        const sentence = parsed.message || parsed.error || parsed.code;
+        return sentence ? `${sentence}${describeRefusalReasons(err)}` : null;
     }
     catch {
         return err.body.trim() || null;

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

@@ -1,4 +1,5 @@
 import { io, type Socket } from 'socket.io-client';
+import { type PendingShellCommandStatus } from '@skrr-ai/data-provider';
 /**
  * A real pseudo-terminal on a Dedicated Runtime, from a local terminal.
  *
@@ -17,13 +18,6 @@ import { io, type Socket } from 'socket.io-client';
 export declare const TERMINAL_DETACH_BYTE = 29;
 /** How long the machine has to answer a start before the CLI gives up. */
 export declare const TERMINAL_START_TIMEOUT_MS = 30000;
-/**
- * When to type an initial command: once the shell has printed something and
- * then gone quiet, or after a fallback — the same heuristic the web terminal
- * uses for its Sign in menu, because both are waiting on the same login bash.
- */
-export declare const TERMINAL_READY_QUIET_MS = 300;
-export declare const TERMINAL_READY_FALLBACK_MS = 2500;
 export interface TerminalOutputFrame {
     sessionId?: string;
     daemonId?: string;
@@ -44,25 +38,11 @@ export interface TerminalStartAck {
 /** Bytes of one output frame, without splitting a UTF-8 or ANSI sequence. */
 export declare function decodeTerminalFrame(frame: TerminalOutputFrame): Buffer;
 /**
- * Types `command` once, when the shell looks ready.
- *
- * Returned as an object with injectable timers so the readiness rule is tested
- * without a PTY. `onOutput` re-arms the quiet timer; the fallback fires
- * regardless, because a shell with a silent prompt must not wait forever.
+ * What the terminal tells the user about an initial command that has not been
+ * typed. The web terminal shows the same two states with a button; here the
+ * user types it themselves.
  */
-export declare function createInitialCommandTyper(options: {
-    command: string;
-    send: (data: string) => void;
-    quietMs?: number;
-    fallbackMs?: number;
-    setTimer?: (fn: () => void, ms: number) => unknown;
-    clearTimer?: (handle: unknown) => void;
-}): {
-    start(): void;
-    onOutput(): void;
-    cancel(): void;
-    readonly typed: boolean;
-};
+export declare function describePendingCommand(status: PendingShellCommandStatus, command: string): string | null;
 export declare class DedicatedTerminalError extends Error {
     readonly code: string;
     constructor(message: string, code: string);

package/dist/lib/dedicated-terminal.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DedicatedTerminalError = exports.TERMINAL_READY_FALLBACK_MS = exports.TERMINAL_READY_QUIET_MS = exports.TERMINAL_START_TIMEOUT_MS = exports.TERMINAL_DETACH_BYTE = void 0;
+exports.DedicatedTerminalError = exports.TERMINAL_START_TIMEOUT_MS = exports.TERMINAL_DETACH_BYTE = void 0;
 exports.decodeTerminalFrame = decodeTerminalFrame;
-exports.createInitialCommandTyper = createInitialCommandTyper;
+exports.describePendingCommand = describePendingCommand;
 exports.describeTerminalStartRefusal = describeTerminalStartRefusal;
 exports.runDedicatedTerminal = runDedicatedTerminal;
 const node_crypto_1 = require("node:crypto");
@@ -27,13 +27,6 @@ const agentic_stream_1 = require("./agentic-stream");
 exports.TERMINAL_DETACH_BYTE = 0x1d;
 /** How long the machine has to answer a start before the CLI gives up. */
 exports.TERMINAL_START_TIMEOUT_MS = 30_000;
-/**
- * When to type an initial command: once the shell has printed something and
- * then gone quiet, or after a fallback — the same heuristic the web terminal
- * uses for its Sign in menu, because both are waiting on the same login bash.
- */
-exports.TERMINAL_READY_QUIET_MS = 300;
-exports.TERMINAL_READY_FALLBACK_MS = 2_500;
 /** Bytes of one output frame, without splitting a UTF-8 or ANSI sequence. */
 function decodeTerminalFrame(frame) {
     const encoded = frame.dataBase64 ?? (frame.encoding === 'base64' ? frame.data : undefined);
@@ -43,54 +36,17 @@ function decodeTerminalFrame(frame) {
     return Buffer.from(typeof frame.data === 'string' ? frame.data : '', 'utf8');
 }
 /**
- * Types `command` once, when the shell looks ready.
- *
- * Returned as an object with injectable timers so the readiness rule is tested
- * without a PTY. `onOutput` re-arms the quiet timer; the fallback fires
- * regardless, because a shell with a silent prompt must not wait forever.
+ * What the terminal tells the user about an initial command that has not been
+ * typed. The web terminal shows the same two states with a button; here the
+ * user types it themselves.
  */
-function createInitialCommandTyper(options) {
-    const setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
-    const clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
-    const quietMs = options.quietMs ?? exports.TERMINAL_READY_QUIET_MS;
-    const fallbackMs = options.fallbackMs ?? exports.TERMINAL_READY_FALLBACK_MS;
-    let typed = false;
-    let quietTimer = null;
-    let fallbackTimer = null;
-    const type = () => {
-        if (typed)
-            return;
-        typed = true;
-        if (quietTimer)
-            clearTimer(quietTimer);
-        if (fallbackTimer)
-            clearTimer(fallbackTimer);
-        options.send(`${options.command}\r`);
-    };
-    return {
-        start() {
-            if (typed || fallbackTimer)
-                return;
-            fallbackTimer = setTimer(type, fallbackMs);
-        },
-        onOutput() {
-            if (typed)
-                return;
-            if (quietTimer)
-                clearTimer(quietTimer);
-            quietTimer = setTimer(type, quietMs);
-        },
-        cancel() {
-            typed = true;
-            if (quietTimer)
-                clearTimer(quietTimer);
-            if (fallbackTimer)
-                clearTimer(fallbackTimer);
-        },
-        get typed() {
-            return typed;
-        },
-    };
+function describePendingCommand(status, command) {
+    if (status === 'overdue') {
+        return `[waiting for the shell prompt to type: ${command}; type anything and it is left to you]`;
+    }
+    if (status === 'yielded')
+        return `[not typing ${command}: you typed first]`;
+    return null;
 }
 class DedicatedTerminalError extends Error {
     code;
@@ -143,10 +99,19 @@ function runDedicatedTerminal(options) {
             // different process tree mid-command. Say it ended instead.
             reconnection: false,
         });
-        const typer = options.initialCommand
-            ? createInitialCommandTyper({
-                command: options.initialCommand,
+        // Typed only once the shell's line editor says it is reading a command line
+        // (`createPendingShellCommand`, the rule the web terminal reads too). A
+        // login profile that sleeps or asks a question is never typed into.
+        const { initialCommand } = options;
+        const pending = initialCommand
+            ? (0, data_provider_1.createPendingShellCommand)({
+                command: initialCommand,
                 send: (data) => socket.emit(events.input, { sessionId, data }),
+                onStatusChange: (status) => {
+                    const notice = describePendingCommand(status, initialCommand);
+                    if (notice && !finished)
+                        errorOutput.write(`\r\n${notice}\r\n`);
+                },
             })
             : null;
         const size = () => ({
@@ -162,26 +127,32 @@ function runDedicatedTerminal(options) {
             const detachAt = buffer.indexOf(exports.TERMINAL_DETACH_BYTE);
             if (detachAt >= 0) {
                 if (detachAt > 0) {
-                    socket.emit(events.input, {
-                        sessionId,
-                        data: buffer.subarray(0, detachAt).toString('utf8'),
-                    });
+                    const typed = buffer.subarray(0, detachAt);
+                    pending?.observeUserInput(typed);
+                    socket.emit(events.input, { sessionId, data: typed.toString('utf8') });
                 }
                 errorOutput.write('\r\n[closed the terminal]\r\n');
                 finish(0, true);
                 return;
             }
+            pending?.observeUserInput(buffer);
             socket.emit(events.input, { sessionId, data: buffer.toString('utf8') });
         };
-        const onSignal = () => finish(130, true);
+        // A terminal that closes (SIGHUP) or a supervisor that stops us (SIGTERM):
+        // put the TTY back, stop the remote shell, and exit 128 + the signal's
+        // number. Unreachable until OSK-8708 — auth-core's lock handler exited
+        // first and left the local TTY in raw mode — and it said 130, which is
+        // SIGINT's status, for both.
+        const onSigterm = () => finish(143, true);
+        const onSighup = () => finish(129, true);
         const startTimer = setTimeout(() => {
             fail(new DedicatedTerminalError('The machine did not answer the terminal start in time. Its daemon may be busy or offline.', 'TERMINAL_START_TIMEOUT'));
         }, exports.TERMINAL_START_TIMEOUT_MS);
         function restoreTty() {
             input.off('data', onInput);
             output.off('resize', onResize);
-            process.off('SIGTERM', onSignal);
-            process.off('SIGHUP', onSignal);
+            process.off('SIGTERM', onSigterm);
+            process.off('SIGHUP', onSighup);
             if (rawMode && typeof input.setRawMode === 'function') {
                 input.setRawMode(false);
                 rawMode = false;
@@ -193,7 +164,7 @@ function runDedicatedTerminal(options) {
                 return;
             finished = true;
             clearTimeout(startTimer);
-            typer?.cancel();
+            pending?.close();
             restoreTty();
             if (stopRemote && started)
                 socket.emit(events.stop, { sessionId });
@@ -205,7 +176,7 @@ function runDedicatedTerminal(options) {
                 return;
             finished = true;
             clearTimeout(startTimer);
-            typer?.cancel();
+            pending?.close();
             restoreTty();
             socket.disconnect();
             reject(error);
@@ -239,9 +210,9 @@ function runDedicatedTerminal(options) {
             input.resume();
             input.on('data', onInput);
             output.on('resize', onResize);
-            process.on('SIGTERM', onSignal);
-            process.on('SIGHUP', onSignal);
-            typer?.start();
+            process.on('SIGTERM', onSigterm);
+            process.on('SIGHUP', onSighup);
+            pending?.beginSession();
         });
         socket.on(events.output, (frame) => {
             if (!frame || frame.sessionId !== sessionId || finished)
@@ -258,8 +229,9 @@ function runDedicatedTerminal(options) {
                     errorOutput.write(`\r\n[${frame.type}] ${text}\r\n`);
                 return;
             }
-            output.write(decodeTerminalFrame(frame));
-            typer?.onOutput();
+            const bytes = decodeTerminalFrame(frame);
+            output.write(bytes);
+            pending?.observeOutput(bytes);
         });
         socket.on('disconnect', () => {
             if (finished)

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

@@ -20,6 +20,9 @@ export type DedicatedWaitGoal = {
 } | {
     kind: 'grown';
     storageGb: number;
+} | {
+    kind: 'image_updated';
+    previousUpdateStartedAt: string | null;
 };
 export type DedicatedWaitVerdict = {
     status: 'done';
@@ -37,6 +40,13 @@ export type DedicatedWaitVerdict = {
  * reading that cannot turn into the goal without someone acting again; anything
  * that might still settle is `pending`, and the caller's timeout decides how long
  * that is worth watching.
+ *
+ * Reaching the goal is not the end of the wait while the lease's operation is
+ * still in progress: `--wait` promises the operation has FINISHED, and the
+ * server refuses the next one until it has. A create read `ready` the moment its
+ * guest registered and returned, and the restart that followed was refused for
+ * minutes (OSK-8775). A server that does not report the operation is judged on
+ * the goal alone, as before.
  */
 export declare function evaluateDedicatedWait(goal: DedicatedWaitGoal, lease: DedicatedLease | undefined | null): DedicatedWaitVerdict;
 /**