@byoky/bridge 0.2.0 → 0.3.0

package/bin/byoky-bridge.js

@@ -8,7 +8,12 @@ if (command === 'install' || command === 'uninstall' || command === 'status') {
 
   console.log('Byoky Bridge\n');
 
-  if (command === 'install') install();
+  if (command === 'install') {
+    // --extension-id <id> for custom/unpacked extension IDs
+    const idIdx = process.argv.indexOf('--extension-id');
+    const extensionId = idIdx !== -1 ? process.argv[idIdx + 1] : undefined;
+    install(extensionId);
+  }
   else if (command === 'uninstall') uninstall();
   else if (command === 'status') status();
 } else if (!command || command === 'host') {

package/dist/host.js

@@ -1,231 +1,144 @@
-// 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}]`);
+// src/proxy-server.ts
+import { createServer } from "http";
+var MAX_PENDING_REQUESTS = 100;
+var pendingRequests = /* @__PURE__ */ new Map();
+function handleProxyResponse(msg) {
+  if (msg.type === "proxy_http_response") {
+    const pending = pendingRequests.get(msg.requestId);
+    if (pending) {
+      pending.resolve(msg);
+      pendingRequests.delete(msg.requestId);
+    }
+  } else if (msg.type === "proxy_http_error") {
+    const pending = pendingRequests.get(msg.requestId);
+    if (pending) {
+      pending.reject(new Error(msg.error));
+      pendingRequests.delete(msg.requestId);
     }
   }
-  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 {
-      }
+function startProxyServer(config) {
+  const { port, sessionKey, providers, sendToExtension } = config;
+  const server = createServer(async (req, res) => {
+    const host = req.headers.host || "";
+    const hostWithoutPort = host.split(":")[0];
+    if (hostWithoutPort !== "127.0.0.1" && hostWithoutPort !== "localhost") {
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Forbidden: invalid Host header" }));
+      return;
     }
-  }
-  if (buffer.trim()) {
-    try {
-      yield JSON.parse(buffer.trim());
-    } catch {
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
     }
-  }
-}
-
-// 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;
-        }
-      }
+    if (req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", providers }));
+      return;
     }
-  } 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 match = req.url?.match(/^\/([^/]+)(\/.*)?$/);
+    if (!match) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Unknown route. Use /<providerId>/..." }));
+      return;
+    }
+    const providerId = match[1];
+    const path = match[2] || "/";
+    if (!providers.includes(providerId)) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: `Provider "${providerId}" not available in this session` }));
+      return;
+    }
+    const body = await readBody(req);
+    const providerUrls = {
+      anthropic: "https://api.anthropic.com",
+      openai: "https://api.openai.com",
+      gemini: "https://generativelanguage.googleapis.com",
+      mistral: "https://api.mistral.ai",
+      cohere: "https://api.cohere.com",
+      xai: "https://api.x.ai",
+      deepseek: "https://api.deepseek.com",
+      perplexity: "https://api.perplexity.ai",
+      groq: "https://api.groq.com",
+      together: "https://api.together.xyz",
+      fireworks: "https://api.fireworks.ai",
+      replicate: "https://api.replicate.com",
+      openrouter: "https://openrouter.ai/api",
+      huggingface: "https://api-inference.huggingface.co",
+      azure_openai: "https://YOUR_RESOURCE.openai.azure.com"
     };
-  }
-  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 baseUrl = providerUrls[providerId];
+    if (!baseUrl) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: `Unknown provider base URL for "${providerId}"` }));
+      return;
+    }
+    const realUrl = `${baseUrl}${path}`;
+    const requestId = `proxy-${crypto.randomUUID()}`;
+    const headers = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+      if (key === "host" || key === "connection") continue;
+      if (typeof value === "string") headers[key] = value;
+    }
+    const proxyMsg = {
+      type: "proxy_http",
+      requestId,
+      sessionKey,
+      providerId,
+      url: realUrl,
+      method: req.method || "GET",
+      headers,
+      body: body || void 0
     };
-  }
-  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 }
+    if (pendingRequests.size >= MAX_PENDING_REQUESTS) {
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Too many concurrent requests" }));
+      return;
     }
-  };
-  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)}
-
-`;
+    try {
+      const response = await new Promise((resolve, reject) => {
+        pendingRequests.set(requestId, { resolve, reject });
+        setTimeout(() => {
+          if (pendingRequests.has(requestId)) {
+            pendingRequests.delete(requestId);
+            reject(new Error("Request timed out"));
+          }
+        }, 12e4);
+        sendToExtension(proxyMsg);
+      });
+      const responseHeaders = { ...response.headers };
+      delete responseHeaders["transfer-encoding"];
+      res.writeHead(response.status, responseHeaders);
+      res.end(response.body);
+    } catch (err) {
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+  });
+  server.listen(port, "127.0.0.1", () => {
+    process.stderr.write(`Byoky proxy listening on http://127.0.0.1:${port}
+`);
+  });
+  return server;
 }
-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)}
-
-`;
+var MAX_BODY_SIZE = 10 * 1024 * 1024;
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_SIZE) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      body += chunk.toString();
+    });
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
 }
 
 // src/host.ts
@@ -250,9 +163,13 @@ function readMessage() {
         resolve(null);
         return;
       }
-      readBody(msgLength);
+      if (msgLength > 1048576) {
+        reject(new Error(`Message too large: ${msgLength} bytes (max 1MB)`));
+        return;
+      }
+      readBody2(msgLength);
     }
-    function readBody(length) {
+    function readBody2(length) {
       let body = Buffer.alloc(0);
       function readChunk() {
         const chunk = process.stdin.read(length - body.length);
@@ -294,20 +211,37 @@ async function handleMessage(msg) {
   }
   if (message.type === "proxy") {
     const req = msg;
-    await handleProxy(req);
+    await handleSetupTokenProxy(req);
+    return;
+  }
+  if (message.type === "start-proxy") {
+    const req = msg;
+    handleStartProxy(req);
+    return;
+  }
+  if (message.type === "proxy_http_response" || message.type === "proxy_http_error") {
+    handleProxyResponse(msg);
     return;
   }
 }
-async function handleProxy(req) {
+async function handleSetupTokenProxy(req) {
   try {
-    const apiRequest = JSON.parse(req.body);
-    const result = await translateRequest(apiRequest, req.setupToken);
+    const res = await fetch(req.url, {
+      method: req.method,
+      headers: req.headers,
+      body: req.body || void 0
+    });
+    const body = await res.text();
+    const headers = {};
+    res.headers.forEach((v, k) => {
+      headers[k] = v;
+    });
     writeMessage({
       type: "proxy_response",
       requestId: req.requestId,
-      status: result.status,
-      headers: result.headers,
-      body: result.body
+      status: res.status,
+      headers,
+      body
     });
   } catch (e) {
     writeMessage({
@@ -317,6 +251,26 @@ async function handleProxy(req) {
     });
   }
 }
+function handleStartProxy(req) {
+  try {
+    startProxyServer({
+      port: req.port,
+      sessionKey: req.sessionKey,
+      providers: req.providers,
+      sendToExtension: (msg) => writeMessage(msg)
+    });
+    writeMessage({
+      type: "proxy-started",
+      port: req.port
+    });
+  } catch (e) {
+    writeMessage({
+      type: "proxy_error",
+      requestId: "start-proxy",
+      error: e.message
+    });
+  }
+}
 async function main() {
   process.stdin.resume();
   while (true) {

package/dist/installer.d.ts

@@ -6,7 +6,7 @@
  *   byoky-bridge uninstall  — remove registrations
  *   byoky-bridge status     — check if registered
  */
-declare function install(): void;
+declare function install(extensionId?: string): void;
 declare function uninstall(): void;
 declare function status(): void;
 

package/dist/installer.js

@@ -1,5 +1,5 @@
 // src/installer.ts
-import { writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs";
+import { writeFileSync, mkdirSync, unlinkSync, existsSync, chmodSync } from "fs";
 import { dirname, resolve } from "path";
 import { homedir, platform } from "os";
 import { execSync } from "child_process";
@@ -11,7 +11,20 @@ function getHostPath() {
     return resolve(dirname(new URL(import.meta.url).pathname), "../bin/byoky-bridge.js");
   }
 }
-function buildManifest(hostPath, browserType) {
+function createNativeWrapper(hostPath, manifestDir) {
+  const nodePath = process.execPath;
+  const wrapperPath = resolve(manifestDir, "byoky-bridge-host");
+  const userPath = process.env.PATH || "";
+  const script = `#!/bin/bash
+export PATH="${userPath}"
+exec "${nodePath}" "${hostPath}" host "$@"
+`;
+  writeFileSync(wrapperPath, script);
+  chmodSync(wrapperPath, 493);
+  return wrapperPath;
+}
+var DEFAULT_EXTENSION_ID = "ahhecmfcclkjdgjnmackoacldnmgmipl";
+function buildManifest(hostPath, browserType, extensionId) {
   const base = {
     name: HOST_NAME,
     description: "Byoky Bridge \u2014 routes setup token requests through Claude Code CLI",
@@ -19,11 +32,11 @@ function buildManifest(hostPath, browserType) {
     type: "stdio"
   };
   if (browserType === "chrome") {
+    const id = extensionId || DEFAULT_EXTENSION_ID;
     return {
       ...base,
       allowed_origins: [
-        // Chrome uses extension IDs — we allow all since the ID varies per install
-        "chrome-extension://*/"
+        `chrome-extension://${id}/`
       ]
     };
   }
@@ -95,7 +108,7 @@ function getManifestLocations() {
   }
   return [];
 }
-function install() {
+function install(extensionId) {
   const hostPath = getHostPath();
   const locations = getManifestLocations();
   if (locations.length === 0) {
@@ -105,8 +118,10 @@ function install() {
   let installed = 0;
   for (const loc of locations) {
     try {
-      const manifest = buildManifest(hostPath, loc.type);
-      mkdirSync(dirname(loc.path), { recursive: true });
+      const manifestDir = dirname(loc.path);
+      mkdirSync(manifestDir, { recursive: true });
+      const wrapperPath = createNativeWrapper(hostPath, manifestDir);
+      const manifest = buildManifest(wrapperPath, loc.type, extensionId);
       writeFileSync(loc.path, JSON.stringify(manifest, null, 2));
       console.log(`  Registered with ${loc.browser}`);
       installed++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byoky/bridge",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Native messaging bridge for Byoky — routes setup token requests through Claude Code CLI",
   "type": "module",
   "main": "dist/host.js",