@pulso/companion 0.4.3 → 0.4.4

package/dist/index.js

@@ -346,7 +346,7 @@ var require_dist = __commonJS({
 
 // src/index.ts
 import WebSocket from "ws";
-import { exec as exec5, execSync as execSync3 } from "child_process";
+import { exec as exec5, execSync as execSync3, spawn } from "child_process";
 import { createRequire } from "module";
 import { createInterface } from "readline/promises";
 import { stdin as input, stdout as output } from "process";
@@ -1835,6 +1835,57 @@ var LinuxAdapter = class {
       };
     }
   }
+  async browserListProfiles() {
+    const home = process.env.HOME || "";
+    const browserPaths = [
+      { browser: "Google Chrome", dir: `${home}/.config/google-chrome` },
+      { browser: "Chromium", dir: `${home}/.config/chromium` },
+      { browser: "Microsoft Edge", dir: `${home}/.config/microsoft-edge` },
+      { browser: "Brave Browser", dir: `${home}/.config/BraveSoftware/Brave-Browser` }
+    ];
+    const profiles = [];
+    for (const { browser, dir } of browserPaths) {
+      if (!existsSync(dir)) continue;
+      let entries = [];
+      try {
+        entries = readdirSync(dir);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (entry !== "Default" && !entry.startsWith("Profile ")) continue;
+        const prefsPath = `${dir}/${entry}/Preferences`;
+        if (!existsSync(prefsPath)) continue;
+        try {
+          const prefs = JSON.parse(readFileSync(prefsPath, "utf-8"));
+          profiles.push({
+            browser,
+            profileDir: `${dir}/${entry}`,
+            name: prefs.profile?.name || entry,
+            email: prefs.account_info?.[0]?.email,
+            isDefault: entry === "Default"
+          });
+        } catch {
+        }
+      }
+    }
+    const ffDir = `${home}/.mozilla/firefox`;
+    if (existsSync(ffDir)) {
+      try {
+        for (const entry of readdirSync(ffDir)) {
+          if (!existsSync(`${ffDir}/${entry}/prefs.js`)) continue;
+          profiles.push({
+            browser: "Firefox",
+            profileDir: `${ffDir}/${entry}`,
+            name: entry.replace(/^[a-z0-9]+\./, ""),
+            isDefault: entry.includes("default")
+          });
+        }
+      } catch {
+      }
+    }
+    return { success: true, data: { profiles, total: profiles.length } };
+  }
   /* ══════════════════════════════════════════════════════════
    *  Productivity: Calendar
    *
@@ -3443,6 +3494,18 @@ function runSwift(code, timeout = 1e4) {
     child.stdin?.end();
   });
 }
+async function hasScreenRecordingPermission() {
+  try {
+    const out = await runSwift(`
+import Cocoa
+import CoreGraphics
+print(CGPreflightScreenCaptureAccess() ? "granted" : "denied")
+`, 6e3);
+    return out.trim().toLowerCase() === "granted";
+  } catch {
+    return false;
+  }
+}
 function safePath2(relative) {
   const full = resolve2(HOME2, relative);
   if (!full.startsWith(HOME2)) return null;
@@ -3651,6 +3714,14 @@ var MacOSAdapter = class {
    *  Screenshots & Computer Use
    * ══════════════════════════════════════════════════════════ */
   async screenshot() {
+    const allowed = await hasScreenRecordingPermission();
+    if (!allowed) {
+      return {
+        image: "",
+        format: "jpeg",
+        note: "Screen Recording permission is not granted for this Companion binary. Enable it in System Settings -> Privacy & Security -> Screen Recording, then reopen Pulso Companion."
+      };
+    }
     const ts = Date.now();
     const pngPath = `/tmp/pulso-ss-${ts}.png`;
     const jpgPath = `/tmp/pulso-ss-${ts}.jpg`;
@@ -4065,6 +4136,89 @@ end tell`);
       return { success: false, error: `JS execution failed: ${err.message}` };
     }
   }
+  async browserListProfiles() {
+    const os = homedir2();
+    const browserPaths = [
+      { browser: "Google Chrome", dir: `${os}/Library/Application Support/Google/Chrome` },
+      { browser: "Google Chrome Beta", dir: `${os}/Library/Application Support/Google/Chrome Beta` },
+      { browser: "Google Chrome Dev", dir: `${os}/Library/Application Support/Google/Chrome Dev` },
+      { browser: "Microsoft Edge", dir: `${os}/Library/Application Support/Microsoft Edge` },
+      { browser: "Brave Browser", dir: `${os}/Library/Application Support/BraveSoftware/Brave-Browser` },
+      { browser: "Opera", dir: `${os}/Library/Application Support/com.operasoftware.Opera` },
+      { browser: "Vivaldi", dir: `${os}/Library/Application Support/Vivaldi` },
+      { browser: "Arc", dir: `${os}/Library/Application Support/Arc/User Data` },
+      { browser: "Chromium", dir: `${os}/Library/Application Support/Chromium` }
+    ];
+    const profiles = [];
+    for (const { browser, dir } of browserPaths) {
+      if (!existsSync2(dir)) continue;
+      let dirs = [];
+      try {
+        dirs = readdirSync2(dir);
+      } catch {
+        continue;
+      }
+      for (const entry of dirs) {
+        if (entry !== "Default" && !entry.startsWith("Profile ")) continue;
+        const prefsPath = `${dir}/${entry}/Preferences`;
+        if (!existsSync2(prefsPath)) continue;
+        try {
+          const raw = readFileSync2(prefsPath, "utf-8");
+          const prefs = JSON.parse(raw);
+          const name = prefs.profile?.name || entry;
+          const email = prefs.account_info?.[0]?.email;
+          profiles.push({
+            browser,
+            profileDir: `${dir}/${entry}`,
+            name,
+            email,
+            isDefault: entry === "Default"
+          });
+        } catch {
+        }
+      }
+    }
+    const firefoxPaths = [
+      `${os}/Library/Application Support/Firefox/Profiles`,
+      `${os}/Library/Application Support/Firefox Developer Edition/Profiles`
+    ];
+    for (const ffDir of firefoxPaths) {
+      if (!existsSync2(ffDir)) continue;
+      try {
+        const dirs = readdirSync2(ffDir);
+        const browserName = ffDir.includes("Developer") ? "Firefox Developer Edition" : "Firefox";
+        for (const entry of dirs) {
+          const userJs = `${ffDir}/${entry}/user.js`;
+          const prefsJs = `${ffDir}/${entry}/prefs.js`;
+          if (!existsSync2(prefsJs) && !existsSync2(userJs)) continue;
+          profiles.push({
+            browser: browserName,
+            profileDir: `${ffDir}/${entry}`,
+            name: entry.replace(/^[a-z0-9]+\./, ""),
+            // strip hash prefix
+            isDefault: entry.includes("default")
+          });
+        }
+      } catch {
+      }
+    }
+    let running = [];
+    try {
+      const ps = await runShell2("ps aux | grep -E '(Chrome|Edge|Brave|Firefox|Opera|Vivaldi|Arc)' | grep -v grep | awk '{print $11}'");
+      running = ps.split("\n").filter(Boolean);
+    } catch {
+    }
+    return {
+      success: true,
+      data: {
+        profiles: profiles.map((p) => ({
+          ...p,
+          isRunning: running.some((r) => r.toLowerCase().includes(p.browser.toLowerCase().replace(/ /g, "")))
+        })),
+        total: profiles.length
+      }
+    };
+  }
   /* ══════════════════════════════════════════════════════════
    *  Productivity: Calendar
    * ══════════════════════════════════════════════════════════ */
@@ -6099,6 +6253,47 @@ foreach ($w in $windows) {
       };
     }
   }
+  async browserListProfiles() {
+    try {
+      const userProfile = process.env.LOCALAPPDATA || process.env.APPDATA || "";
+      const browserPaths = [
+        { browser: "Google Chrome", dir: `${userProfile}\\Google\\Chrome\\User Data` },
+        { browser: "Microsoft Edge", dir: `${userProfile}\\Microsoft\\Edge\\User Data` },
+        { browser: "Brave Browser", dir: `${userProfile}\\BraveSoftware\\Brave-Browser\\User Data` },
+        { browser: "Vivaldi", dir: `${userProfile}\\Vivaldi\\User Data` },
+        { browser: "Opera", dir: `${userProfile}\\Opera Software\\Opera Stable` }
+      ];
+      const profiles = [];
+      for (const { browser, dir } of browserPaths) {
+        if (!existsSync3(dir)) continue;
+        let entries = [];
+        try {
+          entries = readdirSync3(dir);
+        } catch {
+          continue;
+        }
+        for (const entry of entries) {
+          if (entry !== "Default" && !entry.startsWith("Profile ")) continue;
+          const prefsPath = `${dir}\\${entry}\\Preferences`;
+          if (!existsSync3(prefsPath)) continue;
+          try {
+            const prefs = JSON.parse(readFileSync3(prefsPath, "utf-8"));
+            profiles.push({
+              browser,
+              profileDir: `${dir}\\${entry}`,
+              name: prefs.profile?.name || entry,
+              email: prefs.account_info?.[0]?.email,
+              isDefault: entry === "Default"
+            });
+          } catch {
+          }
+        }
+      }
+      return { success: true, data: { profiles, total: profiles.length } };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
   /* ══════════════════════════════════════════════════════════
    *  Productivity: Calendar
    *
@@ -8755,6 +8950,61 @@ var WAKE_WORD_LOCAL_STT_BUDGET_MS_RAW = process.env.PULSO_WAKE_WORD_LOCAL_STT_BU
 var WS_BASE = API_URL.replace("https://", "wss://").replace("http://", "ws://") + "/ws/companion";
 var HOME4 = homedir4();
 var RECONNECT_DELAY = 5e3;
+var COMPANION_LOCK_FILE = join5(CREDENTIALS_DIR, "companion.lock.json");
+function releaseCompanionLock() {
+  try {
+    if (!existsSync4(COMPANION_LOCK_FILE)) return;
+    const raw = readFileSync4(COMPANION_LOCK_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.pid === process.pid) {
+      unlinkSync5(COMPANION_LOCK_FILE);
+    }
+  } catch {
+  }
+}
+function acquireCompanionLock() {
+  try {
+    if (!existsSync4(CREDENTIALS_DIR)) {
+      mkdirSync3(CREDENTIALS_DIR, { recursive: true });
+    }
+    if (existsSync4(COMPANION_LOCK_FILE)) {
+      try {
+        const raw = readFileSync4(COMPANION_LOCK_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        const existingPid = Number(parsed?.pid || 0);
+        if (existingPid > 1 && existingPid !== process.pid) {
+          try {
+            process.kill(existingPid, 0);
+            console.log("");
+            console.log("  \u26A0\uFE0F  Another Pulso Companion instance is already running.");
+            console.log(`  PID: ${existingPid}${parsed?.startedAt ? ` (${parsed.startedAt})` : ""}`);
+            console.log("  Exiting this instance to avoid command collisions.\n");
+            process.exit(0);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    writeFileSync5(
+      COMPANION_LOCK_FILE,
+      JSON.stringify(
+        {
+          pid: process.pid,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          argv: process.argv.slice(2)
+        },
+        null,
+        2
+      ),
+      "utf-8"
+    );
+    if (platform() !== "win32") {
+      chmodSync(COMPANION_LOCK_FILE, 384);
+    }
+  } catch {
+  }
+}
 async function requestWsTicket() {
   try {
     const res = await fetch(`${API_URL}/ws/ticket`, {
@@ -8841,6 +9091,18 @@ function runSwift2(code, timeout = 1e4) {
     child.stdin?.end();
   });
 }
+async function hasScreenRecordingPermission2() {
+  try {
+    const out = await runSwift2(`
+import Cocoa
+import CoreGraphics
+print(CGPreflightScreenCaptureAccess() ? "granted" : "denied")
+`, 6e3);
+    return out.trim().toLowerCase() === "granted";
+  } catch {
+    return false;
+  }
+}
 var SETUP_DONE_FILE = join5(HOME4, ".pulso-companion-setup");
 async function setupPermissions() {
   const isFirstRun = !existsSync4(SETUP_DONE_FILE);
@@ -8944,6 +9206,39 @@ var ADAPTER_COMMANDS = {
   sys_open_url: (a, p) => a.openUrl(p.url),
   sys_speak: (a, p) => a.speak(p.text, p.voice),
   sys_notification: (a, p) => a.notification(p.title, p.message),
+  sys_dialog_action: async (_, p) => {
+    const buttonName = p.button;
+    const procName = p.procName ?? activeDialog?.procName;
+    if (!procName || !buttonName) {
+      return { success: false, error: "No active dialog or button not specified" };
+    }
+    const script = `
+tell application "System Events"
+  tell process "${procName.replace(/"/g, '\\"')}"
+    set targetWindow to window 1
+    repeat with w in windows
+      try
+        if role of w is "AXSheet" or role of w is "AXDialog" then
+          set targetWindow to w
+          exit repeat
+        end if
+      end try
+    end repeat
+    tell targetWindow
+      click button "${buttonName.replace(/"/g, '\\"')}"
+    end tell
+  end tell
+end tell`;
+    try {
+      await runAppleScript2(script);
+      console.log(`   \u2713 Dialog action: clicked "${buttonName}" in [${procName}]`);
+      activeDialog = null;
+      lastDialogSignature = null;
+      return { success: true, clicked: buttonName };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  },
   sys_clipboard_read: (a, _) => a.clipboardRead(),
   sys_clipboard_write: (a, p) => a.clipboardWrite(p.text),
   sys_screenshot: (a, _) => a.screenshot(),
@@ -8964,6 +9259,7 @@ var ADAPTER_COMMANDS = {
   sys_browser_new_tab: (a, p) => a.browserNewTab(p.url, p.browser),
   sys_browser_read_page: (a, p) => a.browserReadPage(p.browser, Number(p.maxLength) || void 0),
   sys_browser_execute_js: (a, p) => a.browserExecuteJs(p.code, p.browser),
+  sys_browser_list_profiles: (a, _) => a.browserListProfiles(),
   sys_calendar_list: (a, p) => a.calendarList(Number(p.days) || void 0),
   sys_calendar_create: (a, p) => a.calendarCreate(
     p.title ?? p.summary,
@@ -9024,7 +9320,16 @@ var ADAPTER_COMMANDS = {
     return level !== void 0 ? a.setBrightness(Number(level)) : a.getBrightness();
   }
 };
-async function handleCommand(command, params) {
+var claudePipeQueue = Promise.resolve();
+function runClaudePipeSerial(task) {
+  const run = claudePipeQueue.then(task, task);
+  claudePipeQueue = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+async function handleCommand(command, params, streamCb) {
   try {
     if (command === "ollama_detect") {
       try {
@@ -9072,6 +9377,14 @@ async function handleCommand(command, params) {
         const rh = params.height;
         if (rx == null || ry == null || rw == null || rh == null)
           return { success: false, error: "Missing x, y, width, or height" };
+        const screenPermitted = await hasScreenRecordingPermission2();
+        if (!screenPermitted) {
+          return {
+            success: false,
+            error: "Screen Recording permission is not granted. Enable Pulso Companion in System Settings -> Privacy & Security -> Screen Recording, then reopen the app.",
+            errorCode: "SCREEN_PERMISSION_REQUIRED"
+          };
+        }
         const ts2 = Date.now();
         const regPath = `/tmp/pulso-ss-region-${ts2}.png`;
         const regJpg = `/tmp/pulso-ss-region-${ts2}.jpg`;
@@ -9722,71 +10035,198 @@ print(result.stdout[:5000])
         const model = params.model;
         const maxTurns = params.max_turns;
         const systemPrompt = params.system_prompt;
-        const outputFormat = params.output_format || "json";
-        const timeout = Number(params.timeout) || 12e4;
-        const flags = ["-p", `--output-format ${outputFormat}`];
-        if (model) flags.push(`--model ${model}`);
-        if (maxTurns) flags.push(`--max-turns ${maxTurns}`);
-        if (systemPrompt) flags.push(`--append-system-prompt ${JSON.stringify(systemPrompt)}`);
-        flags.push("--allowedTools ''");
-        const cmd = `claude ${flags.join(" ")}`;
-        return new Promise((resolve5) => {
-          const child = exec5(cmd, { timeout }, (err, stdout, stderr) => {
-            if (err) {
-              resolve5({
-                success: false,
-                error: `Claude pipe error: ${stderr || err.message}`,
-                errorCode: "CLAUDE_PIPE_FAILED"
-              });
-            } else {
+        const effort = params.effort || "low";
+        const outputFormat = params.output_format || "text";
+        const timeout = Number(params.timeout) || 18e4;
+        const home = process.env.HOME || "";
+        const claudePaths = [
+          `${home}/.local/bin/claude`,
+          `${home}/.local/share/claude/versions/latest/claude`,
+          "/usr/local/bin/claude",
+          "/opt/homebrew/bin/claude"
+        ];
+        let claudeBin = "claude";
+        for (const p of claudePaths) {
+          try {
+            execSync3(`test -x "${p}"`, { stdio: "ignore" });
+            claudeBin = p;
+            break;
+          } catch {
+          }
+        }
+        const useStreamJson = Boolean(streamCb);
+        const effectiveOutputFormat = useStreamJson ? "stream-json" : outputFormat;
+        const args = ["-p", "--output-format", effectiveOutputFormat];
+        if (useStreamJson) {
+          args.push("--verbose", "--include-partial-messages");
+        }
+        args.push("--tools", "");
+        if (systemPrompt && systemPrompt.trim()) {
+          args.push("--system-prompt", systemPrompt.trim());
+        }
+        if (effort) args.push("--effort", effort);
+        if (model) args.push("--model", model);
+        if (maxTurns) args.push("--max-turns", String(maxTurns));
+        const promptInput = prompt;
+        return runClaudePipeSerial(
+          () => new Promise((resolve5) => {
+            let stdout = "";
+            let stderr = "";
+            let streamBuffer = "";
+            let streamedResponse = "";
+            let finalResultText = "";
+            let assistantSnapshotText = "";
+            const processJsonLine = (line) => {
+              const trimmed = line.trim();
+              if (!trimmed) return;
+              let evt = null;
               try {
-                if (outputFormat === "json") {
-                  const parsed = JSON.parse(stdout);
+                evt = JSON.parse(trimmed);
+              } catch {
+                return;
+              }
+              const deltaType = evt?.event?.delta?.type;
+              if (evt?.type === "stream_event" && deltaType === "text_delta") {
+                const deltaText = String(evt?.event?.delta?.text ?? "");
+                if (deltaText) {
+                  streamedResponse += deltaText;
+                  if (streamCb) streamCb(deltaText);
+                }
+                return;
+              }
+              if (evt?.type === "result" && typeof evt?.result === "string") {
+                finalResultText = evt.result;
+                return;
+              }
+              if (evt?.type === "assistant" && Array.isArray(evt?.message?.content)) {
+                const textBlocks = evt.message.content.filter((p) => p?.type === "text" && typeof p?.text === "string").map((p) => p.text);
+                if (textBlocks.length > 0) {
+                  assistantSnapshotText = textBlocks.join("");
+                }
+              }
+            };
+            const childEnv = {
+              ...process.env,
+              PATH: `${home}/.local/bin:${process.env.PATH}`
+            };
+            delete childEnv.CLAUDECODE;
+            delete childEnv.CLAUDE_CODE;
+            const child = spawn(claudeBin, args, {
+              env: childEnv,
+              timeout,
+              stdio: ["pipe", "pipe", "pipe"]
+            });
+            child.stdout.on("data", (chunk) => {
+              const text = chunk.toString();
+              stdout += text;
+              if (useStreamJson) {
+                streamBuffer += text;
+                const lines = streamBuffer.split(/\r?\n/);
+                streamBuffer = lines.pop() || "";
+                for (const ln of lines) {
+                  processJsonLine(ln);
+                }
+              } else if (streamCb) {
+                streamCb(text);
+              }
+            });
+            child.stderr.on("data", (chunk) => {
+              stderr += chunk.toString();
+            });
+            child.on("close", (code) => {
+              if (code !== 0) {
+                const detail = (stderr.trim() || stdout.trim() || "Unknown error").slice(0, 500);
+                const errorCode = detail.toLowerCase().includes("out of extra usage") ? "CLAUDE_USAGE_LIMIT" : "CLAUDE_PIPE_FAILED";
+                resolve5({
+                  success: false,
+                  error: `Claude pipe error (exit ${code}): ${detail}`,
+                  errorCode
+                });
+                return;
+              }
+              try {
+                if (effectiveOutputFormat === "stream-json") {
+                  if (streamBuffer.trim()) {
+                    processJsonLine(streamBuffer);
+                  }
+                  const response = (finalResultText || streamedResponse || assistantSnapshotText || "").trim();
                   resolve5({
                     success: true,
                     data: {
-                      response: parsed.result || stdout.trim(),
-                      session_id: parsed.session_id,
-                      cost_usd: parsed.total_cost_usd ?? 0,
-                      duration_ms: parsed.duration_ms,
-                      num_turns: parsed.num_turns,
+                      response,
                       model: model || "default",
                       via: "claude-max-subscription"
                     }
                   });
-                } else {
+                  return;
+                }
+                if (outputFormat === "json") {
+                  const parsed = JSON.parse(stdout);
                   resolve5({
                     success: true,
                     data: {
-                      response: stdout.trim(),
+                      response: parsed.result || stdout.trim(),
+                      session_id: parsed.session_id,
+                      cost_usd: 0,
+                      duration_ms: parsed.duration_ms,
+                      num_turns: parsed.num_turns,
                       model: model || "default",
                       via: "claude-max-subscription"
                     }
                   });
+                  return;
                 }
               } catch {
-                resolve5({
-                  success: true,
-                  data: {
-                    response: stdout.trim(),
-                    model: model || "default",
-                    via: "claude-max-subscription"
-                  }
-                });
               }
-            }
-          });
-          child.stdin?.write(prompt);
-          child.stdin?.end();
-        });
+              resolve5({
+                success: true,
+                data: {
+                  response: stdout.trim(),
+                  model: model || "default",
+                  via: "claude-max-subscription"
+                }
+              });
+            });
+            child.on("error", (err) => {
+              resolve5({
+                success: false,
+                error: `Claude pipe spawn error: ${err.message}`,
+                errorCode: "CLAUDE_PIPE_FAILED"
+              });
+            });
+            child.stdin.write(promptInput);
+            child.stdin.end();
+          })
+        );
       }
       case "sys_claude_status": {
         try {
           const version = await runShell4("claude --version 2>/dev/null", 5e3);
           let authStatus = "unknown";
+          let authDetails;
           try {
             const status = await runShell4("claude auth status 2>&1", 1e4);
-            authStatus = status.includes("Authenticated") || status.includes("logged in") ? "authenticated" : "not_authenticated";
+            const trimmed = status.trim();
+            let parsed = null;
+            try {
+              parsed = JSON.parse(trimmed);
+            } catch {
+              parsed = null;
+            }
+            if (parsed && typeof parsed === "object") {
+              const loggedIn = parsed.loggedIn === true;
+              authStatus = loggedIn ? "authenticated" : "not_authenticated";
+              authDetails = {
+                authMethod: typeof parsed.authMethod === "string" ? parsed.authMethod : void 0,
+                apiProvider: typeof parsed.apiProvider === "string" ? parsed.apiProvider : void 0,
+                email: typeof parsed.email === "string" ? parsed.email : void 0,
+                orgId: typeof parsed.orgId === "string" ? parsed.orgId : void 0,
+                subscriptionType: typeof parsed.subscriptionType === "string" ? parsed.subscriptionType : void 0
+              };
+            } else {
+              const lower = trimmed.toLowerCase();
+              authStatus = lower.includes("authenticated") || lower.includes("logged in") || lower.includes('loggedin":true') ? "authenticated" : "not_authenticated";
+            }
           } catch {
             authStatus = "not_authenticated";
           }
@@ -9796,7 +10236,8 @@ print(result.stdout[:5000])
               installed: true,
               version: version.trim(),
               authenticated: authStatus === "authenticated",
-              status: authStatus
+              status: authStatus,
+              ...authDetails ? { details: authDetails } : {}
             }
           };
         } catch {
@@ -9990,6 +10431,99 @@ function stopImessageMonitor() {
     imessageTimer = null;
   }
 }
+var permissionDialogTimer = null;
+var lastDialogSignature = null;
+var DIALOG_POLL_INTERVAL = 1500;
+var activeDialog = null;
+function startPermissionDialogWatcher() {
+  if (adapter.platform !== "macos") return;
+  permissionDialogTimer = setInterval(async () => {
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    try {
+      const script = `
+tell application "System Events"
+  set procList to every process where visible is true
+  repeat with proc in procList
+    set procName to name of proc as string
+    repeat with w in (windows of proc)
+      try
+        set wRole to role of w as string
+        if wRole is "AXSheet" or wRole is "AXDialog" then
+          set wTitle to ""
+          try
+            set wTitle to title of w as string
+          end try
+          set wDesc to ""
+          try
+            set wDesc to description of w as string
+          end try
+          set btnNames to {}
+          repeat with btn in (buttons of w)
+            try
+              set end of btnNames to (name of btn as string)
+            end try
+          end repeat
+          if (count of btnNames) > 0 then
+            set btnStr to ""
+            repeat with b in btnNames
+              if btnStr is not "" then set btnStr to btnStr & "|||"
+              set btnStr to btnStr & b
+            end repeat
+            return procName & ":::" & wTitle & ":::" & wDesc & ":::" & btnStr
+          end if
+        end if
+      end try
+    end repeat
+  end repeat
+  return ""
+end tell`;
+      const raw = await runAppleScript2(script);
+      if (!raw) {
+        if (activeDialog) {
+          lastDialogSignature = null;
+          activeDialog = null;
+        }
+        return;
+      }
+      const sig = raw;
+      if (sig === lastDialogSignature) return;
+      lastDialogSignature = sig;
+      const [procName = "", title = "", desc = "", btnStr = ""] = raw.split(":::");
+      const buttons = btnStr.split("|||").map((b) => b.trim()).filter(Boolean);
+      const dialogId = `dlg_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+      activeDialog = { dialogId, procName, buttons, detectedAt: Date.now() };
+      let screenshot;
+      try {
+        const scrResult = await adapter.screenshot();
+        if (scrResult.image) {
+          screenshot = scrResult.image;
+        }
+      } catch {
+      }
+      console.log(`
+\u{1F514} Permission dialog: [${procName}] "${title}" \u2014 buttons: ${buttons.join(", ")}`);
+      ws.send(JSON.stringify({
+        type: "permission_dialog",
+        dialogId,
+        procName,
+        title: title || procName,
+        message: desc,
+        buttons,
+        screenshot,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    } catch {
+    }
+  }, DIALOG_POLL_INTERVAL);
+}
+function stopPermissionDialogWatcher() {
+  if (permissionDialogTimer) {
+    clearInterval(permissionDialogTimer);
+    permissionDialogTimer = null;
+  }
+  lastDialogSignature = null;
+  activeDialog = null;
+}
 var LAZY_CAPABILITY_TOOLS = [
   "sys_calendar_list",
   "sys_calendar_create",
@@ -10043,7 +10577,7 @@ var CAPABILITY_PROBES = [
     name: "claude_cli",
     test: async () => {
       try {
-        await runShell4("which claude >/dev/null 2>&1 && claude --version >/dev/null 2>&1", 5e3);
+        await runShell4('(which claude >/dev/null 2>&1 || test -x "$HOME/.local/bin/claude" || test -x "$HOME/.local/share/claude/versions/"*/claude) && (claude --version >/dev/null 2>&1 || "$HOME/.local/bin/claude" --version >/dev/null 2>&1)', 5e3);
         return true;
       } catch {
         return false;
@@ -10193,6 +10727,8 @@ async function connect() {
     }, HEARTBEAT_INTERVAL);
     stopImessageMonitor();
     startImessageMonitor();
+    stopPermissionDialogWatcher();
+    startPermissionDialogWatcher();
   });
   ws.on("message", async (raw) => {
     try {
@@ -10210,7 +10746,13 @@ async function connect() {
 \u26A1 Command: ${msg.command}`,
           msg.params ? JSON.stringify(msg.params).slice(0, 200) : ""
         );
-        const result = await handleCommand(msg.command, msg.params ?? {});
+        const streamCb = (chunk) => {
+          try {
+            ws.send(JSON.stringify({ id: msg.id, type: "stream", chunk }));
+          } catch {
+          }
+        };
+        const result = await handleCommand(msg.command, msg.params ?? {}, streamCb);
         console.log(
           `   \u2192 ${result.success ? "\u2705" : "\u274C"}`,
           result.success ? JSON.stringify(result.data).slice(0, 200) : result.error
@@ -10228,6 +10770,7 @@ async function connect() {
     console.log(`
 \u{1F50C} Disconnected (${code}: ${reasonStr})`);
     stopImessageMonitor();
+    stopPermissionDialogWatcher();
     if (heartbeatTimer) {
       clearInterval(heartbeatTimer);
       heartbeatTimer = null;
@@ -10933,6 +11476,10 @@ function writeString(view, offset, str) {
 }
 var currentPlatform = detectPlatform();
 var platformName = { macos: "macOS", windows: "Windows", linux: "Linux" }[currentPlatform] || "Unknown";
+acquireCompanionLock();
+process.on("exit", () => {
+  releaseCompanionLock();
+});
 console.log("");
 console.log("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
 console.log(`  \u2551   Pulso ${platformName} Companion v0.4.3  \u2551`);
@@ -10958,10 +11505,12 @@ process.on("SIGINT", () => {
   console.log("\n\u{1F44B} Shutting down Pulso Companion...");
   wakeWordActive = false;
   ws?.close(1e3, "User shutdown");
+  releaseCompanionLock();
   process.exit(0);
 });
 process.on("SIGTERM", () => {
   wakeWordActive = false;
   ws?.close(1e3, "Process terminated");
+  releaseCompanionLock();
   process.exit(0);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pulso/companion",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "type": "module",
   "description": "Pulso Companion — gives your AI agent real control over your computer",
   "bin": {