clawmux 0.1.0 → 0.1.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HyeokjaeLee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -14,36 +14,40 @@ Smart model routing + context compression proxy for OpenClaw.
 
 ## Quick Start
 
-Requires [Bun](https://bun.sh) or [Node.js](https://nodejs.org) (18+) and a working OpenClaw installation.
+Requires [Node.js](https://nodejs.org) (18+) or [Bun](https://bun.sh) and a working OpenClaw installation.
 
 ```bash
-# Clone and install
-git clone https://github.com/your-org/ClawMux
-cd ClawMux
-bash scripts/install.sh
+npx clawmux init
 ```
 
-The install script:
-1. Detects your OpenClaw config at `~/.openclaw/openclaw.json` (override with `OPENCLAW_CONFIG_PATH`)
-2. Creates `clawmux.json` from the example if it doesn't exist
-3. Registers ClawMux as a provider in your OpenClaw config
+This will:
+1. Detect your OpenClaw config at `~/.openclaw/openclaw.json`
+2. Create `clawmux.json` from the default template
+3. Register 6 ClawMux providers in your OpenClaw config
+4. Install a system service for auto-start on boot (systemd on Linux, launchd on macOS)
 
-Then start the proxy:
+ClawMux is now running. Select a provider and start chatting:
 
 ```bash
-# Bun (recommended — faster startup & runtime)
-bun run dev        # watch mode (development)
-bun run start      # production
+openclaw provider clawmux-anthropic
+openclaw chat
+```
+
+### CLI Commands
 
-# Node.js
-npm run start:node # requires tsx: npm i -D tsx
+```bash
+clawmux status      # check if running
+clawmux stop        # stop the service
+clawmux start       # manual foreground start
+clawmux uninstall   # remove service + OpenClaw providers
 ```
 
-Select a provider in OpenClaw and start chatting:
+### From Source (development)
 
 ```bash
-openclaw provider clawmux-anthropic
-openclaw chat
+git clone https://github.com/nagle-app/ClawMux
+cd ClawMux
+bun install && bun run dev
 ```
 
 ## Configuration
@@ -63,9 +67,6 @@ Copy `clawmux.example.json` to `clawmux.json` and adjust as needed:
       "MEDIUM": "anthropic/claude-sonnet-4-20250514",
       "HEAVY": "anthropic/claude-opus-4-20250514"
       // Model IDs use 'provider/model' format. Do NOT use provider names starting with "clawmux-" — causes infinite loops
-    },
-    "scoring": {
-      "confidenceThreshold": 0.7  // classification confidence below this → fallback to MEDIUM tier
     }
   },
   "server": {
@@ -125,9 +126,9 @@ OpenClaw → ClawMux Proxy (localhost:3456) → Upstream Provider(s)
               └── 6. Translate response back to original format
 ```
 
-**Routing tiers** map to model IDs you configure. A local embedding model (`Xenova/paraphrase-multilingual-MiniLM-L12-v2`) classifies the semantic complexity of each request using nearest-centroid classification (~4ms first run, <1ms cached), supporting both Korean and English. Short queries are detected by a lightweight heuristic and routed to LIGHT tier directly. No external API calls are needed for classification.
+**Routing tiers** map to model IDs you configure. A local embedding model (`Xenova/multilingual-e5-small`) classifies the semantic complexity of each request using nearest-centroid classification (~8ms p50), supporting both Korean and English. Short queries are detected by a lightweight heuristic and routed to LIGHT tier directly. No external API calls are needed for classification.
 
-**Low confidence fallback**: When the classifier's confidence falls below `confidenceThreshold` (default 0.7), the request is routed to MEDIUM tier regardless of the computed score. This prevents unreliable classifications from sending requests to an inappropriate tier — MEDIUM provides a safe cost/quality balance compared to risking unnecessary cost (HEAVY) or degraded quality (LIGHT).
+**Low confidence fallback**: When the classifier's confidence is low, the request is routed to MEDIUM tier. This prevents unreliable classifications from sending requests to an inappropriate tier — MEDIUM provides a safe cost/quality balance.
 
 **Context compression** runs in the background after each response. When the conversation approaches the configured threshold, ClawMux summarizes older messages before the next request goes out. This keeps costs down on long conversations without interrupting the flow.
 
@@ -168,10 +169,10 @@ Tests are co-located with source files as `*.test.ts`.
 ## Uninstall
 
 ```bash
-bash scripts/uninstall.sh
+clawmux uninstall
 ```
 
-Removes all `clawmux-*` providers from your OpenClaw config. Your original config is backed up before any changes.
+Stops the system service, removes the service file, and removes all `clawmux-*` providers from your OpenClaw config. A backup is created before any changes.
 
 ## License
 

package/dist/cli.cjs

@@ -1,12 +1,16 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -77,6 +81,8 @@ async function writeWebResponse(res, response) {
 // src/cli.ts
 var import_promises = require("node:fs/promises");
 var import_node_path = require("node:path");
+var import_node_child_process = require("node:child_process");
+var import_node_os = require("node:os");
 
 // src/proxy/router.ts
 var VERSION = "0.1.0";
@@ -243,16 +249,21 @@ function createNodeServer(config) {
 
 // src/cli.ts
 var VERSION2 = process.env.npm_package_version ?? "0.1.0";
+var SERVICE_NAME = "clawmux";
 var HELP = `Usage: clawmux <command>
 
 Commands:
-  init      Detect OpenClaw config, create clawmux.json, register providers
-  start     Start the proxy server (foreground)
-  version   Print version
-  help      Show this help message
+  init        Detect OpenClaw config, register providers, install system service
+  start       Start the proxy server (foreground)
+  stop        Stop the system service
+  status      Check if ClawMux service is running
+  uninstall   Remove system service and OpenClaw providers
+  version     Print version
+  help        Show this help message
 
 Options:
   --port, -p <port>   Override server port (default: 3456)
+  --no-service        Skip system service installation during init
 
 Environment:
   CLAWMUX_PORT            Server port override
@@ -273,8 +284,176 @@ async function fileExistsLocal(path) {
     return false;
   }
 }
+function resolveClawmuxBin() {
+  try {
+    return import_node_child_process.execSync("which clawmux", { encoding: "utf-8" }).trim();
+  } catch {
+    return "npx clawmux";
+  }
+}
+function getHomeDir() {
+  return process.env.HOME ?? "/root";
+}
+var SYSTEMD_DIR = import_node_path.join(getHomeDir(), ".config", "systemd", "user");
+var SYSTEMD_PATH = import_node_path.join(SYSTEMD_DIR, `${SERVICE_NAME}.service`);
+var LAUNCHD_DIR = import_node_path.join(getHomeDir(), "Library", "LaunchAgents");
+var LAUNCHD_PATH = import_node_path.join(LAUNCHD_DIR, `com.${SERVICE_NAME}.plist`);
+function buildSystemdUnit(bin, port, workDir) {
+  return `[Unit]
+Description=ClawMux - Smart model routing proxy
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${bin} start --port ${port}
+WorkingDirectory=${workDir}
+Restart=on-failure
+RestartSec=5
+Environment=CLAWMUX_PORT=${port}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function buildLaunchdPlist(bin, port, workDir) {
+  const logDir = import_node_path.join(getHomeDir(), ".local", "log");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.${SERVICE_NAME}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${bin}</string>
+    <string>start</string>
+    <string>--port</string>
+    <string>${port}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${workDir}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>CLAWMUX_PORT</key>
+    <string>${port}</string>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logDir}/clawmux.log</string>
+  <key>StandardErrorPath</key>
+  <string>${logDir}/clawmux.err</string>
+</dict>
+</plist>
+`;
+}
+async function installService(port, workDir) {
+  const bin = resolveClawmuxBin();
+  const os = import_node_os.platform();
+  if (os === "linux") {
+    await import_promises.mkdir(SYSTEMD_DIR, { recursive: true });
+    await import_promises.writeFile(SYSTEMD_PATH, buildSystemdUnit(bin, port, workDir));
+    try {
+      import_node_child_process.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
+      import_node_child_process.execSync(`systemctl --user enable ${SERVICE_NAME}`, { stdio: "pipe" });
+      import_node_child_process.execSync(`systemctl --user start ${SERVICE_NAME}`, { stdio: "pipe" });
+      import_node_child_process.execSync("loginctl enable-linger $(whoami)", { stdio: "pipe" });
+      console.log("[info] systemd user service installed and started");
+      console.log(`       Service file: ${SYSTEMD_PATH}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`[warn] systemd setup failed: ${msg}`);
+      console.warn("       You can start manually: clawmux start");
+    }
+  } else if (os === "darwin") {
+    await import_promises.mkdir(LAUNCHD_DIR, { recursive: true });
+    const logDir = import_node_path.join(getHomeDir(), ".local", "log");
+    await import_promises.mkdir(logDir, { recursive: true });
+    await import_promises.writeFile(LAUNCHD_PATH, buildLaunchdPlist(bin, port, workDir));
+    try {
+      import_node_child_process.execSync(`launchctl load -w ${LAUNCHD_PATH}`, { stdio: "pipe" });
+      console.log("[info] launchd service installed and started");
+      console.log(`       Plist file: ${LAUNCHD_PATH}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`[warn] launchd setup failed: ${msg}`);
+      console.warn("       You can start manually: clawmux start");
+    }
+  } else {
+    console.warn(`[warn] Auto-start not supported on ${os}. Start manually: clawmux start`);
+  }
+}
+function stopService() {
+  const os = import_node_os.platform();
+  if (os === "linux") {
+    try {
+      import_node_child_process.execSync(`systemctl --user stop ${SERVICE_NAME}`, { stdio: "pipe" });
+      console.log("[info] Service stopped");
+    } catch {
+      console.log("[info] Service is not running");
+    }
+  } else if (os === "darwin") {
+    try {
+      import_node_child_process.execSync(`launchctl unload ${LAUNCHD_PATH}`, { stdio: "pipe" });
+      console.log("[info] Service stopped");
+    } catch {
+      console.log("[info] Service is not running");
+    }
+  } else {
+    console.error(`[error] Auto-start not supported on ${os}`);
+  }
+}
+function getStatus() {
+  const os = import_node_os.platform();
+  if (os === "linux") {
+    try {
+      const output = import_node_child_process.execSync(`systemctl --user is-active ${SERVICE_NAME}`, { encoding: "utf-8" }).trim();
+      console.log(`ClawMux service: ${output}`);
+    } catch {
+      console.log("ClawMux service: inactive");
+    }
+  } else if (os === "darwin") {
+    try {
+      const output = import_node_child_process.execSync(`launchctl list | grep com.${SERVICE_NAME}`, { encoding: "utf-8" }).trim();
+      console.log(output ? `ClawMux service: running
+${output}` : "ClawMux service: not loaded");
+    } catch {
+      console.log("ClawMux service: not loaded");
+    }
+  } else {
+    console.log(`Auto-start not supported on ${os}`);
+  }
+}
+async function removeService() {
+  const os = import_node_os.platform();
+  if (os === "linux") {
+    try {
+      import_node_child_process.execSync(`systemctl --user stop ${SERVICE_NAME}`, { stdio: "pipe" });
+      import_node_child_process.execSync(`systemctl --user disable ${SERVICE_NAME}`, { stdio: "pipe" });
+    } catch (_) {}
+    if (await fileExistsLocal(SYSTEMD_PATH)) {
+      await import_promises.unlink(SYSTEMD_PATH);
+      import_node_child_process.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
+      console.log("[info] systemd service removed");
+    }
+  } else if (os === "darwin") {
+    try {
+      import_node_child_process.execSync(`launchctl unload ${LAUNCHD_PATH}`, { stdio: "pipe" });
+    } catch (_) {}
+    if (await fileExistsLocal(LAUNCHD_PATH)) {
+      await import_promises.unlink(LAUNCHD_PATH);
+      console.log("[info] launchd plist removed");
+    }
+  }
+}
 async function init() {
-  const homeDir = process.env.HOME ?? "/root";
+  const args = process.argv.slice(2);
+  const noService = args.includes("--no-service");
+  const homeDir = getHomeDir();
   const openclawConfigPath = process.env.OPENCLAW_CONFIG_PATH ?? import_node_path.join(homeDir, ".openclaw", "openclaw.json");
   if (!await fileExistsLocal(openclawConfigPath)) {
     console.error(`[error] OpenClaw config not found at ${openclawConfigPath}`);
@@ -326,12 +505,22 @@ Added ${added} provider(s) to openclaw.json`);
     console.log(`
 All ClawMux providers already registered.`);
   }
+  const port = process.env.CLAWMUX_PORT ?? "3456";
+  if (!noService) {
+    console.log("");
+    await installService(port, process.cwd());
+  }
   console.log(`
-[info] ClawMux provider registration complete!`);
+[info] ClawMux setup complete!`);
   console.log(`
 Next steps:`);
   console.log("  1. Edit clawmux.json to configure your models");
-  console.log("  2. Run: clawmux start");
+  if (noService) {
+    console.log("  2. Run: clawmux start");
+  } else {
+    console.log("  2. ClawMux is running and will auto-start on boot");
+    console.log("     Check status: clawmux status");
+  }
   console.log("  3. Select a provider: openclaw provider clawmux-openai");
   console.log("  4. Start chatting: openclaw chat");
 }
@@ -346,6 +535,32 @@ function start() {
   server.start();
   console.log(`[clawmux] Proxy server running on http://127.0.0.1:${port}`);
 }
+async function uninstall() {
+  await removeService();
+  const homeDir = getHomeDir();
+  const openclawConfigPath = process.env.OPENCLAW_CONFIG_PATH ?? import_node_path.join(homeDir, ".openclaw", "openclaw.json");
+  if (await fileExistsLocal(openclawConfigPath)) {
+    const backupPath = `${openclawConfigPath}.bak.${Date.now()}`;
+    await import_promises.copyFile(openclawConfigPath, backupPath);
+    const raw = await import_promises.readFile(openclawConfigPath, "utf-8");
+    const config = JSON.parse(raw);
+    const models = config.models ?? {};
+    const providers = models.providers ?? {};
+    let removed = 0;
+    for (const key of Object.keys(providers)) {
+      if (key.startsWith("clawmux-")) {
+        delete providers[key];
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      await import_promises.writeFile(openclawConfigPath, JSON.stringify(config, null, 2) + `
+`);
+      console.log(`[info] Removed ${removed} ClawMux provider(s) from openclaw.json`);
+    }
+  }
+  console.log("[info] ClawMux uninstalled");
+}
 var command = process.argv[2];
 switch (command) {
   case "init":
@@ -357,6 +572,18 @@ switch (command) {
   case "start":
     start();
     break;
+  case "stop":
+    stopService();
+    break;
+  case "status":
+    getStatus();
+    break;
+  case "uninstall":
+    uninstall().catch((err) => {
+      console.error(`[error] ${err.message}`);
+      process.exit(1);
+    });
+    break;
   case "version":
   case "--version":
   case "-v":

package/dist/index.cjs

@@ -1,11 +1,15 @@
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmux",
-  "version": "0.1.0",
+  "version": "0.1.6",
   "description": "Smart model routing + context compression proxy for OpenClaw",
   "type": "module",
   "bin": {
@@ -34,7 +34,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/nagle-app/ClawMux.git"
+    "url": "git+https://github.com/HyeokjaeLee/ClawMux.git"
   },
   "keywords": [
     "llm",