tab-agent 0.3.3 → 0.4.0

package/cli/detect-extension.js

@@ -3,8 +3,10 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
+const PREF_FILES = ['Secure Preferences', 'Preferences'];
+
 // Support multiple browsers: Chrome, Brave, Edge, Chromium
-function getAllBrowserExtensionPaths() {
+function getBrowserRoots() {
   const platform = os.platform();
   const home = os.homedir();
   const paths = [];
@@ -35,24 +37,99 @@ function getAllBrowserExtensionPaths() {
     );
   }
 
-  // Expand to include Default and Profile N directories
-  const expandedPaths = [];
-  for (const browserPath of paths) {
+  return paths;
+}
+
+function getAllBrowserProfileDirs() {
+  const profileDirs = [];
+
+  for (const browserPath of getBrowserRoots()) {
     if (!fs.existsSync(browserPath)) continue;
 
     const profiles = ['Default', ...fs.readdirSync(browserPath).filter(f => f.startsWith('Profile '))];
     for (const profile of profiles) {
-      const extPath = path.join(browserPath, profile, 'Extensions');
-      if (fs.existsSync(extPath)) {
-        expandedPaths.push(extPath);
+      const profileDir = path.join(browserPath, profile);
+      if (fs.existsSync(profileDir)) {
+        profileDirs.push({ browserPath, profileDir, profile });
       }
     }
   }
 
+  return profileDirs;
+}
+
+function getAllBrowserExtensionPaths() {
+  const expandedPaths = [];
+  for (const { profileDir } of getAllBrowserProfileDirs()) {
+    const extPath = path.join(profileDir, 'Extensions');
+    if (fs.existsSync(extPath)) {
+      expandedPaths.push(extPath);
+    }
+  }
+
   return expandedPaths;
 }
 
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    return null;
+  }
+}
+
+function readExtensionManifest(extensionPath) {
+  if (!extensionPath) return null;
+
+  for (const filename of ['manifest.json', 'manifest.chrome.json']) {
+    const manifestPath = path.join(extensionPath, filename);
+    if (fs.existsSync(manifestPath)) {
+      const manifest = readJson(manifestPath);
+      if (manifest) return manifest;
+    }
+  }
+
+  return null;
+}
+
+function isTabAgentManifest(manifest) {
+  return manifest?.name === 'Tab Agent';
+}
+
+function findTabAgentFromPreferences() {
+  for (const { browserPath, profileDir, profile } of getAllBrowserProfileDirs()) {
+    for (const prefFile of PREF_FILES) {
+      const prefs = readJson(path.join(profileDir, prefFile));
+      const settings = prefs?.extensions?.settings;
+      if (!settings) continue;
+
+      for (const [extId, info] of Object.entries(settings)) {
+        const manifest = isTabAgentManifest(info.manifest)
+          ? info.manifest
+          : readExtensionManifest(info.path);
+
+        if (!isTabAgentManifest(manifest)) continue;
+
+        return {
+          extId,
+          browser: path.join(profileDir, 'Extensions'),
+          browserPath,
+          profile,
+          path: info.path || null,
+          source: 'preferences',
+          version: manifest.version || info.service_worker_registration_info?.version || null
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
 function findTabAgentExtension() {
+  const unpacked = findTabAgentFromPreferences();
+  if (unpacked) return unpacked;
+
   const extensionPaths = getAllBrowserExtensionPaths();
 
   for (const extPath of extensionPaths) {
@@ -68,12 +145,16 @@ function findTabAgentExtension() {
         for (const version of versions) {
           const manifestPath = path.join(extDir, version, 'manifest.json');
           if (fs.existsSync(manifestPath)) {
-            try {
-              const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-              if (manifest.name === 'Tab Agent') {
-                return { extId, browser: extPath };
-              }
-            } catch (e) {}
+            const manifest = readJson(manifestPath);
+            if (isTabAgentManifest(manifest)) {
+              return {
+                extId,
+                browser: extPath,
+                path: path.join(extDir, version),
+                source: 'extensions-dir',
+                version: manifest.version || version
+              };
+            }
           }
         }
       }
@@ -127,5 +208,6 @@ module.exports = {
   findTabAgentExtension,
   checkExistingManifest,
   promptForExtensionId,
-  getAllBrowserExtensionPaths
+  getAllBrowserExtensionPaths,
+  getAllBrowserProfileDirs
 };

package/cli/launch-chrome.js

@@ -0,0 +1,150 @@
+// cli/launch-chrome.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+const { execSync, spawn } = require('child_process');
+
+function getChromeUserDataDir() {
+  const home = os.homedir();
+  const platform = os.platform();
+
+  if (platform === 'darwin') {
+    return path.join(home, 'Library/Application Support/Google/Chrome');
+  } else if (platform === 'linux') {
+    return path.join(home, '.config/google-chrome');
+  } else if (platform === 'win32') {
+    return path.join(process.env.LOCALAPPDATA, 'Google/Chrome/User Data');
+  }
+  return null;
+}
+
+function detectProfiles() {
+  const userDataDir = getChromeUserDataDir();
+  if (!userDataDir || !fs.existsSync(userDataDir)) return [];
+
+  const candidates = ['Default'];
+  try {
+    const entries = fs.readdirSync(userDataDir);
+    for (const entry of entries) {
+      if (entry.startsWith('Profile ')) candidates.push(entry);
+    }
+  } catch (e) {}
+
+  const profiles = [];
+  for (const dir of candidates) {
+    const prefsPath = path.join(userDataDir, dir, 'Preferences');
+    if (!fs.existsSync(prefsPath)) continue;
+    try {
+      const prefs = JSON.parse(fs.readFileSync(prefsPath, 'utf8'));
+      const name = prefs.profile?.name || dir;
+      profiles.push({ dir, name });
+    } catch (e) {
+      profiles.push({ dir, name: dir });
+    }
+  }
+  return profiles;
+}
+
+async function promptForProfile(profiles) {
+  if (profiles.length === 0) {
+    console.log('No Chrome profiles found.');
+    return null;
+  }
+
+  if (profiles.length === 1) {
+    console.log(`Using profile: ${profiles[0].name}`);
+    return profiles[0];
+  }
+
+  console.log('\nChrome Profiles:');
+  profiles.forEach((p, i) => {
+    console.log(`  ${i + 1}. ${p.name} (${p.dir})`);
+  });
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`\nSelect profile [1-${profiles.length}]: `, (answer) => {
+      rl.close();
+      const idx = parseInt(answer, 10) - 1;
+      if (idx >= 0 && idx < profiles.length) {
+        resolve(profiles[idx]);
+      } else {
+        console.log('Invalid selection, using first profile.');
+        resolve(profiles[0]);
+      }
+    });
+  });
+}
+
+function isChromeRunning() {
+  const platform = os.platform();
+  try {
+    if (platform === 'darwin') {
+      execSync('pgrep -x "Google Chrome"', { stdio: 'ignore' });
+      return true;
+    } else if (platform === 'linux') {
+      execSync('pgrep -x chrome', { stdio: 'ignore' });
+      return true;
+    } else if (platform === 'win32') {
+      const result = execSync('tasklist /FI "IMAGENAME eq chrome.exe" /NH', { encoding: 'utf8' });
+      return result.includes('chrome.exe');
+    }
+  } catch (e) {}
+  return false;
+}
+
+function launchChrome(profileDir) {
+  const platform = os.platform();
+  const args = profileDir ? [`--profile-directory=${profileDir}`] : [];
+
+  if (platform === 'darwin') {
+    spawn('open', ['-a', 'Google Chrome', '--args', ...args], {
+      detached: true,
+      stdio: 'ignore'
+    }).unref();
+  } else if (platform === 'linux') {
+    spawn('google-chrome', args, {
+      detached: true,
+      stdio: 'ignore'
+    }).unref();
+  } else if (platform === 'win32') {
+    const chromePath = path.join(
+      process.env.PROGRAMFILES || 'C:\\Program Files',
+      'Google\\Chrome\\Application\\chrome.exe'
+    );
+    spawn(chromePath, args, {
+      detached: true,
+      stdio: 'ignore'
+    }).unref();
+  }
+}
+
+function getConfigPath() {
+  return path.join(os.homedir(), '.tab-agent.json');
+}
+
+function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(getConfigPath(), 'utf8'));
+  } catch (e) {
+    return {};
+  }
+}
+
+function saveConfig(config) {
+  const existing = loadConfig();
+  const merged = { ...existing, ...config };
+  fs.writeFileSync(getConfigPath(), JSON.stringify(merged, null, 2));
+}
+
+function getSavedProfile() {
+  const config = loadConfig();
+  return config.profile || null;
+}
+
+module.exports = { detectProfiles, getChromeUserDataDir, promptForProfile, isChromeRunning, launchChrome, loadConfig, saveConfig, getSavedProfile };

package/cli/setup.js

@@ -3,6 +3,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { findTabAgentExtension, checkExistingManifest, promptForExtensionId } = require('./detect-extension');
+const { detectProfiles, promptForProfile, saveConfig } = require('./launch-chrome');
 
 async function setup() {
   console.log('Tab Agent Setup\n');
@@ -15,6 +16,12 @@ async function setup() {
   if (found) {
     extensionId = found.extId;
     console.log(`✓ Found extension: ${extensionId}`);
+    if (found.profile) {
+      console.log(`  Profile: ${found.profile}`);
+    }
+    if (found.path) {
+      console.log(`  Path: ${found.path}`);
+    }
   } else {
     extensionId = checkExistingManifest();
     if (extensionId) {
@@ -36,15 +43,28 @@ async function setup() {
   installNativeHost(extensionId);
   console.log('✓ Native messaging host installed');
 
-  // 3. Install skills
+  // 3. Select Chrome profile
+  console.log('\nDetecting Chrome profiles...');
+  const profiles = detectProfiles();
+  if (profiles.length > 0) {
+    const selected = await promptForProfile(profiles);
+    if (selected) {
+      saveConfig({ profile: selected.dir });
+      console.log(`✓ Saved default profile: ${selected.name} (${selected.dir})`);
+    }
+  } else {
+    console.log('  No Chrome profiles found, skipping.');
+  }
+
+  // 4. Install skills
   console.log('\nInstalling skills...');
   installSkills();
 
   console.log('\n✓ Setup complete!\n');
   console.log('Usage:');
-  console.log('  1. Click Tab Agent icon on any tab (turns green)');
-  console.log('  2. Ask Claude/Codex: "Use tab-agent to search Google"');
-  console.log('\nThe relay server starts automatically when needed.');
+  console.log('  1. Start relay server: npx tab-agent@latest start');
+  console.log('  2. Click Tab Agent icon on any tab (turns green)');
+  console.log('  3. Ask Claude/Codex: "Use tab-agent to search Google"');
 }
 
 function installNativeHost(extensionId) {
@@ -99,35 +119,50 @@ function installSkills() {
   const skillSource = path.join(packageDir, 'skills');
 
   // Claude Code - always install
-  const claudeSkillDir = path.join(home, '.claude', 'skills');
-  const claudeSkillPath = path.join(claudeSkillDir, 'tab-agent.md');
+  // Expected structure: ~/.claude/skills/tab-agent/SKILL.md
+  const claudeSkillDir = path.join(home, '.claude', 'skills', 'tab-agent');
+  const claudeSkillPath = path.join(claudeSkillDir, 'SKILL.md');
+
+  // Remove old flat file if it exists (from previous versions)
+  const oldClaudeSkillPath = path.join(home, '.claude', 'skills', 'tab-agent.md');
+  if (fs.existsSync(oldClaudeSkillPath)) {
+    fs.unlinkSync(oldClaudeSkillPath);
+    console.log('  Removed old skill file format');
+  }
+
   fs.mkdirSync(claudeSkillDir, { recursive: true });
 
   if (fs.existsSync(claudeSkillPath)) {
-    console.log(`  Updating existing skill at ${claudeSkillPath}`);
+    console.log(`  Updating existing skill at ${claudeSkillDir}`);
   }
   fs.copyFileSync(
-    path.join(skillSource, 'claude-code', 'tab-agent.md'),
+    path.join(skillSource, 'claude-code', 'tab-agent', 'SKILL.md'),
     claudeSkillPath
   );
   console.log('✓ Installed Claude Code skill');
 
-  // Codex (only if .codex exists)
-  const codexDir = path.join(home, '.codex');
-  if (fs.existsSync(codexDir)) {
-    const codexSkillDir = path.join(codexDir, 'skills');
-    const codexSkillPath = path.join(codexSkillDir, 'tab-agent.md');
-    fs.mkdirSync(codexSkillDir, { recursive: true });
+  // Codex - always install (create .codex if needed)
+  // Expected structure: ~/.codex/skills/tab-agent/SKILL.md
+  const codexSkillDir = path.join(home, '.codex', 'skills', 'tab-agent');
+  const codexSkillPath = path.join(codexSkillDir, 'SKILL.md');
 
-    if (fs.existsSync(codexSkillPath)) {
-      console.log(`  Updating existing skill at ${codexSkillPath}`);
-    }
-    fs.copyFileSync(
-      path.join(skillSource, 'codex', 'tab-agent.md'),
-      codexSkillPath
-    );
-    console.log('✓ Installed Codex skill');
+  // Remove old flat file if it exists (from previous versions)
+  const oldCodexSkillPath = path.join(home, '.codex', 'skills', 'tab-agent.md');
+  if (fs.existsSync(oldCodexSkillPath)) {
+    fs.unlinkSync(oldCodexSkillPath);
+    console.log('  Removed old Codex skill file format');
   }
+
+  fs.mkdirSync(codexSkillDir, { recursive: true });
+
+  if (fs.existsSync(codexSkillPath)) {
+    console.log(`  Updating existing skill at ${codexSkillDir}`);
+  }
+  fs.copyFileSync(
+    path.join(skillSource, 'codex', 'tab-agent', 'SKILL.md'),
+    codexSkillPath
+  );
+  console.log('✓ Installed Codex skill');
 }
 
 setup().catch(console.error);

package/cli/start.js

@@ -1,19 +1,71 @@
 // cli/start.js
 const path = require('path');
 const { spawn } = require('child_process');
+const { detectProfiles, promptForProfile, isChromeRunning, launchChrome, getSavedProfile } = require('./launch-chrome');
 
-const serverPath = path.join(__dirname, '..', 'relay', 'server.js');
-const server = spawn('node', [serverPath], {
-  stdio: 'inherit',
-  detached: false
-});
+async function start() {
+  // Parse --profile flag
+  const profileFlag = process.argv.find(a => a.startsWith('--profile'));
+  let requestedProfile = null;
+  if (profileFlag) {
+    requestedProfile = profileFlag.includes('=')
+      ? profileFlag.split('=')[1]
+      : process.argv[process.argv.indexOf(profileFlag) + 1];
+  }
 
-server.on('error', (err) => {
-  console.error('Failed to start server:', err.message);
-  process.exit(1);
-});
+  // Launch Chrome if not running
+  if (!isChromeRunning()) {
+    console.log('Chrome is not running.\n');
+    const profiles = detectProfiles();
 
-process.on('SIGINT', () => {
-  server.kill();
-  process.exit(0);
-});
+    if (profiles.length > 0) {
+      let selected;
+      // Priority: --profile flag > saved config > interactive prompt
+      const profileToFind = requestedProfile || getSavedProfile();
+      if (profileToFind) {
+        selected = profiles.find(p =>
+          p.name.toLowerCase() === profileToFind.toLowerCase() ||
+          p.dir.toLowerCase() === profileToFind.toLowerCase()
+        );
+        if (!selected) {
+          console.log(`Profile "${profileToFind}" not found. Available profiles:`);
+          profiles.forEach(p => console.log(`  - ${p.name} (${p.dir})`));
+          process.exit(1);
+        }
+      } else {
+        selected = await promptForProfile(profiles);
+      }
+      if (selected) {
+        console.log(`\nLaunching Chrome with profile "${selected.name}"...`);
+        launchChrome(selected.dir);
+        // Give Chrome time to start and load extension
+        await new Promise(r => setTimeout(r, 3000));
+      }
+    } else {
+      console.log('Launching Chrome...');
+      launchChrome(null);
+      await new Promise(r => setTimeout(r, 3000));
+    }
+  } else {
+    console.log('Chrome is already running.');
+  }
+
+  // Start relay server
+  const serverPath = path.join(__dirname, '..', 'relay', 'server.js');
+  const server = spawn('node', [serverPath], {
+    stdio: 'inherit',
+    detached: false
+  });
+
+  server.on('error', (err) => {
+    console.error('Failed to start server:', err.message);
+    process.exit(1);
+  });
+
+  process.on('SIGINT', () => {
+    server.kill();
+    process.exit(0);
+  });
+}
+
+start().catch(console.error);

package/cli/status.js

@@ -3,6 +3,9 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const http = require('http');
+const { findTabAgentExtension } = require('./detect-extension');
+
+const PACKAGE_VERSION = require('../package.json').version;
 
 function checkRelayServer() {
   return new Promise((resolve) => {
@@ -27,7 +30,7 @@ function checkRelayServer() {
 }
 
 async function status() {
-  console.log('Tab Agent Status\n');
+  console.log(`Tab Agent Status v${PACKAGE_VERSION}\n`);
 
   // Check native host
   const home = os.homedir();
@@ -46,16 +49,47 @@ async function status() {
     const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
     console.log('Native Host: Installed');
     console.log(`  Extension: ${manifest.allowed_origins[0]}`);
+    console.log(`  Path: ${manifest.path}`);
   } else {
-    console.log('Native Host: Not installed (run: npx tab-agent setup)');
+    console.log('Native Host: Not installed (run: npx tab-agent@latest setup)');
+  }
+
+  const extension = findTabAgentExtension();
+  if (extension) {
+    console.log('\nExtension: Detected');
+    console.log(`  ID: ${extension.extId}`);
+    if (extension.version) {
+      console.log(`  Version: ${extension.version}`);
+    }
+    if (extension.profile) {
+      console.log(`  Profile: ${extension.profile}`);
+    }
+    if (extension.path) {
+      console.log(`  Path: ${extension.path}`);
+    }
+  } else {
+    console.log('\nExtension: Not detected');
   }
 
   // Check skills
-  const claudeSkill = path.join(home, '.claude', 'skills', 'tab-agent.md');
-  const codexSkill = path.join(home, '.codex', 'skills', 'tab-agent.md');
+  const claudeSkill = path.join(home, '.claude', 'skills', 'tab-agent', 'SKILL.md');
+  const codexSkill = path.join(home, '.codex', 'skills', 'tab-agent', 'SKILL.md');
+  const legacyClaudeSkill = path.join(home, '.claude', 'skills', 'tab-agent.md');
+  const legacyCodexSkill = path.join(home, '.codex', 'skills', 'tab-agent.md');
+
+  const claudeSkillStatus = fs.existsSync(claudeSkill)
+    ? 'Installed'
+    : fs.existsSync(legacyClaudeSkill)
+      ? 'Installed (legacy path)'
+      : 'Not installed';
+  const codexSkillStatus = fs.existsSync(codexSkill)
+    ? 'Installed'
+    : fs.existsSync(legacyCodexSkill)
+      ? 'Installed (legacy path)'
+      : 'Not installed (optional)';
 
-  console.log(`\nClaude Skill: ${fs.existsSync(claudeSkill) ? 'Installed' : 'Not installed'}`);
-  console.log(`Codex Skill:  ${fs.existsSync(codexSkill) ? 'Installed' : 'Not installed (optional)'}`);
+  console.log(`\nClaude Skill: ${claudeSkillStatus}`);
+  console.log(`Codex Skill:  ${codexSkillStatus}`);
 
   // Check relay server
   console.log('\nRelay Server:');
@@ -63,7 +97,7 @@ async function status() {
   if (relayStatus.running) {
     console.log(`  Status: Running (${relayStatus.clients} client${relayStatus.clients !== 1 ? 's' : ''})`);
   } else {
-    console.log('  Status: Not running (starts automatically when needed)');
+    console.log('  Status: Not running (start with: npx tab-agent@latest start)');
   }
 }