@clawrent/cli 0.4.3 → 0.5.0

package/dist/lib.d.ts

@@ -1,204 +1 @@
-import { EventEmitter } from 'node:events';
-import WebSocket from 'ws';
-
-interface ClawRentConfig {
-    apiUrl: string;
-    wsUrl: string;
-    token?: string;
-    apiKey?: string;
-    userId?: string;
-    email?: string;
-    name?: string;
-}
-declare function getConfigPath(): string;
-declare function loadConfig(): ClawRentConfig;
-declare function saveConfig(partial: Partial<ClawRentConfig>): void;
-declare function clearConfig(): void;
-
-declare class ApiClient {
-    private config;
-    /** When set (e.g. by ProviderAgent.start), overrides config.token for REST auth. */
-    private agentTokenOverride;
-    constructor(config: ClawRentConfig);
-    /**
-     * Set a token that overrides config.token for subsequent REST requests.
-     * Used by the in-process provider agent: once serving with an agentToken,
-     * provider REST calls (approve/list/end + internal autoApprove) authenticate
-     * as the agent owner via this token, so they work without a separate user
-     * JWT login. The backend's resolveAuth accepts the agt_clawrent_* prefix.
-     * Pass null to clear (e.g. on stop_serving).
-     */
-    setAgentToken(token: string | null): void;
-    get apiUrl(): string;
-    get wsUrl(): string;
-    get userId(): string | undefined;
-    sendVerification(email: string): Promise<{
-        message: string;
-    }>;
-    registerUser(input: {
-        email: string;
-        password: string;
-        name: string;
-        verificationCode: string;
-    }): Promise<{
-        user: {
-            id: string;
-            email: string;
-            name: string;
-            role: string;
-        };
-        token: string;
-        apiKey: string;
-    }>;
-    login(email: string, password: string): Promise<{
-        user: {
-            id: string;
-            email: string;
-            name: string;
-            role: string;
-        };
-        token: string;
-    }>;
-    getMe(): Promise<Record<string, unknown>>;
-    browse(query?: {
-        search?: string;
-        category?: string;
-        page?: number;
-        limit?: number;
-    }): Promise<unknown>;
-    getAgent(slug: string): Promise<unknown>;
-    rent(options: {
-        agentId: string;
-        taskDescription: string;
-        grantedPermissions?: Record<string, unknown>;
-    }): Promise<unknown>;
-    getSessions(query?: {
-        role?: string;
-        status?: string;
-        page?: number;
-        limit?: number;
-    }): Promise<unknown>;
-    getSession(sessionId: string): Promise<Record<string, unknown>>;
-    getSessionMessages(sessionId: string): Promise<unknown>;
-    endSession(sessionId: string): Promise<unknown>;
-    approveSession(sessionId: string): Promise<unknown>;
-    getBalance(): Promise<{
-        balance: string;
-    }>;
-    topUp(amount: string): Promise<{
-        balance: string;
-    }>;
-    registerAgent(data: Record<string, unknown>): Promise<unknown>;
-    getMyAgents(query?: {
-        page?: number;
-        limit?: number;
-        roles?: string;
-    }): Promise<unknown>;
-    /** Resolve the current agent from agentToken. Requires agt_clawrent_ token auth. */
-    getMyAgent(): Promise<Record<string, unknown>>;
-    applyProvider(agentId: string, data: Record<string, unknown>): Promise<unknown>;
-    /** Publish agent — simplified apply-provider with defaults, submits for admin review */
-    publishAgent(agentId: string, data?: Record<string, unknown>): Promise<unknown>;
-    /** Activate agent — verify admin-approved + WebSocket connected, then go online */
-    activateAgent(agentId: string): Promise<unknown>;
-    setOnlineStatus(agentId: string, onlineStatus: string): Promise<unknown>;
-    generateAgentToken(agentId: string): Promise<{
-        agentId: string;
-        token: string;
-        createdAt: string;
-        warning: string;
-    }>;
-    revokeAgentToken(agentId: string): Promise<{
-        message: string;
-    }>;
-    createOrder(data: {
-        items: Array<{
-            providerAgentId: string;
-            consumerAgentId?: string;
-            taskDescription: string;
-            grantedPermissions?: Record<string, unknown>;
-        }>;
-        note?: string;
-        fromCart?: boolean;
-    }): Promise<unknown>;
-    getOrders(query?: {
-        status?: string;
-        page?: number;
-        limit?: number;
-    }): Promise<unknown>;
-    getOrder(orderId: string): Promise<unknown>;
-    cancelOrder(orderId: string): Promise<unknown>;
-    getCart(): Promise<unknown>;
-    addToCart(data: {
-        providerAgentId: string;
-        taskDescription: string;
-    }): Promise<unknown>;
-    updateCartItem(itemId: string, data: {
-        taskDescription: string;
-    }): Promise<unknown>;
-    removeFromCart(itemId: string): Promise<unknown>;
-    clearCart(): Promise<unknown>;
-    listFavorites(query?: {
-        page?: number;
-        limit?: number;
-    }): Promise<unknown>;
-    addFavorite(agentId: string): Promise<unknown>;
-    removeFavorite(agentId: string): Promise<unknown>;
-    health(): Promise<unknown>;
-    getDocsTree(): Promise<unknown>;
-    getDocByPath(path: string): Promise<unknown>;
-    searchDocs(query: string): Promise<unknown>;
-    getDoc(id: string): Promise<unknown>;
-    createDoc(data: {
-        type: string;
-        title: string;
-        parentId?: string;
-        content?: string;
-        slug?: string;
-        icon?: string;
-    }): Promise<unknown>;
-    updateDoc(id: string, data: {
-        title?: string;
-        content?: string;
-        changeSummary?: string;
-    }): Promise<unknown>;
-    deleteDoc(id: string): Promise<unknown>;
-    publishDoc(id: string): Promise<unknown>;
-    unpublishDoc(id: string): Promise<unknown>;
-    private request;
-}
-
-interface SessionConnection {
-    sessionId: string;
-    sessionToken: string;
-    ws: WebSocket;
-    heartbeatTimer: ReturnType<typeof setInterval> | null;
-    reconnectAttempts: number;
-}
-/**
- * SessionManager manages multiple concurrent WebSocket connections,
- * one per active session.
- */
-declare class SessionManager extends EventEmitter {
-    private sessions;
-    private wsUrl;
-    private heartbeatInterval;
-    private maxReconnectDelay;
-    agentId?: string;
-    constructor(wsUrl: string, heartbeatInterval?: number, maxReconnectDelay?: number);
-    /** Connect to a session via WebSocket as provider */
-    connect(sessionId: string, sessionToken: string): void;
-    /** Send a message to a specific session, auto-wrapping with protocol envelope */
-    send(sessionId: string, message: Record<string, unknown>): boolean;
-    /** Disconnect a specific session */
-    disconnect(sessionId: string): void;
-    /** Disconnect all sessions */
-    disconnectAll(): void;
-    /** Get active session count */
-    get activeCount(): number;
-    /** Check if a session is connected */
-    isConnected(sessionId: string): boolean;
-    private clearHeartbeat;
-}
-
-export { ApiClient, type ClawRentConfig, type SessionConnection, SessionManager, clearConfig, getConfigPath, loadConfig, saveConfig };
+export { ApiClient, ClawRentConfig, SessionConnection, SessionManager, clearConfig, getConfigPath, loadConfig, saveConfig } from '@clawrent/provider';

package/dist/lib.js

@@ -1,434 +1,12 @@
-// src/api-client.ts
-var ApiClient = class {
-  config;
-  /** When set (e.g. by ProviderAgent.start), overrides config.token for REST auth. */
-  agentTokenOverride = null;
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Set a token that overrides config.token for subsequent REST requests.
-   * Used by the in-process provider agent: once serving with an agentToken,
-   * provider REST calls (approve/list/end + internal autoApprove) authenticate
-   * as the agent owner via this token, so they work without a separate user
-   * JWT login. The backend's resolveAuth accepts the agt_clawrent_* prefix.
-   * Pass null to clear (e.g. on stop_serving).
-   */
-  setAgentToken(token) {
-    this.agentTokenOverride = token;
-  }
-  get apiUrl() {
-    return this.config.apiUrl;
-  }
-  get wsUrl() {
-    return this.config.wsUrl;
-  }
-  get userId() {
-    return this.config.userId;
-  }
-  // --- Auth (no auth needed) ---
-  async sendVerification(email) {
-    return this.request("POST", "/api/auth/send-verification", { email }, false);
-  }
-  async registerUser(input) {
-    return this.request("POST", "/api/auth/register", input, false);
-  }
-  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?.roles) params.set("roles", query.roles);
-    const qs = params.toString();
-    return this.request("GET", `/api/agents/my${qs ? `?${qs}` : ""}`);
-  }
-  /** Resolve the current agent from agentToken. Requires agt_clawrent_ token auth. */
-  async getMyAgent() {
-    return this.request("GET", "/api/agents/me/agent");
-  }
-  async applyProvider(agentId, data) {
-    return this.request("POST", `/api/agents/${encodeURIComponent(agentId)}/apply-provider`, data);
-  }
-  /** Publish agent — simplified apply-provider with defaults, submits for admin review */
-  async publishAgent(agentId, data) {
-    return this.request("POST", `/api/agents/${encodeURIComponent(agentId)}/publish`, data ?? {});
-  }
-  /** Activate agent — verify admin-approved + WebSocket connected, then go online */
-  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);
-  }
-  // --- Docs (MCP interface) ---
-  async getDocsTree() {
-    return this.request("GET", "/api/mcp/docs/tree", void 0, false);
-  }
-  async getDocByPath(path) {
-    return this.request("GET", `/api/mcp/docs/by-path/${encodeURI(path)}`, void 0, false);
-  }
-  async searchDocs(query) {
-    const params = new URLSearchParams({ q: query });
-    return this.request("GET", `/api/mcp/docs/search?${params.toString()}`, void 0, false);
-  }
-  async getDoc(id) {
-    return this.request("GET", `/api/mcp/docs/${encodeURIComponent(id)}`, void 0, false);
-  }
-  async createDoc(data) {
-    return this.request("POST", "/api/mcp/docs", data);
-  }
-  async updateDoc(id, data) {
-    return this.request("PATCH", `/api/mcp/docs/${encodeURIComponent(id)}`, data);
-  }
-  async deleteDoc(id) {
-    return this.request("DELETE", `/api/mcp/docs/${encodeURIComponent(id)}`);
-  }
-  async publishDoc(id) {
-    return this.request("POST", `/api/mcp/docs/${encodeURIComponent(id)}/publish`);
-  }
-  async unpublishDoc(id) {
-    return this.request("POST", `/api/mcp/docs/${encodeURIComponent(id)}/unpublish`);
-  }
-  // --- 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.agentTokenOverride) {
-        headers["Authorization"] = `Bearer ${this.agentTokenOverride}`;
-      } else 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/config.ts
-import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-var DEFAULT_CONFIG = {
-  apiUrl: "https://clawrent.cloud",
-  wsUrl: "wss://clawrent.cloud"
-};
-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 {
-    }
-  }
-  if (fileConfig.apiUrl?.includes("localhost") || fileConfig.wsUrl?.includes("localhost")) {
-    delete fileConfig.apiUrl;
-    delete fileConfig.wsUrl;
-    try {
-      const cleaned = { ...fileConfig };
-      writeFileSync(configPath, JSON.stringify(cleaned, null, 2), "utf-8");
-    } 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/serve/session-manager.ts
-import { EventEmitter } from "events";
-import WebSocket 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 WebSocket(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 === WebSocket.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 !== WebSocket.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 === WebSocket.OPEN || conn.ws.readyState === WebSocket.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 === WebSocket.OPEN;
-  }
-  clearHeartbeat(conn) {
-    if (conn.heartbeatTimer) {
-      clearInterval(conn.heartbeatTimer);
-      conn.heartbeatTimer = null;
-    }
-  }
-};
+// src/lib.ts
+import {
+  ApiClient,
+  SessionManager,
+  loadConfig,
+  saveConfig,
+  clearConfig,
+  getConfigPath
+} from "@clawrent/provider";
 export {
   ApiClient,
   SessionManager,