service_worker.js

'use strict';

const ALARM_NAME = 'browserclaw-poll';
const RESULT_TIMEOUT_MS = 5 * 60 * 1000;
var bridgeOffTimer = null;
const MESSAGE_RETRY_MS = 2000;
const MESSAGE_RETRIES = 15;

function getConfig() {
  return new Promise(function (resolve) {
    chrome.storage.sync.get(
      { repo: 'MinglesAI/mingles_ai_strategy', labels: 'agent-ready', pollInterval: 5, ghPat: '', ghAgentUseApi: false },
      resolve
    );
  });
}

function schedulePoll() {
  getConfig().then(function (cfg) {
    const minutes = Math.max(1, Number(cfg.pollInterval) || 5);
    chrome.alarms.create(ALARM_NAME, { periodInMinutes: minutes });
    console.log('[BrowserClaw] Poll scheduled every', minutes, 'min');
  });
}

function parseRepo(repo) {
  const parts = (repo || '').trim().split('/');
  return { owner: parts[0] || '', repo: parts[1] || '' };
}

function authHeaders(pat) {
  return {
    Accept: 'application/vnd.github+json',
    'X-GitHub-Api-Version': '2022-11-28',
    Authorization: 'Bearer ' + (pat || ''),
  };
}

function fetchOpenIssues(cfg) {
  const { owner, repo } = parseRepo(cfg.repo);
  const labels = encodeURIComponent((cfg.labels || 'agent-ready').split(',')[0].trim());
  const url = `https://api.github.com/repos/${owner}/${repo}/issues?labels=${labels}&state=open`;
  console.log('[BrowserClaw] Fetching issues', url);
  return fetch(url, { headers: authHeaders(cfg.ghPat) }).then(function (r) {
    if (!r.ok) throw new Error('GitHub API ' + r.status + ' ' + r.statusText);
    return r.json();
  });
}

function postComment(cfg, issueNumber, body) {
  const { owner, repo } = parseRepo(cfg.repo);
  const url = `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}/comments`;
  console.log('[BrowserClaw] POST comment', url);
  return fetch(url, {
    method: 'POST',
    headers: { ...authHeaders(cfg.ghPat), 'Content-Type': 'application/json' },
    body: JSON.stringify({ body }),
  }).then(function (r) {
    if (!r.ok) throw new Error('GitHub comment ' + r.status);
    return r.json();
  });
}

function removeLabel(cfg, issueNumber, labelToRemove) {
  const { owner, repo } = parseRepo(cfg.repo);
  return fetch(`https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}`, {
    headers: authHeaders(cfg.ghPat),
  })
    .then(function (r) {
      if (!r.ok) throw new Error('GitHub get issue ' + r.status);
      return r.json();
    })
    .then(function (issue) {
      const labels = (issue.labels || []).map(function (l) { return l.name; }).filter(function (n) { return n !== labelToRemove; });
      return fetch(`https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}`, {
        method: 'PATCH',
        headers: { ...authHeaders(cfg.ghPat), 'Content-Type': 'application/json' },
        body: JSON.stringify({ labels }),
      });
    })
    .then(function (r) {
      if (!r.ok) throw new Error('GitHub PATCH issue ' + r.status);
      return r.json();
    });
}

function sendMessageToTab(tabId, payload) {
  return new Promise(function (resolve, reject) {
    let attempts = 0;
    function trySend() {
      chrome.tabs.sendMessage(tabId, payload, function (response) {
        if (chrome.runtime.lastError) {
          attempts++;
          if (attempts < MESSAGE_RETRIES) {
            console.log('[BrowserClaw] Content script not ready, retry', attempts);
            setTimeout(trySend, MESSAGE_RETRY_MS);
          } else {
            reject(new Error(chrome.runtime.lastError.message || 'Content script timeout'));
          }
          return;
        }
        resolve(response);
      });
    }
    trySend();
  });
}

function waitForTabReady(tabId) {
  return new Promise(function (resolve, reject) {
    function check() {
      chrome.tabs.get(tabId, function (tab) {
        if (chrome.runtime.lastError) {
          reject(new Error('Tab gone'));
          return;
        }
        if (tab.status === 'complete') {
          resolve();
          return;
        }
        setTimeout(check, 500);
      });
    }
    check();
  });
}

function toSingleLine(s) {
  return (s || '').replace(/\r\n|\n|\r/g, ' ').replace(/\s+/g, ' ').trim();
}

function setTaskInProgress(issueNumber) {
  return new Promise(function (resolve) {
    chrome.storage.local.set({
      taskInProgress: true,
      currentIssueNumber: issueNumber || null,
      taskStartedAt: Date.now(),
    }, resolve);
  });
}

function clearTaskInProgress() {
  return new Promise(function (resolve) {
    chrome.storage.local.remove(['taskInProgress', 'currentIssueNumber', 'taskStartedAt'], resolve);
  });
}

function addToSentQueue(issueNumber) {
  return new Promise(function (resolve) {
    chrome.storage.local.get('browserclawSentIssues', function (d) {
      var arr = d.browserclawSentIssues || [];
      if (arr.indexOf(issueNumber) === -1) arr.push(issueNumber);
      chrome.storage.local.set({ browserclawSentIssues: arr }, resolve);
    });
  });
}

function runIssue(issue, cfg) {
  const issueNumber = issue.number;
  const issueUrl = issue.html_url || `https://github.com/${cfg.repo}/issues/${issueNumber}`;
  var title = toSingleLine(issue.title);
  var body = toSingleLine(issue.body);

  var labelToRemove = (cfg.labels || 'agent-ready').split(',')[0].trim();
  var promptText;
  if (cfg.ghAgentUseApi && cfg.ghPat) {
    promptText =
      'Task: ' + title + ' Description: ' + body + ' Link: ' + issueUrl + ' ' +
      'Complete this task. You MUST add the result as a comment to the GitHub issue via the API. Use this token for Authorization: Bearer ' + (cfg.ghPat || '').trim() +
      ' When done, remove the label "' + labelToRemove + '" from the issue.';
  } else {
    promptText =
      'Task: ' + title + ' Description: ' + body + ' Link: ' + issueUrl + ' ' +
      'Open the link above in the browser, complete the task. You MUST add the result as a comment on the issue. Use your existing session if you have access.' +
      ' When done, remove the label "' + labelToRemove + '" from the issue.';
  }

  appendLog('Issue #' + issueNumber + ' received');
  console.log('[BrowserClaw] Sending issue #' + issueNumber + ' via bridge');
  return setTaskInProgress(issueNumber).then(function () {
    return addToSentQueue(issueNumber);
  }).then(function () {
    return new Promise(function (resolve, reject) {
      chrome.storage.local.set({ bridgePrompt: promptText, bridgeNewSession: true }, function () {
        appendLog('Sent to bridge');
        appendLog('In progress');
        console.log('[BrowserClaw] Issue #' + issueNumber + ' queued for bridge');
        resolve();
      });
    });
  });
}

var LOG_MAX = 20;

function appendLog(line) {
  chrome.storage.local.get('browserclawLogs', function (d) {
    var arr = d.browserclawLogs || [];
    arr.push(new Date().toLocaleTimeString() + ' ' + line);
    if (arr.length > LOG_MAX) arr = arr.slice(-LOG_MAX);
    chrome.storage.local.set({ browserclawLogs: arr });
  });
}

function doPoll() {
  console.log('[BrowserClaw] Poll started');
  chrome.storage.local.get(['bridgeLastPoll', 'taskInProgress'], function (d) {
    var last = d.bridgeLastPoll || 0;
    if (Date.now() - last > 6000) {
      console.log('[BrowserClaw] Bridge offline, skip poll');
      return;
    }
    if (d.taskInProgress) {
      console.log('[BrowserClaw] Task already in progress, skip poll');
      return;
    }
    getConfig().then(function (cfg) {
      if (!cfg.ghPat) {
        console.log('[BrowserClaw] No PAT, skip poll');
        return;
      }
      chrome.storage.local.get('browserclawSentIssues', function (d) {
        var sent = d.browserclawSentIssues || [];
        fetchOpenIssues(cfg).then(function (issues) {
          if (!issues || issues.length === 0) {
            console.log('[BrowserClaw] No open issues with label');
            return;
          }
          var available = issues.filter(function (iss) { return sent.indexOf(iss.number) === -1; });
          if (available.length === 0) {
            console.log('[BrowserClaw] All issues already sent/completed');
            return;
          }
          console.log('[BrowserClaw] Found', available.length, 'issue(s) to run');
          const next = available[0];
          runIssue(next, cfg).catch(function () {});
        }).catch(function (e) {
          console.error('[BrowserClaw] Poll fetch error', e);
        });
      });
    }).catch(function (e) {
      console.error('[BrowserClaw] Poll fetch error', e);
    });
  });
}

chrome.alarms.onAlarm.addListener(function (alarm) {
  if (alarm.name === ALARM_NAME) {
    doPoll();
  }
});

var SIDECAR_URL = 'https://www.perplexity.ai/sidecar';

function getOrCreateCometTab() {
  return new Promise(function (resolve, reject) {
    chrome.tabs.query({ url: 'https://www.perplexity.ai/*' }, function (tabs) {
      var sidecar = tabs && tabs.filter(function (t) { return (t.url || '').indexOf('/sidecar') !== -1; })[0];
      var tab = sidecar || (tabs && tabs[0]);
      if (tab) {
        chrome.tabs.update(tab.id, { active: true }, function () {
          if (tab.windowId) chrome.windows.update(tab.windowId, { focused: true }).catch(function () {});
          resolve(tab.id);
        });
      } else {
        chrome.tabs.create({ url: SIDECAR_URL }, function (tab) {
          resolve(tab.id);
        });
      }
    });
  });
}

function injectContentScript(tabId) {
  return chrome.scripting.executeScript({ target: { tabId }, files: ['content.js'] })
    .then(function () {
      console.log('[BrowserClaw] Content script injected into tab', tabId);
      return new Promise(function (r) { setTimeout(r, 800); });
    })
    .catch(function (err) {
      console.error('[BrowserClaw] Inject failed (tab URL may be non-https?)', err);
      throw err;
    });
}

function sendTestPromptToComet(prompt) {
  return getOrCreateCometTab().then(function (tabId) {
    return chrome.tabs.get(tabId).then(function (tab) {
      console.log('[BrowserClaw] Comet tab', tabId, 'url=', tab.url);
      return waitForTabReady(tabId).then(function () {
        return injectContentScript(tabId).then(function () {
          return sendMessageToTab(tabId, {
            action: 'sendPrompt',
            issue: { prompt: prompt, title: '', body: '', url: '' },
          });
        });
      });
    });
  });
}

chrome.runtime.onMessage.addListener(function (msg, sender, sendResponse) {
  if (msg.action === 'schedulePoll') {
    schedulePoll();
    sendResponse({ ok: true });
    return true;
  }
  if (msg.action === 'diagnosticsTabs') {
    chrome.windows.getAll({ populate: true }, function (windows) {
      var lines = [];
      windows.forEach(function (win) {
        (win.tabs || []).forEach(function (tab) {
          lines.push('tabId=' + tab.id + ' windowId=' + win.id + ' url=' + (tab.url || '') + ' title=' + (tab.title || '').slice(0, 50));
        });
      });
      sendResponse({ text: lines.length ? lines.join('\n') : 'No tabs.', raw: lines });
    });
    return true;
  }
  if (msg.action === 'sendTestPrompt') {
    var prompt = (msg.prompt || '').trim();
    if (!prompt) {
      sendResponse({ message: 'Empty command.' });
      return true;
    }
    chrome.storage.local.get('taskInProgress', function (d) {
      if (d.taskInProgress) {
        sendResponse({ message: 'Task already in progress. Wait or click Stop first.' });
        return;
      }
      setTaskInProgress(null).then(function () {
        appendLog('Prompt sent');
        chrome.storage.local.set({ bridgePrompt: prompt }, function () {
          sendResponse({ message: 'Sent.' });
        });
      });
    });
    return true;
  }
  if (msg.action === 'getLogs') {
    chrome.storage.local.get('browserclawLogs', function (d) {
      sendResponse({ logs: d.browserclawLogs || [] });
    });
    return true;
  }
  if (msg.action === 'getBridgeStatus') {
    chrome.storage.local.get(['bridgeLastPoll', 'bridgeWrongContext'], function (d) {
      var t = d.bridgeLastPoll || 0;
      var connected = Date.now() - t < 6000;
      sendResponse({ connected: connected, lastPoll: t, wrongContext: !!d.bridgeWrongContext });
    });
    return true;
  }
  if (msg.action === 'getTaskStatus') {
    chrome.storage.local.get(['taskInProgress', 'currentIssueNumber', 'taskStartedAt'], function (d) {
      var inProgress = !!d.taskInProgress;
      if (inProgress && d.taskStartedAt && Date.now() - d.taskStartedAt > RESULT_TIMEOUT_MS) {
        clearTaskInProgress().then(function () {
          appendLog('Task timeout, cleared');
        });
        sendResponse({ taskInProgress: false, currentIssueNumber: null });
        return;
      }
      sendResponse({
        taskInProgress: inProgress,
        currentIssueNumber: d.currentIssueNumber || null,
      });
    });
    return true;
  }
  if (msg.action === 'stopTask') {
    clearTaskInProgress().then(function () {
      appendLog('Stopped by user');
      sendResponse({ ok: true });
    });
    return true;
  }
  if (msg.action === 'cometResult') {
    var responseText = msg.responseText || '';
    if (responseText) {
      chrome.storage.local.set({ browserclawLastResponse: responseText });
    }
    clearTaskInProgress().then(function () {
      appendLog('Task finished');
      console.log('[BrowserClaw] cometResult received, task cleared');
    });
    sendResponse({});
    return true;
  }
  if (msg.action === 'getCompletedQueue') {
    chrome.storage.local.get('browserclawSentIssues', function (d) {
      sendResponse({ issues: d.browserclawSentIssues || [] });
    });
    return true;
  }
  if (msg.action === 'clearCompletedQueue') {
    chrome.storage.local.remove('browserclawSentIssues', function () {
      appendLog('Queue cleared');
      sendResponse({ ok: true });
    });
    return true;
  }
  if (msg.action === 'bridgePoll') {
    chrome.action.setBadgeText({ text: 'on' });
    chrome.action.setBadgeBackgroundColor({ color: '#198754' });
    if (bridgeOffTimer) clearTimeout(bridgeOffTimer);
    bridgeOffTimer = setTimeout(function () {
      chrome.action.setBadgeText({ text: 'off' });
      chrome.action.setBadgeBackgroundColor({ color: '#6c757d' });
    }, 6000);
    sendResponse({});
    return true;
  }
  if (msg.action === 'triggerPoll') {
    doPoll();
    sendResponse({ ok: true, message: 'Poll triggered.' });
    return true;
  }
  if (msg.action === 'manualTrigger') {
    getConfig().then(function (cfg) {
      if (!cfg.ghPat) {
        sendResponse({ message: 'Set GitHub PAT first.' });
        return;
      }
      var testNum = msg.testIssueNumber || 50;
      const { owner, repo } = parseRepo(cfg.repo);
      const url = `https://api.github.com/repos/${owner}/${repo}/issues/${testNum}`;
      fetch(url, { headers: authHeaders(cfg.ghPat) })
        .then(function (r) {
          if (!r.ok) throw new Error('Issue #' + testNum + ' not found or no access');
          return r.json();
        })
        .then(function (issue) {
          return runIssue(issue, cfg);
        })
        .then(function () {
          sendResponse({ message: 'Test issue #' + testNum + ' triggered. Check Comet tab.' });
        })
        .catch(function (e) {
          sendResponse({ message: 'Error: ' + (e.message || e) });
        });
    });
    return true;
  }
});

chrome.runtime.onInstalled.addListener(function () {
  chrome.action.setBadgeText({ text: 'off' });
  chrome.action.setBadgeBackgroundColor({ color: '#6c757d' });
  schedulePoll();
  console.log('[BrowserClaw] Installed, poll scheduled');
});

chrome.runtime.onStartup.addListener(function () {
  schedulePoll();
});