@clawrent/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1164 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/auth.ts
+import { createInterface } from "readline";
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_CONFIG = {
+  apiUrl: "http://localhost:3001",
+  wsUrl: "ws://localhost:3001"
+};
+function getConfigDir() {
+  return join(homedir(), ".clawrent");
+}
+function getConfigFilePath() {
+  return join(getConfigDir(), "config.json");
+}
+function getConfigPath() {
+  return getConfigFilePath();
+}
+function loadConfig() {
+  let fileConfig = {};
+  const configPath = getConfigFilePath();
+  if (existsSync(configPath)) {
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {
+    }
+  }
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...fileConfig
+  };
+  const envApiUrl = process.env["CLAWRENT_API_URL"];
+  const envWsUrl = process.env["CLAWRENT_WS_URL"];
+  const envToken = process.env["CLAWRENT_TOKEN"];
+  const envApiKey = process.env["CLAWRENT_API_KEY"];
+  const envUserId = process.env["CLAWRENT_USER_ID"];
+  if (envApiUrl) config.apiUrl = envApiUrl;
+  if (envWsUrl) config.wsUrl = envWsUrl;
+  if (envToken) config.token = envToken;
+  if (envApiKey) config.apiKey = envApiKey;
+  if (envUserId) config.userId = envUserId;
+  return config;
+}
+function saveConfig(partial) {
+  const configDir = getConfigDir();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  let existing = {};
+  const configPath = getConfigFilePath();
+  if (existsSync(configPath)) {
+    try {
+      existing = JSON.parse(readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  const merged = { ...existing, ...partial };
+  writeFileSync(configPath, JSON.stringify(merged, null, 2), "utf-8");
+}
+function clearConfig() {
+  const configPath = getConfigFilePath();
+  if (existsSync(configPath)) {
+    unlinkSync(configPath);
+  }
+}
+
+// src/api-client.ts
+var ApiClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  get apiUrl() {
+    return this.config.apiUrl;
+  }
+  get wsUrl() {
+    return this.config.wsUrl;
+  }
+  get userId() {
+    return this.config.userId;
+  }
+  // --- Auth (no auth needed) ---
+  async login(email, password) {
+    return this.request("POST", "/api/auth/login", { email, password }, false);
+  }
+  async getMe() {
+    return this.request("GET", "/api/auth/me");
+  }
+  // --- Marketplace ---
+  async browse(query) {
+    const params = new URLSearchParams();
+    if (query?.search) params.set("search", query.search);
+    if (query?.category) params.set("category", query.category);
+    if (query?.page) params.set("page", String(query.page));
+    if (query?.limit) params.set("limit", String(query.limit));
+    const qs = params.toString();
+    return this.request("GET", `/api/marketplace/browse${qs ? `?${qs}` : ""}`);
+  }
+  async getAgent(slug) {
+    return this.request("GET", `/api/marketplace/agents/${encodeURIComponent(slug)}`);
+  }
+  // --- Sessions ---
+  async rent(options) {
+    return this.request("POST", "/api/sessions", {
+      agentId: options.agentId,
+      taskDescription: options.taskDescription,
+      grantedPermissions: options.grantedPermissions ?? {}
+    });
+  }
+  async getSessions(query) {
+    const params = new URLSearchParams();
+    if (query?.role) params.set("role", query.role);
+    if (query?.status) params.set("status", query.status);
+    if (query?.page) params.set("page", String(query.page));
+    if (query?.limit) params.set("limit", String(query.limit));
+    const qs = params.toString();
+    return this.request("GET", `/api/sessions${qs ? `?${qs}` : ""}`);
+  }
+  async getSession(sessionId) {
+    return this.request("GET", `/api/sessions/${encodeURIComponent(sessionId)}`);
+  }
+  async getSessionMessages(sessionId) {
+    return this.request("GET", `/api/sessions/${encodeURIComponent(sessionId)}/messages`);
+  }
+  async endSession(sessionId) {
+    return this.request("POST", `/api/sessions/${encodeURIComponent(sessionId)}/end`);
+  }
+  async approveSession(sessionId) {
+    return this.request("POST", `/api/sessions/${encodeURIComponent(sessionId)}/approve`);
+  }
+  // --- Billing ---
+  async getBalance() {
+    return this.request("GET", "/api/billing/wallet");
+  }
+  async topUp(amount) {
+    return this.request("POST", "/api/billing/wallet/topup", { amount });
+  }
+  // --- Provider: Agents ---
+  async registerAgent(data) {
+    return this.request("POST", "/api/agents", data);
+  }
+  async getMyAgents(query) {
+    const params = new URLSearchParams();
+    if (query?.page) params.set("page", String(query.page));
+    if (query?.limit) params.set("limit", String(query.limit));
+    if (query?.status) params.set("status", query.status);
+    const qs = params.toString();
+    return this.request("GET", `/api/agents/my${qs ? `?${qs}` : ""}`);
+  }
+  async publishAgent(agentId) {
+    return this.request("POST", `/api/agents/${encodeURIComponent(agentId)}/publish`);
+  }
+  async activateAgent(agentId) {
+    return this.request("POST", `/api/agents/${encodeURIComponent(agentId)}/activate`);
+  }
+  async setOnlineStatus(agentId, onlineStatus) {
+    return this.request("PATCH", `/api/agents/${encodeURIComponent(agentId)}/status`, { onlineStatus });
+  }
+  async generateAgentToken(agentId) {
+    return this.request("POST", `/api/agents/${encodeURIComponent(agentId)}/token`);
+  }
+  async revokeAgentToken(agentId) {
+    return this.request("DELETE", `/api/agents/${encodeURIComponent(agentId)}/token`);
+  }
+  // --- Orders ---
+  async createOrder(data) {
+    return this.request("POST", "/api/orders", data);
+  }
+  async getOrders(query) {
+    const params = new URLSearchParams();
+    if (query?.status) params.set("status", query.status);
+    if (query?.page) params.set("page", String(query.page));
+    if (query?.limit) params.set("limit", String(query.limit));
+    const qs = params.toString();
+    return this.request("GET", `/api/orders${qs ? `?${qs}` : ""}`);
+  }
+  async getOrder(orderId) {
+    return this.request("GET", `/api/orders/${encodeURIComponent(orderId)}`);
+  }
+  async cancelOrder(orderId) {
+    return this.request("POST", `/api/orders/${encodeURIComponent(orderId)}/cancel`);
+  }
+  // --- Cart ---
+  async getCart() {
+    return this.request("GET", "/api/cart");
+  }
+  async addToCart(data) {
+    return this.request("POST", "/api/cart", data);
+  }
+  async updateCartItem(itemId, data) {
+    return this.request("PATCH", `/api/cart/${encodeURIComponent(itemId)}`, data);
+  }
+  async removeFromCart(itemId) {
+    return this.request("DELETE", `/api/cart/${encodeURIComponent(itemId)}`);
+  }
+  async clearCart() {
+    return this.request("DELETE", "/api/cart");
+  }
+  // --- Favorites ---
+  async listFavorites(query) {
+    const params = new URLSearchParams();
+    if (query?.page) params.set("page", String(query.page));
+    if (query?.limit) params.set("limit", String(query.limit));
+    const qs = params.toString();
+    return this.request("GET", `/api/favorites${qs ? `?${qs}` : ""}`);
+  }
+  async addFavorite(agentId) {
+    return this.request("POST", `/api/favorites/${encodeURIComponent(agentId)}`);
+  }
+  async removeFavorite(agentId) {
+    return this.request("DELETE", `/api/favorites/${encodeURIComponent(agentId)}`);
+  }
+  // --- Health ---
+  async health() {
+    return this.request("GET", "/api/health", void 0, false);
+  }
+  // --- Private ---
+  async request(method, path, body, requireAuth = true) {
+    const url = `${this.config.apiUrl}${path}`;
+    const headers = {};
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (requireAuth) {
+      if (this.config.token) {
+        headers["Authorization"] = `Bearer ${this.config.token}`;
+      } else if (this.config.apiKey) {
+        headers["x-api-key"] = this.config.apiKey;
+      } else {
+        throw new Error("Not authenticated. Run `clawrent auth login` first.");
+      }
+    }
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const errBody = await response.json().catch(() => ({ message: response.statusText }));
+      throw new Error(`API error ${response.status}: ${errBody["message"] ?? JSON.stringify(errBody)}`);
+    }
+    return response.json();
+  }
+};
+
+// src/output.ts
+function printJson(data) {
+  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+function printError(message) {
+  process.stderr.write(`Error: ${message}
+`);
+}
+function printSuccess(message) {
+  process.stdout.write(`${message}
+`);
+}
+
+// src/commands/auth.ts
+function deriveWsUrl(apiUrl) {
+  return apiUrl.replace(/^http/, "ws");
+}
+async function promptInput(prompt, hidden = false) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    if (hidden) {
+      process.stderr.write(prompt);
+      const stdin = process.stdin;
+      const wasRaw = stdin.isRaw;
+      if (stdin.isTTY) stdin.setRawMode(true);
+      let input = "";
+      const onData = (ch) => {
+        const c = ch.toString("utf-8");
+        if (c === "\n" || c === "\r") {
+          stdin.removeListener("data", onData);
+          if (stdin.isTTY && wasRaw !== void 0) stdin.setRawMode(wasRaw);
+          process.stderr.write("\n");
+          rl.close();
+          resolve(input);
+        } else if (c === "") {
+          rl.close();
+          process.exit(1);
+        } else if (c === "\x7F" || c === "\b") {
+          input = input.slice(0, -1);
+        } else {
+          input += c;
+        }
+      };
+      stdin.on("data", onData);
+    } else {
+      rl.question(prompt, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    }
+  });
+}
+function registerAuthCommand(program2) {
+  const auth = program2.command("auth").description("Authentication management");
+  auth.command("login").description("Login to ClawRent platform").option("-e, --email <email>", "Email address").option("-p, --password <password>", "Password").option("--api-url <url>", "Platform API URL").action(async (opts) => {
+    try {
+      const currentConfig = loadConfig();
+      const apiUrl = opts.apiUrl ?? currentConfig.apiUrl;
+      const wsUrl = deriveWsUrl(apiUrl);
+      const email = opts.email ?? await promptInput("Email: ");
+      const password = opts.password ?? await promptInput("Password: ", true);
+      if (!email || !password) {
+        printError("Email and password are required.");
+        process.exit(1);
+      }
+      const client = new ApiClient({ ...currentConfig, apiUrl, wsUrl });
+      const result = await client.login(email, password);
+      saveConfig({
+        apiUrl,
+        wsUrl,
+        token: result.token,
+        userId: result.user.id,
+        email: result.user.email,
+        name: result.user.name
+      });
+      printSuccess(`Logged in as ${result.user.name} (${result.user.email})`);
+      printSuccess(`Config saved to ${getConfigPath()}`);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  auth.command("logout").description("Logout and clear saved credentials").action(() => {
+    try {
+      clearConfig();
+      printSuccess("Logged out. Config cleared.");
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  auth.command("whoami").description("Show current user info").action(async () => {
+    try {
+      const config = loadConfig();
+      const client = new ApiClient(config);
+      const me = await client.getMe();
+      printJson(me);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/browse.ts
+function registerBrowseCommand(program2) {
+  program2.command("browse").description("Browse available agents on the marketplace").option("-s, --search <query>", "Search by name").option("-c, --category <category>", "Filter by category").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Results per page", "20").action(async (opts) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.browse({
+        search: opts.search,
+        category: opts.category,
+        page: parseInt(opts.page, 10),
+        limit: parseInt(opts.limit, 10)
+      });
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/agent.ts
+function registerAgentCommand(program2) {
+  program2.command("agent <slug>").description("Get agent details by slug").action(async (slug) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.getAgent(slug);
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/sessions.ts
+function registerSessionsCommand(program2) {
+  program2.command("sessions").description("List your sessions").option("-r, --role <role>", "Filter by role (consumer/provider)").option("-s, --status <status>", "Filter by status").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Results per page", "20").action(async (opts) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.getSessions({
+        role: opts.role,
+        status: opts.status,
+        page: parseInt(opts.page, 10),
+        limit: parseInt(opts.limit, 10)
+      });
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/balance.ts
+function registerBalanceCommand(program2) {
+  program2.command("balance").description("Check wallet balance").action(async () => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.getBalance();
+      printSuccess(`Balance: ${result.balance}`);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/topup.ts
+function registerTopupCommand(program2) {
+  program2.command("topup <amount>").description("Top up wallet balance").action(async (amount) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.topUp(amount);
+      printSuccess(`New balance: ${result.balance}`);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/health.ts
+function registerHealthCommand(program2) {
+  program2.command("health").description("Check platform health").action(async () => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.health();
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/rent.ts
+function registerRentCommand(program2) {
+  program2.command("rent").description("Rent an agent (create a session)").requiredOption("--agent-id <id>", "Agent ID to rent").requiredOption("--task <description>", "Task description").option("--permissions <json>", "Granted permissions as JSON string", "{}").action(async (opts) => {
+    try {
+      let grantedPermissions = {};
+      try {
+        grantedPermissions = JSON.parse(opts.permissions);
+      } catch {
+        printError("Invalid JSON for --permissions");
+        process.exit(1);
+      }
+      const client = new ApiClient(loadConfig());
+      const result = await client.rent({
+        agentId: opts.agentId,
+        taskDescription: opts.task,
+        grantedPermissions
+      });
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/end.ts
+function registerEndCommand(program2) {
+  program2.command("end <sessionId>").description("End a session").action(async (sessionId) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.endSession(sessionId);
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/send.ts
+import WebSocket from "ws";
+function registerSendCommand(program2) {
+  program2.command("send <sessionId>").description("Send a message to a session via WebSocket").requiredOption("--content <text>", "Message content").option("--type <messageType>", "Message type", "dialogue.message").option("--token <sessionToken>", "Session token (auto-fetched if not provided)").option("--wait <ms>", "Wait for response (milliseconds)").action(async (sessionId, opts) => {
+    try {
+      const config = loadConfig();
+      const client = new ApiClient(config);
+      let sessionToken = opts.token;
+      let role = "consumer";
+      if (!sessionToken) {
+        const session = await client.getSession(sessionId);
+        sessionToken = session["sessionToken"];
+        if (config.userId && session["providerUserId"] === config.userId) {
+          role = "provider";
+        }
+      }
+      if (!sessionToken) {
+        printError("Could not determine session token. Use --token flag.");
+        process.exit(1);
+      }
+      const wsUrl = `${config.wsUrl}/ws/session?sessionId=${sessionId}&token=${sessionToken}&role=${role}`;
+      await new Promise((resolve, reject) => {
+        const ws = new WebSocket(wsUrl);
+        let responded = false;
+        ws.on("open", () => {
+          const message = {
+            id: `msg_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+            sessionId,
+            timestamp: Date.now(),
+            sender: { role, agentId: config.userId ?? "unknown" },
+            type: opts.type,
+            payload: { content: opts.content, dialogueType: "message" }
+          };
+          ws.send(JSON.stringify(message));
+          if (opts.wait) {
+            setTimeout(() => {
+              if (!responded) {
+                ws.close(1e3);
+                printSuccess("Message sent (no response within timeout).");
+                resolve();
+              }
+            }, parseInt(opts.wait, 10));
+          } else {
+            setTimeout(() => {
+              ws.close(1e3);
+              printSuccess("Message sent.");
+              resolve();
+            }, 500);
+          }
+        });
+        ws.on("message", (raw) => {
+          try {
+            const data = JSON.parse(raw.toString());
+            if (data.type !== "system.heartbeat_ack" && data.type !== "system.peer_connected") {
+              responded = true;
+              printJson(data);
+              if (opts.wait) {
+                ws.close(1e3);
+                resolve();
+              }
+            }
+          } catch {
+          }
+        });
+        ws.on("error", (err) => {
+          reject(err);
+        });
+        ws.on("close", () => {
+          if (!responded && opts.wait) {
+            resolve();
+          }
+        });
+      });
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/provider/index.ts
+function registerProviderCommands(program2) {
+  const provider = program2.command("provider").description("Provider operations");
+  const agent = provider.command("agent").description("Manage your agents");
+  agent.command("create").description("Register a new agent").requiredOption("--name <name>", "Agent name").requiredOption("--slug <slug>", "Agent slug (URL-friendly)").requiredOption("--description <desc>", "Agent description (10-500 chars)").option("--long-description <text>", "Detailed description").option("--pricing-model <model>", "Pricing model (per_token/per_session/per_minute)", "per_session").option("--price <amount>", "Price amount", "1.00").option("--currency <cur>", "Currency (CNY/USD)", "CNY").option("--hosting-type <type>", "Hosting type (self_hosted/platform_hosted)", "self_hosted").option("--approval-mode <mode>", "Approval mode (manual/auto)", "manual").option("--max-concurrent <n>", "Max concurrent sessions", "5").option("--capabilities <json>", "Capabilities as JSON array").action(async (opts) => {
+    try {
+      const data = {
+        name: opts.name,
+        slug: opts.slug,
+        description: opts.description,
+        pricingModel: opts.pricingModel,
+        priceAmount: opts.price,
+        currency: opts.currency,
+        hostingType: opts.hostingType,
+        approvalMode: opts.approvalMode,
+        maxConcurrentSessions: parseInt(opts.maxConcurrent, 10)
+      };
+      if (opts.longDescription) data["longDescription"] = opts.longDescription;
+      if (opts.capabilities) {
+        try {
+          data["capabilities"] = JSON.parse(opts.capabilities);
+        } catch {
+          printError("Invalid JSON for --capabilities");
+          process.exit(1);
+        }
+      }
+      const client = new ApiClient(loadConfig());
+      const result = await client.registerAgent(data);
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  agent.command("list").description("List your agents").option("-s, --status <status>", "Filter by status").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Results per page", "20").action(async (opts) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.getMyAgents({
+        status: opts.status,
+        page: parseInt(opts.page, 10),
+        limit: parseInt(opts.limit, 10)
+      });
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  agent.command("publish <agentId>").description("Publish an agent (draft -> pending_review)").action(async (agentId) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.publishAgent(agentId);
+      printSuccess("Agent published successfully.");
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  agent.command("activate <agentId>").description("Activate an agent (pending_review -> active)").action(async (agentId) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.activateAgent(agentId);
+      printSuccess("Agent activated successfully.");
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  agent.command("status <agentId>").description("Set agent online status").requiredOption("--status <status>", "Online status (online/offline/busy)").action(async (agentId, opts) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.setOnlineStatus(agentId, opts.status);
+      printSuccess(`Agent status set to ${opts.status}.`);
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  provider.command("sessions").description("List provider sessions").option("-s, --status <status>", "Filter by status").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Results per page", "20").action(async (opts) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.getSessions({
+        role: "provider",
+        status: opts.status,
+        page: parseInt(opts.page, 10),
+        limit: parseInt(opts.limit, 10)
+      });
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  provider.command("approve <sessionId>").description("Approve a pending session").action(async (sessionId) => {
+    try {
+      const client = new ApiClient(loadConfig());
+      const result = await client.approveSession(sessionId);
+      printSuccess("Session approved.");
+      printJson(result);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+
+// src/serve/index.ts
+import WebSocket3 from "ws";
+
+// src/serve/stdio-bridge.ts
+import { createInterface as createInterface2 } from "readline";
+var StdioBridge = class {
+  handler = null;
+  rl = null;
+  /** Start reading from stdin */
+  start(handler) {
+    this.handler = handler;
+    this.rl = createInterface2({ input: process.stdin, crlfDelay: Infinity });
+    this.rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try {
+        const msg = JSON.parse(trimmed);
+        if (msg.jsonrpc !== "2.0") {
+          this.writeError("Invalid JSON-RPC: missing jsonrpc field");
+          return;
+        }
+        this.handler?.(msg);
+      } catch {
+        this.writeError(`Failed to parse JSON: ${trimmed.slice(0, 100)}`);
+      }
+    });
+    this.rl.on("close", () => {
+    });
+  }
+  /** Stop reading */
+  stop() {
+    this.rl?.close();
+    this.rl = null;
+  }
+  /** Write a JSON-RPC message to stdout */
+  write(msg) {
+    process.stdout.write(JSON.stringify(msg) + "\n");
+  }
+  /** Write a notification */
+  writeNotification(method, params) {
+    const msg = { jsonrpc: "2.0", method, params };
+    this.write(msg);
+  }
+  /** Write a request (expects response) */
+  writeRequest(method, id, params) {
+    const msg = { jsonrpc: "2.0", method, id, params };
+    this.write(msg);
+  }
+  /** Write a response */
+  writeResponse(id, result) {
+    const msg = { jsonrpc: "2.0", id, result };
+    this.write(msg);
+  }
+  /** Write an error notification to stdout */
+  writeError(message) {
+    this.writeNotification("error", { message });
+  }
+};
+
+// src/serve/session-manager.ts
+import { EventEmitter } from "events";
+import WebSocket2 from "ws";
+var SessionManager = class extends EventEmitter {
+  sessions = /* @__PURE__ */ new Map();
+  wsUrl;
+  heartbeatInterval;
+  maxReconnectDelay;
+  agentId;
+  constructor(wsUrl, heartbeatInterval = 25e3, maxReconnectDelay = 3e4) {
+    super();
+    this.wsUrl = wsUrl;
+    this.heartbeatInterval = heartbeatInterval;
+    this.maxReconnectDelay = maxReconnectDelay;
+  }
+  /** Connect to a session via WebSocket as provider */
+  connect(sessionId, sessionToken) {
+    if (this.sessions.has(sessionId)) {
+      return;
+    }
+    const url = `${this.wsUrl}/ws/session?sessionId=${sessionId}&token=${sessionToken}&role=provider`;
+    const ws = new WebSocket2(url);
+    const conn = {
+      sessionId,
+      sessionToken,
+      ws,
+      heartbeatTimer: null,
+      reconnectAttempts: 0
+    };
+    this.sessions.set(sessionId, conn);
+    ws.on("open", () => {
+      conn.reconnectAttempts = 0;
+      conn.heartbeatTimer = setInterval(() => {
+        if (ws.readyState === WebSocket2.OPEN) {
+          ws.send(JSON.stringify({ type: "system.heartbeat", payload: {} }));
+        }
+      }, this.heartbeatInterval);
+      this.emit("session:connected", sessionId);
+    });
+    ws.on("message", (raw) => {
+      try {
+        const message = JSON.parse(raw.toString());
+        if (message["type"] === "system.heartbeat_ack") return;
+        this.emit("session:message", sessionId, message);
+      } catch {
+      }
+    });
+    ws.on("close", (code, reason) => {
+      this.clearHeartbeat(conn);
+      if (code !== 1e3) {
+        const delay = Math.min(
+          1e3 * Math.pow(2, conn.reconnectAttempts),
+          this.maxReconnectDelay
+        );
+        conn.reconnectAttempts++;
+        this.emit("session:reconnecting", sessionId, delay);
+        setTimeout(() => {
+          this.sessions.delete(sessionId);
+          this.connect(sessionId, sessionToken);
+        }, delay);
+      } else {
+        this.sessions.delete(sessionId);
+        this.emit("session:disconnected", sessionId, reason.toString());
+      }
+    });
+    ws.on("error", (err) => {
+      this.emit("session:error", sessionId, err);
+    });
+  }
+  /** Send a message to a specific session, auto-wrapping with protocol envelope */
+  send(sessionId, message) {
+    const conn = this.sessions.get(sessionId);
+    if (!conn || conn.ws.readyState !== WebSocket2.OPEN) {
+      return false;
+    }
+    const envelope = {
+      id: message["id"] ?? `msg_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+      sessionId: message["sessionId"] ?? sessionId,
+      timestamp: message["timestamp"] ?? Date.now(),
+      sender: message["sender"] ?? { role: "provider", agentId: this.agentId ?? "unknown" },
+      type: message["type"] ?? "result.success",
+      payload: message["payload"] ?? {}
+    };
+    conn.ws.send(JSON.stringify(envelope));
+    return true;
+  }
+  /** Disconnect a specific session */
+  disconnect(sessionId) {
+    const conn = this.sessions.get(sessionId);
+    if (!conn) return;
+    this.clearHeartbeat(conn);
+    if (conn.ws.readyState === WebSocket2.OPEN || conn.ws.readyState === WebSocket2.CONNECTING) {
+      conn.ws.close(1e3, "Provider disconnecting");
+    }
+    this.sessions.delete(sessionId);
+  }
+  /** Disconnect all sessions */
+  disconnectAll() {
+    for (const sessionId of this.sessions.keys()) {
+      this.disconnect(sessionId);
+    }
+  }
+  /** Get active session count */
+  get activeCount() {
+    return this.sessions.size;
+  }
+  /** Check if a session is connected */
+  isConnected(sessionId) {
+    const conn = this.sessions.get(sessionId);
+    return conn?.ws.readyState === WebSocket2.OPEN;
+  }
+  clearHeartbeat(conn) {
+    if (conn.heartbeatTimer) {
+      clearInterval(conn.heartbeatTimer);
+      conn.heartbeatTimer = null;
+    }
+  }
+};
+
+// src/serve/protocol.ts
+var correlationCounter = 0;
+function createCorrelationId() {
+  return `corr_${Date.now().toString(36)}_${(correlationCounter++).toString(36)}`;
+}
+function isResponse(msg) {
+  return "id" in msg && ("result" in msg || "error" in msg) && !("method" in msg);
+}
+function isRequest(msg) {
+  return "method" in msg && "id" in msg;
+}
+
+// src/serve/index.ts
+var pendingInstructions = /* @__PURE__ */ new Map();
+var knownPendingSessions = /* @__PURE__ */ new Set();
+var activeSessions = /* @__PURE__ */ new Set();
+function registerServeCommand(program2) {
+  program2.command("serve").description("Start serve daemon - bridge WebSocket sessions to stdin/stdout").requiredOption("--agent-id <id>", "Agent ID to serve").option("--agent-token <token>", "Agent token for /ws/agent control channel").option("--auto-approve", "Automatically approve incoming sessions", false).option("--poll-interval <ms>", "Polling interval for pending sessions (ms)", "5000").action(async (opts) => {
+    try {
+      await runDaemon(opts);
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runDaemon(opts) {
+  const config = loadConfig();
+  const client = new ApiClient(config);
+  const bridge = new StdioBridge();
+  const sessionManager = new SessionManager(config.wsUrl);
+  sessionManager.agentId = opts.agentId;
+  const pollInterval = parseInt(opts.pollInterval, 10);
+  let agentWs = null;
+  let agentHeartbeatTimer = null;
+  let agentName = opts.agentId;
+  try {
+    const agents = await client.getMyAgents();
+    const agent = agents.data.find((a) => a["id"] === opts.agentId);
+    if (agent) {
+      agentName = agent["name"] ?? opts.agentId;
+      if (!opts.agentToken) {
+        const status = agent["status"];
+        if (status === "draft") {
+          await client.publishAgent(opts.agentId);
+          await client.activateAgent(opts.agentId);
+        } else if (status === "pending_review") {
+          await client.activateAgent(opts.agentId);
+        }
+        await client.setOnlineStatus(opts.agentId, "online");
+      }
+    }
+  } catch {
+  }
+  bridge.writeNotification("ready", {
+    agentId: opts.agentId,
+    agentName
+  });
+  sessionManager.on("session:connected", (sessionId) => {
+    bridge.writeNotification("session.connected", { sessionId });
+  });
+  sessionManager.on("session:message", (sessionId, message) => {
+    const type = message["type"];
+    if (type?.startsWith("instruction.")) {
+      const corrId = createCorrelationId();
+      pendingInstructions.set(corrId, sessionId);
+      bridge.writeRequest("instruction", corrId, {
+        sessionId,
+        messageId: message["id"] ?? corrId,
+        type,
+        payload: message["payload"] ?? {},
+        sender: message["sender"]
+      });
+    } else if (type?.startsWith("dialogue.")) {
+      const payload = message["payload"] ?? {};
+      bridge.writeNotification("dialogue", {
+        sessionId,
+        content: payload["content"] ?? "",
+        dialogueType: payload["dialogueType"] ?? "message"
+      });
+    } else if (type?.startsWith("result.")) {
+      bridge.writeNotification("result", {
+        sessionId,
+        type,
+        payload: message["payload"] ?? {}
+      });
+    } else if (type === "system.session_ended" || type === "system.peer_disconnected") {
+      activeSessions.delete(sessionId);
+      bridge.writeNotification("session.ended", {
+        sessionId,
+        reason: type
+      });
+    } else if (type === "system.peer_connected") {
+      bridge.writeNotification("session.peer_connected", { sessionId });
+    } else if (type !== "system.heartbeat_ack") {
+      bridge.writeNotification("message", { sessionId, ...message });
+    }
+  });
+  sessionManager.on("session:disconnected", (sessionId, reason) => {
+    activeSessions.delete(sessionId);
+    bridge.writeNotification("session.disconnected", { sessionId, reason });
+  });
+  sessionManager.on("session:reconnecting", (sessionId, delay) => {
+    bridge.writeNotification("session.reconnecting", { sessionId, delay });
+  });
+  sessionManager.on("session:error", (sessionId, err) => {
+    bridge.writeNotification("session.error", { sessionId, message: err.message });
+  });
+  bridge.start((msg) => {
+    if (isResponse(msg)) {
+      const sessionId = pendingInstructions.get(msg.id);
+      if (sessionId && msg.result) {
+        pendingInstructions.delete(msg.id);
+        const result = msg.result;
+        sessionManager.send(sessionId, {
+          type: result.type ?? "result.success",
+          payload: result.payload ?? result
+        });
+      }
+    } else if (isRequest(msg)) {
+      if (msg.method === "send") {
+        const params = msg.params;
+        if (params?.["sessionId"]) {
+          const sent = sessionManager.send(params["sessionId"], {
+            type: params["type"] ?? "dialogue.message",
+            payload: params["payload"] ?? { content: "" }
+          });
+          bridge.writeResponse(msg.id, { success: sent });
+        }
+      } else if (msg.method === "approve") {
+        const params = msg.params;
+        const sid = params?.["sessionId"];
+        if (sid) {
+          approveAndConnect(client, sessionManager, bridge, sid).catch(() => {
+            bridge.writeResponse(msg.id, { success: false, error: "Failed to approve" });
+          }).then(() => {
+            bridge.writeResponse(msg.id, { success: true });
+          });
+        }
+      }
+    }
+  });
+  let pollTimer = null;
+  function connectAgentWs(token) {
+    const wsBase = config.wsUrl ?? config.apiUrl.replace(/^http/, "ws");
+    const url = `${wsBase}/ws/agent?token=${token}`;
+    agentWs = new WebSocket3(url);
+    agentWs.on("open", () => {
+      bridge.writeNotification("agent.connected", { agentId: opts.agentId });
+      agentHeartbeatTimer = setInterval(() => {
+        if (agentWs && agentWs.readyState === WebSocket3.OPEN) {
+          agentWs.send(JSON.stringify({ type: "system.heartbeat", payload: {} }));
+        }
+      }, 25e3);
+      if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+      }
+    });
+    agentWs.on("message", (raw) => {
+      try {
+        const message = JSON.parse(raw.toString());
+        const type = message.type;
+        if (type === "session.new" || type === "session.approved") {
+          const payload = message.payload;
+          const sid = payload["sessionId"];
+          const sessionToken = payload["sessionToken"];
+          if (knownPendingSessions.has(sid) || activeSessions.has(sid)) return;
+          knownPendingSessions.add(sid);
+          if (opts.autoApprove && type === "session.new") {
+            approveAndConnect(client, sessionManager, bridge, sid);
+          } else if (type === "session.approved" && sessionToken) {
+            activeSessions.add(sid);
+            bridge.writeNotification("session.new", {
+              sessionId: sid,
+              sessionToken,
+              taskDescription: payload["taskDescription"] ?? "",
+              consumerUserId: payload["consumerUserId"] ?? ""
+            });
+            sessionManager.connect(sid, sessionToken);
+          } else {
+            bridge.writeNotification("session.pending", {
+              sessionId: sid,
+              taskDescription: payload["taskDescription"] ?? "",
+              consumerUserId: payload["consumerUserId"] ?? ""
+            });
+          }
+        }
+      } catch {
+      }
+    });
+    agentWs.on("close", (code, reason) => {
+      if (agentHeartbeatTimer) {
+        clearInterval(agentHeartbeatTimer);
+        agentHeartbeatTimer = null;
+      }
+      bridge.writeNotification("agent.disconnected", {
+        agentId: opts.agentId,
+        code,
+        reason: reason.toString()
+      });
+      if (!pollTimer) {
+        startPollLoop();
+      }
+      if (code !== 1e3 && code !== 4009) {
+        setTimeout(() => connectAgentWs(token), 5e3);
+      }
+    });
+    agentWs.on("error", () => {
+    });
+  }
+  function startPollLoop() {
+    pollTimer = setInterval(async () => {
+      try {
+        const sessions = await client.getSessions({
+          role: "provider",
+          status: "pending_approval"
+        });
+        for (const session of sessions.data ?? []) {
+          const sid = session["id"];
+          if (knownPendingSessions.has(sid) || activeSessions.has(sid)) continue;
+          knownPendingSessions.add(sid);
+          if (opts.autoApprove) {
+            await approveAndConnect(client, sessionManager, bridge, sid);
+          } else {
+            bridge.writeNotification("session.pending", {
+              sessionId: sid,
+              taskDescription: session["taskDescription"] ?? "",
+              consumerUserId: session["consumerUserId"] ?? ""
+            });
+          }
+        }
+      } catch {
+      }
+    }, pollInterval);
+  }
+  if (opts.agentToken) {
+    connectAgentWs(opts.agentToken);
+  } else {
+    startPollLoop();
+  }
+  const shutdown = async () => {
+    if (pollTimer) clearInterval(pollTimer);
+    if (agentHeartbeatTimer) clearInterval(agentHeartbeatTimer);
+    bridge.stop();
+    if (agentWs) {
+      try {
+        agentWs.close(1e3, "Shutting down");
+      } catch {
+      }
+      agentWs = null;
+    }
+    if (!opts.agentToken) {
+      try {
+        await client.setOnlineStatus(opts.agentId, "offline");
+      } catch {
+      }
+    }
+    sessionManager.disconnectAll();
+    bridge.writeNotification("shutdown", { reason: "signal" });
+    setTimeout(() => process.exit(0), 500);
+  };
+  process.on("SIGINT", () => {
+    void shutdown();
+  });
+  process.on("SIGTERM", () => {
+    void shutdown();
+  });
+}
+async function approveAndConnect(client, sessionManager, bridge, sessionId) {
+  try {
+    const approved = await client.approveSession(sessionId);
+    const sessionToken = approved["sessionToken"];
+    const taskDescription = approved["taskDescription"];
+    activeSessions.add(sessionId);
+    bridge.writeNotification("session.new", {
+      sessionId,
+      sessionToken,
+      taskDescription: taskDescription ?? "",
+      consumerUserId: approved["consumerUserId"] ?? ""
+    });
+    sessionManager.connect(sessionId, sessionToken);
+  } catch (err) {
+    bridge.writeNotification("session.approve_failed", {
+      sessionId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("clawrent").description("ClawRent CLI - Agent capability rental platform").version("0.1.0");
+registerAuthCommand(program);
+registerBrowseCommand(program);
+registerAgentCommand(program);
+registerSessionsCommand(program);
+registerBalanceCommand(program);
+registerTopupCommand(program);
+registerRentCommand(program);
+registerEndCommand(program);
+registerSendCommand(program);
+registerHealthCommand(program);
+registerProviderCommands(program);
+registerServeCommand(program);
+program.parse();
+//# sourceMappingURL=index.js.map