kroki 1.0.3 → 1.0.5

package/bin/kroki.js

@@ -160,10 +160,18 @@ class RealtimeConnection {
 
             if (onEvent) onEvent(envelope);
 
-            if (envelope.kind === 'chat_task_complete' || envelope.kind === 'workflow_complete') {
+            if (
+              envelope.kind === 'chat_task_complete' ||
+              envelope.kind === 'workflow_complete' ||
+              envelope.kind === 'pair_approved'
+            ) {
               clearTimeout(timer);
               this.ws.removeEventListener('message', handler);
               resolve(envelope.payload);
+            } else if (envelope.kind === 'pair_rejected') {
+              clearTimeout(timer);
+              this.ws.removeEventListener('message', handler);
+              reject(new Error('Pairing request was rejected in Kroki browser.'));
             } else if (envelope.kind === 'error') {
               clearTimeout(timer);
               this.ws.removeEventListener('message', handler);
@@ -227,6 +235,28 @@ Requires an active \x1b[33mUltra\x1b[0m plan.
   const conn = new RealtimeConnection(payload);
   await conn.connect();
 
+  console.log(`\x1b[33mWaiting for confirmation in Kroki browser (click "Разрешить")...\x1b[0m`);
+
+  const pairCmd = {
+    v: 1,
+    id: `pair-${Date.now()}`,
+    kind: 'pair_request',
+    targetDeviceId: payload.deviceId,
+    taskId: `pair-${Date.now()}`,
+    issuedAt: Date.now(),
+    payload: {
+      clientName: 'Antigravity CLI',
+    },
+  };
+
+  try {
+    await conn.sendCommand(pairCmd, undefined, 60000);
+  } catch (err) {
+    conn.close();
+    console.error(`\x1b[31m✖ ${err.message}\x1b[0m`);
+    process.exit(1);
+  }
+
   saveActiveSession({
     ...payload,
     pairedAt: Date.now(),
@@ -240,7 +270,54 @@ Requires an active \x1b[33mUltra\x1b[0m plan.
   console.log('  \x1b[33mnpx kroki run "My Workflow Name"\x1b[0m\n');
 }
 
-async function taskCommand(taskText) {
+function createProgressTracker({ verbose = false, isJson = false, initialText = '' }) {
+  const steps = [];
+  let currentStatus = initialText;
+  let timer = null;
+  const isTTY = Boolean(process.stdout.isTTY) && !isJson && !verbose;
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let frameIdx = 0;
+
+  if (isTTY) {
+    timer = setInterval(() => {
+      const frame = frames[frameIdx++ % frames.length];
+      const text = currentStatus ? ` \x1b[90m${currentStatus.slice(0, 65)}\x1b[0m` : '';
+      process.stdout.write(`\r\x1b[36m${frame}\x1b[0m${text}\x1b[K`);
+    }, 80);
+  } else if (!isJson && !verbose) {
+    if (initialText) console.log(initialText);
+  } else if (verbose && initialText) {
+    console.log(initialText);
+  }
+
+  return {
+    onStep(stepText) {
+      if (!stepText || typeof stepText !== 'string') return;
+      const firstLine = stepText.split('\n')[0].trim();
+      if (!firstLine) return;
+      steps.push(firstLine);
+      if (verbose) {
+        console.log(`  \x1b[90m→ ${firstLine.slice(0, 100)}\x1b[0m`);
+      } else {
+        currentStatus = firstLine;
+      }
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      if (isTTY) {
+        process.stdout.write('\r\x1b[K');
+      }
+    },
+    getSteps() {
+      return steps;
+    },
+  };
+}
+
+async function taskCommand(taskText, { verbose = false, json = false } = {}) {
   const session = getActiveSession();
   if (!session) {
     console.error('\x1b[31mError: Not paired.\x1b[0m');
@@ -264,25 +341,52 @@ async function taskCommand(taskText) {
     },
   };
 
+  const initialMsg = `\x1b[36m[Kroki: ${session.deviceName || 'Browser'}]\x1b[0m Running: "${taskText}"...`;
+  const tracker = createProgressTracker({ verbose, isJson: json, initialText: initialMsg });
+
   try {
-    console.log(`\x1b[36m[Kroki: ${session.deviceName || 'Browser'}]\x1b[0m Running: "${taskText}"...`);
     const result = await conn.sendCommand(command, ev => {
       if (ev.kind === 'execution') {
-        const title = ev.payload?.title || ev.payload?.type;
-        if (title) console.log(`  \x1b[90m→ ${title}\x1b[0m`);
+        const details = ev.payload?.data?.details || ev.payload?.title || ev.payload?.type;
+        if (details) tracker.onStep(details);
       }
     });
 
-    console.log('\x1b[32m✔ Task completed.\x1b[0m');
-    if (result && typeof result === 'object') {
+    tracker.stop();
+
+    if (json) {
       console.log(JSON.stringify(result, null, 2));
+    } else {
+      if (verbose) {
+        console.log('\x1b[32m✔ Task completed.\x1b[0m\n');
+      }
+      if (result && typeof result === 'object' && result.message) {
+        console.log(result.message);
+      } else if (result && typeof result === 'object') {
+        console.log(JSON.stringify(result, null, 2));
+      }
+    }
+  } catch (err) {
+    tracker.stop();
+    if (!verbose && tracker.getSteps().length > 0) {
+      console.error('\x1b[90mRecent steps before failure:\x1b[0m');
+      for (const step of tracker.getSteps().slice(-10)) {
+        console.error(`  \x1b[90m→ ${step}\x1b[0m`);
+      }
+      console.error('');
     }
+    if (json) {
+      console.error(JSON.stringify({ success: false, error: err.message, steps: tracker.getSteps() }, null, 2));
+    } else {
+      console.error(`\x1b[31m✖ Error: ${err.message}\x1b[0m`);
+    }
+    process.exit(1);
   } finally {
     conn.close();
   }
 }
 
-async function workflowCommand(nameOrId, varsJson) {
+async function workflowCommand(nameOrId, varsJson, { verbose = false, json = false } = {}) {
   const session = getActiveSession();
   if (!session) {
     console.error('\x1b[31mError: Not paired.\x1b[0m');
@@ -316,29 +420,75 @@ async function workflowCommand(nameOrId, varsJson) {
     },
   };
 
+  const initialMsg = `\x1b[36m[Kroki: ${session.deviceName || 'Browser'}]\x1b[0m Executing workflow "${nameOrId}"...`;
+  const tracker = createProgressTracker({ verbose, isJson: json, initialText: initialMsg });
+
   try {
-    console.log(`\x1b[36m[Kroki: ${session.deviceName || 'Browser'}]\x1b[0m Executing workflow "${nameOrId}"...`);
     const result = await conn.sendCommand(command, ev => {
       if (ev.kind === 'workflow_step_start') {
-        console.log(`  \x1b[90m[step] ${ev.payload?.stepType || 'action'}: ${ev.payload?.comment || ''}\x1b[0m`);
+        const stepDesc = `[step] ${ev.payload?.stepType || 'action'}: ${ev.payload?.comment || ''}`;
+        tracker.onStep(stepDesc);
       }
     });
 
-    console.log('\x1b[32m✔ Workflow finished.\x1b[0m');
-    if (result) console.log(JSON.stringify(result, null, 2));
+    tracker.stop();
+
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      if (verbose) {
+        console.log('\x1b[32m✔ Workflow finished.\x1b[0m\n');
+      }
+      if (result) console.log(JSON.stringify(result, null, 2));
+    }
+  } catch (err) {
+    tracker.stop();
+    if (!verbose && tracker.getSteps().length > 0) {
+      console.error('\x1b[90mRecent steps before failure:\x1b[0m');
+      for (const step of tracker.getSteps().slice(-10)) {
+        console.error(`  \x1b[90m→ ${step}\x1b[0m`);
+      }
+      console.error('');
+    }
+    if (json) {
+      console.error(JSON.stringify({ success: false, error: err.message, steps: tracker.getSteps() }, null, 2));
+    } else {
+      console.error(`\x1b[31m✖ Error: ${err.message}\x1b[0m`);
+    }
+    process.exit(1);
   } finally {
     conn.close();
   }
 }
 
-function statusCommand() {
+function statusCommand({ json = false } = {}) {
   const session = getActiveSession();
   if (!session) {
+    if (json) {
+      console.log(JSON.stringify({ paired: false }, null, 2));
+      return;
+    }
     console.log('No active paired profile.');
     console.log('To pair, get a code from https://kroki.ai/#/devices and run:');
     console.log('  npx kroki pair <CODE>');
     return;
   }
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          paired: true,
+          deviceId: session.deviceId,
+          deviceName: session.deviceName,
+          platform: session.platform,
+          pairedAt: session.pairedAt,
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
   console.log(
     `\x1b[32m✔ Paired\x1b[0m with "${session.deviceName || session.deviceId}" (${session.platform || 'browser'})`,
   );
@@ -350,11 +500,16 @@ function helpCommand() {
 \x1b[1mKroki CLI\x1b[0m — Browser Automation & AI Agent Bridge for Google Chrome
 
 \x1b[1mUsage:\x1b[0m
-  npx kroki pair <CODE>                   Pair with a browser profile (from https://kroki.ai/#/devices)
-  npx kroki "<task>"                      Send an AI task to the live browser
-  npx kroki run "<workflow>" [json]       Execute a saved workflow
-  npx kroki status                        View paired profile and status
-  npx kroki clear                         Disconnect active pairing session
+  npx kroki "<task>" [options]             Send an AI task to the live browser
+  npx kroki run "<workflow>" [json] [opts] Execute a saved workflow
+  npx kroki pair <CODE>                    Pair with a browser profile (from https://kroki.ai/#/devices)
+  npx kroki status [options]               View paired profile and status
+  npx kroki clear                          Disconnect active pairing session
+
+\x1b[1mOptions:\x1b[0m
+  -v, --verbose                            Show real-time execution steps and logs
+  -j, --json                               Output result as JSON
+  -h, --help                               Show help
 
 \x1b[1mDashboard:\x1b[0m
   https://kroki.ai/#/devices
@@ -364,24 +519,38 @@ function helpCommand() {
 // ── Entry Point ─────────────────────────────────────────────────────────────
 
 const rawArgs = process.argv.slice(2);
-const first = rawArgs[0] || 'help';
+let verbose = false;
+let json = false;
+const filteredArgs = [];
+
+for (const arg of rawArgs) {
+  if (arg === '--verbose' || arg === '-v') {
+    verbose = true;
+  } else if (arg === '--json' || arg === '-j') {
+    json = true;
+  } else {
+    filteredArgs.push(arg);
+  }
+}
+
+const first = filteredArgs[0] || 'help';
 
 switch (first) {
   case 'pair':
   case 'connect':
-    pairCommand(rawArgs[1]).catch(e => {
+    pairCommand(filteredArgs[1]).catch(e => {
       console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
       process.exit(1);
     });
     break;
 
   case 'status':
-    statusCommand();
+    statusCommand({ json });
     break;
 
   case 'run':
   case 'workflow':
-    workflowCommand(rawArgs[1], rawArgs[2]).catch(e => {
+    workflowCommand(filteredArgs[1], filteredArgs[2], { verbose, json }).catch(e => {
       console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
       process.exit(1);
     });
@@ -399,10 +568,16 @@ switch (first) {
     helpCommand();
     break;
 
-  default:
-    taskCommand(rawArgs.join(' ')).catch(e => {
+  default: {
+    const taskText = filteredArgs.join(' ').trim();
+    if (!taskText) {
+      helpCommand();
+      break;
+    }
+    taskCommand(taskText, { verbose, json }).catch(e => {
       console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
       process.exit(1);
     });
     break;
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kroki",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Kroki Browser Automation CLI — Control Chrome from terminal and AI agents",
   "keywords": [
     "kroki",