@leg3ndy/otto-bridge 0.9.2 → 1.0.0

package/dist/local_automations.js

@@ -231,6 +231,9 @@ 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;
     automations = new Map();
@@ -353,7 +356,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)) {
@@ -438,6 +444,17 @@ export class LocalAutomationRuntime {
             }
         }
     }
+    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;

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,6 +105,10 @@ 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
@@ -113,6 +122,9 @@ 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
@@ -574,6 +586,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);
@@ -306,7 +312,7 @@ export class BridgeRuntime {
                 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)}`);
@@ -335,42 +341,95 @@ export class BridgeRuntime {
             console.log(`[otto-bridge] update available current=${this.config.bridgeVersion} latest=${latestVersion || "unknown"} command="${updateCommand}"`);
         }
     }
+    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)}`);
             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)) {
+            console.log(`[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}`);
             return;
         }
+        if (stepId) {
+            console.log(`[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,7 +437,7 @@ 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);
             }
@@ -386,53 +445,69 @@ export class BridgeRuntime {
         });
         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 +515,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,
+    });
+}