@byoky/bridge 0.2.0

package/bin/byoky-bridge.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+const command = process.argv[2];
+
+if (command === 'install' || command === 'uninstall' || command === 'status') {
+  // CLI mode: manage native messaging registration
+  const { install, uninstall, status } = await import('../dist/installer.js');
+
+  console.log('Byoky Bridge\n');
+
+  if (command === 'install') install();
+  else if (command === 'uninstall') uninstall();
+  else if (command === 'status') status();
+} else if (!command || command === 'host') {
+  // Native messaging host mode (called by browser)
+  await import('../dist/host.js');
+} else {
+  console.log(`Usage: byoky-bridge <command>
+
+Commands:
+  install     Register native messaging host with browsers
+  uninstall   Remove native messaging registration
+  status      Check registration status
+
+The bridge runs automatically when called by the Byoky extension.`);
+}

package/dist/host.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/host.js

@@ -0,0 +1,333 @@
+// src/claude-runner.ts
+import { spawn } from "child_process";
+function runClaude(request, setupToken) {
+  const prompt = formatMessagesAsPrompt(request);
+  const args = ["-p", "--output-format", "stream-json"];
+  if (request.max_tokens) {
+    args.push("--max-tokens", String(request.max_tokens));
+  }
+  if (request.model) {
+    args.push("--model", request.model);
+  }
+  const proc = spawn("claude", args, {
+    env: {
+      ...process.env,
+      ANTHROPIC_AUTH_TOKEN: setupToken
+    },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  proc.stdin.write(prompt);
+  proc.stdin.end();
+  const output = streamEvents(proc);
+  return { process: proc, output };
+}
+function formatMessagesAsPrompt(request) {
+  const parts = [];
+  if (request.system) {
+    parts.push(`[System: ${request.system}]`);
+  }
+  for (const msg of request.messages) {
+    if (msg.role === "user") {
+      parts.push(msg.content);
+    } else if (msg.role === "assistant") {
+      parts.push(`[Previous assistant response: ${msg.content}]`);
+    }
+  }
+  return parts.join("\n\n");
+}
+async function* streamEvents(proc) {
+  if (!proc.stdout) return;
+  let buffer = "";
+  for await (const chunk of proc.stdout) {
+    buffer += chunk.toString();
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        yield JSON.parse(trimmed);
+      } catch {
+      }
+    }
+  }
+  if (buffer.trim()) {
+    try {
+      yield JSON.parse(buffer.trim());
+    } catch {
+    }
+  }
+}
+
+// src/translator.ts
+async function translateRequest(request, setupToken) {
+  const messages = request.messages.map((m) => ({
+    role: m.role,
+    content: typeof m.content === "string" ? m.content : m.content.filter((c) => c.type === "text").map((c) => c.text).join("\n")
+  }));
+  let system;
+  if (typeof request.system === "string") {
+    system = request.system;
+  } else if (Array.isArray(request.system)) {
+    system = request.system.map((s) => s.text).join("\n");
+  }
+  const claudeRequest = {
+    model: request.model,
+    messages,
+    max_tokens: request.max_tokens,
+    system
+  };
+  const { process: proc, output } = runClaude(claudeRequest, setupToken);
+  let fullText = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  const streamChunks = [];
+  try {
+    for await (const event of output) {
+      if (event.type === "assistant" && event.content) {
+        fullText += event.content;
+        if (request.stream) {
+          streamChunks.push(
+            buildStreamChunk(event.content, request.model)
+          );
+        }
+      }
+      if (event.type === "result") {
+        if (event.result && !fullText) {
+          fullText = event.result;
+        }
+        if (event.tokens) {
+          inputTokens = event.tokens.input;
+          outputTokens = event.tokens.output;
+        }
+      }
+    }
+  } catch {
+  }
+  await new Promise((resolve) => {
+    proc.on("close", () => resolve());
+    if (proc.exitCode !== null) resolve();
+  });
+  if (!fullText && proc.exitCode !== 0) {
+    return {
+      status: 500,
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        type: "error",
+        error: {
+          type: "api_error",
+          message: "Claude Code process failed. Is Claude Code installed and is the setup token valid?"
+        }
+      }),
+      isStream: false
+    };
+  }
+  const responseId = `msg_byoky_${Date.now().toString(36)}`;
+  if (request.stream) {
+    streamChunks.push(
+      buildStreamMessageStart(responseId, request.model)
+    );
+    streamChunks.push(
+      buildStreamContentDelta(fullText)
+    );
+    streamChunks.push(
+      buildStreamMessageDelta(inputTokens, outputTokens)
+    );
+    streamChunks.push('event: message_stop\ndata: {"type":"message_stop"}\n\n');
+    return {
+      status: 200,
+      headers: {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache"
+      },
+      body: streamChunks.join(""),
+      isStream: true,
+      streamChunks
+    };
+  }
+  const response = {
+    id: responseId,
+    type: "message",
+    role: "assistant",
+    content: [{ type: "text", text: fullText }],
+    model: request.model,
+    stop_reason: "end_turn",
+    usage: { input_tokens: inputTokens, output_tokens: outputTokens }
+  };
+  return {
+    status: 200,
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(response),
+    isStream: false
+  };
+}
+function buildStreamChunk(text, _model) {
+  const data = {
+    type: "content_block_delta",
+    index: 0,
+    delta: { type: "text_delta", text }
+  };
+  return `event: content_block_delta
+data: ${JSON.stringify(data)}
+
+`;
+}
+function buildStreamMessageStart(id, model) {
+  const data = {
+    type: "message_start",
+    message: {
+      id,
+      type: "message",
+      role: "assistant",
+      content: [],
+      model,
+      stop_reason: null,
+      usage: { input_tokens: 0, output_tokens: 0 }
+    }
+  };
+  return `event: message_start
+data: ${JSON.stringify(data)}
+
+`;
+}
+function buildStreamContentDelta(text) {
+  const start = {
+    type: "content_block_start",
+    index: 0,
+    content_block: { type: "text", text: "" }
+  };
+  const delta = {
+    type: "content_block_delta",
+    index: 0,
+    delta: { type: "text_delta", text }
+  };
+  const stop = {
+    type: "content_block_stop",
+    index: 0
+  };
+  return `event: content_block_start
+data: ${JSON.stringify(start)}
+
+event: content_block_delta
+data: ${JSON.stringify(delta)}
+
+event: content_block_stop
+data: ${JSON.stringify(stop)}
+
+`;
+}
+function buildStreamMessageDelta(inputTokens, outputTokens) {
+  const data = {
+    type: "message_delta",
+    delta: { stop_reason: "end_turn" },
+    usage: { input_tokens: inputTokens, output_tokens: outputTokens }
+  };
+  return `event: message_delta
+data: ${JSON.stringify(data)}
+
+`;
+}
+
+// src/host.ts
+function readMessage() {
+  return new Promise((resolve, reject) => {
+    const lengthBuf = Buffer.alloc(4);
+    let bytesRead = 0;
+    function readLength() {
+      const chunk = process.stdin.read(4 - bytesRead);
+      if (!chunk) {
+        process.stdin.once("readable", readLength);
+        return;
+      }
+      chunk.copy(lengthBuf, bytesRead);
+      bytesRead += chunk.length;
+      if (bytesRead < 4) {
+        process.stdin.once("readable", readLength);
+        return;
+      }
+      const msgLength = lengthBuf.readUInt32LE(0);
+      if (msgLength === 0) {
+        resolve(null);
+        return;
+      }
+      readBody(msgLength);
+    }
+    function readBody(length) {
+      let body = Buffer.alloc(0);
+      function readChunk() {
+        const chunk = process.stdin.read(length - body.length);
+        if (!chunk) {
+          process.stdin.once("readable", readChunk);
+          return;
+        }
+        body = Buffer.concat([body, chunk]);
+        if (body.length < length) {
+          process.stdin.once("readable", readChunk);
+          return;
+        }
+        try {
+          resolve(JSON.parse(body.toString("utf-8")));
+        } catch (e) {
+          reject(new Error(`Invalid JSON: ${e.message}`));
+        }
+      }
+      readChunk();
+    }
+    process.stdin.once("readable", readLength);
+    process.stdin.on("end", () => resolve(null));
+  });
+}
+function writeMessage(msg) {
+  const json = JSON.stringify(msg);
+  const buf = Buffer.from(json, "utf-8");
+  const lengthBuf = Buffer.alloc(4);
+  lengthBuf.writeUInt32LE(buf.length, 0);
+  process.stdout.write(lengthBuf);
+  process.stdout.write(buf);
+}
+async function handleMessage(msg) {
+  if (!msg || typeof msg !== "object") return;
+  const message = msg;
+  if (message.type === "ping") {
+    writeMessage({ type: "pong", version: "0.2.0" });
+    return;
+  }
+  if (message.type === "proxy") {
+    const req = msg;
+    await handleProxy(req);
+    return;
+  }
+}
+async function handleProxy(req) {
+  try {
+    const apiRequest = JSON.parse(req.body);
+    const result = await translateRequest(apiRequest, req.setupToken);
+    writeMessage({
+      type: "proxy_response",
+      requestId: req.requestId,
+      status: result.status,
+      headers: result.headers,
+      body: result.body
+    });
+  } catch (e) {
+    writeMessage({
+      type: "proxy_error",
+      requestId: req.requestId,
+      error: e.message
+    });
+  }
+}
+async function main() {
+  process.stdin.resume();
+  while (true) {
+    const msg = await readMessage();
+    if (msg === null) break;
+    await handleMessage(msg);
+  }
+  process.exit(0);
+}
+main().catch((e) => {
+  process.stderr.write(`byoky-bridge fatal: ${e.message}
+`);
+  process.exit(1);
+});

package/dist/installer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Installs/uninstalls the native messaging host manifest for each browser.
+ *
+ * Usage:
+ *   byoky-bridge install    — register with Chrome, Firefox, and Safari
+ *   byoky-bridge uninstall  — remove registrations
+ *   byoky-bridge status     — check if registered
+ */
+declare function install(): void;
+declare function uninstall(): void;
+declare function status(): void;
+
+export { install, status, uninstall };

package/dist/installer.js

@@ -0,0 +1,149 @@
+// src/installer.ts
+import { writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { homedir, platform } from "os";
+import { execSync } from "child_process";
+var HOST_NAME = "com.byoky.bridge";
+function getHostPath() {
+  try {
+    return execSync("which byoky-bridge", { encoding: "utf-8" }).trim();
+  } catch {
+    return resolve(dirname(new URL(import.meta.url).pathname), "../bin/byoky-bridge.js");
+  }
+}
+function buildManifest(hostPath, browserType) {
+  const base = {
+    name: HOST_NAME,
+    description: "Byoky Bridge \u2014 routes setup token requests through Claude Code CLI",
+    path: hostPath,
+    type: "stdio"
+  };
+  if (browserType === "chrome") {
+    return {
+      ...base,
+      allowed_origins: [
+        // Chrome uses extension IDs — we allow all since the ID varies per install
+        "chrome-extension://*/"
+      ]
+    };
+  }
+  return {
+    ...base,
+    allowed_extensions: ["byoky@byoky.com"]
+  };
+}
+function getManifestLocations() {
+  const home = homedir();
+  const os = platform();
+  if (os === "darwin") {
+    return [
+      {
+        browser: "Chrome",
+        path: `${home}/Library/Application Support/Google/Chrome/NativeMessagingHosts/${HOST_NAME}.json`,
+        type: "chrome"
+      },
+      {
+        browser: "Chromium",
+        path: `${home}/Library/Application Support/Chromium/NativeMessagingHosts/${HOST_NAME}.json`,
+        type: "chrome"
+      },
+      {
+        browser: "Brave",
+        path: `${home}/Library/Application Support/BraveSoftware/Brave-Browser/NativeMessagingHosts/${HOST_NAME}.json`,
+        type: "chrome"
+      },
+      {
+        browser: "Firefox",
+        path: `${home}/Library/Application Support/Mozilla/NativeMessagingHosts/${HOST_NAME}.json`,
+        type: "firefox"
+      }
+    ];
+  }
+  if (os === "linux") {
+    return [
+      {
+        browser: "Chrome",
+        path: `${home}/.config/google-chrome/NativeMessagingHosts/${HOST_NAME}.json`,
+        type: "chrome"
+      },
+      {
+        browser: "Chromium",
+        path: `${home}/.config/chromium/NativeMessagingHosts/${HOST_NAME}.json`,
+        type: "chrome"
+      },
+      {
+        browser: "Firefox",
+        path: `${home}/.mozilla/native-messaging-hosts/${HOST_NAME}.json`,
+        type: "firefox"
+      }
+    ];
+  }
+  if (os === "win32") {
+    const appData = process.env.LOCALAPPDATA || `${home}/AppData/Local`;
+    return [
+      {
+        browser: "Chrome",
+        path: `${appData}/Google/Chrome/User Data/NativeMessagingHosts/${HOST_NAME}.json`,
+        type: "chrome"
+      },
+      {
+        browser: "Firefox",
+        path: `${appData}/Mozilla/NativeMessagingHosts/${HOST_NAME}.json`,
+        type: "firefox"
+      }
+    ];
+  }
+  return [];
+}
+function install() {
+  const hostPath = getHostPath();
+  const locations = getManifestLocations();
+  if (locations.length === 0) {
+    console.error("Unsupported platform");
+    process.exit(1);
+  }
+  let installed = 0;
+  for (const loc of locations) {
+    try {
+      const manifest = buildManifest(hostPath, loc.type);
+      mkdirSync(dirname(loc.path), { recursive: true });
+      writeFileSync(loc.path, JSON.stringify(manifest, null, 2));
+      console.log(`  Registered with ${loc.browser}`);
+      installed++;
+    } catch {
+    }
+  }
+  if (installed > 0) {
+    console.log(`
+Byoky Bridge installed for ${installed} browser(s).`);
+    console.log("Restart your browser for changes to take effect.");
+  } else {
+    console.error("No supported browsers found.");
+  }
+}
+function uninstall() {
+  const locations = getManifestLocations();
+  for (const loc of locations) {
+    try {
+      if (existsSync(loc.path)) {
+        unlinkSync(loc.path);
+        console.log(`  Removed from ${loc.browser}`);
+      }
+    } catch {
+    }
+  }
+  console.log("\nByoky Bridge uninstalled.");
+}
+function status() {
+  const locations = getManifestLocations();
+  for (const loc of locations) {
+    const exists = existsSync(loc.path);
+    const icon = exists ? "\u2713" : "\u2717";
+    console.log(`  ${icon} ${loc.browser}: ${exists ? "registered" : "not registered"}`);
+  }
+}
+export {
+  install,
+  status,
+  uninstall
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@byoky/bridge",
+  "version": "0.2.0",
+  "description": "Native messaging bridge for Byoky — routes setup token requests through Claude Code CLI",
+  "type": "module",
+  "main": "dist/host.js",
+  "bin": {
+    "byoky-bridge": "./bin/byoky-bridge.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "keywords": [
+    "byoky",
+    "claude",
+    "native-messaging",
+    "bridge"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MichaelLod/byoky.git",
+    "directory": "packages/bridge"
+  },
+  "devDependencies": {
+    "@types/node": "25.5.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  }
+}