@skrr-ai/cli 0.1.91 → 0.1.92

package/dist/commands/machines/dedicated/power/index.js

@@ -6,7 +6,7 @@ const core_1 = require("@oclif/core");
  * on its own. `set` is the standing policy; more verbs arrive with the power card.
  */
 class DedicatedMachinesPower extends core_1.Command {
-    static description = 'Power policy of a Dedicated Runtime — when it may stop and start on its own. Files are preserved across stops.\n\nSubcommands:\n  show        state, policy, holders, usage, next wake\n  explain     why it stayed on, stopped or woke, and the fix\n  set         always_on | on_demand | manual (+ --idle-after, --budget-hours)\n  keep-awake  --for <duration> | --until <iso> | --clear';
+    static description = 'Power policy of a Dedicated Runtime — when it may stop and start on its own. Files are preserved across stops.\n\nSubcommands:\n  show        state, policy, holders, usage, next wake\n  explain     why it stayed on, stopped or woke, and the fix\n  waiting     work waiting for the machine\n  set         always_on | on_demand | manual (+ --idle-after, --budget-hours/--no-budget)\n  keep-awake  --for <duration> | --until <iso> | --clear';
     static examples = [
         '<%= config.bin %> machines dedicated power set <lease-id> --policy manual',
         '<%= config.bin %> machines dedicated power set <lease-id> --policy on_demand --idle-after 60',
@@ -15,7 +15,8 @@ class DedicatedMachinesPower extends core_1.Command {
         this.log('skrr machines dedicated power commands:');
         this.log('  skrr machines dedicated power show      state, policy, holders, usage, next wake');
         this.log('  skrr machines dedicated power explain   why it stayed on, stopped or woke, and the fix');
-        this.log('  skrr machines dedicated power set   always_on | on_demand | manual (+ --idle-after)');
+        this.log('  skrr machines dedicated power waiting   work waiting for the machine');
+        this.log('  skrr machines dedicated power set   always_on | on_demand | manual (+ --idle-after, --budget-hours/--no-budget)');
         this.log('  skrr machines dedicated power keep-awake   --for <duration> | --until <iso> | --clear');
         this.log('');
         this.log('Every command takes a lease id (or `self` on the machine) and --json.');

package/dist/commands/machines/dedicated/power/waiting.d.ts

@@ -0,0 +1,13 @@
+import { DedicatedLeaseCommand } from '../../../../lib/dedicated-lease-command';
+/** `skrr machines dedicated power waiting` — what is waiting for this machine. Read-only. */
+export default class DedicatedMachinesPowerWaiting extends DedicatedLeaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        lease: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/dedicated/power/waiting.js

@@ -0,0 +1,36 @@
+"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_power_1 = require("../../../../lib/dedicated-power");
+/** `skrr machines dedicated power waiting` — what is waiting for this machine. Read-only. */
+class DedicatedMachinesPowerWaiting extends dedicated_lease_command_1.DedicatedLeaseCommand {
+    static description = 'List work waiting for a Dedicated Runtime: parked trigger fires and runs, queued runs, and work just aimed at it. Derived from the schedulers own records. A source that cannot be read is said, not read as nothing waiting. Read-only.';
+    static examples = [
+        '<%= config.bin %> machines dedicated power waiting <lease-id>',
+        '<%= config.bin %> machines dedicated power waiting self --json',
+    ];
+    static args = {
+        lease: core_1.Args.string({
+            description: dedicated_lease_command_1.DEDICATED_LEASE_ARG_DESCRIPTION,
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DedicatedMachinesPowerWaiting);
+        const leaseId = await this.resolveLeaseArg(args.lease);
+        const waiting = await this.callDedicated(() => (0, dedicated_power_1.getDedicatedWaitingWork)(leaseId, this.scopeFrom(flags)));
+        if (flags.json) {
+            this.log(JSON.stringify(waiting, null, 2));
+            return;
+        }
+        for (const line of (0, dedicated_power_1.describeWaitingWork)(waiting))
+            this.log(line);
+    }
+}
+exports.default = DedicatedMachinesPowerWaiting;

package/dist/commands/tasks/chat/send.d.ts

@@ -0,0 +1,44 @@
+import { BaseCommand } from '../../../base-command';
+export interface TaskChatSendInput {
+    text: string;
+    commandId?: string;
+    now?: boolean;
+}
+/**
+ * Build the `POST /api/tasks/:id/exchanges/messages` body.
+ *
+ * Every mutation on the task-chat surface requires an actor-scoped `commandId`;
+ * the server refuses to mint one (a server-minted id cannot make the caller's
+ * own retry idempotent). Without `--command-id` each invocation gets a FRESH id,
+ * because two sends of identical text are two intents (the unfenced-write rule
+ * in `idempotency.ts`). Pass the same `--command-id` to retry safely.
+ */
+export declare function buildTaskChatSendBody(input: TaskChatSendInput): {
+    immediate?: boolean | undefined;
+    commandId: string;
+    text: string;
+};
+/** One human line for a send result; never claims dispatch the server did not report. */
+export declare function describeSendResult(result: Record<string, unknown>): string;
+/**
+ * `skrr tasks chat send <task-id> --text "..."` — post a message into a Task's
+ * chat (the Task Multi-Turn Conversation surface).
+ *
+ * By default the message joins the current batch and the agent answers when the
+ * batch closes (several messages, one response). `--now` closes the batch and
+ * dispatches in the same request.
+ */
+export default class TasksChatSend extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        text: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        now: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'command-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/chat/send.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTaskChatSendBody = buildTaskChatSendBody;
+exports.describeSendResult = describeSendResult;
+const node_crypto_1 = require("node:crypto");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const task_extras_1 = require("../../../lib/task-extras");
+/** The server's `appendSchema` bounds on `commandId`. */
+const COMMAND_ID_MIN = 8;
+const COMMAND_ID_MAX = 128;
+/**
+ * Build the `POST /api/tasks/:id/exchanges/messages` body.
+ *
+ * Every mutation on the task-chat surface requires an actor-scoped `commandId`;
+ * the server refuses to mint one (a server-minted id cannot make the caller's
+ * own retry idempotent). Without `--command-id` each invocation gets a FRESH id,
+ * because two sends of identical text are two intents (the unfenced-write rule
+ * in `idempotency.ts`). Pass the same `--command-id` to retry safely.
+ */
+function buildTaskChatSendBody(input) {
+    const text = input.text?.trim() ? input.text : '';
+    if (!text)
+        throw new Error('A message needs non-empty text (--text).');
+    const commandId = input.commandId ?? `cli-${(0, node_crypto_1.randomUUID)()}`;
+    if (commandId.length < COMMAND_ID_MIN) {
+        throw new Error(`--command-id must be at least ${COMMAND_ID_MIN} characters.`);
+    }
+    if (commandId.length > COMMAND_ID_MAX) {
+        throw new Error(`--command-id must be at most ${COMMAND_ID_MAX} characters.`);
+    }
+    return {
+        commandId,
+        text,
+        ...(input.now ? { immediate: true } : {}),
+    };
+}
+/** One human line for a send result; never claims dispatch the server did not report. */
+function describeSendResult(result) {
+    const exchangeId = String(result.exchangeId ?? '?');
+    const replay = result.replay === true ? ' (replay of an earlier send)' : '';
+    if (result.alreadyClosed === true) {
+        return `Exchange ${exchangeId} was already closed${replay}.`;
+    }
+    if (result.materialized === false) {
+        return `Message recorded in exchange ${exchangeId}${replay}, but no run was started: ${String(result.reason ?? 'unknown reason')}.`;
+    }
+    if (result.materialized === true) {
+        const run = result.taskExecutionRunId ? ` as run ${String(result.taskExecutionRunId)}` : '';
+        return `Message sent in exchange ${exchangeId}${replay}; dispatched${run}.`;
+    }
+    const close = result.softCloseAt ? ` Batch closes at ${String(result.softCloseAt)}.` : '';
+    return `Message recorded in exchange ${exchangeId}${replay}; the batch is still collecting, not yet dispatched.${close} Use --now to dispatch immediately.`;
+}
+/**
+ * `skrr tasks chat send <task-id> --text "..."` — post a message into a Task's
+ * chat (the Task Multi-Turn Conversation surface).
+ *
+ * By default the message joins the current batch and the agent answers when the
+ * batch closes (several messages, one response). `--now` closes the batch and
+ * dispatches in the same request.
+ */
+class TasksChatSend extends base_command_1.BaseCommand {
+    static description = "Send a message into a task's chat";
+    static examples = [
+        '<%= config.bin %> tasks chat send task_abc123 --text "Also cover the retry path"',
+        '<%= config.bin %> tasks chat send OSK-42 --text "Go ahead" --now',
+        '<%= config.bin %> tasks chat send OSK-42 --text "Go ahead" --now --command-id my-retry-key-1',
+    ];
+    static args = {
+        id: core_1.Args.string({ ignoreStdin: true, description: 'Task ID or identifier', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        text: core_1.Flags.string({ description: 'Message text', required: true }),
+        now: core_1.Flags.boolean({
+            description: 'Close the batch and dispatch immediately instead of waiting for it to close',
+        }),
+        'command-id': core_1.Flags.string({
+            description: `Actor-scoped command id (${COMMAND_ID_MIN}-${COMMAND_ID_MAX} chars). Reuse it to retry safely; generated fresh when omitted`,
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksChatSend);
+        let body;
+        try {
+            body = buildTaskChatSendBody({
+                text: flags.text,
+                commandId: flags['command-id'],
+                now: flags.now,
+            });
+        }
+        catch (err) {
+            this.error(err.message, { exit: 2 });
+        }
+        const taskId = await this.resolveTaskReference(args.id);
+        let result;
+        try {
+            result = await task_extras_1.taskChatApi.sendExchangeMessage(taskId, body);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({ commandId: body.commandId, ...result }, null, 2));
+            return;
+        }
+        this.log(describeSendResult(result));
+    }
+}
+exports.default = TasksChatSend;

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

@@ -1,4 +1,4 @@
-import { type DedicatedRuntimePowerSummary, type DedicatedPowerPolicy, type DedicatedRuntimePowerPolicyState, type OnDemandIneligibleError, type SetDedicatedRuntimePowerPolicyResponse } from '@skrr-ai/data-provider';
+import { type DedicatedRuntimePowerSummary, type DedicatedRuntimeWaitingWork, type DedicatedPowerPolicy, type DedicatedRuntimePowerPolicyState, type OnDemandIneligibleError, type SetDedicatedRuntimePowerPolicyResponse } from '@skrr-ai/data-provider';
 import { type WhenOptions } from './format';
 import { type DedicatedRuntimeScope } from './dedicated-machines';
 /**
@@ -33,6 +33,16 @@ export declare function describePolicyWords(policy: DedicatedPowerPolicy, idleAf
 export declare function describePowerPolicy(power: DedicatedRuntimePowerPolicyState, autoStopMode?: 'off' | 'canary' | 'on'): string;
 /** `GET /api/machines/dedicated/:leaseId/power` — the read-only power card. */
 export declare function getDedicatedPowerSummary(leaseId: string, scope?: DedicatedRuntimeScope): Promise<DedicatedRuntimePowerSummary>;
+/** `GET /api/machines/dedicated/:leaseId/power/waiting` — work waiting for this machine. */
+export declare function getDedicatedWaitingWork(leaseId: string, scope?: DedicatedRuntimeScope): Promise<DedicatedRuntimeWaitingWork>;
+/** The lines of `power waiting`. An unreadable source is said, never folded into "nothing waiting". */
+export declare function describeWaitingWork(waiting: DedicatedRuntimeWaitingWork, when?: WhenOptions): string[];
+/** Last wake timing. A wake that never became assignable shows the phases it reached and no latency. */
+export declare function describeLastWakeTiming(wake: DedicatedRuntimePowerSummary['lastWake']): string[];
+/** on_demand availability, so a plan does not need a failed `power set` to find out. */
+export declare function describeOnDemandAvailability(onDemand: DedicatedRuntimePowerSummary['onDemand']): string[];
+/** Pre-warm lines: only a PAUSED pre-warm is in the summary, so silence here is not "pre-warm is on". */
+export declare function describePrewarm(prewarm: DedicatedRuntimePowerSummary['prewarm'], when?: WhenOptions): string[];
 type PowerDecisionView = NonNullable<DedicatedRuntimePowerSummary['decision']>;
 /** The stay/stop/wake decision in words: the shared reason copy backs the server's detail. */
 export declare function describePowerDecisionLines(decision: PowerDecisionView): {

package/dist/lib/dedicated-power.js

@@ -4,6 +4,11 @@ exports.setDedicatedPowerPolicy = setDedicatedPowerPolicy;
 exports.describePolicyWords = describePolicyWords;
 exports.describePowerPolicy = describePowerPolicy;
 exports.getDedicatedPowerSummary = getDedicatedPowerSummary;
+exports.getDedicatedWaitingWork = getDedicatedWaitingWork;
+exports.describeWaitingWork = describeWaitingWork;
+exports.describeLastWakeTiming = describeLastWakeTiming;
+exports.describeOnDemandAvailability = describeOnDemandAvailability;
+exports.describePrewarm = describePrewarm;
 exports.describePowerDecisionLines = describePowerDecisionLines;
 exports.describeLastAutoStopLines = describeLastAutoStopLines;
 exports.describeLastWakeDecisionLines = describeLastWakeDecisionLines;
@@ -83,6 +88,118 @@ function describePowerPolicy(power, autoStopMode) {
 function getDedicatedPowerSummary(leaseId, scope = {}) {
     return (0, api_fetch_1.apiFetch)((0, dedicated_machines_1.withDedicatedScope)(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/power`, scope));
 }
+/** `GET /api/machines/dedicated/:leaseId/power/waiting` — work waiting for this machine. */
+function getDedicatedWaitingWork(leaseId, scope = {}) {
+    return (0, api_fetch_1.apiFetch)((0, dedicated_machines_1.withDedicatedScope)(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/power/waiting`, scope));
+}
+const WAITING_SOURCE_LABELS = {
+    dispatch_intent: 'just dispatched',
+    parked_fire: 'parked trigger fire',
+    parked_run: 'parked run',
+    queued_run: 'queued run',
+    agent_queued_run: 'queued run (agent)',
+    expected_firing: 'expected firing',
+};
+/** The lines of `power waiting`. An unreadable source is said, never folded into "nothing waiting". */
+function describeWaitingWork(waiting, when = {}) {
+    const lines = [`Dedicated Runtime ${waiting.leaseId} (${waiting.state})`];
+    if (waiting.items.length === 0 && waiting.unreadable.length === 0) {
+        lines.push('Waiting work: none');
+    }
+    else {
+        lines.push(waiting.items.length === 0
+            ? 'Waiting work: none seen'
+            : `Waiting work: ${waiting.items.length} item${waiting.items.length === 1 ? '' : 's'}`);
+        for (const item of waiting.items) {
+            const label = WAITING_SOURCE_LABELS[item.source] ?? item.source;
+            lines.push(`  - ${label} ${item.ref}${item.since ? ` · since ${(0, format_1.formatWhen)(item.since, when)}` : ''}`);
+            if (item.detail)
+                lines.push(`    ${item.detail}`);
+        }
+    }
+    if (waiting.truncated.length > 0) {
+        lines.push(`More exists than is listed (${waiting.truncated.join(', ')}).`);
+    }
+    for (const u of waiting.unreadable) {
+        lines.push(`Cannot see ${u.source} (${u.reason}) — treat the list as incomplete.`);
+    }
+    const up = waiting.upcoming;
+    if (up) {
+        if (up.items.length > 0) {
+            lines.push(`Scheduled to fire: ${up.items.length}${up.truncated ? '+' : ''}`);
+            for (const f of up.items) {
+                lines.push(`  - ${f.source} ${f.title ?? f.ref}${f.at ? ` · ${(0, format_1.formatWhen)(f.at, when)}` : ''}`);
+            }
+        }
+        else if (up.unreadable.length === 0) {
+            lines.push('Scheduled to fire: none');
+        }
+        else {
+            lines.push('Scheduled to fire: none seen');
+        }
+        if (up.overdue > 0) {
+            lines.push(`${up.overdue} overdue firing${up.overdue === 1 ? '' : 's'} not yet fired.`);
+        }
+        for (const u of up.unreadable) {
+            lines.push(`Cannot see ${u.source} (${u.reason}) — scheduled firings may be missing.`);
+        }
+    }
+    if (waiting.state === 'stopped' && waiting.items.length > 0) {
+        lines.push('The machine is stopped. `skrr machines dedicated start <lease> --wait` starts it; work on an on_demand machine wakes it by itself.');
+    }
+    return lines;
+}
+const PHASE_ORDER = [
+    'start_requested',
+    'provider_start_accepted',
+    'instance_running',
+    'daemon_connected',
+    'first_heartbeat',
+    'assignable',
+];
+function formatMs(ms) {
+    return ms >= 1000 ? `${Math.round(ms / 100) / 10}s` : `${Math.round(ms)}ms`;
+}
+/** Last wake timing. A wake that never became assignable shows the phases it reached and no latency. */
+function describeLastWakeTiming(wake) {
+    if (!wake)
+        return [];
+    const known = Object.keys(wake.phases ?? {});
+    const names = [
+        ...PHASE_ORDER.filter((p) => known.includes(p)),
+        ...known.filter((p) => !PHASE_ORDER.includes(p)),
+    ].filter((p) => p !== 'start_requested');
+    const phases = names.map((p) => `${p} +${formatMs(wake.phases[p])}`).join(', ');
+    const total = wake.latencyMs === null || wake.latencyMs === undefined
+        ? 'not ready yet (no latency recorded)'
+        : `ready after ${formatMs(wake.latencyMs)}`;
+    return [`Wake timing: ${total}${phases ? ` — ${phases}` : ''}`];
+}
+/** on_demand availability, so a plan does not need a failed `power set` to find out. */
+function describeOnDemandAvailability(onDemand) {
+    if (!onDemand)
+        return [];
+    if (onDemand.eligible)
+        return ['on_demand: available'];
+    return [
+        `on_demand: not available (${onDemand.reason})`,
+        `          ${onDemand.detail}`,
+        `          Fix: ${onDemand.fix}`,
+    ];
+}
+/** Pre-warm lines: only a PAUSED pre-warm is in the summary, so silence here is not "pre-warm is on". */
+function describePrewarm(prewarm, when = {}) {
+    if (!prewarm?.paused)
+        return [];
+    const lines = [
+        `Pre-warm: paused${prewarm.since ? ` since ${(0, format_1.formatWhen)(prewarm.since, when)}` : ''} (${prewarm.idleStreak} early start${prewarm.idleStreak === 1 ? '' : 's'} in a row went unused)`,
+    ];
+    if (prewarm.decision?.detail)
+        lines.push(`          ${prewarm.decision.detail}`);
+    if (prewarm.decision?.fix)
+        lines.push(`          ${prewarm.decision.fix}`);
+    return lines;
+}
 /** The stay/stop/wake decision in words: the shared reason copy backs the server's detail. */
 function describePowerDecisionLines(decision) {
     const copy = (0, data_provider_1.describePowerReason)(decision.reason);
@@ -205,6 +322,10 @@ function describePowerSummary(summary, when = {}) {
     lines.push(`Last wake: ${summary.lastWake
         ? `${summary.lastWake.at ? (0, format_1.formatWhen)(summary.lastWake.at, when) : 'unknown time'}${summary.lastWake.source ? ` (${summary.lastWake.source})` : ''}`
         : 'none'}`);
+    lines.push(...describeLastWakeTiming(summary.lastWake));
+    lines.push(...describePrewarm(summary.prewarm, when));
+    if (power.policy !== 'on_demand')
+        lines.push(...describeOnDemandAvailability(summary.onDemand));
     return lines;
 }
 /** The lines of `power explain`; the fix is always last. */
@@ -229,6 +350,8 @@ function describePowerExplanation(summary, when = {}) {
     const stop = describeLastAutoStopLines(summary.lastAutoStop, d.detail, when);
     lines.push(...stop.lines);
     lines.push(...wakeLines);
+    lines.push(...describeLastWakeTiming(summary.lastWake));
+    lines.push(...describePrewarm(summary.prewarm, when));
     // A false stop's fix replaces nothing: the decision's own fix is still last-but-one.
     if (text.fix && text.fix !== stop.fix)
         lines.push(`Fix: ${text.fix}`);

package/dist/node_modules/@skrr-ai/data-provider/index.js

@@ -45462,6 +45462,10 @@ var vM = Object.freeze({ __proto__: null, acceptAgentIntuition: function(e3, t2,
   return gf.get((function(e4) {
     return "".concat(nn, "/api/machines/dedicated/").concat(encodeURIComponent(e4), "/power");
   })(e3));
+}, getDedicatedRuntimeWaitingWork: function(e3) {
+  return gf.get((function(e4) {
+    return "".concat(nn, "/api/machines/dedicated/").concat(encodeURIComponent(e4), "/power/waiting");
+  })(e3));
 }, getDeviceTokens: function() {
   return gf.get(nr());
 }, getDirectChatWithFriend: function(e3) {