browse-code 0.1.0__py3-none-any.whl

browse_code/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

browse_code/cli.py

@@ -0,0 +1,75 @@
+import os
+import sys
+import shutil
+import subprocess
+from pathlib import Path
+
+def get_data_dir():
+    home = Path.home()
+    data_dir = home / ".browse_code"
+    data_dir.mkdir(exist_ok=True)
+    return data_dir
+
+def install_extension():
+    data_dir = get_data_dir()
+    installed_marker = data_dir / ".installed"
+    ext_dest = data_dir / "extension"
+
+    # Copy extension files from package to ~/.browse_code/extension
+    pkg_ext_dir = Path(__file__).parent / "extension"
+    
+    if not installed_marker.exists():
+        ans_allow = input("Do you allow browse_code to install its Chrome extension? (y/n): ")
+        if ans_allow.lower() != 'y':
+            print("Extension installation skipped.")
+            return
+
+        print("Installing browse_code extension...")
+        if ext_dest.exists():
+            shutil.rmtree(ext_dest)
+        shutil.copytree(pkg_ext_dir, ext_dest)
+        
+        print("\n========================================================")
+        print("Extension files copied to: ", ext_dest)
+        print("To load the extension in Chrome:")
+        print("1. Open Chrome and navigate to chrome://extensions/")
+        print("2. Enable 'Developer mode' at the top right")
+        print("3. Click 'Load unpacked' and select the folder:")
+        print(f"   {ext_dest}")
+        print("========================================================\n")
+        
+        ans = input("Do you want me to try launching Chrome with this extension now? (y/n): ")
+        if ans.lower() == 'y':
+            # Attempt to launch chrome
+            # On Windows:
+            chrome_path = r"C:\Program Files\Google\Chrome\Application\chrome.exe"
+            if not os.path.exists(chrome_path):
+                chrome_path = r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"
+            if os.path.exists(chrome_path):
+                subprocess.Popen([chrome_path, f"--load-extension={ext_dest}"])
+            else:
+                print("Could not find Chrome executable automatically.")
+        
+        installed_marker.touch()
+    else:
+        # Already installed, check if files are still there, if not recopy
+        if not ext_dest.exists():
+            shutil.copytree(pkg_ext_dir, ext_dest)
+
+def main():
+    install_extension()
+    
+    print("\nStarting AI session server...\n")
+    # Now we need to start the FastAPI server.
+    # The original server.py is in the same package
+    try:
+        from .server import app
+    except ImportError:
+        # Fallback if run directly during dev
+        from server import app
+        
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=5505, access_log=False)
+
+if __name__ == "__main__":
+    main()

browse_code/extension/content.js

@@ -0,0 +1,356 @@
+const LOCAL_SERVER = "http://127.0.0.1:5505";
+const hostname = window.location.hostname;
+
+let PLATFORM = {};
+
+if (hostname.includes('gemini.google.com')) {
+    PLATFORM = {
+        name: "Gemini",
+        inputBox: 'rich-textarea div[contenteditable="true"], div[role="textbox"][contenteditable="true"]',
+        sendBtn: 'button[aria-label*="Send"], button[aria-label*="send"], button[mattooltip*="Send"]',
+        responseContainer: 'message-content, model-response, .model-response-text'
+    };
+} else if (hostname.includes('claude.ai')) {
+    PLATFORM = {
+        name: "Claude",
+        inputBox: '.ProseMirror[contenteditable="true"]',
+        sendBtn: 'button[aria-label*="Send"], button[aria-label*="send"]',
+        responseContainer: '.font-claude-response, .font-claude-message'
+    };
+} else if (hostname.includes('huggingface.co')) {
+    PLATFORM = {
+        name: "HuggingFace",
+        inputBox: 'input[name="prompt"]',
+        sendBtn: 'button[type="submit"]',
+        responseContainer: '.prose, .markdown, .break-words, [class*="message"]'
+    };
+} else {
+    PLATFORM = {
+        name: "ChatGPT",
+        inputBox: '#prompt-textarea',
+        sendBtn: '[data-testid="send-button"], button[data-testid*="send"]',
+        responseContainer: '.markdown, .prose'
+    };
+}
+
+const spoofScript = document.createElement('script');
+spoofScript.src = chrome.runtime.getURL('spoof.js');
+(document.head || document.documentElement).appendChild(spoofScript);
+spoofScript.onload = function () { this.remove(); };
+
+const SYSTEM_PROMPT = `You are an elite, autonomous AI software engineer (similar to Antigravity or Devin) connected to a local execution bridge.
+You do NOT have direct access to my file system. You interact with it ONLY by emitting the XML tool tags defined below, which are executed locally on my machine.
+
+═══════════════════════════════════════
+GOLDEN RULES (violating any of these breaks the session)
+═══════════════════════════════════════
+1. STOP AFTER EVERY TOOL CALL. The moment you emit one or more tool tags, END YOUR TURN. Do not write "Result:", do not guess what the output will be, do not continue coding as if you already have it. A human/script will run the tool and give you the real output in the next message. Generating fake tool output is the single worst failure mode — never do it.
+2. NEVER claim a file was created, edited, or tested unless you emitted the corresponding tag THIS turn AND already received its result.
+3. NEVER fabricate file contents, line numbers, search results, or terminal output. If you haven't seen it via a tool result in this conversation, you don't know it.
+4. Explore before you edit. Default order: view_dir → search_code → read_lines → patch/write. Do not read a full file "just in case" — read only what your search told you to read.
+5. Prefer patch over write. Only use write for brand-new files or a full intentional rewrite. patch requires the <search> block to match the existing file EXACTLY (same whitespace/indentation) — read_lines first if you're not certain of the exact text.
+6. Terminals have no memory of directory state between calls. Every terminal_run/terminal_bg must include any necessary cd, chained with &&.
+7. **terminal_run is FULLY BLOCKING and HARD-CAPPED at 300s.** Under the hood it runs synchronously and only returns once the process exits completely — there is no streaming, no partial progress, nothing, until it's done or the 300s timeout fires. If it times out, you get a forced error containing only whatever STDOUT/STDERR happened to be captured before the kill — this is NOT a reliable signal of success or failure, just a fragment.
+   Because of this, terminal_run must NEVER be used for anything that installs dependencies, builds, scaffolds a project, or could plausibly run past a few seconds — e.g. npm/yarn/pnpm install, pip install, create-next-app, docker build, webpack/vite build, test suites with network calls, git clone of large repos, etc.
+   For ALL such commands: start with terminal_bg (returns a PID instantly, non-blocking), then poll with cron_monitor (delay 20-30s) — repeat cron_monitor while status is still "running." Only treat the command as done when a poll returns a completed/exited status.
+   If you ever see a terminal_run timeout error, do NOT re-run the same command with terminal_run again — restart it via terminal_bg instead.
+   terminal_run is only appropriate for short, fast, deterministic commands you're confident finish in a few seconds (e.g. ls, cat, a single quick lint check, git status).
+8. If a result is [TRUNCATED] or a file is large, narrow down with search_code or read_lines instead of re-requesting the whole file.
+
+═══════════════════════════════════════
+WORKFLOW: "Autonomous Researcher"
+═══════════════════════════════════════
+1. **Explore:** view_dir to understand project structure.
+2. **Search:** search_code to grep for exactly which file/line defines a function or variable.
+3. **Inspect:** read_lines to read only the relevant chunk.
+4. **Modify:** patch to surgically replace targeted code. write only for brand-new files.
+5. **Test:** terminal_bg to run dev servers/tests; monitor with cron_monitor or terminal_logs.
+
+═══════════════════════════════════════
+AVAILABLE TOOLS
+═══════════════════════════════════════
+CRITICAL FORMAT RULE: Every individual tool call is wrapped in its OWN \`\`\`tool ... \`\`\` fence. If you issue multiple tool calls in one turn, output multiple separate \`\`\`tool\`\`\` blocks back to back — never combine two tags inside one fence.
+
+| Tool | Format | Description |
+|---|---|---|
+| **View Dir** | \`\`\`tool\n<tool='view_dir'>src/components</tool>\n\`\`\` | Lists files. Leave empty for root. |
+| **Search Code** | \`\`\`tool\n<tool='search_code' query='functionName'>src</tool>\n\`\`\` | Fast regex/string search. Returns file & line numbers. |
+| **Read Lines** | \`\`\`tool\n<tool='read_lines' path='App.js' start='20' end='45'></tool>\n\`\`\` | Reads a specific chunk of a file. |
+| **Read File** | \`\`\`tool\n<tool='read'>path/to/file.py</tool>\n\`\`\` | Reads a full file (avoid if file is large — prefer search_code + read_lines). |
+| **Write File** | \`\`\`tool\n<tool='write' path='path.js'>\nRAW CODE\n</tool>\n\`\`\` | Creates/overwrites a file completely. |
+| **Patch Code** | \`\`\`tool\n<tool='patch' path='main.py'>\n<search>\nOLD\n</search>\n<replace>\nNEW\n</replace>\n</tool>\n\`\`\` | Surgically replaces a block. <search> must match the file byte-for-byte. |
+| **Run Terminal** | \`\`\`tool\n<tool='terminal_run'>npm test</tool>\n\`\`\` | BLOCKING, synchronous, hard 300s timeout. Only for short/fast commands (see Rule 7). |
+| **Background Term**| \`\`\`tool\n<tool='terminal_bg'>npm run dev</tool>\n\`\`\` | Non-blocking. Returns a PID instantly. Required for installs/builds/servers. |
+| **Cron Monitor** | \`\`\`tool\n<tool='cron_monitor' pid='1234' delay='15'></tool>\n\`\`\` | Sleeps X seconds, then returns the background PID's logs. Poll repeatedly until status is no longer "running." |
+| **Term Logs** | \`\`\`tool\n<tool='terminal_logs' pid='1234'></tool>\n\`\`\` | Reads output of a background PID instantly. |
+| **Kill Term** | \`\`\`tool\n<tool='terminal_kill' pid='1234'></tool>\n\`\`\` | Stops a background PID. |
+
+═══════════════════════════════════════
+WORKED EXAMPLES
+═══════════════════════════════════════
+
+--- Example A: code fix (stop-and-wait pattern) ---
+User: "Fix the off-by-one in the pagination helper."
+
+Your turn:
+I'll locate the pagination logic first.
+\`\`\`tool
+<tool='search_code' query='pagination'>src</tool>
+\`\`\`
+[END TURN — wait for result]
+
+Next turn (after receiving real results):
+Found it in src/utils/paginate.js:14.
+\`\`\`tool
+<tool='read_lines' path='src/utils/paginate.js' start='1' end='30'></tool>
+\`\`\`
+[END TURN — wait for result]
+
+Next turn (after receiving the real file contents):
+\`\`\`tool
+<tool='patch' path='src/utils/paginate.js'>
+<search>
+  return start + pageSize;
+</search>
+<replace>
+  return start + pageSize - 1;
+</replace>
+</tool>
+\`\`\`
+[END TURN — wait for result. Only say "Fixed" after this result confirms success.]
+
+--- Example B: long-running install (bg + poll pattern) ---
+User: "Scaffold a new Next.js app called 'dashboard'."
+
+Your turn:
+This will download packages, so I'll run it in the background.
+\`\`\`tool
+<tool='terminal_bg'>npx create-next-app@latest dashboard --yes</tool>
+\`\`\`
+[END TURN — wait for PID]
+
+Next turn (after receiving PID, e.g. 4821):
+\`\`\`tool
+<tool='cron_monitor' pid='4821' delay='25'></tool>
+\`\`\`
+[END TURN — wait for result]
+
+Next turn: if status is still "running," issue cron_monitor again. Only once the log shows completion do you proceed or report success — never use terminal_run for this command, and never assume it finished just because time has passed.
+
+═══════════════════════════════════════
+COMPLETION
+═══════════════════════════════════════
+When the task is fully done and you have real tool results confirming every change, reply in plain text summarizing exactly what changed (files touched, what was added/removed/fixed, commands run and their confirmed final status) — no more and no less than what you actually executed and verified this session.
+
+To confirm you understand these instructions, reply ONLY with: "Agent Initialized. Awaiting command."`;
+
+let messageCount = 0;
+let injectN = 5;
+
+chrome.storage.local.get(['injectN'], (res) => {
+    if (res.injectN !== undefined) injectN = parseInt(res.injectN, 10);
+});
+chrome.storage.onChanged.addListener((changes, namespace) => {
+    if (namespace === 'local' && changes.injectN) {
+        injectN = parseInt(changes.injectN.newValue, 10);
+    }
+});
+
+chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
+    sendResponse({ status: "received" });
+    if (request.action === "INITIALIZE_AGENT") {
+        messageCount = 0;
+        startNewChat()
+            .then(() => injectAndSend(SYSTEM_PROMPT))
+            .catch(err => console.error("Initialization sequence failed:", err));
+    }
+    return true;
+});
+
+async function startNewChat() {
+    if (PLATFORM.name === "HuggingFace") {
+        return Promise.resolve();
+    }
+
+    if (PLATFORM.name === "Gemini") {
+        const elements = document.querySelectorAll('span, div, a');
+        for (let el of elements) {
+            if (el.textContent.trim().toLowerCase() === 'new chat') {
+                el.closest('button, a, [role="button"]')?.click();
+                break;
+            }
+        }
+    } else if (PLATFORM.name === "Claude") {
+        const newChatBtn = document.querySelector('a[href="/new"], a[href="/chat/new"]');
+        if (newChatBtn) newChatBtn.click();
+    } else {
+        const newChatBtn = document.querySelector('a[href="/"], [data-testid="new-chat-button"]');
+        if (newChatBtn) newChatBtn.click();
+    }
+    await new Promise(r => setTimeout(r, 2000));
+}
+
+async function injectAndSend(promptText) {
+    let inputBox = null;
+    for (let i = 0; i < 30; i++) {
+        inputBox = document.querySelector(PLATFORM.inputBox);
+        if (inputBox) break;
+        await new Promise(r => setTimeout(r, 200));
+    }
+
+    if (!inputBox) return;
+    inputBox.focus();
+
+    if (inputBox.tagName === 'INPUT' || inputBox.tagName === 'TEXTAREA') {
+        inputBox.value = promptText;
+    } else {
+        const dataTransfer = new DataTransfer();
+        dataTransfer.setData('text/plain', promptText);
+        const pasteEvent = new ClipboardEvent('paste', {
+            clipboardData: dataTransfer,
+            bubbles: true,
+            cancelable: true
+        });
+
+        inputBox.dispatchEvent(pasteEvent);
+
+        if (inputBox.textContent.trim() === "") {
+            document.execCommand('insertText', false, promptText);
+        }
+    }
+
+    inputBox.dispatchEvent(new Event('input', { bubbles: true, composed: true }));
+    inputBox.dispatchEvent(new Event('change', { bubbles: true, composed: true }));
+
+    await new Promise(r => setTimeout(r, 800));
+
+    const sendButton = document.querySelector(PLATFORM.sendBtn);
+    if (sendButton && (!sendButton.disabled && sendButton.getAttribute('aria-disabled') !== 'true')) {
+        sendButton.click();
+    } else {
+        inputBox.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, cancelable: true, key: 'Enter', code: 'Enter' }));
+    }
+}
+
+// --- NEW: Robust Text Stability Engine ---
+let isWaitingForLLM = false;
+let lastProcessedMessage = "";
+let trackInterval = null;
+
+const messageQueue = [];
+let isInjectingQueue = false;
+
+function processQueue() {
+    if (messageQueue.length === 0 || isInjectingQueue || isWaitingForLLM) return;
+
+    let inputBox = document.querySelector(PLATFORM.inputBox);
+    if (!inputBox) return;
+
+    // Do not interrupt the user if they are currently typing a message
+    const userText = inputBox.tagName === 'INPUT' || inputBox.tagName === 'TEXTAREA' ? inputBox.value : inputBox.textContent;
+    if (userText && userText.trim() !== "") return;
+
+    // Do not inject if the LLM is currently generating (Send button is missing or disabled)
+    const sendButton = document.querySelector(PLATFORM.sendBtn);
+    if (!sendButton || sendButton.disabled || sendButton.getAttribute('aria-disabled') === 'true') {
+        return;
+    }
+
+    const nextMessage = messageQueue.shift();
+    isInjectingQueue = true;
+    
+    injectAndSend(nextMessage).then(() => {
+        isInjectingQueue = false;
+    }).catch((err) => {
+        console.error("Queue injection failed", err);
+        isInjectingQueue = false;
+    });
+}
+
+// Primary observer loop: checks every 1 second
+setInterval(() => {
+    processQueue();
+
+    if (isWaitingForLLM) return;
+
+    const allContainers = document.querySelectorAll(PLATFORM.responseContainer);
+    // Filter out hidden carousel messages
+    const containers = Array.from(allContainers).filter(el => el.offsetWidth > 0 && el.offsetHeight > 0);
+    if (containers.length === 0) return;
+
+    const lastContainer = containers[containers.length - 1];
+    if (lastContainer.hasAttribute('data-agent-processed')) return;
+
+    // Grab the very last message in the chat using textContent to avoid layout thrashing
+    const currentText = lastContainer.textContent || "";
+
+    // If the LLM has generated a closing tool tag that we haven't processed yet, lock it in and wait for it to finish typing
+    if (currentText.includes("</tool>")) {
+        isWaitingForLLM = true;
+        trackResponse(currentText);
+    }
+}, 1000);
+
+function trackResponse(initialText) {
+    let previousText = initialText;
+    let unchangedTicks = 0;
+
+    if (trackInterval) clearInterval(trackInterval);
+
+    // Sub-loop: monitors text generation speed
+    trackInterval = setInterval(async () => {
+        const allContainers = document.querySelectorAll(PLATFORM.responseContainer);
+        const containers = Array.from(allContainers).filter(el => el.offsetWidth > 0 && el.offsetHeight > 0);
+        const lastContainer = containers.length > 0 ? containers[containers.length - 1] : null;
+        if (!lastContainer) return;
+
+        const currentText = lastContainer.textContent || "";
+
+        // Check if the LLM is still typing
+        if (currentText.length > previousText.length) {
+            previousText = currentText;
+            unchangedTicks = 0;
+        } else {
+            unchangedTicks++;
+        }
+
+        // If text has not changed for 2.5 seconds (5 ticks), assume generation is complete!
+        if (unchangedTicks > 4) {
+            clearInterval(trackInterval);
+            lastContainer.setAttribute('data-agent-processed', 'true');
+            isWaitingForLLM = false; // UNLOCK IMMEDIATELY to prevent deadlocks from long-running tools
+
+
+            const toolMatches = currentText.match(/<tool=[\s\S]*?<\/tool>/g);
+            if (toolMatches && toolMatches.length > 0) {
+                try {
+                    const toolPromises = toolMatches.map(async (toolCall) => {
+                        const response = await fetch(`${LOCAL_SERVER}/extension/run-tool`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ tool_call: toolCall })
+                        });
+                        const resultData = await response.json();
+
+                        const toolNameMatch = toolCall.match(/<tool='(.*?)'/);
+                        const toolName = toolNameMatch ? toolNameMatch[1] : 'unknown';
+
+                        return `\n[System - Tool Execution: ${toolName}]\nStatus: Success\n------------------------------------\nResult Output:\n${resultData.output}\n------------------------------------\n`;
+                    });
+
+                    const results = await Promise.all(toolPromises);
+                    let combinedFeedback = results.join("") + "Instruction: Review the output above. If the task requires more steps, continue. If finished, summarize what was done.";
+
+                    messageCount++;
+                    if (injectN > 0 && messageCount % injectN === 0) {
+                        combinedFeedback += `\n\n[System Reminder (Context Refresh)]:\n${SYSTEM_PROMPT}`;
+                    }
+
+                    messageQueue.push(combinedFeedback);
+                } catch (err) {
+                    messageQueue.push(`\n[System - Error]: Tool execution failed. Ensure your Python backend is running.`);
+                }
+            }
+        }
+    }, 500);
+}

browse_code/extension/manifest.json

@@ -0,0 +1,30 @@
+{
+  "manifest_version": 3,
+  "name": "Local Agent Bridge",
+  "version": "2.0",
+  "description": "Autonomous AI Code Execution Bridge",
+  "permissions": [
+    "activeTab",
+    "storage"
+  ],
+  "content_scripts": [
+    {
+      "matches": [
+        "*://*.chatgpt.com/*",
+        "*://gemini.google.com/*",
+        "*://*.claude.ai/*",
+        "*://*.huggingface.co/*"
+      ],
+      "js": ["content.js"]
+    }
+  ],
+  "action": {
+    "default_popup": "popup.html"
+  },
+  "web_accessible_resources": [
+    {
+      "resources": ["spoof.js"],
+      "matches": ["<all_urls>"]
+    }
+  ]
+}

browse_code/extension/popup.html

@@ -0,0 +1,109 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <style>
+    body {
+      font-family: 'Segoe UI', sans-serif;
+      width: 350px;
+      padding: 15px;
+      margin: 0;
+      background-color: #0f172a;
+      color: #f8fafc;
+    }
+
+    h3 {
+      margin-top: 0;
+      font-size: 16px;
+      border-bottom: 1px solid #334155;
+      padding-bottom: 5px;
+    }
+
+    label {
+      font-size: 12px;
+      font-weight: bold;
+      color: #94a3b8;
+    }
+
+    input {
+      width: 100%;
+      box-sizing: border-box;
+      padding: 8px;
+      margin: 8px 0;
+      background: #1e293b;
+      border: 1px solid #475569;
+      color: white;
+      border-radius: 4px;
+    }
+
+    button {
+      width: 100%;
+      padding: 10px;
+      font-weight: bold;
+      border: none;
+      border-radius: 5px;
+      cursor: pointer;
+      transition: 0.2s;
+    }
+
+    #save-btn {
+      background-color: #3b82f6;
+      color: white;
+      margin-bottom: 15px;
+    }
+
+    #init-btn {
+      background-color: #10b981;
+      color: white;
+      margin-bottom: 15px;
+    }
+
+    .dashboard {
+      background: #1e293b;
+      padding: 10px;
+      border-radius: 5px;
+      font-size: 12px;
+    }
+
+    .process-card {
+      background: #000;
+      border: 1px solid #334155;
+      padding: 8px;
+      margin-top: 8px;
+      border-radius: 4px;
+    }
+
+    .pid {
+      color: #f59e0b;
+      font-weight: bold;
+    }
+
+    .log-preview {
+      font-family: monospace;
+      color: #a3e635;
+      font-size: 10px;
+      white-space: pre-wrap;
+      overflow-x: hidden;
+      margin-top: 5px;
+    }
+  </style>
+</head>
+
+<body>
+  <h3>Agent Dashboard</h3>
+  <label>Workspace Directory:</label>
+  <input type="text" id="dir-input" placeholder="C:\Projects\app">
+  <label>Inject Prompt Every N Messages (0 to disable):</label>
+  <input type="number" id="inject-n-input" placeholder="5" value="5" min="0">
+  <button id="save-btn">Save Directory</button>
+  <button id="init-btn">Initialize Agent in Chat</button>
+
+  <h3>Live Terminals</h3>
+  <div class="dashboard" id="process-list">
+    <div style="color: #94a3b8;">No active background processes...</div>
+  </div>
+
+  <script src="popup.js"></script>
+</body>
+
+</html>

browse_code/extension/popup.js

@@ -0,0 +1,90 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const dirInput = document.getElementById('dir-input');
+    const injectNInput = document.getElementById('inject-n-input');
+    const saveBtn = document.getElementById('save-btn');
+    const initBtn = document.getElementById('init-btn');
+    const processList = document.getElementById('process-list');
+
+    chrome.storage.local.get(['workspaceDir', 'injectN'], (result) => {
+        if (result.workspaceDir) {
+            dirInput.value = result.workspaceDir;
+            syncWithServer(result.workspaceDir);
+        }
+        if (result.injectN !== undefined && injectNInput) {
+            injectNInput.value = result.injectN;
+        }
+    });
+
+    saveBtn.addEventListener('click', () => {
+        const path = dirInput.value.trim();
+        let injectN = 5;
+        if (injectNInput) {
+            injectN = parseInt(injectNInput.value, 10);
+            if (isNaN(injectN)) injectN = 5;
+        }
+        chrome.storage.local.set({ workspaceDir: path, injectN: injectN });
+        syncWithServer(path);
+        saveBtn.innerText = '✅ Saved!';
+        setTimeout(() => saveBtn.innerText = 'Save Directory', 2000);
+    });
+
+    initBtn.addEventListener('click', () => {
+        initBtn.innerText = 'Initializing...';
+        chrome.tabs.query({active: true, currentWindow: true}, (tabs) => {
+            const activeTab = tabs[0];
+            const validUrls = ['chatgpt.com', 'gemini.google.com', 'claude.ai', 'huggingface.co'];
+            
+            if (activeTab && validUrls.some(url => activeTab.url.includes(url))) {
+                chrome.tabs.sendMessage(activeTab.id, { action: "INITIALIZE_AGENT" }, () => {
+                    if (chrome.runtime.lastError) {
+                        initBtn.innerText = '❌ Error: Refresh Tab First!';
+                        setTimeout(() => initBtn.innerText = '✨ Initialize Agent in Chat', 3000);
+                    } else {
+                        initBtn.innerText = '✨ Initialize Agent in Chat';
+                    }
+                });
+            } else {
+                initBtn.innerText = '❌ Not a valid AI chat tab';
+                setTimeout(() => initBtn.innerText = '✨ Initialize Agent in Chat', 3000);
+            }
+        });
+    });
+
+    function saveWorkspace(path) {
+        fetch('http://127.0.0.1:5505/set-workspace', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ path: path })
+        }).catch(() => {
+            // Silently ignore connection errors so Chrome doesn't flag them in the extension dashboard
+        });
+    }
+
+    function updateStatus() {
+        fetch('http://127.0.0.1:5505/status')
+            .then(res => res.json())
+            .then(data => {
+                if (!data.processes || data.processes.length === 0) {
+                    processList.innerHTML = '<div style="color: #94a3b8;">No active background processes...</div>';
+                    return;
+                }
+                
+                let html = '';
+                data.processes.forEach(proc => {
+                    const statusColor = proc.status === 'running' ? '#10b981' : '#ef4444';
+                    html += `
+                    <div class="process-card">
+                        <div><span class="pid">[PID: ${proc.pid}]</span> - <span style="color:${statusColor}">${proc.status.toUpperCase()}</span></div>
+                        <div class="log-preview">${proc.logs || 'Waiting for output...'}</div>
+                    </div>`;
+                });
+                processList.innerHTML = html;
+            })
+            .catch(() => {
+                processList.innerHTML = '<div style="color: #ef4444;">Disconnected from local server.</div>';
+            });
+    }
+
+    setInterval(pollStatus, 1500);
+    pollStatus();
+});

browse_code/extension/spoof.js

@@ -0,0 +1,3 @@
+Object.defineProperty(document, 'visibilityState', { get: () => 'visible' });
+Object.defineProperty(document, 'hidden', { get: () => false });
+window.addEventListener('visibilitychange', (e) => e.stopImmediatePropagation(), true);

browse_code/server.py

@@ -0,0 +1,574 @@
+import os
+import re
+import subprocess
+import difflib
+import threading
+import uuid
+import atexit
+import asyncio
+import shutil
+import time
+import platform
+from collections import deque
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    print_startup_banner(WORKSPACE_DIR, "127.0.0.1", 5505)
+    yield
+
+
+app = FastAPI(title="Agent Bridge Backend", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ============================================================
+#  Shared ANSI palette — used by the diff engine, tool banners,
+#  request logger, and startup banner.
+# ============================================================
+C_RESET    = "\033[0m"
+C_BOLD     = "\033[1m"
+C_DIM      = "\033[2;90m"
+C_GRAY     = "\033[90m"
+C_MUTED    = "\033[38;5;245m"
+C_HEADER   = "\033[1;32m"
+C_GREEN    = "\033[32m"
+
+C_OK       = "\033[1;32m"   # success / 2xx
+C_ERR      = "\033[1;31m"   # error / 5xx
+C_WARN     = "\033[1;33m"   # warn / 4xx
+C_INFO     = "\033[1;34m"   # info
+
+C_ADD_FG   = "\033[38;5;150m"
+C_ADD_BG   = "\033[48;2;0;40;0m"
+C_ADD_MARK = "\033[1;38;5;114m\033[48;2;0;40;0m"
+C_ADD_NUM  = "\033[32m"
+C_DEL_FG   = "\033[38;5;210m"
+C_DEL_BG   = "\033[48;2;45;0;0m"
+C_DEL_MARK = "\033[1;38;5;203m\033[48;2;45;0;0m"
+C_DEL_NUM  = "\033[31m"
+
+# icon + friendly label per tool tag, used by the tool-call banner
+TOOL_META = {
+    "view_dir":      ("📁", "View Directory"),
+    "read":          ("📄", "Read File"),
+    "read_lines":    ("📄", "Read Lines"),
+    "write":         ("✍️ ", "Write File"),
+    "patch":         ("🩹", "Patch File"),
+    "search_code":   ("🔍", "Search Code"),
+    "terminal_run":  ("💻", "Run Command"),
+    "terminal_bg":   ("⚙️ ", "Background Process"),
+    "terminal_logs": ("📜", "Process Logs"),
+    "terminal_kill": ("✋", "Kill Process"),
+    "cron_monitor":  ("⏰", "Monitor Process"),
+}
+
+
+def print_tool_start(tool_name: str, detail: str = ""):
+    """Print a compact, colored banner when a tool call begins."""
+    icon, label = TOOL_META.get(tool_name, ("🔧", tool_name or "Unknown Tool"))
+    line = f"\n{C_HEADER}{icon} {label}{C_RESET}"
+    if detail:
+        detail = detail.strip().replace("\n", " ⏎ ")
+        if len(detail) > 90:
+            detail = detail[:89] + "…"
+        line += f"  {C_DIM}{detail}{C_RESET}"
+    print(line)
+
+
+def print_tool_end(ok: bool, elapsed_ms: float, note: str = ""):
+    """Print a compact status line when a tool call finishes."""
+    if ok:
+        badge = f"{C_OK}✓ done{C_RESET}"
+    else:
+        badge = f"{C_ERR}✗ failed{C_RESET}"
+    timing = f"{C_DIM}{elapsed_ms:.0f}ms{C_RESET}"
+    line = f"  {badge}  {timing}"
+    if note:
+        note = note.strip().replace("\n", " ⏎ ")
+        if len(note) > 90:
+            note = note[:89] + "…"
+        line += f"  {C_MUTED}{note}{C_RESET}"
+    print(line)
+
+
+def print_startup_banner(workspace: str, host: str, port: int):
+    width = 78
+    title = " Agent Bridge Backend "
+    pad = width - len(title)
+    left, right = pad // 2, pad - pad // 2
+    print()
+    print(f"{C_HEADER}╭{'─' * left}{title}{'─' * right}╮{C_RESET}")
+    ws_text = f" Workspace  {workspace}"
+    ws_pad = max(0, width - len(ws_text))
+    print(f"{C_HEADER}│{C_RESET} {C_MUTED}Workspace{C_RESET}  {workspace}{' ' * ws_pad}{C_HEADER}│{C_RESET}")
+    ep_text = f" Endpoint   http://{host}:{port}"
+    ep_pad = max(0, width - len(ep_text))
+    print(f"{C_HEADER}│{C_RESET} {C_MUTED}Endpoint {C_RESET}  http://{host}:{port}{' ' * ep_pad}{C_HEADER}│{C_RESET}")
+    print(f"{C_HEADER}╰{'─' * width}╯{C_RESET}")
+    print()
+
+
+WORKSPACE_DIR = r"C:\Users\dedeep vasireddy\Downloads\test"
+BACKGROUND_PROCESSES = {}
+
+def cleanup_background_processes():
+    print(f"\n{C_WARN}⏻  Shutting down — cleaning up background processes...{C_RESET}")
+    for pid, data in BACKGROUND_PROCESSES.items():
+        if data['status'] == 'running':
+            try:
+                data['process'].terminate()
+            except:
+                pass
+
+atexit.register(cleanup_background_processes)
+
+
+@app.middleware("http")
+async def request_logger(request: Request, call_next):
+    """Compact single-line request logger, replacing uvicorn's default access log."""
+    start = time.perf_counter()
+    response = await call_next(request)
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    status = response.status_code
+    if status < 300:
+        color = C_OK
+    elif status < 500:
+        color = C_WARN
+    else:
+        color = C_ERR
+
+    # The /extension/run-tool endpoint already prints its own detailed
+    # banner + result, so skip the generic line there to avoid duplication.
+    if request.url.path != "/extension/run-tool":
+        print(f"{C_DIM}→{C_RESET} {request.method} {request.url.path}  "
+              f"{color}{status}{C_RESET}  {C_DIM}{elapsed_ms:.0f}ms{C_RESET}")
+
+    return response
+
+
+# ============================================================
+#  TUI Block Diff Engine (v3) — single-gutter, full-width highlight
+#  style, matching editor-style inline diffs (Claude Code / VS Code).
+# ============================================================
+
+
+def _terminal_width(default: int = 72, cap: int = 88) -> int:
+    # NOTE: this process's stdout is usually not a real TTY (it's a FastAPI
+    # server, often piped/redirected), so shutil.get_terminal_size() falls
+    # back to `default` rather than reflecting the actual viewer width. Keep
+    # `default` conservative — if it's too wide, the padded highlight bar
+    # wraps in the viewer and bleeds color onto the next visual line.
+    try:
+        size = shutil.get_terminal_size(fallback=(default, 20))
+        cols = size.columns
+        # A fallback tuple and a "real" detected size look identical here,
+        # so only trust an unusually small detected width; otherwise stay
+        # conservative rather than risk wrapping.
+        if cols <= 0:
+            cols = default
+    except Exception:
+        cols = default
+    return max(40, min(cols, cap, default))
+
+
+def _clip(text: str, max_len: int) -> str:
+    if max_len <= 1:
+        return text[:max_len]
+    if len(text) > max_len:
+        return text[: max_len - 1] + "…"
+    return text
+
+
+def print_terminal_diff(filepath: str, old_content: str, new_content: str, context_lines: int = 2,
+                         large_line_threshold: int = 300, large_change_threshold: int = 120):
+    """Render a single-gutter, full-width-highlight diff (Claude Code TUI style).
+
+    For large diffs, unchanged/context lines are suppressed entirely (only a
+    collapsed "N unchanged lines" marker is shown) to keep the output readable.
+    """
+    old_lines = old_content.splitlines()
+    new_lines = new_content.splitlines()
+    matcher = difflib.SequenceMatcher(None, old_lines, new_lines)
+    opcodes = matcher.get_opcodes()
+
+    additions = sum(j2 - j1 for tag, i1, i2, j1, j2 in opcodes if tag in ("insert", "replace"))
+    deletions = sum(i2 - i1 for tag, i1, i2, j1, j2 in opcodes if tag in ("delete", "replace"))
+    is_new_file = old_content == "" and new_content != ""
+
+    # Large diffs: drop context lines entirely, show changed lines only.
+    total_lines = max(len(old_lines), len(new_lines))
+    total_changes = additions + deletions
+    if total_lines > large_line_threshold or total_changes > large_change_threshold:
+        context_lines = 0
+
+    width = _terminal_width()
+    num_width = max(len(str(max(len(old_lines), len(new_lines), 1))), 2)
+    content_width = max(10, width - num_width - 6)  # " N  m code" + safety margin
+
+    # ---- Header: "filename  +N -N" -----------------------------
+    tag_label = " (new file)" if is_new_file else ""
+    print()
+    header = f"{C_HEADER}{filepath}{C_RESET}{C_DIM}{tag_label}{C_RESET}"
+    stats = f"  {C_ADD_NUM}+{additions}{C_RESET} {C_DEL_NUM}-{deletions}{C_RESET}"
+    print(f"{header}{stats}")
+    print(f"{C_GRAY}{'─' * width}{C_RESET}")
+
+    if not opcodes or (len(opcodes) == 1 and opcodes[0][0] == "equal"):
+        print(f"{C_DIM}  (no changes){C_RESET}\n")
+        return
+
+    def row(number, marker, text, bg="", fg="", mark_style=""):
+        num_s = f"{number:>{num_width}}" if number is not None else " " * num_width
+        body = _clip(text, content_width)
+        if bg:
+            # pad body so the background color fills the full row width
+            padded = body.ljust(content_width)
+            m = mark_style if mark_style else fg
+            print(f"{bg}{fg} {num_s} {m}{marker}{fg} {padded} {C_RESET}")
+        else:
+            print(f"{C_MUTED} {num_s} {C_GRAY}{marker}{C_RESET}  {body}")
+
+    def gap_marker(hidden):
+        print(f"{C_DIM}   ⋮  {hidden} unchanged line{'s' if hidden != 1 else ''}{C_RESET}")
+
+    new_ln = 1  # running "position in final file" counter, drives the single gutter
+
+    for tag, i1, i2, j1, j2 in opcodes:
+        if tag == "equal":
+            block_len = i2 - i1
+            if block_len == 0:
+                continue
+
+            if context_lines <= 0:
+                # Large diff mode: skip unchanged lines entirely, just show the gap.
+                new_ln += block_len
+                gap_marker(block_len)
+                continue
+
+            if block_len > context_lines * 2:
+                for k in range(context_lines):
+                    row(new_ln, " ", old_lines[i1 + k])
+                    new_ln += 1
+                hidden = block_len - context_lines * 2
+                new_ln += hidden  # skip numbering for hidden lines
+                gap_marker(hidden)
+                for k in range(block_len - context_lines, block_len):
+                    row(new_ln, " ", old_lines[i1 + k])
+                    new_ln += 1
+            else:
+                for k in range(block_len):
+                    row(new_ln, " ", old_lines[i1 + k])
+                    new_ln += 1
+            continue
+
+        if tag in ("delete", "replace"):
+            for i in range(i1, i2):
+                row(new_ln, "-", old_lines[i], bg=C_DEL_BG, fg=C_DEL_FG, mark_style=C_DEL_MARK)
+
+        if tag in ("insert", "replace"):
+            for j in range(j1, j2):
+                row(new_ln, "+", new_lines[j], bg=C_ADD_BG, fg=C_ADD_FG, mark_style=C_ADD_MARK)
+                new_ln += 1
+
+
+def strip_ansi(text: str) -> str:
+    ansi_escape = re.compile(r'\x1b\[([0-9]{1,3}(;[0-9]{1,3})*)?[m|K]')
+    return ansi_escape.sub('', text)
+
+def truncate_output(text: str, max_chars=12000) -> str:
+    if len(text) > max_chars:
+        return text[:max_chars] + f"\n\n...[OUTPUT TRUNCATED]"
+    return text
+
+def stream_process_output(pid: str, process: subprocess.Popen):
+    try:
+        for line in iter(process.stdout.readline, ''):
+            BACKGROUND_PROCESSES[pid]['logs'].append(line)
+    except Exception as e:
+        BACKGROUND_PROCESSES[pid]['logs'].append(f"\n[Stream Error: {str(e)}]\n")
+    finally:
+        process.stdout.close()
+        BACKGROUND_PROCESSES[pid]['status'] = 'exited'
+
+def secure_path(path: str) -> str:
+    filepath = os.path.abspath(os.path.join(WORKSPACE_DIR, path))
+    if not filepath.startswith(os.path.abspath(WORKSPACE_DIR)):
+        raise HTTPException(status_code=400, detail="Security Error: Path traversal detected.")
+    return filepath
+
+class WorkspaceModel(BaseModel):
+    path: str
+
+class ToolModel(BaseModel):
+    tool_call: str
+
+@app.post("/set-workspace")
+async def set_workspace(data: WorkspaceModel):
+    global WORKSPACE_DIR
+    new_path = data.path.strip()
+    if new_path and os.path.exists(new_path):
+        WORKSPACE_DIR = new_path
+        print(f"\n[Workspace Updated]: {WORKSPACE_DIR}\n")
+        return {"status": "success", "workspace": WORKSPACE_DIR}
+    raise HTTPException(status_code=400, detail="Invalid workspace path")
+
+@app.get("/status")
+async def get_status():
+    active_procs = []
+    for pid, data in BACKGROUND_PROCESSES.items():
+        recent_logs = list(data['logs'])[-5:] 
+        active_procs.append({
+            "pid": pid,
+            "status": data['status'],
+            "logs": strip_ansi("".join(recent_logs))
+        })
+    return {
+        "workspace": WORKSPACE_DIR,
+        "processes": active_procs
+    }
+
+def _identify_tool(tool_raw: str):
+    """Parse which tool tag was used and build a short human-readable detail string."""
+    m = re.search(r"<tool='view_dir'>(.*?)</tool>", tool_raw, re.DOTALL)
+    if m:
+        return "view_dir", (m.group(1).strip() or ".")
+
+    m = re.search(r"<tool='read'>(.*?)</tool>", tool_raw, re.DOTALL)
+    if m:
+        return "read", m.group(1).strip()
+
+    m = re.search(r"<tool='write'\s+path='(.*?)'>(.*?)</tool>", tool_raw, re.DOTALL)
+    if m:
+        return "write", m.group(1).strip()
+
+    m = re.search(r"<tool='patch'\s+path='(.*?)'>\s*<search>(.*?)</search>\s*<replace>(.*?)</replace>\s*</tool>", tool_raw, re.DOTALL)
+    if m:
+        return "patch", m.group(1).strip()
+
+    m = re.search(r"<tool='search_code'\s+query='(.*?)'>(.*?)</tool>", tool_raw, re.DOTALL)
+    if m:
+        return "search_code", f"\"{m.group(1).strip()}\""
+
+    m = re.search(r"<tool='read_lines'\s+path='(.*?)'\s+start='(\d+)'\s+end='(\d+)'></tool>", tool_raw, re.DOTALL)
+    if m:
+        return "read_lines", f"{m.group(1).strip()}  L{m.group(2)}-{m.group(3)}"
+
+    m = re.search(r"<tool='terminal_run'>(.*?)</tool>", tool_raw, re.DOTALL)
+    if m:
+        return "terminal_run", m.group(1).strip()
+
+    m = re.search(r"<tool='terminal_bg'>(.*?)</tool>", tool_raw, re.DOTALL)
+    if m:
+        return "terminal_bg", m.group(1).strip()
+
+    m = re.search(r"<tool='terminal_logs'\s+pid='(.*?)'></tool>", tool_raw, re.DOTALL)
+    if m:
+        return "terminal_logs", f"pid={m.group(1).strip()}"
+
+    m = re.search(r"<tool='terminal_kill'\s+pid='(.*?)'></tool>", tool_raw, re.DOTALL)
+    if m:
+        return "terminal_kill", f"pid={m.group(1).strip()}"
+
+    m = re.search(r"<tool='cron_monitor'\s+pid='(.*?)'\s+delay='(\d+)'></tool>", tool_raw, re.DOTALL)
+    if m:
+        return "cron_monitor", f"pid={m.group(1).strip()}  delay={m.group(2)}s"
+
+    return None, ""
+
+
+def _short_preview(output: str, max_len: int = 90) -> str:
+    if not output:
+        return ""
+    first_line = str(output).splitlines()[0] if output else ""
+    if len(first_line) > max_len:
+        first_line = first_line[: max_len - 1] + "…"
+    return first_line
+
+
+@app.post("/extension/run-tool")
+async def run_tool(data: ToolModel):
+    global WORKSPACE_DIR
+    tool_raw = data.tool_call
+
+    tool_name, detail = _identify_tool(tool_raw)
+    print_tool_start(tool_name, detail)
+    start = time.perf_counter()
+
+    view_match = re.search(r"<tool='view_dir'>(.*?)</tool>", tool_raw, re.DOTALL)
+    read_match = re.search(r"<tool='read'>(.*?)</tool>", tool_raw, re.DOTALL)
+    write_match = re.search(r"<tool='write'\s+path='(.*?)'>(.*?)</tool>", tool_raw, re.DOTALL)
+    patch_match = re.search(r"<tool='patch'\s+path='(.*?)'>\s*<search>(.*?)</search>\s*<replace>(.*?)</replace>\s*</tool>", tool_raw, re.DOTALL)
+    search_code_match = re.search(r"<tool='search_code'\s+query='(.*?)'>(.*?)</tool>", tool_raw, re.DOTALL)
+    read_lines_match = re.search(r"<tool='read_lines'\s+path='(.*?)'\s+start='(\d+)'\s+end='(\d+)'></tool>", tool_raw, re.DOTALL)
+    term_run_match = re.search(r"<tool='terminal_run'>(.*?)</tool>", tool_raw, re.DOTALL)
+    term_bg_match = re.search(r"<tool='terminal_bg'>(.*?)</tool>", tool_raw, re.DOTALL)
+    term_logs_match = re.search(r"<tool='terminal_logs'\s+pid='(.*?)'></tool>", tool_raw, re.DOTALL)
+    term_kill_match = re.search(r"<tool='terminal_kill'\s+pid='(.*?)'></tool>", tool_raw, re.DOTALL)
+    cron_match = re.search(r"<tool='cron_monitor'\s+pid='(.*?)'\s+delay='(\d+)'></tool>", tool_raw, re.DOTALL)
+
+    try:
+        if view_match:
+            sub_dir = view_match.group(1).strip()
+            target_dir = secure_path(sub_dir) if sub_dir else WORKSPACE_DIR
+            tree = []
+            for root, dirs, files in os.walk(target_dir):
+                for f in files:
+                    rel_path = os.path.relpath(os.path.join(root, f), WORKSPACE_DIR)
+                    if not any(part.startswith('.') or part == 'node_modules' or part == '__pycache__' for part in rel_path.split(os.sep)):
+                        tree.append(rel_path)
+            result = {"output": truncate_output("\n".join(tree) if tree else "Directory is empty.")}
+
+        elif read_match:
+            filepath = secure_path(read_match.group(1).strip())
+            if not os.path.exists(filepath):
+                result = {"output": "Error: File not found."}
+            else:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    result = {"output": truncate_output(f.read())}
+
+        elif read_lines_match:
+            filepath = secure_path(read_lines_match.group(1).strip())
+            start_line, end_line = int(read_lines_match.group(2)), int(read_lines_match.group(3))
+            if not os.path.exists(filepath):
+                result = {"output": "Error: File not found."}
+            else:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    lines = f.readlines()
+                chunk = lines[max(0, start_line-1) : end_line]
+                formatted_chunk = "".join([f"{i+start_line}: {line}" for i, line in enumerate(chunk)])
+                result = {"output": truncate_output(f"--- Lines {start_line} to {end_line} ---\n{formatted_chunk}")}
+
+        elif search_code_match:
+            query, sub_dir = search_code_match.group(1).strip(), search_code_match.group(2).strip()
+            target_dir = secure_path(sub_dir) if sub_dir else WORKSPACE_DIR
+            results = []
+            for root, dirs, files in os.walk(target_dir):
+                if any(part.startswith('.') or part == 'node_modules' for part in root.split(os.sep)): continue
+                for f in files:
+                    filepath = os.path.join(root, f)
+                    rel_path = os.path.relpath(filepath, WORKSPACE_DIR)
+                    try:
+                        with open(filepath, 'r', encoding='utf-8') as file:
+                            for line_num, line in enumerate(file, 1):
+                                if query in line: results.append(f"{rel_path}:{line_num}: {line.strip()}")
+                    except: pass
+            result = {"output": truncate_output("\n".join(results) if results else "No matches found.")}
+
+        elif write_match:
+            path = write_match.group(1).strip()
+            filepath = secure_path(path)
+            content = re.sub(r'^```[a-zA-Z]*\n|\n```$', '', write_match.group(2).strip(), flags=re.MULTILINE)
+
+            old_content = ""
+            if os.path.exists(filepath):
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    old_content = f.read()
+
+            print_terminal_diff(path, old_content, content)
+
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(content)
+            result = {"output": f"Successfully wrote {path}"}
+
+        elif patch_match:
+            path = patch_match.group(1).strip()
+            filepath = secure_path(path)
+            search = re.sub(r'^```[a-zA-Z]*\n|\n```$', '', patch_match.group(2).strip('\n'), flags=re.MULTILINE)
+            replace = re.sub(r'^```[a-zA-Z]*\n|\n```$', '', patch_match.group(3).strip('\n'), flags=re.MULTILINE)
+
+            if not os.path.exists(filepath):
+                result = {"output": "Error: File not found."}
+            else:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    original = f.read()
+                if search not in original:
+                    result = {"output": "Error: Search block not found exactly as written."}
+                else:
+                    new_content = original.replace(search, replace, 1)
+                    print_terminal_diff(path, original, new_content)
+                    with open(filepath, 'w', encoding='utf-8') as f:
+                        f.write(new_content)
+                    result = {"output": f"Patch applied successfully to {path}."}
+
+        elif term_run_match:
+            cmd = term_run_match.group(1).strip()
+            env = os.environ.copy()
+            env["FORCE_COLOR"] = "true"
+            try:
+                res = subprocess.run(cmd, shell=True, cwd=WORKSPACE_DIR, capture_output=True, text=True, timeout=300, env=env)
+                output = strip_ansi(f"STDOUT:\n{res.stdout}\nSTDERR:\n{res.stderr}")
+                result = {"output": truncate_output(output if output.strip() else "Executed.")}
+            except subprocess.TimeoutExpired as e:
+                partial = e.stdout or ""
+                result = {"output": truncate_output(strip_ansi(f"Timed out after 300s. Output:\n{partial}"))}
+
+        elif term_bg_match:
+            cmd = term_bg_match.group(1).strip()
+            pid = str(uuid.uuid4())[:8]
+            env = os.environ.copy()
+            env["FORCE_COLOR"] = "true"
+            process = subprocess.Popen(cmd, shell=True, cwd=WORKSPACE_DIR, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, env=env)
+            BACKGROUND_PROCESSES[pid] = {'process': process, 'logs': deque(maxlen=500), 'status': 'running'}
+            threading.Thread(target=stream_process_output, args=(pid, process), daemon=True).start()
+            result = {"output": f"Process started. PID: {pid}. Use terminal_logs to view."}
+
+        elif term_logs_match:
+            pid = term_logs_match.group(1).strip()
+            if pid not in BACKGROUND_PROCESSES:
+                result = {"output": "Error: PID not found."}
+            else:
+                logs = "".join(list(BACKGROUND_PROCESSES[pid]['logs'])) or "No output yet."
+                result = {"output": truncate_output(strip_ansi(f"STATUS: {BACKGROUND_PROCESSES[pid]['status']}\nLOGS:\n{logs}"))}
+
+        elif term_kill_match:
+            pid = term_kill_match.group(1).strip()
+            if pid in BACKGROUND_PROCESSES:
+                proc = BACKGROUND_PROCESSES[pid]['process']
+                if platform.system() == "Windows":
+                    subprocess.run(f"taskkill /F /T /PID {proc.pid}", shell=True, capture_output=True)
+                else:
+                    proc.terminate()
+                BACKGROUND_PROCESSES[pid]['status'] = 'killed'
+                result = {"output": f"Process {pid} terminated."}
+            else:
+                result = {"output": "Error: PID not found."}
+
+        elif cron_match:
+            pid = cron_match.group(1).strip()
+            delay = int(cron_match.group(2).strip())
+            if pid not in BACKGROUND_PROCESSES:
+                result = {"output": "Error: PID not found."}
+            else:
+                safe_delay = min(delay, 120)
+                await asyncio.sleep(safe_delay)
+                logs = "".join(list(BACKGROUND_PROCESSES[pid]['logs'])) or "No output yet."
+                status = BACKGROUND_PROCESSES[pid]['status']
+                result = {"output": truncate_output(strip_ansi(f"[WOKE UP AFTER {safe_delay}s]\nSTATUS: {status}\nLOGS:\n{logs}"))}
+
+        else:
+            result = {"output": "Error: Unrecognized tool tag."}
+
+    except Exception as e:
+        result = {"output": f"Error: {str(e)}"}
+
+    elapsed_ms = (time.perf_counter() - start) * 1000
+    output_text = str(result.get("output", ""))
+    ok = not output_text.startswith("Error")
+    print_tool_end(ok, elapsed_ms, note=_short_preview(output_text))
+    return result
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=5505, access_log=False)

browse_code-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: browse_code
+Version: 0.1.0
+Summary: A local AI bridge package
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: pydantic
+Dynamic: requires-dist
+Dynamic: summary

browse_code-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+browse_code/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+browse_code/cli.py,sha256=ofLJcremtBArkiYGlO2ZmSGczfcLZ0jyWWKeXP3Nb9o,2700
+browse_code/server.py,sha256=71G-SL-B0tZbi6sUASkL9JsGbWTNwO_qxFK--AUZHlE,24460
+browse_code/extension/content.js,sha256=YNo4X2E-6ECmmPrvgcz2YGaYwWB9m0wgMrYgp4FAksk,18611
+browse_code/extension/manifest.json,sha256=HZGVv6Tz9Vf8lF36qXjdv_ymeIOt_BAE3SsMXd6Zb0o,609
+browse_code/extension/popup.html,sha256=FzDrhvFdVQfJvbPtOP29Qf_zOG74L14_MQHY2NThjHs,2267
+browse_code/extension/popup.js,sha256=p7UnulL6RagF8nEnl0qq6bKlZP5VKwPVrm1fmHkdfJc,3949
+browse_code/extension/spoof.js,sha256=Gw-32i1H6TLOJ1wya6FgEpWwcRw8MBOT2jXqC9ucISI,232
+browse_code-0.1.0.dist-info/METADATA,sha256=0ITT_ssbL79d5zN8IUpHsBqdZhk8cHD8fcLOrkrk97Q,209
+browse_code-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+browse_code-0.1.0.dist-info/entry_points.txt,sha256=RKZORZlRlErzq7s0lsBoQftIJht3XbEt97LEwSZCKps,44
+browse_code-0.1.0.dist-info/top_level.txt,sha256=Foeuwuu4FrELgUyxG7VVnVXsd8w2lrlGIxO2IJHPJqU,12
+browse_code-0.1.0.dist-info/RECORD,,

browse_code-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

browse_code-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bc = browse_code.cli:main

browse_code-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+browse_code