@leg3ndy/otto-bridge 0.9.2 → 1.0.1

package/dist/local_automations.js

@@ -231,8 +231,12 @@ function isSupportedWhatsAppInboxAutomation(automation) {
     const bridgeConfig = automation.bridge_config || {};
     return String(bridgeConfig.monitor_scope || "").trim().toLowerCase() === "inbox";
 }
+function isSupportedBridgeAutomation(automation) {
+    return normalizeChannel(automation.channel) === "bridge";
+}
 export class LocalAutomationRuntime {
     config;
+    logger;
     automations = new Map();
     states = new Map();
     syncTimer = null;
@@ -242,8 +246,12 @@ export class LocalAutomationRuntime {
     started = false;
     stopped = false;
     whatsappBrowser = null;
-    constructor(config) {
+    constructor(config, logger) {
         this.config = config;
+        this.logger = logger;
+    }
+    logWarn(message) {
+        (this.logger?.warn || console.warn)(message);
     }
     async start() {
         if (this.started) {
@@ -253,11 +261,11 @@ export class LocalAutomationRuntime {
         this.stopped = false;
         await this.syncAutomations().catch((error) => {
             const detail = error instanceof Error ? error.message : String(error);
-            console.warn(`[otto-bridge] local automations sync failed: ${detail}`);
+            this.logWarn(`[otto-bridge] local automations sync failed: ${detail}`);
         });
         await this.tick().catch((error) => {
             const detail = error instanceof Error ? error.message : String(error);
-            console.warn(`[otto-bridge] local automations tick failed: ${detail}`);
+            this.logWarn(`[otto-bridge] local automations tick failed: ${detail}`);
         });
         this.syncTimer = setInterval(() => {
             void this.syncAutomations();
@@ -329,7 +337,7 @@ export class LocalAutomationRuntime {
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
-            console.warn(`[otto-bridge] local automations sync failed: ${detail}`);
+            this.logWarn(`[otto-bridge] local automations sync failed: ${detail}`);
         }
         finally {
             this.syncInFlight = false;
@@ -353,7 +361,10 @@ export class LocalAutomationRuntime {
                 }
                 state.running = true;
                 try {
-                    if (isSupportedWhatsAppContactAutomation(automation)) {
+                    if (isSupportedBridgeAutomation(automation)) {
+                        await this.handleBridgeAutomation(automation);
+                    }
+                    else if (isSupportedWhatsAppContactAutomation(automation)) {
                         await this.handleWhatsAppContactAutomation(automation, state);
                     }
                     else if (isSupportedWhatsAppInboxAutomation(automation)) {
@@ -362,7 +373,7 @@ export class LocalAutomationRuntime {
                 }
                 catch (error) {
                     const detail = error instanceof Error ? error.message : String(error);
-                    console.warn(`[otto-bridge] local automation failed id=${automationId}: ${detail}`);
+                    this.logWarn(`[otto-bridge] local automation failed id=${automationId}: ${detail}`);
                 }
                 finally {
                     state.running = false;
@@ -395,7 +406,7 @@ export class LocalAutomationRuntime {
         await browser.ensureReady();
         const selected = await browser.selectConversation(contact);
         if (!selected) {
-            console.warn(`[otto-bridge] local whatsapp automation could not find contact="${contact}"`);
+            this.logWarn(`[otto-bridge] local whatsapp automation could not find contact="${contact}"`);
             return;
         }
         await this.processWhatsAppConversation(automation, state, browser, contact, { alreadySelected: true });
@@ -424,7 +435,7 @@ export class LocalAutomationRuntime {
             try {
                 const selected = await browser.selectConversation(contact);
                 if (!selected) {
-                    console.warn(`[otto-bridge] local whatsapp inbox automation could not find contact="${contact}"`);
+                    this.logWarn(`[otto-bridge] local whatsapp inbox automation could not find contact="${contact}"`);
                     continue;
                 }
                 await this.processWhatsAppConversation(automation, state, browser, contact, {
@@ -434,10 +445,21 @@ export class LocalAutomationRuntime {
             }
             catch (error) {
                 const detail = error instanceof Error ? error.message : String(error);
-                console.warn(`[otto-bridge] local whatsapp inbox conversation failed contact="${contact}": ${detail}`);
+                this.logWarn(`[otto-bridge] local whatsapp inbox conversation failed contact="${contact}": ${detail}`);
             }
         }
     }
+    async handleBridgeAutomation(automation) {
+        const automationId = String(automation.id || "").trim();
+        if (!automationId) {
+            return;
+        }
+        await postDeviceJson(this.config.apiBaseUrl, this.config.deviceToken, "/v1/devices/automations/local/bridge/trigger", {
+            automation_id: automationId,
+            observed_at: new Date().toISOString(),
+            reason: "schedule_tick",
+        });
+    }
     isPrimaryContactForAutomation(automation, contact) {
         if (!isSupportedWhatsAppContactAutomation(automation)) {
             return false;
@@ -478,7 +500,7 @@ export class LocalAutomationRuntime {
         if (!options?.alreadySelected) {
             const selected = await browser.selectConversation(contact);
             if (!selected) {
-                console.warn(`[otto-bridge] local whatsapp automation could not find contact="${contact}"`);
+                this.logWarn(`[otto-bridge] local whatsapp automation could not find contact="${contact}"`);
                 return;
             }
         }
@@ -552,7 +574,7 @@ export class LocalAutomationRuntime {
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : String(error);
-            console.warn(`[otto-bridge] local whatsapp completion failed id=${automation.id}: ${detail}`);
+            this.logWarn(`[otto-bridge] local whatsapp completion failed id=${automation.id}: ${detail}`);
             this.rememberDeltaHash(automation, state, contact, sent ? completionDeltaHash : deltaHash);
         }
     }

package/dist/main.js

@@ -7,10 +7,15 @@ import { pairDevice } from "./pairing.js";
 import { BridgeRuntime } from "./runtime.js";
 import { detectWhatsAppBackgroundStatus, runWhatsAppBackgroundSetup, } from "./whatsapp_background.js";
 import { BRIDGE_PACKAGE_NAME, BRIDGE_VERSION, DEFAULT_PAIR_TIMEOUT_SECONDS, DEFAULT_POLL_INTERVAL_MS, } from "./types.js";
+import { launchInteractiveCli, runConsoleCommand, runSetupCommand, } from "./cli_terminal.js";
 const RUNTIME_STATUS_FRESHNESS_MS = 90_000;
 const UPDATE_RETRY_DELAYS_MS = [0, 8_000, 20_000];
 function parseArgs(argv) {
     const [maybeCommand, ...rest] = argv;
+    if (!maybeCommand) {
+        const interactiveDefault = process.stdout.isTTY && process.stdin.isTTY && process.env.OTTO_BRIDGE_LEGACY_DEFAULT_RUN !== "1";
+        return { command: interactiveDefault ? "home" : "run", options: new Map() };
+    }
     if (maybeCommand === "--help" || maybeCommand === "-h") {
         return { command: "help", options: new Map() };
     }
@@ -100,8 +105,11 @@ function resolveExecutorOverrides(args, current) {
 }
 function printUsage() {
     console.log(`Usage:
+  otto-bridge
+  otto-bridge home
+  otto-bridge setup
+  otto-bridge console
   otto-bridge pair --api http://localhost:8000 --code ABC123 [--name "Meu PC"] [--executor native-macos|mock|clawd-cursor]
-  otto-bridge run [--executor native-macos|mock|clawd-cursor] [--clawd-url http://127.0.0.1:3847]
   otto-bridge status
   otto-bridge extensions --list
   otto-bridge extensions --install github
@@ -113,8 +121,10 @@ function printUsage() {
   otto-bridge unpair
 
 Examples:
+  otto-bridge
+  otto-bridge setup
+  otto-bridge console
   otto-bridge pair --api https://api.leg3ndy.com.br --code ABC123
-  otto-bridge run
   otto-bridge extensions --install whatsappweb
   otto-bridge extensions --setup whatsappweb
   otto-bridge extensions --status whatsappweb
@@ -275,7 +285,7 @@ async function runPairCommand(args) {
     console.log(`[otto-bridge] paired device=${config.deviceId}`);
     console.log(`[otto-bridge] executor=${config.executor.type}`);
     console.log(`[otto-bridge] config=${getBridgeConfigPath()}`);
-    console.log("[otto-bridge] next step: run `otto-bridge run` to keep this device online");
+    console.log("[otto-bridge] next step: run `otto-bridge` to abrir o hub e manter o runtime local online");
 }
 async function loadRequiredBridgeConfig() {
     const config = await loadBridgeConfig();
@@ -285,6 +295,7 @@ async function loadRequiredBridgeConfig() {
     return config;
 }
 async function runRuntimeCommand(args) {
+    console.log("[otto-bridge] `run` agora é um alias legado. Prefira `otto-bridge`.");
     const config = await loadRequiredBridgeConfig();
     const runtimeConfig = {
         ...config,
@@ -574,6 +585,17 @@ async function runUpdateCommand(args) {
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     switch (args.command) {
+        case "home":
+            await launchInteractiveCli();
+            return;
+        case "setup":
+            await runSetupCommand({
+                postinstall: args.options.has("postinstall"),
+            });
+            return;
+        case "console":
+            await runConsoleCommand(option(args, "prompt"));
+            return;
         case "pair":
             await runPairCommand(args);
             return;

package/dist/runtime.js

@@ -6,6 +6,7 @@ import { JobCancelledError } from "./executors/shared.js";
 import { isManagedBridgeExtensionSlug, loadManagedBridgeExtensionState, } from "./extensions.js";
 import { LocalAutomationRuntime } from "./local_automations.js";
 import { buildLocalToolCatalog } from "./tool_catalog.js";
+import { parseJobRuntimeManifest, runtimeStepIdForEvent, } from "./runtime_contract.js";
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -55,6 +56,11 @@ function bridgeReleaseFromMessage(message) {
     }
     return null;
 }
+function confirmationKey(jobId, stepId) {
+    const normalizedJobId = String(jobId || "").trim();
+    const normalizedStepId = String(stepId || "").trim();
+    return normalizedStepId ? `${normalizedJobId}:${normalizedStepId}` : normalizedJobId;
+}
 async function parseSocketMessage(data) {
     if (typeof data === "string") {
         return JSON.parse(data);
@@ -72,6 +78,7 @@ async function parseSocketMessage(data) {
 }
 export class BridgeRuntime {
     config;
+    options;
     reconnectDelayMs = DEFAULT_RECONNECT_BASE_DELAY_MS;
     executor;
     localAutomationRuntime;
@@ -81,10 +88,23 @@ export class BridgeRuntime {
     started = false;
     pendingConfirmations = new Map();
     activeCancels = new Map();
-    constructor(config, executor) {
+    constructor(config, executor, options = {}) {
         this.config = config;
+        this.options = options;
         this.executor = executor ?? this.createDefaultExecutor(config);
-        this.localAutomationRuntime = new LocalAutomationRuntime(config);
+        this.localAutomationRuntime = new LocalAutomationRuntime(config, this.options.logger);
+    }
+    logInfo(message) {
+        (this.options.logger?.info || console.log)(message);
+    }
+    logWarn(message) {
+        (this.options.logger?.warn || console.warn)(message);
+    }
+    logError(message) {
+        (this.options.logger?.error || console.error)(message);
+    }
+    emit(event) {
+        this.options.logger?.event?.(event);
     }
     async buildHelloMetadata() {
         const metadata = {
@@ -163,10 +183,11 @@ export class BridgeRuntime {
             }
             await this.localAutomationRuntime.start().catch((error) => {
                 const detail = error instanceof Error ? error.message : String(error);
-                console.error(`[otto-bridge] local automation runtime failed to start: ${detail}`);
+                this.logError(`[otto-bridge] local automation runtime failed to start: ${detail}`);
             });
         }
-        console.log(`[otto-bridge] runtime start device=${this.config.deviceId}`);
+        this.logInfo(`[otto-bridge] runtime start device=${this.config.deviceId}`);
+        this.emit({ type: "starting", deviceId: this.config.deviceId });
         while (!this.stopped) {
             try {
                 await this.connectOnce();
@@ -177,12 +198,14 @@ export class BridgeRuntime {
                     break;
                 }
                 const message = error instanceof Error ? error.message : String(error);
-                console.error(`[otto-bridge] socket error: ${message}`);
+                this.logError(`[otto-bridge] socket error: ${message}`);
+                this.emit({ type: "socket_error", message });
             }
             if (this.stopped) {
                 break;
             }
-            console.log(`[otto-bridge] reconnecting in ${this.reconnectDelayMs}ms`);
+            this.logInfo(`[otto-bridge] reconnecting in ${this.reconnectDelayMs}ms`);
+            this.emit({ type: "reconnecting", delayMs: this.reconnectDelayMs });
             await delay(this.reconnectDelayMs);
             this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, DEFAULT_RECONNECT_MAX_DELAY_MS);
         }
@@ -232,10 +255,11 @@ export class BridgeRuntime {
         };
         return await new Promise((resolve, reject) => {
             socket.addEventListener("open", () => {
-                console.log(`[otto-bridge] connected ws=${this.config.wsUrl}`);
+                this.logInfo(`[otto-bridge] connected ws=${this.config.wsUrl}`);
+                this.emit({ type: "connected", wsUrl: this.config.wsUrl });
                 this.sendHello(socket).catch((error) => {
                     const detail = error instanceof Error ? error.message : String(error);
-                    console.error(`[otto-bridge] hello metadata failed: ${detail}`);
+                    this.logError(`[otto-bridge] hello metadata failed: ${detail}`);
                 });
                 heartbeatTimer = setInterval(() => {
                     if (socket.readyState === WebSocket.OPEN) {
@@ -254,14 +278,15 @@ export class BridgeRuntime {
                 }
                 catch (error) {
                     const detail = error instanceof Error ? error.message : String(error);
-                    console.error(`[otto-bridge] invalid message: ${detail}`);
+                    this.logError(`[otto-bridge] invalid message: ${detail}`);
                 }
             });
             socket.addEventListener("close", (event) => {
                 stopHeartbeat();
                 rejectPendingConfirmations(new Error("WebSocket closed while awaiting confirmation"));
                 this.activeSocket = null;
-                console.log(`[otto-bridge] socket closed code=${event.code}`);
+                this.logInfo(`[otto-bridge] socket closed code=${event.code}`);
+                this.emit({ type: "socket_closed", code: event.code });
                 resolve();
             });
             socket.addEventListener("error", () => {
@@ -282,14 +307,16 @@ export class BridgeRuntime {
         const type = String(message.type || "");
         switch (type) {
             case "device.hello":
-                console.log(`[otto-bridge] server hello device=${String(message.device_id || "")}`);
+                this.logInfo(`[otto-bridge] server hello device=${String(message.device_id || "")}`);
+                this.emit({ type: "server_hello", deviceId: String(message.device_id || "") });
                 return;
             case "device.hello_ack":
                 this.maybeLogBridgeReleaseNotice(message);
             case "device.heartbeat_ack":
                 return;
             case "device.job.start":
-                console.log(`[otto-bridge] job start payload=${JSON.stringify(message)}`);
+                this.logInfo(`[otto-bridge] job start payload=${JSON.stringify(message)}`);
+                this.emit({ type: "job_start", jobId: String(message.job_id || "") });
                 this.executeJob(socket, {
                     job_id: String(message.job_id || ""),
                     device_id: String(message.device_id || ""),
@@ -299,17 +326,17 @@ export class BridgeRuntime {
                         : {},
                 }).catch((error) => {
                     const detail = error instanceof Error ? error.message : String(error);
-                    console.error(`[otto-bridge] executor error: ${detail}`);
+                    this.logError(`[otto-bridge] executor error: ${detail}`);
                 });
                 return;
             case "device.job.confirmation":
                 this.resolveConfirmation(message);
                 return;
             case "device.job.cancel":
-                await this.cancelJob(String(message.job_id || ""));
+                await this.cancelJob(String(message.job_id || ""), String(message.step_id || ""));
                 return;
             default:
-                console.log(`[otto-bridge] event=${type || "unknown"} payload=${JSON.stringify(message)}`);
+                this.logInfo(`[otto-bridge] event=${type || "unknown"} payload=${JSON.stringify(message)}`);
         }
     }
     maybeLogBridgeReleaseNotice(message) {
@@ -328,49 +355,106 @@ export class BridgeRuntime {
         }
         this.lastBridgeReleaseNoticeKey = noticeKey;
         if (updateRequired) {
-            console.warn(`[otto-bridge] update required current=${this.config.bridgeVersion} min_supported=${minSupportedVersion || "unknown"} latest=${latestVersion || "unknown"} command="${updateCommand}"`);
+            const message = `[otto-bridge] update required current=${this.config.bridgeVersion} min_supported=${minSupportedVersion || "unknown"} latest=${latestVersion || "unknown"} command="${updateCommand}"`;
+            this.logWarn(message);
+            this.emit({ type: "update_required", message });
             return;
         }
         if (updateAvailable) {
-            console.log(`[otto-bridge] update available current=${this.config.bridgeVersion} latest=${latestVersion || "unknown"} command="${updateCommand}"`);
+            const message = `[otto-bridge] update available current=${this.config.bridgeVersion} latest=${latestVersion || "unknown"} command="${updateCommand}"`;
+            this.logInfo(message);
+            this.emit({ type: "update_available", message });
         }
     }
+    clearPendingConfirmations(jobId) {
+        const normalizedJobId = String(jobId || "").trim();
+        if (!normalizedJobId) {
+            return;
+        }
+        for (const key of Array.from(this.pendingConfirmations.keys())) {
+            if (key === normalizedJobId || key.startsWith(`${normalizedJobId}:`)) {
+                this.pendingConfirmations.delete(key);
+            }
+        }
+    }
+    resolvePendingCancellation(jobId, stepId) {
+        const normalizedJobId = String(jobId || "").trim();
+        if (!normalizedJobId) {
+            return false;
+        }
+        const keys = stepId
+            ? [confirmationKey(normalizedJobId, stepId), normalizedJobId]
+            : Array.from(this.pendingConfirmations.keys()).filter((key) => (key === normalizedJobId || key.startsWith(`${normalizedJobId}:`)));
+        let resolved = false;
+        for (const key of keys) {
+            const waiter = this.pendingConfirmations.get(key);
+            if (!waiter) {
+                continue;
+            }
+            this.pendingConfirmations.delete(key);
+            waiter.resolve({
+                action: "reject",
+                note: "Cancelled by Otto Bridge",
+            });
+            resolved = true;
+        }
+        return resolved;
+    }
     resolveConfirmation(message) {
         const jobId = String(message.job_id || "");
+        const stepId = String(message.step_id || "");
         const action = String(message.action || "").trim().toLowerCase();
-        const waiter = this.pendingConfirmations.get(jobId);
+        const waiter = this.pendingConfirmations.get(confirmationKey(jobId, stepId))
+            || this.pendingConfirmations.get(jobId);
         if (!jobId || !waiter) {
-            console.warn(`[otto-bridge] unexpected confirmation payload=${JSON.stringify(message)}`);
+            this.logWarn(`[otto-bridge] unexpected confirmation payload=${JSON.stringify(message)}`);
             return;
         }
         if (action !== "approve" && action !== "reject") {
             waiter.reject(new Error(`Unsupported confirmation action: ${action || "unknown"}`));
+            this.pendingConfirmations.delete(confirmationKey(jobId, stepId));
             this.pendingConfirmations.delete(jobId);
             return;
         }
+        this.pendingConfirmations.delete(confirmationKey(jobId, stepId));
         this.pendingConfirmations.delete(jobId);
         waiter.resolve({
             action,
             note: typeof message.note === "string" ? message.note : undefined,
         });
     }
-    async waitForConfirmation(jobId) {
+    async waitForConfirmation(jobId, stepId) {
         return await new Promise((resolve, reject) => {
-            this.pendingConfirmations.set(jobId, { resolve, reject });
+            this.pendingConfirmations.set(confirmationKey(jobId, stepId), { resolve, reject });
         });
     }
-    async cancelJob(jobId) {
+    async cancelJob(jobId, stepId) {
         if (!jobId) {
             return;
         }
+        if (this.resolvePendingCancellation(jobId, stepId)) {
+            this.logInfo(`[otto-bridge] confirmation cancelled job=${jobId}${stepId ? ` step=${stepId}` : ""}`);
+            return;
+        }
         const cancel = this.activeCancels.get(jobId);
         if (!cancel) {
-            console.warn(`[otto-bridge] cancel requested for unknown job=${jobId}`);
+            this.logWarn(`[otto-bridge] cancel requested for unknown job=${jobId}`);
             return;
         }
+        if (stepId) {
+            this.logInfo(`[otto-bridge] cancel requested job=${jobId} step=${stepId}`);
+        }
         await cancel();
     }
     async executeJob(socket, job) {
+        const runtimeManifest = parseJobRuntimeManifest(job);
+        const eventStepId = (eventType, options) => {
+            const explicitStepId = String(options?.stepId || "").trim();
+            if (explicitStepId) {
+                return explicitStepId;
+            }
+            return runtimeStepIdForEvent(runtimeManifest, eventType);
+        };
         const sendJson = async (payload) => {
             if (socket.readyState !== WebSocket.OPEN) {
                 throw new Error("Socket is not open");
@@ -378,61 +462,78 @@ export class BridgeRuntime {
             socket.send(JSON.stringify(payload));
         };
         this.activeCancels.set(job.job_id, async () => {
-            this.pendingConfirmations.delete(job.job_id);
+            this.clearPendingConfirmations(job.job_id);
             if (typeof this.executor.cancel === "function") {
                 await this.executor.cancel(job.job_id);
             }
-            console.log(`[otto-bridge] job cancelled job_id=${job.job_id}`);
+            this.logInfo(`[otto-bridge] job cancelled job_id=${job.job_id}`);
+            this.emit({ type: "job_cancelled", jobId: job.job_id });
         });
         try {
             await this.executor.run(job, {
-                accepted: async () => {
+                accepted: async (options) => {
+                    const stepId = eventStepId("accepted", options);
                     await sendJson({
                         type: "device.job.accepted",
                         device_id: this.config.deviceId,
                         job_id: job.job_id,
+                        graph_id: runtimeManifest.graphId,
+                        step_id: stepId,
                         accepted_at: Date.now(),
                     });
                 },
-                progress: async (progressPercent, progressMessage) => {
+                progress: async (progressPercent, progressMessage, options) => {
+                    const stepId = eventStepId("progress", options);
                     await sendJson({
                         type: "device.job.progress",
                         device_id: this.config.deviceId,
                         job_id: job.job_id,
+                        graph_id: runtimeManifest.graphId,
+                        step_id: stepId,
                         progress_percent: progressPercent,
                         progress_message: progressMessage,
                     });
                 },
-                confirmRequired: async (progressMessage, confirmationContext) => {
-                    const confirmationPromise = this.waitForConfirmation(job.job_id);
+                confirmRequired: async (progressMessage, confirmationContext, options) => {
+                    const stepId = eventStepId("confirm_required", options);
+                    const confirmationPromise = this.waitForConfirmation(job.job_id, stepId);
                     try {
                         await sendJson({
                             type: "device.job.confirm_required",
                             device_id: this.config.deviceId,
                             job_id: job.job_id,
+                            graph_id: runtimeManifest.graphId,
+                            step_id: stepId,
                             progress_message: progressMessage,
                             confirmation_context: confirmationContext || {},
                         });
                     }
                     catch (error) {
+                        this.pendingConfirmations.delete(confirmationKey(job.job_id, stepId));
                         this.pendingConfirmations.delete(job.job_id);
                         throw error;
                     }
                     return await confirmationPromise;
                 },
-                completed: async (result) => {
+                completed: async (result, options) => {
+                    const stepId = eventStepId("completed", options);
                     await sendJson({
                         type: "device.job.completed",
                         device_id: this.config.deviceId,
                         job_id: job.job_id,
+                        graph_id: runtimeManifest.graphId,
+                        step_id: stepId,
                         result: result || {},
                     });
                 },
-                failed: async (errorMessage, result) => {
+                failed: async (errorMessage, result, options) => {
+                    const stepId = eventStepId("failed", options);
                     await sendJson({
                         type: "device.job.failed",
                         device_id: this.config.deviceId,
                         job_id: job.job_id,
+                        graph_id: runtimeManifest.graphId,
+                        step_id: stepId,
                         error_message: errorMessage,
                         result: result || {},
                     });
@@ -440,16 +541,19 @@ export class BridgeRuntime {
             });
         }
         catch (error) {
-            this.pendingConfirmations.delete(job.job_id);
+            this.clearPendingConfirmations(job.job_id);
             if (error instanceof JobCancelledError) {
                 return;
             }
             const detail = error instanceof Error ? error.message : String(error);
+            const stepId = runtimeStepIdForEvent(runtimeManifest, "failed");
             try {
                 await sendJson({
                     type: "device.job.failed",
                     device_id: this.config.deviceId,
                     job_id: job.job_id,
+                    graph_id: runtimeManifest.graphId,
+                    step_id: stepId,
                     error_message: detail || "Executor failed",
                     result: {
                         executor: this.config.executor.type,

package/dist/runtime_cli_client.js

@@ -0,0 +1,18 @@
+import { getDeviceJson, postDeviceJson } from "./http.js";
+export async function submitRuntimeCliAssistantPrompt(config, request) {
+    return await postDeviceJson(config.apiBaseUrl, config.deviceToken, "/v1/devices/cli/runtime/assistant", request);
+}
+export async function getRuntimeCliJob(config, jobId) {
+    return await getDeviceJson(config.apiBaseUrl, config.deviceToken, `/v1/devices/cli/runtime/jobs/${encodeURIComponent(jobId)}`);
+}
+export async function confirmRuntimeCliJob(config, jobId, action, note) {
+    return await postDeviceJson(config.apiBaseUrl, config.deviceToken, `/v1/devices/cli/runtime/jobs/${encodeURIComponent(jobId)}/confirm`, {
+        action,
+        note,
+    });
+}
+export async function cancelRuntimeCliJob(config, jobId, note) {
+    return await postDeviceJson(config.apiBaseUrl, config.deviceToken, `/v1/devices/cli/runtime/jobs/${encodeURIComponent(jobId)}/cancel`, {
+        note,
+    });
+}