tabclaude-host 0.1.0

package/README.md

@@ -0,0 +1,39 @@
+# tabclaude-host
+
+Chrome Native Messaging Host for [Tabclaude](https://github.com/sanghun0724/tabclaude) — AI Tab Manager.
+
+## Prerequisites
+
+- Node.js >= 18
+- [Claude CLI](https://github.com/anthropics/claude-code) installed (`npm install -g @anthropic-ai/claude-code`)
+- Tabclaude Chrome extension loaded
+
+## Installation
+
+**Step 1 — Install the native host:**
+```
+npm install -g tabclaude-host
+```
+
+**Step 2 — Register with Chrome:**
+```
+tabclaude-host setup <your-extension-id>
+```
+
+To find your extension ID: open `chrome://extensions`, enable Developer mode, and copy the ID shown under Tabclaude.
+
+## Uninstall
+
+```
+npm uninstall -g tabclaude-host
+```
+
+## Troubleshooting
+
+- Logs: `/tmp/tabclaude-host.log`
+- If Claude features don't work, verify Claude CLI is installed: `which claude`
+- After updating Node.js or Claude CLI, re-run `tabclaude-host setup <extension-id>`
+
+## License
+
+MIT

package/claude-client.js

@@ -0,0 +1,95 @@
+import { execFile } from "node:child_process";
+import { stderr } from "node:process";
+
+const claudeBin = process.env.CLAUDE_PATH || "claude";
+const CLAUDE_TIMEOUT = 30000;
+
+function runClaude(prompt) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(
+      claudeBin,
+      ["--print", "--", prompt],
+      { timeout: CLAUDE_TIMEOUT, maxBuffer: 1024 * 1024 },
+      (err, stdoutData, stderrData) => {
+        if (err) {
+          if (stderrData) stderr.write(`claude stderr: ${stderrData}\n`);
+          reject(new Error(`Claude CLI failed: ${err.message}`));
+          return;
+        }
+        resolve(stdoutData.trim());
+      },
+    );
+    // Close stdin so claude CLI doesn't wait for input
+    child.stdin.end();
+  });
+}
+
+function parseJsonResponse(text) {
+  // Try extracting JSON from markdown code block first
+  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const jsonStr = codeBlockMatch ? codeBlockMatch[1].trim() : text.trim();
+  return JSON.parse(jsonStr);
+}
+
+export async function analyzeWithClaude(payload) {
+  const { tabs, settings, existingGroups = [] } = payload;
+
+  const existingGroupsSection = existingGroups.length > 0
+    ? `\nExisting tab groups (already created by the user):\n${JSON.stringify(existingGroups, null, 2)}\n`
+    : "";
+
+  const prompt = `You are a tab management assistant. Analyze these browser tabs and respond with ONLY valid JSON (no markdown, no explanation).
+
+Tabs (groupId -1 means ungrouped):
+${JSON.stringify(tabs, null, 2)}
+${existingGroupsSection}
+User settings:
+- Autonomy level: ${settings.autonomyLevel}
+- Tab threshold: ${settings.tabThreshold}
+
+Respond with this exact JSON structure:
+{
+  "categories": [{"name": "string", "tabIds": [numbers]}],
+  "groups": [{"name": "string", "color": "blue|red|yellow|green|pink|purple|cyan|orange|grey", "tabIds": [numbers]}],
+  "closeSuggestions": [{"tabId": number, "reason": "string"}]
+}
+
+Rules:
+- Group related tabs by topic/project
+- Suggest closing tabs that are clearly inactive or duplicated
+- Be ${settings.autonomyLevel === "conservative" ? "very conservative — only suggest obvious duplicates" : settings.autonomyLevel === "aggressive" ? "aggressive — suggest closing anything not recently used" : "balanced — suggest closing old/duplicate tabs"}
+- Use short, descriptive group names
+- Color-code groups logically (dev=blue, social=pink, docs=green, etc.)
+${existingGroups.length > 0 ? `- IMPORTANT: Do NOT create duplicate groups with the same or similar names as existing groups above
+- If ungrouped tabs (groupId: -1) fit an existing group, suggest adding them to that group (use the same group name and color)
+- Only propose a NEW group when no existing group covers the topic` : ""}`;
+
+  const response = await runClaude(prompt);
+  return parseJsonResponse(response);
+}
+
+export async function askClaude(payload) {
+  const { action, query, savedTabs } = payload;
+
+  if (action === "restore") {
+    const prompt = `You are a tab management assistant. The user wants to restore tabs matching this request: "${query}"
+
+Saved tabs:
+${JSON.stringify(savedTabs ?? [], null, 2)}
+
+Respond with ONLY valid JSON:
+{"urls": ["url1", "url2"]}
+
+Return only URLs that match the user's request. If no tabs match, return {"urls": []}.`;
+
+    const response = await runClaude(prompt);
+    return parseJsonResponse(response);
+  }
+
+  // General query
+  const prompt = `You are a tab management assistant. Answer this question concisely: "${query}"
+Respond with ONLY valid JSON: {"answer": "your answer here"}`;
+
+  const response = await runClaude(prompt);
+  return parseJsonResponse(response);
+}

package/host.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+import { stdin, stdout, stderr } from "node:process";
+import { analyzeWithClaude, askClaude } from "./claude-client.js";
+
+// Setup subcommand
+if (process.argv[2] === "setup") {
+  const { setup } = await import("./scripts/setup.js");
+  await setup();
+  process.exit(0);
+}
+
+// Chrome Native Messaging uses length-prefixed messages (4-byte LE header).
+// We use a persistent readable listener to keep the process alive.
+
+let buffer = Buffer.alloc(0);
+
+stdin.on("readable", () => {
+  let chunk;
+  while ((chunk = stdin.read()) !== null) {
+    buffer = Buffer.concat([buffer, chunk]);
+    processBuffer();
+  }
+});
+
+stdin.on("end", () => {
+  stderr.write("Tabclaude Native Host: stdin closed\n");
+  process.exit(0);
+});
+
+function processBuffer() {
+  while (buffer.length >= 4) {
+    const msgLen = buffer.readUInt32LE(0);
+    const MAX_MSG_SIZE = 1024 * 1024; // 1MB
+    if (msgLen > MAX_MSG_SIZE) {
+      stderr.write(`[Tabclaude] Message too large: ${msgLen} bytes\n`);
+      process.exit(1);
+    }
+    if (buffer.length < 4 + msgLen) break;
+
+    const body = buffer.subarray(4, 4 + msgLen).toString("utf-8");
+    buffer = buffer.subarray(4 + msgLen);
+
+    try {
+      const message = JSON.parse(body);
+      handleMessage(message).catch((err) => {
+        stderr.write(`[Tabclaude] Unhandled error: ${err.message}\n`);
+      });
+    } catch (err) {
+      stderr.write(`Parse error: ${err.message}\n`);
+    }
+  }
+}
+
+function sendMessage(message) {
+  const json = JSON.stringify(message);
+  const buf = Buffer.from(json, "utf-8");
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(buf.length, 0);
+  stdout.write(header);
+  stdout.write(buf);
+}
+
+async function handleMessage(message) {
+  try {
+    switch (message.type) {
+      case "ANALYZE_TABS": {
+        const analysis = await analyzeWithClaude(message.payload);
+        sendMessage({ type: "ANALYZE_TABS", success: true, data: analysis });
+        break;
+      }
+      case "ASK_CLAUDE": {
+        const result = await askClaude(message.payload);
+        sendMessage({ type: "ASK_CLAUDE", success: true, data: result });
+        break;
+      }
+      case "PING": {
+        sendMessage({ type: "PING", success: true, data: { pong: true } });
+        break;
+      }
+      default:
+        sendMessage({
+          type: message.type,
+          success: false,
+          error: `Unknown message type: ${message.type}`,
+        });
+    }
+  } catch (err) {
+    stderr.write(`Error: ${err.message}\n`);
+    sendMessage({
+      type: message.type,
+      success: false,
+      error: err.message,
+    });
+  }
+}
+
+stderr.write("Tabclaude Native Host started\n");

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "tabclaude-host",
+  "version": "0.1.0",
+  "description": "Tabclaude Native Messaging Host with Claude CLI integration",
+  "author": "Brady",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "tabclaude-host": "host.js"
+  },
+  "files": [
+    "host.js",
+    "claude-client.js",
+    "scripts/"
+  ],
+  "scripts": {
+    "build": "echo 'No build needed for native host'",
+    "dev": "node host.js",
+    "postinstall": "node scripts/register.js",
+    "preuninstall": "node scripts/unregister.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "chrome-extension",
+    "native-messaging",
+    "claude",
+    "tabclaude",
+    "tab-manager"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sanghun0724/tabclaude.git"
+  },
+  "dependencies": {}
+}

package/scripts/register.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+console.log(
+  "\n[tabclaude-host] Installed successfully!\n" +
+  "To complete setup, run:\n" +
+  "  tabclaude-host setup <your-extension-id>\n\n" +
+  "Find your extension ID at chrome://extensions (Developer mode on).\n"
+);

package/scripts/setup.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+
+import { writeFileSync, mkdirSync, chmodSync, existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { platform, homedir } from "node:os";
+import { execSync } from "node:child_process";
+
+const HOST_NAME = "com.tabclaude.host";
+
+function findClaude() {
+  // 1. which claude
+  try {
+    const p = execSync("which claude", { encoding: "utf-8" }).trim();
+    if (p) return p;
+  } catch {}
+
+  // 2. sibling of node
+  const sibling = join(dirname(process.execPath), "claude");
+  if (existsSync(sibling)) return sibling;
+
+  // 3. /usr/local/bin/claude
+  if (existsSync("/usr/local/bin/claude")) return "/usr/local/bin/claude";
+
+  // 4. /opt/homebrew/bin/claude
+  if (existsSync("/opt/homebrew/bin/claude")) return "/opt/homebrew/bin/claude";
+
+  // 5. fallback
+  console.warn(
+    `[${HOST_NAME}] WARNING: Claude CLI not found. Install it and ensure it's in PATH.`
+  );
+  return "claude";
+}
+
+function getManifestDir() {
+  const os = platform();
+  const home = homedir();
+
+  if (os === "darwin") {
+    return join(home, "Library", "Application Support", "Google", "Chrome", "NativeMessagingHosts");
+  }
+  if (os === "linux") {
+    return join(home, ".config", "google-chrome", "NativeMessagingHosts");
+  }
+  return null;
+}
+
+export async function setup() {
+  // argv[3] when called via "host.js setup <id>", argv[2] when called directly
+  const extensionId = process.argv[2] === "setup" ? process.argv[3] : process.argv[2];
+
+  if (!extensionId) {
+    console.log(
+      `\nUsage: tabclaude-host setup <extension-id>\n\n` +
+      `  <extension-id>  Your Chrome extension ID (32 lowercase letters).\n` +
+      `                  Find it at chrome://extensions (Developer mode on).\n`
+    );
+    return;
+  }
+
+  if (!/^[a-z]{32}$/.test(extensionId)) {
+    console.error(
+      `[${HOST_NAME}] Invalid extension ID: "${extensionId}"\n` +
+      `  Must be exactly 32 lowercase letters (a-z).`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const manifestDir = getManifestDir();
+  if (!manifestDir) {
+    console.error(
+      `[${HOST_NAME}] Unsupported platform: ${platform()}.\n` +
+      `  Only macOS and Linux are supported for automatic setup.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const hostDir = resolve(__dirname, "..");
+  const hostScript = resolve(hostDir, "host.js");
+  const wrapperPath = resolve(hostDir, "run-host.sh");
+
+  const nodePath = process.execPath;
+  const claudePath = findClaude();
+
+  // Generate run-host.sh
+  const wrapperContent =
+    `#!/bin/bash\n` +
+    `DIR="$(cd "$(dirname "$0")" && pwd)"\n` +
+    `NODE="${nodePath}"\n` +
+    `if [ ! -x "$NODE" ]; then NODE=$(which node 2>/dev/null || echo node); fi\n` +
+    `export CLAUDE_PATH="${claudePath}"\n` +
+    `exec "$NODE" "$DIR/host.js" 2>>/tmp/tabclaude-host.log\n`;
+
+  writeFileSync(wrapperPath, wrapperContent, "utf-8");
+  chmodSync(wrapperPath, 0o755);
+
+  // Write Chrome NMH manifest
+  const manifest = {
+    name: HOST_NAME,
+    description: "Tabclaude — AI Tab Manager Native Messaging Host",
+    path: wrapperPath,
+    type: "stdio",
+    allowed_origins: [`chrome-extension://${extensionId}/`],
+  };
+
+  mkdirSync(manifestDir, { recursive: true });
+  const manifestPath = join(manifestDir, `${HOST_NAME}.json`);
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+
+  const claudeDisplay =
+    claudePath === "claude"
+      ? "claude (not found — install Claude CLI)"
+      : claudePath;
+
+  console.log(
+    `\n[${HOST_NAME}] Setup complete!\n` +
+    `  Extension ID: ${extensionId}\n` +
+    `  Manifest:     ${manifestPath}\n` +
+    `  Wrapper:      ${wrapperPath}\n` +
+    `  Node:         ${nodePath}\n` +
+    `  Claude:       ${claudeDisplay}\n\n` +
+    `Restart Chrome and your extension should connect.\n`
+  );
+}
+
+// Run only when invoked directly (not imported from host.js)
+const __setupFile = fileURLToPath(import.meta.url);
+if (process.argv[1] === __setupFile || process.argv[1]?.endsWith("/scripts/setup.js")) {
+  setup().catch((err) => {
+    console.error(`[${HOST_NAME}] Setup failed: ${err.message}`);
+    process.exitCode = 1;
+  });
+}

package/scripts/unregister.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { platform, homedir } from "node:os";
+
+const HOST_NAME = "com.tabclaude.host";
+
+function getManifestDir() {
+  const os = platform();
+  const home = homedir();
+
+  if (os === "darwin") {
+    return join(home, "Library", "Application Support", "Google", "Chrome", "NativeMessagingHosts");
+  }
+  if (os === "linux") {
+    return join(home, ".config", "google-chrome", "NativeMessagingHosts");
+  }
+
+  return null;
+}
+
+async function unregister() {
+  const manifestDir = getManifestDir();
+
+  if (manifestDir === null) {
+    if (platform() === "win32") {
+      console.log(
+        `[${HOST_NAME}] Windows detected — remove the registry key manually:\n` +
+        `  HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${HOST_NAME}`
+      );
+    }
+    return;
+  }
+
+  const manifestPath = join(manifestDir, `${HOST_NAME}.json`);
+
+  try {
+    await unlink(manifestPath);
+    console.log(`[${HOST_NAME}] Native messaging host unregistered.`);
+    console.log(`  Removed: ${manifestPath}`);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      console.log(`[${HOST_NAME}] Manifest not found — nothing to remove.`);
+    } else {
+      console.error(`[${HOST_NAME}] Failed to remove manifest: ${err.message}`);
+    }
+  }
+}
+
+unregister().catch((err) => {
+  console.error(`[${HOST_NAME}] Unregistration failed: ${err.message}`);
+  process.exitCode = 1;
+});