@elvatis_com/openclaw-cli-bridge-elvatis 1.7.5 → 1.8.1

package/README.md

@@ -2,7 +2,7 @@
 
 > OpenClaw plugin that bridges locally installed AI CLIs (Codex, Gemini, Claude Code) as model providers — with slash commands for instant model switching, restore, health testing, and model listing.
 
-**Current version:** `1.7.5`
+**Current version:** `1.8.1`
 
 ---
 
@@ -57,6 +57,12 @@ All commands use gateway-level `commands.allowFrom` for authorization (`requireA
 | `/cli-codex54` | `openai-codex/gpt-5.4` | May require upgraded OAuth scope |
 | `/cli-codex-mini` | `openai-codex/gpt-5.1-codex-mini` | ✅ Tested |
 
+**BitNet local inference** (via local proxy → llama-server on 127.0.0.1:8082, no API key):
+
+| Command | Model |
+|---|---|
+| `/cli-bitnet` | `vllm/local-bitnet/bitnet-2b` |
+
 **Utility:**
 
 | Command | What it does |
@@ -362,6 +368,13 @@ npm test            # vitest run (83 tests)
 
 ## Changelog
 
+### v1.8.1
+- **fix:** `--now` flag now works when followed by additional text (e.g. `/cli-bitnet --now hello`) — was using `===` instead of `startsWith`.
+
+### v1.8.0
+- **feat:** BitNet local inference — `local-bitnet/bitnet-2b` routes to llama-server on 127.0.0.1:8082. No API key, no internet, pure CPU inference (2.87 tok/s on i7-6700K). Use `/cli-bitnet` to switch.
+- **feat:** `/bridge-status` shows BitNet server health as 5th provider.
+
 ### v1.7.5
 - **chore:** Re-published to ClawHub with correct display name "OpenClaw CLI Bridge"
 

package/SKILL.md

@@ -24,6 +24,7 @@ Registers `openai-codex` provider from existing `~/.codex/auth.json` tokens. No
 Local OpenAI-compatible HTTP proxy (`127.0.0.1:31337`) routes vllm model calls to CLI subprocesses:
 - `vllm/cli-gemini/gemini-2.5-pro` / `gemini-2.5-flash` / `gemini-3-pro`
 - `vllm/cli-claude/claude-sonnet-4-6` / `claude-opus-4-6` / `claude-haiku-4-5`
+- `vllm/local-bitnet/bitnet-2b` → BitNet llama-server on 127.0.0.1:8082
 
 Prompts go via stdin/tmpfile — never as CLI args (prevents `E2BIG` for long sessions).
 
@@ -40,6 +41,7 @@ Six instant model-switch commands (authorized senders only):
 | `/cli-gemini3` | `vllm/cli-gemini/gemini-3-pro` |
 | `/cli-codex` | `openai-codex/gpt-5.3-codex` |
 | `/cli-codex54` | `openai-codex/gpt-5.4` |
+| `/cli-bitnet` | `vllm/local-bitnet/bitnet-2b` |
 | `/cli-back` | Restore previous model |
 | `/cli-test [model]` | Health check (no model switch) |
 
@@ -66,4 +68,4 @@ On gateway restart, if any session has expired, a **WhatsApp alert** is sent aut
 
 See `README.md` for full configuration reference and architecture diagram.
 
-**Version:** 1.7.5
+**Version:** 1.8.1

package/index.ts

@@ -705,6 +705,25 @@ function readCurrentModel(): string | null {
   }
 }
 
+// ──────────────────────────────────────────────────────────────────────────────
+// BitNet server health check
+// ──────────────────────────────────────────────────────────────────────────────
+async function checkBitNetServer(url = "http://127.0.0.1:8082"): Promise<boolean> {
+  return new Promise((resolve) => {
+    const target = new URL("/v1/models", url);
+    const req = http.get(
+      { hostname: target.hostname, port: parseInt(target.port), path: target.pathname, timeout: 3_000 },
+      (res) => {
+        let data = "";
+        res.on("data", (c: Buffer) => (data += c));
+        res.on("end", () => resolve(res.statusCode === 200));
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => { req.destroy(); resolve(false); });
+  });
+}
+
 // ──────────────────────────────────────────────────────────────────────────────
 // Phase 3: model command table
 // ──────────────────────────────────────────────────────────────────────────────
@@ -720,6 +739,8 @@ const CLI_MODEL_COMMANDS = [
   // ── Codex CLI (openai-codex provider, OAuth auth) ────────────────────────────
   { name: "cli-codex",        model: "openai-codex/gpt-5.3-codex",          description: "GPT-5.3 Codex (Codex CLI auth)",        label: "GPT-5.3 Codex" },
   { name: "cli-codex54",      model: "openai-codex/gpt-5.4",                description: "GPT-5.4 (Codex CLI auth)",              label: "GPT-5.4" },
+  // ── BitNet local inference (via local proxy → llama-server) ─────────────────
+  { name: "cli-bitnet",       model: "vllm/local-bitnet/bitnet-2b",         description: "BitNet b1.58 2B (local CPU, no API key)", label: "BitNet 2B (local)" },
 ] as const;
 
 /** Default model used by /cli-test when no arg is given */
@@ -918,7 +939,7 @@ function proxyTestRequest(
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "1.7.5",
+  version: "1.8.1",
   description:
     "Phase 1: openai-codex auth bridge. " +
     "Phase 2: HTTP proxy for gemini/claude CLIs. " +
@@ -1387,7 +1408,7 @@ const plugin = {
         acceptsArgs: true,
         requireAuth: false,
         handler: async (ctx: PluginCommandContext): Promise<PluginCommandResult> => {
-          const forceNow = (ctx.args ?? "").trim().toLowerCase() === "--now";
+          const forceNow = (ctx.args ?? "").trim().toLowerCase().startsWith("--now");
           api.logger.info(`[cli-bridge] /${name} by ${ctx.senderId ?? "?"} forceNow=${forceNow}`);
           return switchModel(api, model, label, forceNow);
         },
@@ -2152,6 +2173,16 @@ const plugin = {
           lines.push("");
         }
 
+        // ── BitNet local inference ──────────────────────────────────────────────
+        const bitnetOk = await checkBitNetServer();
+        if (bitnetOk) {
+          lines.push(`✅ *BitNet (local)* — running at 127.0.0.1:8082`);
+          lines.push(`   Models: local-bitnet/bitnet-2b`);
+        } else {
+          lines.push(`❌ *BitNet (local)* — not running (\`sudo systemctl start bitnet-server\`)`);
+        }
+        lines.push("");
+
         lines.push(`🔌 Proxy: \`127.0.0.1:${port}\``);
         return { text: lines.join("\n") };
       },

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "1.7.5",
+  "version": "1.8.1",
   "license": "MIT",
   "description": "Phase 1: openai-codex auth bridge. Phase 2: local HTTP proxy routing model calls through gemini/claude CLIs (vllm provider).",
   "providers": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvatis_com/openclaw-cli-bridge-elvatis",
-  "version": "1.7.5",
+  "version": "1.8.1",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {

package/src/proxy-server.ts

@@ -69,6 +69,8 @@ export interface ProxyServerOptions {
   };
   /** Plugin version string for the status page */
   version?: string;
+  /** Returns the BitNet llama-server base URL (default: http://127.0.0.1:8082) */
+  getBitNetServerUrl?: () => string;
 }
 
 /** Available CLI bridge models for GET /v1/models */
@@ -104,6 +106,8 @@ export const CLI_MODELS = [
   { id: "web-chatgpt/o4-mini",          name: "o4-mini (web session)",           contextWindow: 200_000, maxTokens: 100_000 },
   { id: "web-chatgpt/gpt-5",            name: "GPT-5 (web session)",             contextWindow: 1_047_576, maxTokens: 32_768 },
   { id: "web-chatgpt/gpt-5-mini",       name: "GPT-5 Mini (web session)",        contextWindow: 1_047_576, maxTokens: 32_768 },
+  // ── Local BitNet inference ──────────────────────────────────────────────────
+  { id: "local-bitnet/bitnet-2b",       name: "BitNet b1.58 2B (local CPU inference)", contextWindow: 4_096, maxTokens: 2_048 },
 ];
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -206,6 +210,7 @@ async function handleRequest(
 
     const cliModels = CLI_MODELS.filter(m => m.id.startsWith("cli-"));
     const webModels = CLI_MODELS.filter(m => m.id.startsWith("web-"));
+    const localModels = CLI_MODELS.filter(m => m.id.startsWith("local-"));
     const modelList = (models: typeof CLI_MODELS) =>
       models.map(m => `<li style="margin:2px 0;font-size:13px;color:#d1d5db"><code style="color:#93c5fd">${m.id}</code></li>`).join("");
 
@@ -259,6 +264,10 @@ async function handleRequest(
       <div class="card-header">Web Session Models (${webModels.length})</div>
       <ul>${modelList(webModels)}</ul>
     </div>
+    <div class="card">
+      <div class="card-header">Local Models (${localModels.length})</div>
+      <ul>${modelList(localModels)}</ul>
+    </div>
   </div>
 
   <p class="footer">openclaw-cli-bridge-elvatis v${version} &nbsp;·&nbsp; <a href="/v1/models" style="color:#4b5563">/v1/models</a> &nbsp;·&nbsp; <a href="/health" style="color:#4b5563">/health</a></p>
@@ -284,7 +293,7 @@ async function handleRequest(
           owned_by: "openclaw-cli-bridge",
           // CLI-proxy models stream plain text — no tool/function call support
           capabilities: {
-            tools: !(m.id.startsWith("cli-gemini/") || m.id.startsWith("cli-claude/")),
+            tools: !(m.id.startsWith("cli-gemini/") || m.id.startsWith("cli-claude/") || m.id.startsWith("local-bitnet/")),
           },
         })),
       })
@@ -332,7 +341,7 @@ async function handleRequest(
     // CLI-proxy models (cli-gemini/*, cli-claude/*) are plain text completions —
     // they cannot process tool/function call schemas. Return a clear 400 so
     // OpenClaw can surface a meaningful error instead of getting a garbled response.
-    const isCliModel = model.startsWith("cli-gemini/") || model.startsWith("cli-claude/");
+    const isCliModel = model.startsWith("cli-gemini/") || model.startsWith("cli-claude/") || model.startsWith("local-bitnet/");
     if (hasTools && isCliModel) {
       res.writeHead(400, { "Content-Type": "application/json" });
       res.end(JSON.stringify({
@@ -549,6 +558,65 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
+    // ── BitNet local inference routing ────────────────────────────────────────
+    if (model.startsWith("local-bitnet/")) {
+      const bitnetUrl = opts.getBitNetServerUrl?.() ?? "http://127.0.0.1:8082";
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const requestBody = JSON.stringify(parsed);
+
+      try {
+        const targetUrl = new URL("/v1/chat/completions", bitnetUrl);
+        const proxyRes = await new Promise<http.IncomingMessage>((resolve, reject) => {
+          const proxyReq = http.request(
+            {
+              hostname: targetUrl.hostname,
+              port: parseInt(targetUrl.port),
+              path: targetUrl.pathname,
+              method: "POST",
+              headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(requestBody) },
+              timeout: timeoutMs,
+            },
+            resolve
+          );
+          proxyReq.on("error", reject);
+          proxyReq.on("timeout", () => { proxyReq.destroy(new Error("BitNet request timed out")); });
+          proxyReq.write(requestBody);
+          proxyReq.end();
+        });
+
+        // Forward status + headers
+        const fwdHeaders: Record<string, string> = { ...corsHeaders() };
+        const ct = proxyRes.headers["content-type"];
+        if (ct) fwdHeaders["Content-Type"] = ct;
+        if (stream) {
+          fwdHeaders["Cache-Control"] = "no-cache";
+          fwdHeaders["Connection"] = "keep-alive";
+        }
+        res.writeHead(proxyRes.statusCode ?? 200, fwdHeaders);
+        proxyRes.pipe(res);
+      } catch (err) {
+        const msg = (err as Error).message;
+        if (msg.includes("ECONNREFUSED") || msg.includes("ECONNRESET") || msg.includes("ENOTFOUND")) {
+          res.writeHead(503, { "Content-Type": "application/json", ...corsHeaders() });
+          res.end(JSON.stringify({
+            error: {
+              message: "BitNet server not running. Start with: sudo systemctl start bitnet-server",
+              type: "bitnet_error",
+              code: "bitnet_unavailable",
+            },
+          }));
+        } else {
+          opts.warn(`[cli-bridge] BitNet error for ${model}: ${msg}`);
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json", ...corsHeaders() });
+            res.end(JSON.stringify({ error: { message: msg, type: "bitnet_error" } }));
+          }
+        }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
     // ── CLI runner routing (Gemini / Claude Code) ─────────────────────────────
     let content: string;
     try {

package/test/bitnet-proxy.test.ts

@@ -0,0 +1,195 @@
+/**
+ * test/bitnet-proxy.test.ts
+ *
+ * Tests for BitNet local inference routing in the cli-bridge proxy.
+ * Spins up a mock llama-server and validates:
+ *   - 503 when BitNet server is unreachable
+ *   - Successful forward (non-streaming)
+ *   - Tools rejection (400)
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+import { startProxyServer, CLI_MODELS } from "../src/proxy-server.js";
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Mock llama-server — responds to POST /v1/chat/completions
+// ──────────────────────────────────────────────────────────────────────────────
+
+let mockLlamaServer: http.Server;
+let mockLlamaPort: number;
+
+function startMockLlamaServer(): Promise<void> {
+  return new Promise((resolve) => {
+    mockLlamaServer = http.createServer((req, res) => {
+      if (req.url === "/v1/models" && req.method === "GET") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ data: [{ id: "bitnet-2b" }] }));
+        return;
+      }
+      if (req.url === "/v1/chat/completions" && req.method === "POST") {
+        const chunks: Buffer[] = [];
+        req.on("data", (d: Buffer) => chunks.push(d));
+        req.on("end", () => {
+          const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+          const lastMsg = body.messages?.[body.messages.length - 1]?.content ?? "";
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            id: "chatcmpl-bitnet-mock",
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            model: "bitnet-2b",
+            choices: [{ index: 0, message: { role: "assistant", content: `bitnet echo: ${lastMsg}` }, finish_reason: "stop" }],
+            usage: { prompt_tokens: 4, completion_tokens: 6, total_tokens: 10 },
+          }));
+        });
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+    });
+    mockLlamaServer.listen(0, "127.0.0.1", () => {
+      mockLlamaPort = (mockLlamaServer.address() as AddressInfo).port;
+      resolve();
+    });
+  });
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// HTTP helpers
+// ──────────────────────────────────────────────────────────────────────────────
+
+async function httpPost(
+  url: string,
+  body: unknown,
+  headers: Record<string, string> = {}
+): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const urlObj = new URL(url);
+    const req = http.request(
+      {
+        hostname: urlObj.hostname,
+        port: parseInt(urlObj.port),
+        path: urlObj.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(data),
+          ...headers,
+        },
+      },
+      (res) => {
+        let resp = "";
+        res.on("data", (c) => (resp += c));
+        res.on("end", () => {
+          try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(resp) }); }
+          catch { resolve({ status: res.statusCode ?? 0, body: resp }); }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Setup: two proxy servers
+//   - withBitNet: points to mock llama-server
+//   - noBitNet: points to unreachable port (503 expected)
+// ──────────────────────────────────────────────────────────────────────────────
+
+const TEST_KEY = "test-bitnet-key";
+let serverWith: http.Server;
+let serverNo: http.Server;
+let urlWith: string;
+let urlNo: string;
+
+beforeAll(async () => {
+  await startMockLlamaServer();
+
+  serverWith = await startProxyServer({
+    port: 0,
+    apiKey: TEST_KEY,
+    log: () => {},
+    warn: () => {},
+    getBitNetServerUrl: () => `http://127.0.0.1:${mockLlamaPort}`,
+  });
+  const addrWith = serverWith.address() as AddressInfo;
+  urlWith = `http://127.0.0.1:${addrWith.port}`;
+
+  serverNo = await startProxyServer({
+    port: 0,
+    apiKey: TEST_KEY,
+    log: () => {},
+    warn: () => {},
+    getBitNetServerUrl: () => `http://127.0.0.1:1`, // unreachable
+  });
+  const addrNo = serverNo.address() as AddressInfo;
+  urlNo = `http://127.0.0.1:${addrNo.port}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((r) => serverWith.close(() => r()));
+  await new Promise<void>((r) => serverNo.close(() => r()));
+  await new Promise<void>((r) => mockLlamaServer.close(() => r()));
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Tests
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("CLI_MODELS includes BitNet", () => {
+  it("has local-bitnet/bitnet-2b in the model list", () => {
+    const bitnet = CLI_MODELS.filter((m) => m.id.startsWith("local-bitnet/"));
+    expect(bitnet).toHaveLength(1);
+    expect(bitnet[0].id).toBe("local-bitnet/bitnet-2b");
+  });
+});
+
+describe("POST /v1/chat/completions — BitNet routing", () => {
+  const auth = { Authorization: `Bearer ${TEST_KEY}` };
+
+  it("returns 503 when BitNet server is unreachable", async () => {
+    const { status, body } = await httpPost(
+      `${urlNo}/v1/chat/completions`,
+      { model: "local-bitnet/bitnet-2b", messages: [{ role: "user", content: "Hi" }] },
+      auth
+    );
+    expect(status).toBe(503);
+    const b = body as { error: { code: string; message: string } };
+    expect(b.error.code).toBe("bitnet_unavailable");
+    expect(b.error.message).toContain("BitNet server not running");
+  });
+
+  it("forwards request to mock llama-server (non-streaming)", async () => {
+    const { status, body } = await httpPost(
+      `${urlWith}/v1/chat/completions`,
+      { model: "local-bitnet/bitnet-2b", messages: [{ role: "user", content: "Hello BitNet" }], stream: false },
+      auth
+    );
+    expect(status).toBe(200);
+    const b = body as {
+      choices: Array<{ message: { content: string }; finish_reason: string }>;
+    };
+    expect(b.choices[0].message.content).toContain("Hello BitNet");
+    expect(b.choices[0].finish_reason).toBe("stop");
+  });
+
+  it("rejects tool calls with 400", async () => {
+    const { status, body } = await httpPost(
+      `${urlWith}/v1/chat/completions`,
+      {
+        model: "local-bitnet/bitnet-2b",
+        messages: [{ role: "user", content: "use tools" }],
+        tools: [{ type: "function", function: { name: "test", parameters: {} } }],
+      },
+      auth
+    );
+    expect(status).toBe(400);
+    const b = body as { error: { code: string } };
+    expect(b.error.code).toBe("tools_not_supported");
+  });
+});