@leg3ndy/otto-bridge 0.8.3 → 0.8.5

package/dist/executors/native_macos.js

@@ -778,6 +778,46 @@ function noteBodyToHtml(text) {
         .map((block) => `<p>${escapeHtml(block).replace(/\n/g, "<br>")}</p>`);
     return blocks.join("");
 }
+function formatBytesCompact(bytes) {
+    if (!Number.isFinite(bytes) || !bytes || bytes <= 0) {
+        return "0 B";
+    }
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = Number(bytes);
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    const fractionDigits = value >= 10 || unitIndex === 0 ? 0 : 1;
+    return `${value.toFixed(fractionDigits)} ${units[unitIndex]}`;
+}
+function roundMetric(value, decimals = 0) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    const factor = 10 ** decimals;
+    return Math.round(value * factor) / factor;
+}
+function parseScaledBytes(rawValue, rawUnit) {
+    const value = Number(rawValue);
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    const normalizedUnit = rawUnit.trim().toUpperCase();
+    const multipliers = {
+        B: 1,
+        K: 1024,
+        KB: 1024,
+        M: 1024 ** 2,
+        MB: 1024 ** 2,
+        G: 1024 ** 3,
+        GB: 1024 ** 3,
+        T: 1024 ** 4,
+        TB: 1024 ** 4,
+    };
+    return Math.round(value * (multipliers[normalizedUnit] || 1));
+}
 function isSafeShellCommand(command) {
     const trimmed = command.trim();
     if (!trimmed) {
@@ -899,6 +939,39 @@ function parseStructuredActions(job) {
             });
             continue;
         }
+        if (type === "browser_context") {
+            actions.push({
+                type: "browser_context",
+                app: asString(action.app) || asString(action.application) || undefined,
+                include_text: action.include_text === true,
+                include_tabs: action.include_tabs === true,
+            });
+            continue;
+        }
+        if (type === "app_status") {
+            actions.push({
+                type: "app_status",
+                app: asString(action.app) || asString(action.application) || undefined,
+                include_frontmost: action.include_frontmost === true,
+                include_running_apps: action.include_running_apps === true,
+                include_top_processes: action.include_top_processes === true,
+            });
+            continue;
+        }
+        if (type === "filesystem_inspect") {
+            const targetPath = asString(action.path);
+            if (targetPath) {
+                const rawLimit = Number(action.limit);
+                actions.push({
+                    type: "filesystem_inspect",
+                    path: targetPath,
+                    include_children: action.include_children === true,
+                    include_preview: action.include_preview === true,
+                    limit: Number.isFinite(rawLimit) ? Math.max(1, Math.min(Math.round(rawLimit), 20)) : undefined,
+                });
+            }
+            continue;
+        }
         if (type === "read_file" || type === "read_local_file") {
             const filePath = asString(action.path);
             if (filePath) {
@@ -922,6 +995,19 @@ function parseStructuredActions(job) {
             actions.push({ type: "count_files", path: filePath, extensions, recursive });
             continue;
         }
+        if (type === "system_status") {
+            const validSections = Array.isArray(action.sections)
+                ? action.sections
+                    .map((item) => asString(item)?.toLowerCase())
+                    .filter((item) => item === "cpu" || item === "memory" || item === "disk" || item === "battery")
+                : undefined;
+            actions.push({
+                type: "system_status",
+                sections: validSections && validSections.length > 0 ? Array.from(new Set(validSections)) : undefined,
+                include_top_processes: action.include_top_processes === true,
+            });
+            continue;
+        }
         if (type === "run_shell" || type === "shell" || type === "terminal") {
             const command = asString(action.command) || asString(action.cmd);
             const cwd = asString(action.cwd);
@@ -1277,6 +1363,30 @@ export class NativeMacOSJobExecutor {
                     completionNotes.push(`Li a pagina ${page.title || page.url || "ativa"} no navegador.`);
                     continue;
                 }
+                if (action.type === "browser_context") {
+                    await reporter.progress(progressPercent, "Lendo o contexto do navegador ativo");
+                    const browserContext = await this.collectBrowserContext(action.app, action.include_text === true, action.include_tabs === true);
+                    resultPayload.browser_context = browserContext;
+                    resultPayload.summary = browserContext.summary;
+                    completionNotes.push(browserContext.summary);
+                    continue;
+                }
+                if (action.type === "app_status") {
+                    await reporter.progress(progressPercent, "Lendo os apps ativos do Mac");
+                    const appStatus = await this.collectAppStatus(action.app, action.include_frontmost === true, action.include_running_apps === true, action.include_top_processes === true);
+                    resultPayload.app_status = appStatus;
+                    resultPayload.summary = appStatus.summary;
+                    completionNotes.push(appStatus.summary);
+                    continue;
+                }
+                if (action.type === "filesystem_inspect") {
+                    await reporter.progress(progressPercent, `Inspecionando ${action.path}`);
+                    const filesystem = await this.inspectFilesystemPath(action.path, action.include_children === true, action.include_preview === true, action.limit);
+                    resultPayload.filesystem = filesystem;
+                    resultPayload.summary = filesystem.summary;
+                    completionNotes.push(filesystem.summary);
+                    continue;
+                }
                 if (action.type === "read_file") {
                     await reporter.progress(progressPercent, `Lendo ${action.path}`);
                     const fileContent = await this.readLocalFile(action.path, action.max_chars);
@@ -1301,6 +1411,14 @@ export class NativeMacOSJobExecutor {
                     };
                     continue;
                 }
+                if (action.type === "system_status") {
+                    await reporter.progress(progressPercent, "Lendo CPU, memoria, disco e bateria do Mac");
+                    const systemStatus = await this.collectSystemStatus(action.sections, action.include_top_processes === true);
+                    resultPayload.system_status = systemStatus;
+                    resultPayload.summary = systemStatus.summary;
+                    completionNotes.push(systemStatus.summary);
+                    continue;
+                }
                 if (action.type === "run_shell") {
                     await reporter.progress(progressPercent, `Rodando comando local: ${action.command}`);
                     const shellOutput = await this.runShellCommand(action.command, action.cwd);
@@ -1861,6 +1979,406 @@ end tell
         }
         return null;
     }
+    async resolveBrowserContextApp(preferredApp) {
+        const candidates = [
+            preferredApp || null,
+            this.lastActiveApp,
+            await this.getFrontmostAppName(),
+        ];
+        for (const candidate of candidates) {
+            if (candidate === "Safari" || candidate === "Google Chrome") {
+                return candidate;
+            }
+        }
+        return null;
+    }
+    async readCurrentBrowserMetadata(app) {
+        const script = app === "Google Chrome"
+            ? `
+tell application "Google Chrome"
+  activate
+  if (count of windows) = 0 then error "Google Chrome nao possui janelas abertas."
+  set pageTitle to title of active tab of front window
+  set pageUrl to URL of active tab of front window
+end tell
+return pageTitle & linefeed & pageUrl
+`
+            : `
+tell application "Safari"
+  activate
+  if (count of windows) = 0 then error "Safari nao possui janelas abertas."
+  set pageTitle to name of current tab of front window
+  set pageUrl to URL of current tab of front window
+end tell
+return pageTitle & linefeed & pageUrl
+`;
+        const { stdout } = await this.runCommandCapture("osascript", ["-e", script]);
+        const [title, url] = String(stdout || "").split("\n");
+        return {
+            title: String(title || "").trim(),
+            url: String(url || "").trim(),
+        };
+    }
+    async readCurrentBrowserPage(app) {
+        if (app === "Safari") {
+            const page = await this.readFrontmostPage("Safari");
+            return {
+                title: page.title,
+                url: page.url,
+                text: page.text,
+            };
+        }
+        const script = `
+tell application "Google Chrome"
+  activate
+  if (count of windows) = 0 then error "Google Chrome nao possui janelas abertas."
+  delay 0.5
+  set jsCode to "(function(){const title=document.title||'';const url=location.href||'';const text=((document.body&&document.body.innerText)||'').trim().slice(0,12000);return JSON.stringify({title,url,text});})();"
+  set pageJson to execute active tab of front window javascript jsCode
+end tell
+return pageJson
+`;
+        try {
+            const { stdout } = await this.runCommandCapture("osascript", ["-e", script]);
+            const parsed = JSON.parse(String(stdout || "").trim() || "{}");
+            return {
+                title: asString(parsed.title) || "",
+                url: asString(parsed.url) || "",
+                text: asString(parsed.text) || "",
+            };
+        }
+        catch {
+            const metadata = await this.readCurrentBrowserMetadata(app);
+            return {
+                ...metadata,
+                text: "",
+            };
+        }
+    }
+    async listBrowserTabs(app, limit = 8) {
+        const script = app === "Google Chrome"
+            ? `
+tell application "Google Chrome"
+  if (count of windows) = 0 then return ""
+  set activeTabId to id of active tab of front window
+  set outputLines to ""
+  repeat with t in tabs of front window
+    set marker to "0"
+    if (id of t) is activeTabId then set marker to "1"
+    set outputLines to outputLines & marker & tab & (title of t) & tab & (URL of t) & linefeed
+  end repeat
+  return outputLines
+end tell
+`
+            : `
+tell application "Safari"
+  if (count of windows) = 0 then return ""
+  set activeIndex to index of current tab of front window
+  set outputLines to ""
+  set tabIndex to 0
+  repeat with t in tabs of front window
+    set tabIndex to tabIndex + 1
+    set marker to "0"
+    if tabIndex is activeIndex then set marker to "1"
+    set outputLines to outputLines & marker & tab & (name of t) & tab & (URL of t) & linefeed
+  end repeat
+  return outputLines
+end tell
+`;
+        try {
+            const { stdout } = await this.runCommandCapture("osascript", ["-e", script]);
+            return String(stdout || "")
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .slice(0, limit)
+                .map((line) => {
+                const [marker, title, url] = line.split("\t");
+                return {
+                    current: marker === "1",
+                    title: String(title || "").trim(),
+                    url: String(url || "").trim(),
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    buildBrowserContextSummary(context, includeText, includeTabs) {
+        const title = context.title || "sem titulo visivel";
+        let summary = `${context.app} esta na aba "${title}"`;
+        if (context.url) {
+            summary += ` com a URL ${context.url}.`;
+        }
+        else {
+            summary += ".";
+        }
+        if (includeText) {
+            if (context.text) {
+                summary += ` Conteudo visivel: ${clipTextPreview(context.text, 360)}.`;
+            }
+            else {
+                summary += " Nao consegui extrair o texto visivel desta pagina desta vez.";
+            }
+        }
+        if (includeTabs && context.tabs && context.tabs.length > 0) {
+            const tabsPreview = context.tabs
+                .slice(0, 4)
+                .map((tab) => `${tab.current ? "[atual] " : ""}${tab.title || tab.url || "sem titulo"}`)
+                .join(" | ");
+            if (tabsPreview) {
+                summary += ` Abas visiveis: ${tabsPreview}.`;
+            }
+        }
+        return summary;
+    }
+    async collectBrowserContext(preferredApp, includeText = false, includeTabs = false) {
+        const app = await this.resolveBrowserContextApp(preferredApp);
+        if (!app) {
+            throw new Error("Nao encontrei Safari ou Google Chrome em foco para inspecionar agora.");
+        }
+        const page = includeText
+            ? await this.readCurrentBrowserPage(app)
+            : await this.readCurrentBrowserMetadata(app).then((metadata) => ({ ...metadata, text: "" }));
+        const tabs = includeTabs ? await this.listBrowserTabs(app) : undefined;
+        const context = {
+            app,
+            title: page.title,
+            url: page.url,
+            text: page.text ? clipTextPreview(page.text, 1200) : undefined,
+            tabs,
+            summary: "",
+        };
+        context.summary = this.buildBrowserContextSummary(context, includeText, includeTabs);
+        return context;
+    }
+    async readRunningApps(limit = 12) {
+        try {
+            const { stdout } = await this.runCommandCapture("osascript", [
+                "-e",
+                `
+tell application "System Events"
+  set appNames to name of every application process whose background only is false
+end tell
+set AppleScript's text item delimiters to linefeed
+return appNames as text
+`,
+            ]);
+            return Array.from(new Set(String(stdout || "")
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter(Boolean))).slice(0, limit);
+        }
+        catch {
+            return [];
+        }
+    }
+    appMatchesProcessName(app, processName) {
+        const normalizedApp = normalizeText(app || "").replace(/\s+/g, " ").trim();
+        const normalizedProcess = normalizeText(processName || "").replace(/\s+/g, " ").trim();
+        if (!normalizedApp || !normalizedProcess) {
+            return false;
+        }
+        return normalizedProcess === normalizedApp
+            || normalizedProcess.includes(normalizedApp)
+            || normalizedApp.includes(normalizedProcess);
+    }
+    async readAppTopProcesses(limit = 5, preferredApp) {
+        try {
+            const { stdout } = await this.runCommandCapture("/bin/ps", ["-Ao", "pid=,pcpu=,rss=,comm=", "-r"]);
+            const lines = stdout.trim().split(/\r?\n/).filter(Boolean);
+            const processes = lines
+                .map((line) => {
+                const match = line.match(/^\s*(\d+)\s+([0-9.]+)\s+(\d+)\s+(.+)$/);
+                if (!match)
+                    return null;
+                const processName = match[4].trim().split("/").pop() || match[4].trim();
+                return {
+                    name: processName,
+                    cpu_percent: roundMetric(Number(match[2]), 1),
+                    memory_bytes: Math.max(0, Number(match[3])) * 1024,
+                };
+            })
+                .filter((item) => item !== null);
+            const filtered = preferredApp
+                ? processes.filter((item) => this.appMatchesProcessName(preferredApp, item.name))
+                : processes;
+            return filtered
+                .filter((item) => item.cpu_percent > 0 || (item.memory_bytes || 0) > 0)
+                .slice(0, limit);
+        }
+        catch {
+            return [];
+        }
+    }
+    buildAppStatusSummary(status) {
+        const parts = [];
+        if (status.target_app?.name) {
+            if (!status.target_app.running) {
+                parts.push(`${status.target_app.name} nao esta aberto agora`);
+            }
+            else if (status.target_app.frontmost) {
+                parts.push(`${status.target_app.name} esta aberto e em foco agora`);
+            }
+            else {
+                parts.push(`${status.target_app.name} esta aberto`);
+            }
+        }
+        else if (status.frontmost_app) {
+            parts.push(`No foco agora esta ${status.frontmost_app}`);
+        }
+        if (status.running_apps && status.running_apps.length > 0) {
+            const preview = status.running_apps.slice(0, 6).join(", ");
+            parts.push(`apps abertos: ${preview}${status.running_apps.length > 6 ? ", ..." : ""}`);
+        }
+        let summary = parts.length > 0
+            ? `${parts[0]}.`
+            : "Consegui ler o estado atual dos apps no seu Mac.";
+        if (parts.length > 1) {
+            summary += ` Também vejo ${parts.slice(1).join(". ")}.`;
+        }
+        if (status.top_processes && status.top_processes.length > 0) {
+            const topPreview = status.top_processes
+                .slice(0, 3)
+                .map((item) => `${item.name} (${roundMetric(item.cpu_percent)}% CPU${item.memory_bytes ? `, ${formatBytesCompact(item.memory_bytes)}` : ""})`)
+                .join(", ");
+            if (topPreview) {
+                summary += ` Maiores consumos agora: ${topPreview}.`;
+            }
+        }
+        return summary;
+    }
+    async collectAppStatus(preferredApp, includeFrontmost = true, includeRunningApps = true, includeTopProcesses = true) {
+        const frontmostApp = includeFrontmost ? await this.getFrontmostAppName() : null;
+        const runningApps = includeRunningApps ? await this.readRunningApps() : [];
+        const normalizedRunningApps = Array.from(new Set(runningApps));
+        const targetApp = preferredApp || undefined;
+        const targetRunning = targetApp ? normalizedRunningApps.some((item) => normalizeText(item) === normalizeText(targetApp)) : undefined;
+        const topProcesses = includeTopProcesses
+            ? await this.readAppTopProcesses(5, targetApp)
+            : [];
+        const status = {
+            captured_at: new Date().toISOString(),
+            hostname: os.hostname(),
+            platform: process.platform,
+            requested_app: targetApp,
+            frontmost_app: frontmostApp || undefined,
+            summary: "",
+        };
+        if (targetApp) {
+            status.target_app = {
+                name: targetApp,
+                running: Boolean(targetRunning),
+                frontmost: Boolean(frontmostApp && normalizeText(frontmostApp) === normalizeText(targetApp)),
+            };
+        }
+        if (includeRunningApps && normalizedRunningApps.length > 0) {
+            status.running_apps = normalizedRunningApps;
+        }
+        if (includeTopProcesses && topProcesses && topProcesses.length > 0) {
+            status.top_processes = topProcesses;
+        }
+        status.summary = this.buildAppStatusSummary(status);
+        return status;
+    }
+    async resolveFilesystemInspectPath(targetPath) {
+        const expanded = expandUserPath(targetPath);
+        try {
+            await stat(expanded);
+            return expanded;
+        }
+        catch {
+            // Continue below.
+        }
+        if (path.extname(expanded)) {
+            return this.resolveReadableFilePath(targetPath);
+        }
+        return expanded;
+    }
+    async readDirectoryUsageBytes(targetPath) {
+        try {
+            const { stdout } = await this.runCommandCapture("/usr/bin/du", ["-sk", targetPath]);
+            const match = String(stdout || "").match(/^\s*(\d+)/);
+            if (!match) {
+                return 0;
+            }
+            return Number(match[1]) * 1024;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async inspectFilesystemPath(targetPath, includeChildren = true, includePreview = false, limit = 8) {
+        const resolved = await this.resolveFilesystemInspectPath(targetPath);
+        const entryStat = await stat(resolved);
+        const itemName = path.basename(resolved) || resolved;
+        if (entryStat.isDirectory()) {
+            const entries = await readdir(resolved, { withFileTypes: true });
+            const slicedEntries = entries
+                .sort((left, right) => {
+                if (left.isDirectory() !== right.isDirectory()) {
+                    return left.isDirectory() ? -1 : 1;
+                }
+                return left.name.localeCompare(right.name);
+            })
+                .slice(0, Math.max(1, Math.min(limit, 20)));
+            const children = includeChildren
+                ? await Promise.all(slicedEntries.map(async (entry) => {
+                    const childPath = path.join(resolved, entry.name);
+                    try {
+                        const childStat = await stat(childPath);
+                        return {
+                            name: entry.name,
+                            kind: entry.isDirectory() ? "directory" : "file",
+                            size_bytes: entry.isDirectory() ? undefined : childStat.size,
+                        };
+                    }
+                    catch {
+                        return {
+                            name: entry.name,
+                            kind: entry.isDirectory() ? "directory" : "file",
+                        };
+                    }
+                }))
+                : undefined;
+            const totalSize = await this.readDirectoryUsageBytes(resolved);
+            const snapshot = {
+                captured_at: new Date().toISOString(),
+                path: targetPath,
+                resolved_path: resolved,
+                kind: "directory",
+                name: itemName,
+                size_bytes: totalSize,
+                modified_at: entryStat.mtime.toISOString(),
+                item_count: entries.length,
+                children,
+                summary: "",
+            };
+            const childPreview = children && children.length > 0
+                ? children
+                    .slice(0, 5)
+                    .map((item) => `${item.name}${item.kind === "directory" ? "/" : ""}`)
+                    .join(", ")
+                : "";
+            snapshot.summary = `A pasta ${targetPath} tem ${entries.length} item${entries.length === 1 ? "" : "s"} e ocupa ${formatBytesCompact(totalSize)}.${childPreview ? ` Itens visiveis agora: ${childPreview}.` : ""}`;
+            return snapshot;
+        }
+        const preview = includePreview ? await this.readLocalFile(resolved, 1200) : undefined;
+        const snapshot = {
+            captured_at: new Date().toISOString(),
+            path: targetPath,
+            resolved_path: resolved,
+            kind: "file",
+            name: itemName,
+            size_bytes: entryStat.size,
+            modified_at: entryStat.mtime.toISOString(),
+            preview: preview || undefined,
+            summary: "",
+        };
+        snapshot.summary = `O arquivo ${targetPath} pesa ${formatBytesCompact(entryStat.size)} e foi modificado em ${entryStat.mtime.toISOString()}.${preview ? ` Pre-visualizacao: ${clipTextPreview(preview, 320)}.` : ""}`;
+        return snapshot;
+    }
     async captureBrowserPageState(app) {
         if (app !== "Safari") {
             return null;
@@ -4600,6 +5118,233 @@ if let output = String(data: data, encoding: .utf8) {
             extensionsLabel,
         };
     }
+    snapshotCpuTimes() {
+        const cpus = os.cpus();
+        let idle = 0;
+        let total = 0;
+        for (const cpu of cpus) {
+            idle += cpu.times.idle;
+            total += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.irq + cpu.times.idle;
+        }
+        return {
+            idle,
+            total,
+            model: cpus[0]?.model || "Apple Silicon",
+            logicalCores: cpus.length || 0,
+        };
+    }
+    async sampleCpuStatus() {
+        const start = this.snapshotCpuTimes();
+        await delay(320);
+        const end = this.snapshotCpuTimes();
+        const totalDelta = Math.max(1, end.total - start.total);
+        const idleDelta = Math.max(0, end.idle - start.idle);
+        const idlePercent = roundMetric((idleDelta / totalDelta) * 100, 1);
+        const usagePercent = roundMetric(Math.max(0, 100 - idlePercent), 1);
+        const [load1m, load5m, load15m] = os.loadavg();
+        return {
+            usage_percent: usagePercent,
+            idle_percent: idlePercent,
+            logical_cores: end.logicalCores,
+            model: end.model,
+            load_average_1m: roundMetric(load1m, 2),
+            load_average_5m: roundMetric(load5m, 2),
+            load_average_15m: roundMetric(load15m, 2),
+        };
+    }
+    async readMemoryStatus() {
+        const totalBytes = os.totalmem();
+        const freeBytes = os.freemem();
+        const usedBytes = Math.max(0, totalBytes - freeBytes);
+        let compressedBytes = 0;
+        let swapUsedBytes = 0;
+        try {
+            const { stdout } = await this.runCommandCapture("/usr/bin/vm_stat", []);
+            const pageSizeMatch = stdout.match(/page size of (\d+) bytes/i);
+            const pageSize = pageSizeMatch ? Number(pageSizeMatch[1]) : 16384;
+            const compressedMatch = stdout.match(/Pages occupied by compressor:\s+([0-9.]+)/i);
+            if (compressedMatch) {
+                compressedBytes = Math.round(Number(compressedMatch[1]) * pageSize);
+            }
+        }
+        catch {
+            compressedBytes = 0;
+        }
+        try {
+            const { stdout } = await this.runCommandCapture("/usr/sbin/sysctl", ["vm.swapusage"]);
+            const usedMatch = stdout.match(/used = ([0-9.]+)([BKMGTP]+)/i);
+            if (usedMatch) {
+                swapUsedBytes = parseScaledBytes(usedMatch[1], usedMatch[2]);
+            }
+        }
+        catch {
+            swapUsedBytes = 0;
+        }
+        const usedPercent = totalBytes > 0 ? roundMetric((usedBytes / totalBytes) * 100, 1) : 0;
+        const pressure = (usedPercent >= 90 || swapUsedBytes >= 1.5 * 1024 ** 3)
+            ? "high"
+            : (usedPercent >= 80 || swapUsedBytes >= 512 * 1024 ** 2 || compressedBytes >= 1024 ** 3)
+                ? "attention"
+                : "normal";
+        return {
+            total_bytes: totalBytes,
+            used_bytes: usedBytes,
+            free_bytes: freeBytes,
+            used_percent: usedPercent,
+            pressure,
+            swap_used_bytes: swapUsedBytes || undefined,
+            compressed_bytes: compressedBytes || undefined,
+        };
+    }
+    async readDiskStatus() {
+        const { stdout } = await this.runCommandCapture("/bin/df", ["-k", "/"]);
+        const lines = stdout.trim().split(/\r?\n/).filter(Boolean);
+        if (lines.length < 2) {
+            return undefined;
+        }
+        const parts = lines[1].trim().split(/\s+/);
+        if (parts.length < 6) {
+            return undefined;
+        }
+        const totalBytes = Number(parts[1]) * 1024;
+        const usedBytes = Number(parts[2]) * 1024;
+        const availableBytes = Number(parts[3]) * 1024;
+        const usedPercent = roundMetric(Number((parts[4] || "").replace("%", "")), 1);
+        return {
+            mount_path: parts[5] || "/",
+            total_bytes: totalBytes,
+            used_bytes: usedBytes,
+            available_bytes: availableBytes,
+            used_percent: usedPercent,
+            available_gb: roundMetric(availableBytes / (1024 ** 3), 1),
+        };
+    }
+    async readBatteryStatus() {
+        try {
+            const { stdout } = await this.runCommandCapture("/usr/bin/pmset", ["-g", "batt"]);
+            const percentageMatch = stdout.match(/(\d+)%/);
+            if (!percentageMatch) {
+                return undefined;
+            }
+            const powerSourceMatch = stdout.match(/Now drawing from '([^']+)'/i);
+            const powerSource = powerSourceMatch?.[1]?.trim() || "Unknown";
+            const normalized = stdout.toLowerCase();
+            const charging = normalized.includes("charging") || normalized.includes("charged") || powerSource.toLowerCase().includes("ac");
+            return {
+                percentage: Math.max(0, Math.min(100, Number(percentageMatch[1]))),
+                charging,
+                power_source: powerSource,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async readTopProcesses(limit = 4) {
+        try {
+            const { stdout } = await this.runCommandCapture("/bin/ps", ["-Ao", "pcpu,comm", "-r"]);
+            const lines = stdout.trim().split(/\r?\n/).slice(1);
+            return lines
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .slice(0, limit)
+                .map((line) => {
+                const match = line.match(/^([0-9.]+)\s+(.+)$/);
+                if (!match)
+                    return null;
+                const cpuPercent = roundMetric(Number(match[1]), 1);
+                const command = match[2].trim().split("/").pop() || match[2].trim();
+                return {
+                    name: command,
+                    cpu_percent: cpuPercent,
+                };
+            })
+                .filter((item) => item !== null && item.cpu_percent > 0);
+        }
+        catch {
+            return [];
+        }
+    }
+    buildSystemStatusSummary(status) {
+        const parts = [];
+        const warnings = [];
+        if (status.cpu) {
+            parts.push(`CPU em ${roundMetric(status.cpu.usage_percent)}%`);
+            if (status.cpu.usage_percent >= 85) {
+                warnings.push(`CPU em ${roundMetric(status.cpu.usage_percent)}%`);
+            }
+        }
+        if (status.memory) {
+            parts.push(`memoria em ${roundMetric(status.memory.used_percent)}%`);
+            if (status.memory.pressure === "high") {
+                warnings.push(`memoria pressionada (${roundMetric(status.memory.used_percent)}% e swap ativo)`);
+            }
+            else if (status.memory.pressure === "attention") {
+                warnings.push(`memoria em ${roundMetric(status.memory.used_percent)}%`);
+            }
+        }
+        if (status.disk) {
+            parts.push(`${formatBytesCompact(status.disk.available_bytes)} livres no disco`);
+            if (status.disk.used_percent >= 90 || status.disk.available_bytes <= 15 * 1024 ** 3) {
+                warnings.push(`pouco espaco livre (${formatBytesCompact(status.disk.available_bytes)})`);
+            }
+        }
+        if (status.battery) {
+            parts.push(`bateria em ${status.battery.percentage}%${status.battery.charging ? " carregando" : ""}`);
+            if (!status.battery.charging && status.battery.percentage <= 20) {
+                warnings.push(`bateria em ${status.battery.percentage}%`);
+            }
+        }
+        let summary = warnings.length > 0
+            ? `Seu Mac esta operando, mas merece atencao em ${warnings.join(" e ")}.`
+            : "No geral, seu Mac esta de boa.";
+        if (parts.length > 0) {
+            summary += ` Agora vejo ${parts.join(", ")}.`;
+        }
+        if (status.top_processes && status.top_processes.length > 0) {
+            const topProcesses = status.top_processes
+                .slice(0, 3)
+                .map((item) => `${item.name} (${roundMetric(item.cpu_percent)}%)`)
+                .join(", ");
+            if (topProcesses) {
+                summary += ` Maiores consumos agora: ${topProcesses}.`;
+            }
+        }
+        return summary;
+    }
+    async collectSystemStatus(sections, includeTopProcesses = true) {
+        const requestedSections = sections && sections.length > 0
+            ? sections
+            : ["cpu", "memory", "disk", "battery"];
+        const uniqueSections = Array.from(new Set(requestedSections));
+        const status = {
+            captured_at: new Date().toISOString(),
+            hostname: os.hostname(),
+            platform: process.platform,
+            requested_sections: uniqueSections,
+            summary: "",
+        };
+        if (uniqueSections.includes("cpu")) {
+            status.cpu = await this.sampleCpuStatus();
+        }
+        if (uniqueSections.includes("memory")) {
+            status.memory = await this.readMemoryStatus();
+        }
+        if (uniqueSections.includes("disk")) {
+            status.disk = await this.readDiskStatus();
+        }
+        if (uniqueSections.includes("battery")) {
+            status.battery = await this.readBatteryStatus();
+        }
+        if (includeTopProcesses && (uniqueSections.includes("cpu") || uniqueSections.includes("memory"))) {
+            const topProcesses = await this.readTopProcesses();
+            if (topProcesses && topProcesses.length > 0) {
+                status.top_processes = topProcesses;
+            }
+        }
+        status.summary = this.buildSystemStatusSummary(status);
+        return status;
+    }
     async runShellCommand(command, cwd) {
         if (!isSafeShellCommand(command)) {
             throw new Error("Nenhum comando shell foi informado para execucao local.");
@@ -4653,6 +5398,15 @@ if let output = String(data: data, encoding: .utf8) {
         if (action.type === "read_frontmost_page") {
             return `Pagina ativa lida em ${action.app || "Safari"}`;
         }
+        if (action.type === "browser_context") {
+            return `Contexto do navegador coletado${action.app ? ` em ${action.app}` : ""}`;
+        }
+        if (action.type === "app_status") {
+            return `Status de apps coletado${action.app ? ` para ${action.app}` : ""}`;
+        }
+        if (action.type === "filesystem_inspect") {
+            return `Inspecao local concluida em ${action.path}`;
+        }
         if (action.type === "read_file") {
             return `${action.path} foi lido no macOS`;
         }
@@ -4662,6 +5416,9 @@ if let output = String(data: data, encoding: .utf8) {
         if (action.type === "count_files") {
             return `Arquivos contados em ${action.path}`;
         }
+        if (action.type === "system_status") {
+            return "Status do macOS coletado";
+        }
         if (action.type === "run_shell") {
             return `Comando ${action.command} executado no macOS`;
         }

package/dist/types.js

@@ -1,5 +1,5 @@
 export const BRIDGE_CONFIG_VERSION = 1;
-export const BRIDGE_VERSION = "0.8.3";
+export const BRIDGE_VERSION = "0.8.5";
 export const BRIDGE_PACKAGE_NAME = "@leg3ndy/otto-bridge";
 export const DEFAULT_API_BASE_URL = "http://localhost:8000";
 export const DEFAULT_POLL_INTERVAL_MS = 3000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leg3ndy/otto-bridge",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "private": false,
   "type": "module",
   "description": "Local companion for Otto Bridge device pairing and WebSocket runtime.",