@rainfall-devkit/sdk 0.1.8 → 0.2.1

package/dist/cli/index.js

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,93 +30,17 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/cli/index.ts
-var import_fs = require("fs");
-var import_path = require("path");
-var import_os = require("os");
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl, importMetaUrl;
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+  }
+});
 
 // src/errors.ts
-var RainfallError = class _RainfallError extends Error {
-  constructor(message, code, statusCode, details) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
-    this.name = "RainfallError";
-    Object.setPrototypeOf(this, _RainfallError.prototype);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      statusCode: this.statusCode,
-      details: this.details
-    };
-  }
-};
-var AuthenticationError = class _AuthenticationError extends RainfallError {
-  constructor(message = "Invalid API key", details) {
-    super(message, "AUTHENTICATION_ERROR", 401, details);
-    this.name = "AuthenticationError";
-    Object.setPrototypeOf(this, _AuthenticationError.prototype);
-  }
-};
-var RateLimitError = class _RateLimitError extends RainfallError {
-  retryAfter;
-  limit;
-  remaining;
-  resetAt;
-  constructor(message = "Rate limit exceeded", retryAfter = 60, limit = 0, remaining = 0, resetAt) {
-    super(message, "RATE_LIMIT_ERROR", 429, { retryAfter, limit, remaining });
-    this.name = "RateLimitError";
-    this.retryAfter = retryAfter;
-    this.limit = limit;
-    this.remaining = remaining;
-    this.resetAt = resetAt || new Date(Date.now() + retryAfter * 1e3);
-    Object.setPrototypeOf(this, _RateLimitError.prototype);
-  }
-};
-var ValidationError = class _ValidationError extends RainfallError {
-  constructor(message, details) {
-    super(message, "VALIDATION_ERROR", 400, details);
-    this.name = "ValidationError";
-    Object.setPrototypeOf(this, _ValidationError.prototype);
-  }
-};
-var NotFoundError = class _NotFoundError extends RainfallError {
-  constructor(resource, identifier) {
-    super(
-      `${resource}${identifier ? ` '${identifier}'` : ""} not found`,
-      "NOT_FOUND_ERROR",
-      404,
-      { resource, identifier }
-    );
-    this.name = "NotFoundError";
-    Object.setPrototypeOf(this, _NotFoundError.prototype);
-  }
-};
-var ServerError = class _ServerError extends RainfallError {
-  constructor(message = "Internal server error", statusCode = 500) {
-    super(message, "SERVER_ERROR", statusCode);
-    this.name = "ServerError";
-    Object.setPrototypeOf(this, _ServerError.prototype);
-  }
-};
-var TimeoutError = class _TimeoutError extends RainfallError {
-  constructor(timeoutMs) {
-    super(`Request timed out after ${timeoutMs}ms`, "TIMEOUT_ERROR", 408);
-    this.name = "TimeoutError";
-    Object.setPrototypeOf(this, _TimeoutError.prototype);
-  }
-};
-var NetworkError = class _NetworkError extends RainfallError {
-  constructor(message = "Network error", details) {
-    super(message, "NETWORK_ERROR", void 0, details);
-    this.name = "NetworkError";
-    Object.setPrototypeOf(this, _NetworkError.prototype);
-  }
-};
 function parseErrorResponse(response, data) {
   const statusCode = response.status;
   if (statusCode === 429) {
@@ -158,295 +89,441 @@ function parseErrorResponse(response, data) {
       );
   }
 }
+var RainfallError, AuthenticationError, RateLimitError, ValidationError, NotFoundError, ServerError, TimeoutError, NetworkError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    init_cjs_shims();
+    RainfallError = class _RainfallError extends Error {
+      constructor(message, code, statusCode, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = "RainfallError";
+        Object.setPrototypeOf(this, _RainfallError.prototype);
+      }
+      toJSON() {
+        return {
+          name: this.name,
+          code: this.code,
+          message: this.message,
+          statusCode: this.statusCode,
+          details: this.details
+        };
+      }
+    };
+    AuthenticationError = class _AuthenticationError extends RainfallError {
+      constructor(message = "Invalid API key", details) {
+        super(message, "AUTHENTICATION_ERROR", 401, details);
+        this.name = "AuthenticationError";
+        Object.setPrototypeOf(this, _AuthenticationError.prototype);
+      }
+    };
+    RateLimitError = class _RateLimitError extends RainfallError {
+      retryAfter;
+      limit;
+      remaining;
+      resetAt;
+      constructor(message = "Rate limit exceeded", retryAfter = 60, limit = 0, remaining = 0, resetAt) {
+        super(message, "RATE_LIMIT_ERROR", 429, { retryAfter, limit, remaining });
+        this.name = "RateLimitError";
+        this.retryAfter = retryAfter;
+        this.limit = limit;
+        this.remaining = remaining;
+        this.resetAt = resetAt || new Date(Date.now() + retryAfter * 1e3);
+        Object.setPrototypeOf(this, _RateLimitError.prototype);
+      }
+    };
+    ValidationError = class _ValidationError extends RainfallError {
+      constructor(message, details) {
+        super(message, "VALIDATION_ERROR", 400, details);
+        this.name = "ValidationError";
+        Object.setPrototypeOf(this, _ValidationError.prototype);
+      }
+    };
+    NotFoundError = class _NotFoundError extends RainfallError {
+      constructor(resource, identifier) {
+        super(
+          `${resource}${identifier ? ` '${identifier}'` : ""} not found`,
+          "NOT_FOUND_ERROR",
+          404,
+          { resource, identifier }
+        );
+        this.name = "NotFoundError";
+        Object.setPrototypeOf(this, _NotFoundError.prototype);
+      }
+    };
+    ServerError = class _ServerError extends RainfallError {
+      constructor(message = "Internal server error", statusCode = 500) {
+        super(message, "SERVER_ERROR", statusCode);
+        this.name = "ServerError";
+        Object.setPrototypeOf(this, _ServerError.prototype);
+      }
+    };
+    TimeoutError = class _TimeoutError extends RainfallError {
+      constructor(timeoutMs) {
+        super(`Request timed out after ${timeoutMs}ms`, "TIMEOUT_ERROR", 408);
+        this.name = "TimeoutError";
+        Object.setPrototypeOf(this, _TimeoutError.prototype);
+      }
+    };
+    NetworkError = class _NetworkError extends RainfallError {
+      constructor(message = "Network error", details) {
+        super(message, "NETWORK_ERROR", void 0, details);
+        this.name = "NetworkError";
+        Object.setPrototypeOf(this, _NetworkError.prototype);
+      }
+    };
+  }
+});
 
 // src/client.ts
-var DEFAULT_BASE_URL = "https://olympic-api.pragma-digital.org/v1";
-var DEFAULT_TIMEOUT = 3e4;
-var DEFAULT_RETRIES = 3;
-var DEFAULT_RETRY_DELAY = 1e3;
-var RainfallClient = class {
-  apiKey;
-  baseUrl;
-  defaultTimeout;
-  defaultRetries;
-  defaultRetryDelay;
-  lastRateLimitInfo;
-  subscriberId;
-  constructor(config) {
-    this.apiKey = config.apiKey;
-    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
-    this.defaultTimeout = config.timeout || DEFAULT_TIMEOUT;
-    this.defaultRetries = config.retries ?? DEFAULT_RETRIES;
-    this.defaultRetryDelay = config.retryDelay || DEFAULT_RETRY_DELAY;
-  }
-  /**
-   * Get the last rate limit info from the API
-   */
-  getRateLimitInfo() {
-    return this.lastRateLimitInfo;
-  }
-  /**
-   * Make an authenticated request to the Rainfall API
-   */
-  async request(path, options = {}, requestOptions) {
-    const timeout = requestOptions?.timeout ?? this.defaultTimeout;
-    const maxRetries = requestOptions?.retries ?? this.defaultRetries;
-    const retryDelay = requestOptions?.retryDelay ?? this.defaultRetryDelay;
-    const url = `${this.baseUrl}${path}`;
-    const method = options.method || "GET";
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        const response = await fetch(url, {
-          method,
-          headers: {
-            "x-api-key": this.apiKey,
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-            "X-Rainfall-SDK-Version": "0.1.0",
-            ...options.headers
-          },
-          body: options.body ? JSON.stringify(options.body) : void 0,
-          signal: controller.signal
-        });
-        clearTimeout(timeoutId);
-        const limit = response.headers.get("x-ratelimit-limit");
-        const remaining = response.headers.get("x-ratelimit-remaining");
-        const reset = response.headers.get("x-ratelimit-reset");
-        if (limit && remaining && reset) {
-          this.lastRateLimitInfo = {
-            limit: parseInt(limit, 10),
-            remaining: parseInt(remaining, 10),
-            resetAt: new Date(parseInt(reset, 10) * 1e3)
-          };
+var DEFAULT_BASE_URL, DEFAULT_TIMEOUT, DEFAULT_RETRIES, DEFAULT_RETRY_DELAY, RainfallClient;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_errors();
+    DEFAULT_BASE_URL = "https://olympic-api.pragma-digital.org/v1";
+    DEFAULT_TIMEOUT = 3e4;
+    DEFAULT_RETRIES = 3;
+    DEFAULT_RETRY_DELAY = 1e3;
+    RainfallClient = class {
+      apiKey;
+      baseUrl;
+      defaultTimeout;
+      defaultRetries;
+      defaultRetryDelay;
+      lastRateLimitInfo;
+      subscriberId;
+      constructor(config) {
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+        this.defaultTimeout = config.timeout || DEFAULT_TIMEOUT;
+        this.defaultRetries = config.retries ?? DEFAULT_RETRIES;
+        this.defaultRetryDelay = config.retryDelay || DEFAULT_RETRY_DELAY;
+      }
+      /**
+       * Get the last rate limit info from the API
+       */
+      getRateLimitInfo() {
+        return this.lastRateLimitInfo;
+      }
+      /**
+       * Make an authenticated request to the Rainfall API
+       */
+      async request(path, options = {}, requestOptions) {
+        const timeout = requestOptions?.timeout ?? this.defaultTimeout;
+        const maxRetries = requestOptions?.retries ?? this.defaultRetries;
+        const retryDelay = requestOptions?.retryDelay ?? this.defaultRetryDelay;
+        const url = `${this.baseUrl}${path}`;
+        const method = options.method || "GET";
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            const response = await fetch(url, {
+              method,
+              headers: {
+                "x-api-key": this.apiKey,
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+                "X-Rainfall-SDK-Version": "0.1.0",
+                ...options.headers
+              },
+              body: options.body ? JSON.stringify(options.body) : void 0,
+              signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            const limit = response.headers.get("x-ratelimit-limit");
+            const remaining = response.headers.get("x-ratelimit-remaining");
+            const reset = response.headers.get("x-ratelimit-reset");
+            if (limit && remaining && reset) {
+              this.lastRateLimitInfo = {
+                limit: parseInt(limit, 10),
+                remaining: parseInt(remaining, 10),
+                resetAt: new Date(parseInt(reset, 10) * 1e3)
+              };
+            }
+            let data;
+            const contentType = response.headers.get("content-type");
+            if (contentType?.includes("application/json")) {
+              data = await response.json();
+            } else {
+              data = await response.text();
+            }
+            if (!response.ok) {
+              throw parseErrorResponse(response, data);
+            }
+            return data;
+          } catch (error) {
+            if (error instanceof RainfallError) {
+              if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429) {
+                throw error;
+              }
+              if (error.statusCode === 401) {
+                throw error;
+              }
+            }
+            if (error instanceof Error && error.name === "AbortError") {
+              lastError = new TimeoutError(timeout);
+            } else if (error instanceof TypeError) {
+              lastError = new NetworkError(error.message);
+            } else {
+              lastError = error instanceof Error ? error : new Error(String(error));
+            }
+            if (attempt >= maxRetries) {
+              break;
+            }
+            const delay = retryDelay * Math.pow(2, attempt) + Math.random() * 1e3;
+            await this.sleep(delay);
+          }
         }
-        let data;
-        const contentType = response.headers.get("content-type");
-        if (contentType?.includes("application/json")) {
-          data = await response.json();
-        } else {
-          data = await response.text();
+        throw lastError || new RainfallError("Request failed", "REQUEST_FAILED");
+      }
+      /**
+       * Execute a tool/node by ID
+       */
+      async executeTool(toolId, params, options) {
+        const subscriberId = await this.ensureSubscriberId();
+        const response = await this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}`, {
+          method: "POST",
+          body: params || {}
+        }, options);
+        return response.result;
+      }
+      /**
+       * List all available tools
+       */
+      async listTools() {
+        const subscriberId = await this.ensureSubscriberId();
+        const result = await this.request(`/olympic/subscribers/${subscriberId}/nodes/_utils/node-descriptions`);
+        if (result.success && result.nodes) {
+          return Object.values(result.nodes);
         }
-        if (!response.ok) {
-          throw parseErrorResponse(response, data);
+        const legacyResult = await this.request(`/olympic/subscribers/${subscriberId}/nodes/_utils/node-list`);
+        if (legacyResult.keys && Array.isArray(legacyResult.keys)) {
+          return legacyResult.keys.map((key) => ({
+            id: key,
+            name: key,
+            description: "",
+            category: "general"
+          }));
         }
-        return data;
-      } catch (error) {
-        if (error instanceof RainfallError) {
-          if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429) {
-            throw error;
-          }
-          if (error.statusCode === 401) {
-            throw error;
+        return legacyResult.nodes || [];
+      }
+      /**
+       * Get tool schema/parameters
+       */
+      async getToolSchema(toolId) {
+        const subscriberId = await this.ensureSubscriberId();
+        const response = await this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}/params`);
+        return response.params;
+      }
+      /**
+       * Get subscriber info
+       */
+      async getMe() {
+        const result = await this.request("/olympic/subscribers/me");
+        if (result.subscriber?.id) {
+          this.subscriberId = result.subscriber.id;
+        }
+        const subscriber = result.subscriber;
+        return {
+          id: subscriber.id,
+          name: subscriber.name,
+          email: subscriber.google_id,
+          billingStatus: subscriber.billing_status,
+          plan: subscriber.billing_status,
+          usage: {
+            callsThisMonth: subscriber.metadata?.usage?.callsThisMonth ?? 0,
+            callsLimit: subscriber.metadata?.usage?.callsLimit ?? 5e3
           }
+        };
+      }
+      /**
+       * Ensure we have a subscriber ID, fetching it if necessary
+       */
+      async ensureSubscriberId() {
+        if (this.subscriberId) {
+          return this.subscriberId;
         }
-        if (error instanceof Error && error.name === "AbortError") {
-          lastError = new TimeoutError(timeout);
-        } else if (error instanceof TypeError) {
-          lastError = new NetworkError(error.message);
-        } else {
-          lastError = error instanceof Error ? error : new Error(String(error));
+        const me = await this.getMe();
+        if (!me.id) {
+          throw new RainfallError("Failed to get subscriber ID", "NO_SUBSCRIBER_ID");
         }
-        if (attempt >= maxRetries) {
-          break;
+        return me.id;
+      }
+      sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+      }
+      /**
+       * OpenAI-compatible chat completions with tool support
+       */
+      async chatCompletions(params) {
+        const { subscriber_id, ...body } = params;
+        if (body.stream) {
+          const url = `${this.baseUrl}/olympic/subscribers/${subscriber_id}/v1/chat/completions`;
+          const response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "x-api-key": this.apiKey,
+              "Content-Type": "application/json",
+              "Accept": "text/event-stream"
+            },
+            body: JSON.stringify(body)
+          });
+          if (!response.ok) {
+            const error = await response.text();
+            throw new RainfallError(`Chat completions failed: ${error}`, "CHAT_ERROR");
+          }
+          if (!response.body) {
+            throw new RainfallError("No response body", "CHAT_ERROR");
+          }
+          return response.body;
         }
-        const delay = retryDelay * Math.pow(2, attempt) + Math.random() * 1e3;
-        await this.sleep(delay);
+        return this.request(
+          `/olympic/subscribers/${subscriber_id}/v1/chat/completions`,
+          {
+            method: "POST",
+            body
+          }
+        );
       }
-    }
-    throw lastError || new RainfallError("Request failed", "REQUEST_FAILED");
-  }
-  /**
-   * Execute a tool/node by ID
-   */
-  async executeTool(toolId, params, options) {
-    const subscriberId = await this.ensureSubscriberId();
-    const response = await this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}`, {
-      method: "POST",
-      body: params || {}
-    }, options);
-    return response.result;
-  }
-  /**
-   * List all available tools
-   */
-  async listTools() {
-    const subscriberId = await this.ensureSubscriberId();
-    const result = await this.request(`/olympic/subscribers/${subscriberId}/nodes/_utils/node-descriptions`);
-    if (result.success && result.nodes) {
-      return Object.values(result.nodes);
-    }
-    const legacyResult = await this.request(`/olympic/subscribers/${subscriberId}/nodes/_utils/node-list`);
-    if (legacyResult.keys && Array.isArray(legacyResult.keys)) {
-      return legacyResult.keys.map((key) => ({
-        id: key,
-        name: key,
-        description: "",
-        category: "general"
-      }));
-    }
-    return legacyResult.nodes || [];
-  }
-  /**
-   * Get tool schema/parameters
-   */
-  async getToolSchema(toolId) {
-    const subscriberId = await this.ensureSubscriberId();
-    const response = await this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}/params`);
-    return response.params;
-  }
-  /**
-   * Get subscriber info
-   */
-  async getMe() {
-    const result = await this.request("/olympic/subscribers/me");
-    if (result.subscriber?.id) {
-      this.subscriberId = result.subscriber.id;
-    }
-    const subscriber = result.subscriber;
-    return {
-      id: subscriber.id,
-      name: subscriber.name,
-      email: subscriber.google_id,
-      billingStatus: subscriber.billing_status,
-      plan: subscriber.billing_status,
-      usage: {
-        callsThisMonth: subscriber.metadata?.usage?.callsThisMonth ?? 0,
-        callsLimit: subscriber.metadata?.usage?.callsLimit ?? 5e3
+      /**
+       * List available models (OpenAI-compatible format)
+       */
+      async listModels(subscriberId) {
+        const sid = subscriberId || this.subscriberId || await this.ensureSubscriberId();
+        const result = await this.request(
+          `/olympic/subscribers/${sid}/v1/models`
+        );
+        return result.data || [];
       }
     };
   }
-  /**
-   * Ensure we have a subscriber ID, fetching it if necessary
-   */
-  async ensureSubscriberId() {
-    if (this.subscriberId) {
-      return this.subscriberId;
-    }
-    const me = await this.getMe();
-    if (!me.id) {
-      throw new RainfallError("Failed to get subscriber ID", "NO_SUBSCRIBER_ID");
-    }
-    return me.id;
-  }
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-};
+});
 
 // src/namespaces/integrations.ts
 function createIntegrations(client) {
   return new IntegrationsNamespace(client);
 }
-var IntegrationsNamespace = class {
-  constructor(client) {
-    this.client = client;
-  }
-  get github() {
-    return {
-      issues: {
-        create: (params) => this.client.executeTool("github-create-issue", params),
-        list: (params) => this.client.executeTool("github-list-issues", params),
-        get: (params) => this.client.executeTool("github-get-issue", params),
-        update: (params) => this.client.executeTool("github-update-issue", params),
-        addComment: (params) => this.client.executeTool("github-add-issue-comment", params)
-      },
-      repos: {
-        get: (params) => this.client.executeTool("github-get-repository", params),
-        listBranches: (params) => this.client.executeTool("github-list-branches", params)
-      },
-      pullRequests: {
-        list: (params) => this.client.executeTool("github-list-pull-requests", params),
-        get: (params) => this.client.executeTool("github-get-pull-request", params)
+var IntegrationsNamespace;
+var init_integrations = __esm({
+  "src/namespaces/integrations.ts"() {
+    "use strict";
+    init_cjs_shims();
+    IntegrationsNamespace = class {
+      constructor(client) {
+        this.client = client;
       }
-    };
-  }
-  get notion() {
-    return {
-      pages: {
-        create: (params) => this.client.executeTool("notion-pages-create", params),
-        retrieve: (params) => this.client.executeTool("notion-pages-retrieve", params),
-        update: (params) => this.client.executeTool("notion-pages-update", params)
-      },
-      databases: {
-        query: (params) => this.client.executeTool("notion-databases-query", params),
-        retrieve: (params) => this.client.executeTool("notion-databases-retrieve", params)
-      },
-      blocks: {
-        appendChildren: (params) => this.client.executeTool("notion-blocks-append-children", params),
-        retrieveChildren: (params) => this.client.executeTool("notion-blocks-retrieve-children", params)
+      get github() {
+        return {
+          issues: {
+            create: (params) => this.client.executeTool("github-create-issue", params),
+            list: (params) => this.client.executeTool("github-list-issues", params),
+            get: (params) => this.client.executeTool("github-get-issue", params),
+            update: (params) => this.client.executeTool("github-update-issue", params),
+            addComment: (params) => this.client.executeTool("github-add-issue-comment", params)
+          },
+          repos: {
+            get: (params) => this.client.executeTool("github-get-repository", params),
+            listBranches: (params) => this.client.executeTool("github-list-branches", params)
+          },
+          pullRequests: {
+            list: (params) => this.client.executeTool("github-list-pull-requests", params),
+            get: (params) => this.client.executeTool("github-get-pull-request", params)
+          }
+        };
       }
-    };
-  }
-  get linear() {
-    return {
-      issues: {
-        create: (params) => this.client.executeTool("linear-core-issueCreate", params),
-        list: (params) => this.client.executeTool("linear-core-issues", params),
-        get: (params) => this.client.executeTool("linear-core-issue", params),
-        update: (params) => this.client.executeTool("linear-core-issueUpdate", params),
-        archive: (params) => this.client.executeTool("linear-core-issueArchive", params)
-      },
-      teams: {
-        list: () => this.client.executeTool("linear-core-teams", {})
+      get notion() {
+        return {
+          pages: {
+            create: (params) => this.client.executeTool("notion-pages-create", params),
+            retrieve: (params) => this.client.executeTool("notion-pages-retrieve", params),
+            update: (params) => this.client.executeTool("notion-pages-update", params)
+          },
+          databases: {
+            query: (params) => this.client.executeTool("notion-databases-query", params),
+            retrieve: (params) => this.client.executeTool("notion-databases-retrieve", params)
+          },
+          blocks: {
+            appendChildren: (params) => this.client.executeTool("notion-blocks-append-children", params),
+            retrieveChildren: (params) => this.client.executeTool("notion-blocks-retrieve-children", params)
+          }
+        };
       }
-    };
-  }
-  get slack() {
-    return {
-      messages: {
-        send: (params) => this.client.executeTool("slack-core-postMessage", params),
-        list: (params) => this.client.executeTool("slack-core-listMessages", params)
-      },
-      channels: {
-        list: () => this.client.executeTool("slack-core-listChannels", {})
-      },
-      users: {
-        list: () => this.client.executeTool("slack-core-listUsers", {})
-      },
-      reactions: {
-        add: (params) => this.client.executeTool("slack-core-addReaction", params)
+      get linear() {
+        return {
+          issues: {
+            create: (params) => this.client.executeTool("linear-core-issueCreate", params),
+            list: (params) => this.client.executeTool("linear-core-issues", params),
+            get: (params) => this.client.executeTool("linear-core-issue", params),
+            update: (params) => this.client.executeTool("linear-core-issueUpdate", params),
+            archive: (params) => this.client.executeTool("linear-core-issueArchive", params)
+          },
+          teams: {
+            list: () => this.client.executeTool("linear-core-teams", {})
+          }
+        };
       }
-    };
-  }
-  get figma() {
-    return {
-      files: {
-        get: (params) => this.client.executeTool("figma-files-getFile", { fileKey: params.fileKey }),
-        getNodes: (params) => this.client.executeTool("figma-files-getFileNodes", { fileKey: params.fileKey, nodeIds: params.nodeIds }),
-        getImages: (params) => this.client.executeTool("figma-files-getFileImage", { fileKey: params.fileKey, nodeIds: params.nodeIds, format: params.format }),
-        getComments: (params) => this.client.executeTool("figma-comments-getFileComments", { fileKey: params.fileKey }),
-        postComment: (params) => this.client.executeTool("figma-comments-postComment", { fileKey: params.fileKey, message: params.message, nodeId: params.nodeId })
-      },
-      projects: {
-        list: (params) => this.client.executeTool("figma-projects-getTeamProjects", { teamId: params.teamId }),
-        getFiles: (params) => this.client.executeTool("figma-projects-getProjectFiles", { projectId: params.projectId })
+      get slack() {
+        return {
+          messages: {
+            send: (params) => this.client.executeTool("slack-core-postMessage", params),
+            list: (params) => this.client.executeTool("slack-core-listMessages", params)
+          },
+          channels: {
+            list: () => this.client.executeTool("slack-core-listChannels", {})
+          },
+          users: {
+            list: () => this.client.executeTool("slack-core-listUsers", {})
+          },
+          reactions: {
+            add: (params) => this.client.executeTool("slack-core-addReaction", params)
+          }
+        };
       }
-    };
-  }
-  get stripe() {
-    return {
-      customers: {
-        create: (params) => this.client.executeTool("stripe-customers-create", params),
-        retrieve: (params) => this.client.executeTool("stripe-customers-retrieve", { customerId: params.customerId }),
-        update: (params) => this.client.executeTool("stripe-customers-update", params),
-        listPaymentMethods: (params) => this.client.executeTool("stripe-customers-list-payment-methods", { customerId: params.customerId })
-      },
-      paymentIntents: {
-        create: (params) => this.client.executeTool("stripe-payment-intents-create", params),
-        retrieve: (params) => this.client.executeTool("stripe-payment-intents-retrieve", { paymentIntentId: params.paymentIntentId }),
-        confirm: (params) => this.client.executeTool("stripe-payment-intents-confirm", { paymentIntentId: params.paymentIntentId })
-      },
-      subscriptions: {
-        create: (params) => this.client.executeTool("stripe-subscriptions-create", params),
-        retrieve: (params) => this.client.executeTool("stripe-subscriptions-retrieve", { subscriptionId: params.subscriptionId }),
-        cancel: (params) => this.client.executeTool("stripe-subscriptions-cancel", { subscriptionId: params.subscriptionId })
+      get figma() {
+        return {
+          files: {
+            get: (params) => this.client.executeTool("figma-files-getFile", { fileKey: params.fileKey }),
+            getNodes: (params) => this.client.executeTool("figma-files-getFileNodes", { fileKey: params.fileKey, nodeIds: params.nodeIds }),
+            getImages: (params) => this.client.executeTool("figma-files-getFileImage", { fileKey: params.fileKey, nodeIds: params.nodeIds, format: params.format }),
+            getComments: (params) => this.client.executeTool("figma-comments-getFileComments", { fileKey: params.fileKey }),
+            postComment: (params) => this.client.executeTool("figma-comments-postComment", { fileKey: params.fileKey, message: params.message, nodeId: params.nodeId })
+          },
+          projects: {
+            list: (params) => this.client.executeTool("figma-projects-getTeamProjects", { teamId: params.teamId }),
+            getFiles: (params) => this.client.executeTool("figma-projects-getProjectFiles", { projectId: params.projectId })
+          }
+        };
+      }
+      get stripe() {
+        return {
+          customers: {
+            create: (params) => this.client.executeTool("stripe-customers-create", params),
+            retrieve: (params) => this.client.executeTool("stripe-customers-retrieve", { customerId: params.customerId }),
+            update: (params) => this.client.executeTool("stripe-customers-update", params),
+            listPaymentMethods: (params) => this.client.executeTool("stripe-customers-list-payment-methods", { customerId: params.customerId })
+          },
+          paymentIntents: {
+            create: (params) => this.client.executeTool("stripe-payment-intents-create", params),
+            retrieve: (params) => this.client.executeTool("stripe-payment-intents-retrieve", { paymentIntentId: params.paymentIntentId }),
+            confirm: (params) => this.client.executeTool("stripe-payment-intents-confirm", { paymentIntentId: params.paymentIntentId })
+          },
+          subscriptions: {
+            create: (params) => this.client.executeTool("stripe-subscriptions-create", params),
+            retrieve: (params) => this.client.executeTool("stripe-subscriptions-retrieve", { subscriptionId: params.subscriptionId }),
+            cancel: (params) => this.client.executeTool("stripe-subscriptions-cancel", { subscriptionId: params.subscriptionId })
+          }
+        };
       }
     };
   }
-};
+});
 
 // src/namespaces/memory.ts
 function createMemory(client) {
@@ -459,6 +536,12 @@ function createMemory(client) {
     delete: (params) => client.executeTool("memory-delete", { memoryId: params.memoryId })
   };
 }
+var init_memory = __esm({
+  "src/namespaces/memory.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
 
 // src/namespaces/articles.ts
 function createArticles(client) {
@@ -473,6 +556,12 @@ function createArticles(client) {
     extractTopics: (params) => client.executeTool("article-topic-extractor", params)
   };
 }
+var init_articles = __esm({
+  "src/namespaces/articles.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
 
 // src/namespaces/web.ts
 function createWeb(client) {
@@ -486,335 +575,2974 @@ function createWeb(client) {
     extractHtml: (params) => client.executeTool("extract-html-selector", params)
   };
 }
+var init_web = __esm({
+  "src/namespaces/web.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/namespaces/ai.ts
+function createAI(client) {
+  return {
+    embeddings: {
+      document: (params) => client.executeTool("jina-document-embedding", params),
+      query: (params) => client.executeTool("jina-query-embedding", params),
+      image: (params) => client.executeTool("jina-image-embedding", { image: params.imageBase64 })
+    },
+    image: {
+      generate: (params) => client.executeTool("image-generation", params)
+    },
+    ocr: (params) => client.executeTool("ocr-text-extraction", { image: params.imageBase64 }),
+    vision: (params) => client.executeTool("llama-scout-vision", { image: params.imageBase64, prompt: params.prompt }),
+    chat: (params) => client.executeTool("xai-chat-completions", params),
+    complete: (params) => client.executeTool("fim", params),
+    classify: (params) => client.executeTool("jina-document-classifier", params),
+    segment: (params) => client.executeTool("jina-text-segmenter", params),
+    /**
+     * OpenAI-compatible chat completions with full tool support
+     * This is the recommended method for multi-turn conversations with tools
+     */
+    chatCompletions: (params) => client.chatCompletions(params)
+  };
+}
+var init_ai = __esm({
+  "src/namespaces/ai.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/namespaces/data.ts
+function createData(client) {
+  return {
+    csv: {
+      query: (params) => client.executeTool("query-csv", params),
+      convert: (params) => client.executeTool("csv-convert", params)
+    },
+    scripts: {
+      create: (params) => client.executeTool("create-saved-script", params),
+      execute: (params) => client.executeTool("execute-saved-script", params),
+      list: () => client.executeTool("list-saved-scripts", {}),
+      update: (params) => client.executeTool("update-saved-script", params),
+      delete: (params) => client.executeTool("delete-saved-script", params)
+    },
+    similarity: {
+      search: (params) => client.executeTool("duck-db-similarity-search", params),
+      duckDbSearch: (params) => client.executeTool("duck-db-similarity-search", params)
+    }
+  };
+}
+var init_data = __esm({
+  "src/namespaces/data.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/namespaces/utils.ts
+function createUtils(client) {
+  return {
+    mermaid: (params) => client.executeTool("mermaid-diagram-generator", { mermaid: params.diagram }),
+    documentConvert: (params) => client.executeTool("document-format-converter", {
+      base64: `data:${params.mimeType};base64,${Buffer.from(params.document).toString("base64")}`,
+      format: params.format
+    }),
+    regex: {
+      match: (params) => client.executeTool("regex-match", params),
+      replace: (params) => client.executeTool("regex-replace", params)
+    },
+    jsonExtract: (params) => client.executeTool("json-extract", params),
+    digest: (params) => client.executeTool("digest-generator", { text: params.data }),
+    monteCarlo: (params) => client.executeTool("monte-carlo-simulation", params)
+  };
+}
+var init_utils = __esm({
+  "src/namespaces/utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/sdk.ts
+var Rainfall;
+var init_sdk = __esm({
+  "src/sdk.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_client();
+    init_integrations();
+    init_memory();
+    init_articles();
+    init_web();
+    init_ai();
+    init_data();
+    init_utils();
+    Rainfall = class {
+      client;
+      _integrations;
+      _memory;
+      _articles;
+      _web;
+      _ai;
+      _data;
+      _utils;
+      constructor(config) {
+        this.client = new RainfallClient(config);
+      }
+      /**
+       * Integrations namespace - GitHub, Notion, Linear, Slack, Figma, Stripe
+       * 
+       * @example
+       * ```typescript
+       * // GitHub
+       * await rainfall.integrations.github.issues.create({
+       *   owner: 'facebook',
+       *   repo: 'react',
+       *   title: 'Bug report'
+       * });
+       * 
+       * // Slack
+       * await rainfall.integrations.slack.messages.send({
+       *   channelId: 'C123456',
+       *   text: 'Hello team!'
+       * });
+       * 
+       * // Linear
+       * const issues = await rainfall.integrations.linear.issues.list();
+       * ```
+       */
+      get integrations() {
+        if (!this._integrations) {
+          this._integrations = createIntegrations(this.client);
+        }
+        return this._integrations;
+      }
+      /**
+       * Memory namespace - Semantic memory storage and retrieval
+       * 
+       * @example
+       * ```typescript
+       * // Store a memory
+       * await rainfall.memory.create({
+       *   content: 'User prefers dark mode',
+       *   keywords: ['preference', 'ui']
+       * });
+       * 
+       * // Recall similar memories
+       * const memories = await rainfall.memory.recall({
+       *   query: 'user preferences',
+       *   topK: 5
+       * });
+       * ```
+       */
+      get memory() {
+        if (!this._memory) {
+          this._memory = createMemory(this.client);
+        }
+        return this._memory;
+      }
+      /**
+       * Articles namespace - News aggregation and article management
+       * 
+       * @example
+       * ```typescript
+       * // Search news
+       * const articles = await rainfall.articles.search({
+       *   query: 'artificial intelligence'
+       * });
+       * 
+       * // Create from URL
+       * const article = await rainfall.articles.createFromUrl({
+       *   url: 'https://example.com/article'
+       * });
+       * 
+       * // Summarize
+       * const summary = await rainfall.articles.summarize({
+       *   text: article.content
+       * });
+       * ```
+       */
+      get articles() {
+        if (!this._articles) {
+          this._articles = createArticles(this.client);
+        }
+        return this._articles;
+      }
+      /**
+       * Web namespace - Web search, scraping, and content extraction
+       * 
+       * @example
+       * ```typescript
+       * // Search with Exa
+       * const results = await rainfall.web.search.exa({
+       *   query: 'latest AI research'
+       * });
+       * 
+       * // Fetch and convert
+       * const html = await rainfall.web.fetch({ url: 'https://example.com' });
+       * const markdown = await rainfall.web.htmlToMarkdown({ html });
+       * 
+       * // Extract specific elements
+       * const links = await rainfall.web.extractHtml({
+       *   html,
+       *   selector: 'a[href]'
+       * });
+       * ```
+       */
+      get web() {
+        if (!this._web) {
+          this._web = createWeb(this.client);
+        }
+        return this._web;
+      }
+      /**
+       * AI namespace - Embeddings, image generation, OCR, vision, chat
+       * 
+       * @example
+       * ```typescript
+       * // Generate embeddings
+       * const embedding = await rainfall.ai.embeddings.document({
+       *   text: 'Hello world'
+       * });
+       * 
+       * // Generate image
+       * const image = await rainfall.ai.image.generate({
+       *   prompt: 'A serene mountain landscape'
+       * });
+       * 
+       * // OCR
+       * const text = await rainfall.ai.ocr({ imageBase64: '...' });
+       * 
+       * // Chat
+       * const response = await rainfall.ai.chat({
+       *   messages: [{ role: 'user', content: 'Hello!' }]
+       * });
+       * ```
+       */
+      get ai() {
+        if (!this._ai) {
+          this._ai = createAI(this.client);
+        }
+        return this._ai;
+      }
+      /**
+       * Data namespace - CSV processing, scripts, similarity search
+       * 
+       * @example
+       * ```typescript
+       * // Query CSV with SQL
+       * const results = await rainfall.data.csv.query({
+       *   sql: 'SELECT * FROM data WHERE value > 100'
+       * });
+       * 
+       * // Execute saved script
+       * const result = await rainfall.data.scripts.execute({
+       *   name: 'my-script',
+       *   params: { input: 'data' }
+       * });
+       * ```
+       */
+      get data() {
+        if (!this._data) {
+          this._data = createData(this.client);
+        }
+        return this._data;
+      }
+      /**
+       * Utils namespace - Mermaid diagrams, document conversion, regex, JSON extraction
+       * 
+       * @example
+       * ```typescript
+       * // Generate diagram
+       * const diagram = await rainfall.utils.mermaid({
+       *   diagram: 'graph TD; A-->B;'
+       * });
+       * 
+       * // Convert document
+       * const pdf = await rainfall.utils.documentConvert({
+       *   document: markdownContent,
+       *   mimeType: 'text/markdown',
+       *   format: 'pdf'
+       * });
+       * 
+       * // Extract JSON from text
+       * const json = await rainfall.utils.jsonExtract({
+       *   text: 'Here is some data: {"key": "value"}'
+       * });
+       * ```
+       */
+      get utils() {
+        if (!this._utils) {
+          this._utils = createUtils(this.client);
+        }
+        return this._utils;
+      }
+      /**
+       * Get the underlying HTTP client for advanced usage
+       */
+      getClient() {
+        return this.client;
+      }
+      /**
+       * List all available tools
+       */
+      async listTools() {
+        return this.client.listTools();
+      }
+      /**
+       * Get schema for a specific tool
+       */
+      async getToolSchema(toolId) {
+        return this.client.getToolSchema(toolId);
+      }
+      /**
+       * Execute any tool by ID (low-level access)
+       */
+      async executeTool(toolId, params) {
+        return this.client.executeTool(toolId, params);
+      }
+      /**
+       * Get current subscriber info and usage
+       */
+      async getMe() {
+        return this.client.getMe();
+      }
+      /**
+       * Get current rate limit info
+       */
+      getRateLimitInfo() {
+        return this.client.getRateLimitInfo();
+      }
+      /**
+       * OpenAI-compatible chat completions with tool support
+       * 
+       * @example
+       * ```typescript
+       * // Simple chat
+       * const response = await rainfall.chatCompletions({
+       *   subscriber_id: 'my-subscriber',
+       *   messages: [{ role: 'user', content: 'Hello!' }],
+       *   model: 'llama-3.3-70b-versatile'
+       * });
+       * 
+       * // With tools
+       * const response = await rainfall.chatCompletions({
+       *   subscriber_id: 'my-subscriber',
+       *   messages: [{ role: 'user', content: 'Search for AI news' }],
+       *   tools: [{ type: 'function', function: { name: 'web-search' } }],
+       *   enable_stacked: true
+       * });
+       * 
+       * // Streaming
+       * const stream = await rainfall.chatCompletions({
+       *   subscriber_id: 'my-subscriber',
+       *   messages: [{ role: 'user', content: 'Tell me a story' }],
+       *   stream: true
+       * });
+       * ```
+       */
+      async chatCompletions(params) {
+        return this.client.chatCompletions(params);
+      }
+      /**
+       * List available models (OpenAI-compatible format)
+       * 
+       * @example
+       * ```typescript
+       * const models = await rainfall.listModels();
+       * console.log(models); // [{ id: 'llama-3.3-70b-versatile', ... }]
+       * ```
+       */
+      async listModels(subscriberId) {
+        return this.client.listModels(subscriberId);
+      }
+    };
+  }
+});
+
+// src/cli/config.ts
+var config_exports = {};
+__export(config_exports, {
+  getConfigDir: () => getConfigDir,
+  getLLMConfig: () => getLLMConfig,
+  getProviderBaseUrl: () => getProviderBaseUrl,
+  isLocalProvider: () => isLocalProvider,
+  loadConfig: () => loadConfig,
+  saveConfig: () => saveConfig
+});
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function loadConfig() {
+  let config = {};
+  if ((0, import_fs.existsSync)(CONFIG_FILE)) {
+    try {
+      config = JSON.parse((0, import_fs.readFileSync)(CONFIG_FILE, "utf8"));
+    } catch {
+      config = {};
+    }
+  }
+  if (process.env.RAINFALL_API_KEY) {
+    config.apiKey = process.env.RAINFALL_API_KEY;
+  }
+  if (process.env.RAINFALL_BASE_URL) {
+    config.baseUrl = process.env.RAINFALL_BASE_URL;
+  }
+  if (!config.llm) {
+    config.llm = { provider: "rainfall" };
+  }
+  if (process.env.OPENAI_API_KEY) {
+    config.llm.provider = config.llm.provider || "openai";
+    config.llm.apiKey = process.env.OPENAI_API_KEY;
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    config.llm.provider = "anthropic";
+    config.llm.apiKey = process.env.ANTHROPIC_API_KEY;
+  }
+  if (process.env.OLLAMA_HOST || process.env.OLLAMA_URL) {
+    config.llm.provider = "ollama";
+    config.llm.baseUrl = process.env.OLLAMA_HOST || process.env.OLLAMA_URL;
+  }
+  if (process.env.LLM_MODEL) {
+    config.llm.model = process.env.LLM_MODEL;
+  }
+  return config;
+}
+function saveConfig(config) {
+  if (!(0, import_fs.existsSync)(CONFIG_DIR)) {
+    (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
+  }
+  (0, import_fs.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getLLMConfig(config) {
+  const defaults = {
+    provider: "rainfall",
+    apiKey: config.apiKey || "",
+    baseUrl: config.baseUrl || "https://api.rainfall.com",
+    model: "llama-3.3-70b-versatile",
+    options: {}
+  };
+  return { ...defaults, ...config.llm };
+}
+function isLocalProvider(config) {
+  return config.llm?.provider === "ollama" || config.llm?.provider === "local";
+}
+function getProviderBaseUrl(config) {
+  const provider = config.llm?.provider || "rainfall";
+  switch (provider) {
+    case "openai":
+      return config.llm?.baseUrl || "https://api.openai.com/v1";
+    case "anthropic":
+      return config.llm?.baseUrl || "https://api.anthropic.com/v1";
+    case "ollama":
+      return config.llm?.baseUrl || "http://localhost:11434/v1";
+    case "local":
+    case "custom":
+      return config.llm?.baseUrl || "http://localhost:1234/v1";
+    case "rainfall":
+    default:
+      return config.baseUrl || "https://api.rainfall.com";
+  }
+}
+var import_fs, import_path, import_os, CONFIG_DIR, CONFIG_FILE;
+var init_config = __esm({
+  "src/cli/config.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs = require("fs");
+    import_path = require("path");
+    import_os = require("os");
+    CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".rainfall");
+    CONFIG_FILE = (0, import_path.join)(CONFIG_DIR, "config.json");
+  }
+});
+
+// src/services/networked.ts
+var RainfallNetworkedExecutor;
+var init_networked = __esm({
+  "src/services/networked.ts"() {
+    "use strict";
+    init_cjs_shims();
+    RainfallNetworkedExecutor = class {
+      rainfall;
+      options;
+      edgeNodeId;
+      jobCallbacks = /* @__PURE__ */ new Map();
+      resultPollingInterval;
+      constructor(rainfall, options = {}) {
+        this.rainfall = rainfall;
+        this.options = {
+          wsPort: 8765,
+          httpPort: 8787,
+          hostname: process.env.HOSTNAME || "local-daemon",
+          capabilities: {
+            localExec: true,
+            fileWatch: true,
+            passiveListen: true
+          },
+          ...options
+        };
+      }
+      /**
+       * Register this edge node with the Rainfall backend
+       */
+      async registerEdgeNode() {
+        const capabilities = this.buildCapabilitiesList();
+        try {
+          const result = await this.rainfall.executeTool("register-edge-node", {
+            hostname: this.options.hostname,
+            capabilities,
+            wsPort: this.options.wsPort,
+            httpPort: this.options.httpPort,
+            version: "0.1.0"
+          });
+          this.edgeNodeId = result.edgeNodeId;
+          console.log(`\u{1F310} Edge node registered with Rainfall as ${this.edgeNodeId}`);
+          return this.edgeNodeId;
+        } catch (error) {
+          this.edgeNodeId = `edge-${this.options.hostname}-${Date.now()}`;
+          console.log(`\u{1F310} Edge node running in local mode (ID: ${this.edgeNodeId})`);
+          return this.edgeNodeId;
+        }
+      }
+      /**
+       * Unregister this edge node on shutdown
+       */
+      async unregisterEdgeNode() {
+        if (!this.edgeNodeId) return;
+        try {
+          await this.rainfall.executeTool("unregister-edge-node", {
+            edgeNodeId: this.edgeNodeId
+          });
+          console.log(`\u{1F310} Edge node ${this.edgeNodeId} unregistered`);
+        } catch {
+        }
+        if (this.resultPollingInterval) {
+          clearInterval(this.resultPollingInterval);
+        }
+      }
+      /**
+       * Queue a tool execution for distributed processing
+       * Non-blocking - returns immediately with a job ID
+       */
+      async queueToolExecution(toolId, params, options = {}) {
+        const executionMode = options.executionMode || "any";
+        try {
+          const result = await this.rainfall.executeTool("queue-job", {
+            toolId,
+            params,
+            executionMode,
+            requesterEdgeNodeId: this.edgeNodeId
+          });
+          if (options.callback) {
+            this.jobCallbacks.set(result.jobId, options.callback);
+            this.startResultPolling();
+          }
+          return result.jobId;
+        } catch (error) {
+          if (executionMode === "local-only" || executionMode === "any") {
+            try {
+              const result = await this.rainfall.executeTool(toolId, params);
+              if (options.callback) {
+                options.callback(result);
+              }
+              return `local-${Date.now()}`;
+            } catch (execError) {
+              if (options.callback) {
+                options.callback(null, String(execError));
+              }
+              throw execError;
+            }
+          }
+          throw error;
+        }
+      }
+      /**
+       * Get status of a queued job
+       */
+      async getJobStatus(jobId) {
+        try {
+          const result = await this.rainfall.executeTool("get-job-status", {
+            jobId
+          });
+          return result.job;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Subscribe to job results via polling (WebSocket fallback)
+       * In the future, this will use WebSocket push from ApresMoi
+       */
+      async subscribeToResults(callback) {
+        console.log("\u{1F4E1} Subscribed to job results via Rainfall (polling mode)");
+        this.onResultReceived = callback;
+      }
+      onResultReceived;
+      /**
+       * Start polling for job results (fallback until WebSocket push is ready)
+       */
+      startResultPolling() {
+        if (this.resultPollingInterval) return;
+        this.resultPollingInterval = setInterval(async () => {
+          for (const [jobId, callback] of this.jobCallbacks) {
+            try {
+              const job = await this.getJobStatus(jobId);
+              if (job?.status === "completed" || job?.status === "failed") {
+                callback(job.result, job.error);
+                this.jobCallbacks.delete(jobId);
+                if (this.onResultReceived) {
+                  this.onResultReceived(jobId, job.result, job.error);
+                }
+              }
+            } catch {
+            }
+          }
+          if (this.jobCallbacks.size === 0 && this.resultPollingInterval) {
+            clearInterval(this.resultPollingInterval);
+            this.resultPollingInterval = void 0;
+          }
+        }, 2e3);
+      }
+      /**
+       * Claim a job for execution on this edge node
+       */
+      async claimJob() {
+        try {
+          const result = await this.rainfall.executeTool("claim-job", {
+            edgeNodeId: this.edgeNodeId,
+            capabilities: this.buildCapabilitiesList()
+          });
+          return result.job;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Submit job result after execution
+       */
+      async submitJobResult(jobId, result, error) {
+        try {
+          await this.rainfall.executeTool("submit-job-result", {
+            jobId,
+            edgeNodeId: this.edgeNodeId,
+            result,
+            error
+          });
+        } catch {
+        }
+      }
+      /**
+       * Get this edge node's ID
+       */
+      getEdgeNodeId() {
+        return this.edgeNodeId;
+      }
+      /**
+       * Build capabilities list from options
+       */
+      buildCapabilitiesList() {
+        const caps = this.options.capabilities || {};
+        const list = [];
+        if (caps.localExec) list.push("local-exec");
+        if (caps.fileWatch) list.push("file-watch");
+        if (caps.passiveListen) list.push("passive-listen");
+        if (caps.browser) list.push("browser");
+        if (caps.custom) list.push(...caps.custom);
+        return list;
+      }
+    };
+  }
+});
+
+// src/services/context.ts
+var RainfallDaemonContext;
+var init_context = __esm({
+  "src/services/context.ts"() {
+    "use strict";
+    init_cjs_shims();
+    RainfallDaemonContext = class {
+      rainfall;
+      options;
+      localMemories = /* @__PURE__ */ new Map();
+      sessions = /* @__PURE__ */ new Map();
+      executionHistory = [];
+      currentSessionId;
+      constructor(rainfall, options = {}) {
+        this.rainfall = rainfall;
+        this.options = {
+          maxLocalMemories: 1e3,
+          maxMessageHistory: 100,
+          maxExecutionHistory: 500,
+          sessionTtl: 24 * 60 * 60 * 1e3,
+          // 24 hours
+          ...options
+        };
+      }
+      /**
+       * Initialize the context - load recent memories from cloud
+       */
+      async initialize() {
+        try {
+          const recentMemories = await this.rainfall.memory.recall({
+            query: "daemon:context",
+            topK: this.options.maxLocalMemories
+          });
+          for (const memory of recentMemories) {
+            this.localMemories.set(memory.id, {
+              id: memory.id,
+              content: memory.content,
+              keywords: memory.keywords || [],
+              timestamp: memory.timestamp,
+              source: memory.source,
+              metadata: memory.metadata
+            });
+          }
+          console.log(`\u{1F9E0} Loaded ${this.localMemories.size} memories into context`);
+        } catch (error) {
+          console.warn("\u26A0\uFE0F  Could not sync memories:", error instanceof Error ? error.message : error);
+        }
+      }
+      /**
+       * Create or get a session
+       */
+      getSession(sessionId) {
+        if (sessionId && this.sessions.has(sessionId)) {
+          const session = this.sessions.get(sessionId);
+          session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+          return session;
+        }
+        const newSession = {
+          id: sessionId || `session-${Date.now()}`,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+          variables: {},
+          messageHistory: []
+        };
+        this.sessions.set(newSession.id, newSession);
+        this.currentSessionId = newSession.id;
+        return newSession;
+      }
+      /**
+       * Get the current active session
+       */
+      getCurrentSession() {
+        if (this.currentSessionId) {
+          return this.sessions.get(this.currentSessionId);
+        }
+        return void 0;
+      }
+      /**
+       * Set the current active session
+       */
+      setCurrentSession(sessionId) {
+        if (this.sessions.has(sessionId)) {
+          this.currentSessionId = sessionId;
+        }
+      }
+      /**
+       * Add a message to the current session history
+       */
+      addMessage(role, content) {
+        const session = this.getCurrentSession();
+        if (!session) return;
+        session.messageHistory.push({
+          role,
+          content,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (session.messageHistory.length > this.options.maxMessageHistory) {
+          session.messageHistory = session.messageHistory.slice(-this.options.maxMessageHistory);
+        }
+      }
+      /**
+       * Store a memory (local + cloud sync)
+       */
+      async storeMemory(content, options = {}) {
+        const id = `mem-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        const entry = {
+          id,
+          content,
+          keywords: options.keywords || [],
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          source: options.source || "daemon",
+          metadata: options.metadata
+        };
+        this.localMemories.set(id, entry);
+        try {
+          await this.rainfall.memory.create({
+            content,
+            keywords: [...options.keywords || [], "daemon:context"],
+            metadata: {
+              ...options.metadata,
+              daemonMemoryId: id,
+              source: options.source || "daemon"
+            }
+          });
+        } catch (error) {
+          console.warn("\u26A0\uFE0F  Could not sync memory to cloud:", error instanceof Error ? error.message : error);
+        }
+        this.trimLocalMemories();
+        return id;
+      }
+      /**
+       * Recall memories by query
+       */
+      async recallMemories(query, topK = 5) {
+        const localResults = Array.from(this.localMemories.values()).filter(
+          (m) => m.content.toLowerCase().includes(query.toLowerCase()) || m.keywords.some((k) => k.toLowerCase().includes(query.toLowerCase()))
+        ).slice(0, topK);
+        try {
+          const cloudResults = await this.rainfall.memory.recall({ query, topK });
+          const seen = new Set(localResults.map((r) => r.id));
+          for (const mem of cloudResults) {
+            if (!seen.has(mem.id)) {
+              localResults.push({
+                id: mem.id,
+                content: mem.content,
+                keywords: mem.keywords || [],
+                timestamp: mem.timestamp,
+                source: mem.source,
+                metadata: mem.metadata
+              });
+            }
+          }
+        } catch {
+        }
+        return localResults.slice(0, topK);
+      }
+      /**
+       * Set a session variable
+       */
+      setVariable(key, value) {
+        const session = this.getCurrentSession();
+        if (session) {
+          session.variables[key] = value;
+        }
+      }
+      /**
+       * Get a session variable
+       */
+      getVariable(key) {
+        const session = this.getCurrentSession();
+        return session?.variables[key];
+      }
+      /**
+       * Record a tool execution
+       */
+      recordExecution(toolId, params, result, options = { duration: 0 }) {
+        const record = {
+          id: `exec-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+          toolId,
+          params,
+          result,
+          error: options.error,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          duration: options.duration,
+          edgeNodeId: options.edgeNodeId
+        };
+        this.executionHistory.push(record);
+        if (this.executionHistory.length > this.options.maxExecutionHistory) {
+          this.executionHistory = this.executionHistory.slice(-this.options.maxExecutionHistory);
+        }
+      }
+      /**
+       * Get recent execution history
+       */
+      getExecutionHistory(limit = 10) {
+        return this.executionHistory.slice(-limit).reverse();
+      }
+      /**
+       * Get execution statistics
+       */
+      getExecutionStats() {
+        const stats = {
+          total: this.executionHistory.length,
+          successful: 0,
+          failed: 0,
+          averageDuration: 0,
+          byTool: {}
+        };
+        let totalDuration = 0;
+        for (const exec of this.executionHistory) {
+          if (exec.error) {
+            stats.failed++;
+          } else {
+            stats.successful++;
+          }
+          totalDuration += exec.duration;
+          stats.byTool[exec.toolId] = (stats.byTool[exec.toolId] || 0) + 1;
+        }
+        stats.averageDuration = stats.total > 0 ? totalDuration / stats.total : 0;
+        return stats;
+      }
+      /**
+       * Clear old sessions based on TTL
+       */
+      cleanupSessions() {
+        const now = Date.now();
+        const ttl = this.options.sessionTtl;
+        for (const [id, session] of this.sessions) {
+          const lastActivity = new Date(session.lastActivity).getTime();
+          if (now - lastActivity > ttl) {
+            this.sessions.delete(id);
+            if (this.currentSessionId === id) {
+              this.currentSessionId = void 0;
+            }
+          }
+        }
+      }
+      /**
+       * Get context summary for debugging
+       */
+      getStatus() {
+        return {
+          memoriesCached: this.localMemories.size,
+          activeSessions: this.sessions.size,
+          currentSession: this.currentSessionId,
+          executionHistorySize: this.executionHistory.length
+        };
+      }
+      trimLocalMemories() {
+        if (this.localMemories.size <= this.options.maxLocalMemories) return;
+        const entries = Array.from(this.localMemories.entries()).sort((a, b) => new Date(a[1].timestamp).getTime() - new Date(b[1].timestamp).getTime());
+        const toRemove = entries.slice(0, entries.length - this.options.maxLocalMemories);
+        for (const [id] of toRemove) {
+          this.localMemories.delete(id);
+        }
+      }
+    };
+  }
+});
+
+// src/services/listeners.ts
+var RainfallListenerRegistry;
+var init_listeners = __esm({
+  "src/services/listeners.ts"() {
+    "use strict";
+    init_cjs_shims();
+    RainfallListenerRegistry = class {
+      rainfall;
+      context;
+      executor;
+      watchers = /* @__PURE__ */ new Map();
+      cronIntervals = /* @__PURE__ */ new Map();
+      eventHistory = [];
+      maxEventHistory = 100;
+      constructor(rainfall, context, executor) {
+        this.rainfall = rainfall;
+        this.context = context;
+        this.executor = executor;
+      }
+      /**
+       * Register a file watcher
+       * Note: Actual file watching requires fs.watch or chokidar
+       * This is the registry - actual watching is done by the daemon
+       */
+      async registerFileWatcher(config) {
+        console.log(`\u{1F441}\uFE0F  Registering file watcher: ${config.name} (${config.watchPath})`);
+        const existing = Array.from(this.watchers.keys());
+        if (existing.includes(config.id)) {
+          await this.unregisterFileWatcher(config.id);
+        }
+        this.watchers.set(config.id, {
+          stop: () => {
+            console.log(`\u{1F441}\uFE0F  Stopped file watcher: ${config.name}`);
+          }
+        });
+        await this.context.storeMemory(`File watcher registered: ${config.name}`, {
+          keywords: ["listener", "file-watcher", config.name],
+          metadata: { config }
+        });
+      }
+      /**
+       * Unregister a file watcher
+       */
+      async unregisterFileWatcher(id) {
+        const watcher = this.watchers.get(id);
+        if (watcher) {
+          watcher.stop();
+          this.watchers.delete(id);
+        }
+      }
+      /**
+       * Register a cron trigger
+       */
+      async registerCronTrigger(config) {
+        console.log(`\u23F0 Registering cron trigger: ${config.name} (${config.cron})`);
+        if (this.cronIntervals.has(config.id)) {
+          clearInterval(this.cronIntervals.get(config.id));
+          this.cronIntervals.delete(config.id);
+        }
+        const interval = this.parseCronToMs(config.cron);
+        if (interval) {
+          const intervalId = setInterval(async () => {
+            await this.handleCronTick(config);
+          }, interval);
+          this.cronIntervals.set(config.id, intervalId);
+        }
+        await this.context.storeMemory(`Cron trigger registered: ${config.name}`, {
+          keywords: ["listener", "cron", config.name],
+          metadata: { config }
+        });
+      }
+      /**
+       * Unregister a cron trigger
+       */
+      unregisterCronTrigger(id) {
+        const interval = this.cronIntervals.get(id);
+        if (interval) {
+          clearInterval(interval);
+          this.cronIntervals.delete(id);
+        }
+      }
+      /**
+       * Handle a file event
+       */
+      async handleFileEvent(watcherId, eventType, filePath) {
+        const event = {
+          id: `evt-${Date.now()}`,
+          type: "file",
+          source: watcherId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { eventType, filePath }
+        };
+        this.recordEvent(event);
+        console.log(`\u{1F4C1} File event: ${eventType} ${filePath}`);
+      }
+      /**
+       * Handle a cron tick
+       */
+      async handleCronTick(config) {
+        const event = {
+          id: `evt-${Date.now()}`,
+          type: "cron",
+          source: config.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { cron: config.cron }
+        };
+        this.recordEvent(event);
+        console.log(`\u23F0 Cron tick: ${config.name}`);
+        for (const step of config.workflow) {
+          try {
+            await this.executor.queueToolExecution(step.toolId, {
+              ...step.params,
+              _event: event
+            });
+          } catch (error) {
+            console.error(`\u274C Workflow step failed: ${step.toolId}`, error);
+          }
+        }
+      }
+      /**
+       * Trigger a manual event (for testing or programmatic triggers)
+       */
+      async triggerManual(name, data = {}) {
+        const event = {
+          id: `evt-${Date.now()}`,
+          type: "manual",
+          source: name,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data
+        };
+        this.recordEvent(event);
+        console.log(`\u{1F446} Manual trigger: ${name}`);
+        await this.context.storeMemory(`Manual trigger fired: ${name}`, {
+          keywords: ["trigger", "manual", name],
+          metadata: { event }
+        });
+      }
+      /**
+       * Get recent events
+       */
+      getRecentEvents(limit = 10) {
+        return this.eventHistory.slice(-limit).reverse();
+      }
+      /**
+       * Get active listeners status
+       */
+      getStatus() {
+        return {
+          fileWatchers: this.watchers.size,
+          cronTriggers: this.cronIntervals.size,
+          recentEvents: this.eventHistory.length
+        };
+      }
+      /**
+       * Stop all listeners
+       */
+      async stopAll() {
+        for (const [id] of this.watchers) {
+          await this.unregisterFileWatcher(id);
+        }
+        for (const [id] of this.cronIntervals) {
+          this.unregisterCronTrigger(id);
+        }
+        console.log("\u{1F6D1} All listeners stopped");
+      }
+      recordEvent(event) {
+        this.eventHistory.push(event);
+        if (this.eventHistory.length > this.maxEventHistory) {
+          this.eventHistory = this.eventHistory.slice(-this.maxEventHistory);
+        }
+      }
+      /**
+       * Simple cron parser - converts basic cron expressions to milliseconds
+       * Supports: @hourly, @daily, @weekly, and simple intervals like every N minutes
+       */
+      parseCronToMs(cron) {
+        switch (cron) {
+          case "@hourly":
+            return 60 * 60 * 1e3;
+          case "@daily":
+            return 24 * 60 * 60 * 1e3;
+          case "@weekly":
+            return 7 * 24 * 60 * 60 * 1e3;
+          case "@minutely":
+            return 60 * 1e3;
+        }
+        const match = cron.match(/^\*\/(\d+)\s/);
+        if (match) {
+          const minutes = parseInt(match[1], 10);
+          if (minutes > 0 && minutes <= 60) {
+            return minutes * 60 * 1e3;
+          }
+        }
+        console.warn(`\u26A0\uFE0F  Unrecognized cron pattern "${cron}", using 1 minute interval`);
+        return 60 * 1e3;
+      }
+    };
+  }
+});
+
+// src/services/mcp-proxy.ts
+var import_ws, import_client2, import_stdio, import_streamableHttp, import_types, MCPProxyHub;
+var init_mcp_proxy = __esm({
+  "src/services/mcp-proxy.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ws = require("ws");
+    import_client2 = require("@modelcontextprotocol/sdk/client/index.js");
+    import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+    import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    import_types = require("@modelcontextprotocol/sdk/types.js");
+    MCPProxyHub = class {
+      clients = /* @__PURE__ */ new Map();
+      options;
+      refreshTimer;
+      reconnectTimeouts = /* @__PURE__ */ new Map();
+      requestId = 0;
+      constructor(options = {}) {
+        this.options = {
+          debug: options.debug ?? false,
+          autoReconnect: options.autoReconnect ?? true,
+          reconnectDelay: options.reconnectDelay ?? 5e3,
+          toolTimeout: options.toolTimeout ?? 3e4,
+          refreshInterval: options.refreshInterval ?? 3e4
+        };
+      }
+      /**
+       * Initialize the MCP proxy hub
+       */
+      async initialize() {
+        this.log("\u{1F50C} Initializing MCP Proxy Hub...");
+        this.startRefreshTimer();
+        this.log("\u2705 MCP Proxy Hub initialized");
+      }
+      /**
+       * Shutdown the MCP proxy hub and disconnect all clients
+       */
+      async shutdown() {
+        this.log("\u{1F6D1} Shutting down MCP Proxy Hub...");
+        if (this.refreshTimer) {
+          clearInterval(this.refreshTimer);
+          this.refreshTimer = void 0;
+        }
+        for (const timeout of this.reconnectTimeouts.values()) {
+          clearTimeout(timeout);
+        }
+        this.reconnectTimeouts.clear();
+        const disconnectPromises = Array.from(this.clients.entries()).map(
+          async ([name, client]) => {
+            try {
+              await this.disconnectClient(name);
+            } catch (error) {
+              this.log(`Error disconnecting ${name}:`, error);
+            }
+          }
+        );
+        await Promise.allSettled(disconnectPromises);
+        this.clients.clear();
+        this.log("\u{1F44B} MCP Proxy Hub shut down");
+      }
+      /**
+       * Connect to an MCP server
+       */
+      async connectClient(config) {
+        const { name, transport } = config;
+        if (this.clients.has(name)) {
+          this.log(`Reconnecting client: ${name}`);
+          await this.disconnectClient(name);
+        }
+        this.log(`Connecting to MCP server: ${name} (${transport})...`);
+        try {
+          const client = new import_client2.Client(
+            {
+              name: `rainfall-daemon-${name}`,
+              version: "0.2.0"
+            },
+            {
+              capabilities: {}
+            }
+          );
+          let lastErrorTime = 0;
+          client.onerror = (error) => {
+            const now = Date.now();
+            if (now - lastErrorTime > 5e3) {
+              this.log(`MCP Server Error (${name}):`, error.message);
+              lastErrorTime = now;
+            }
+            if (this.options.autoReconnect) {
+              this.scheduleReconnect(name, config);
+            }
+          };
+          let transportInstance;
+          if (transport === "stdio" && config.command) {
+            const env = {};
+            for (const [key, value] of Object.entries({ ...process.env, ...config.env })) {
+              if (value !== void 0) {
+                env[key] = value;
+              }
+            }
+            transportInstance = new import_stdio.StdioClientTransport({
+              command: config.command,
+              args: config.args,
+              env
+            });
+          } else if (transport === "http" && config.url) {
+            transportInstance = new import_streamableHttp.StreamableHTTPClientTransport(
+              new URL(config.url),
+              {
+                requestInit: {
+                  headers: config.headers
+                }
+              }
+            );
+          } else if (transport === "websocket" && config.url) {
+            transportInstance = new import_ws.WebSocket(config.url);
+            await new Promise((resolve, reject) => {
+              transportInstance.on("open", () => resolve());
+              transportInstance.on("error", reject);
+              setTimeout(() => reject(new Error("WebSocket connection timeout")), 1e4);
+            });
+          } else {
+            throw new Error(`Invalid transport configuration for ${name}`);
+          }
+          await client.connect(transportInstance);
+          const toolsResult = await client.request(
+            {
+              method: "tools/list",
+              params: {}
+            },
+            import_types.ListToolsResultSchema
+          );
+          const tools = toolsResult.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description || "",
+            inputSchema: tool.inputSchema,
+            serverName: name
+          }));
+          const clientInfo = {
+            name,
+            client,
+            transport: transportInstance,
+            transportType: transport,
+            tools,
+            connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            lastUsed: (/* @__PURE__ */ new Date()).toISOString(),
+            config,
+            status: "connected"
+          };
+          this.clients.set(name, clientInfo);
+          this.log(`\u2705 Connected to ${name} (${tools.length} tools)`);
+          this.printAvailableTools(name, tools);
+          return name;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          this.log(`\u274C Failed to connect to ${name}:`, errorMessage);
+          if (this.options.autoReconnect) {
+            this.scheduleReconnect(name, config);
+          }
+          throw error;
+        }
+      }
+      /**
+       * Disconnect a specific MCP client
+       */
+      async disconnectClient(name) {
+        const client = this.clients.get(name);
+        if (!client) return;
+        const timeout = this.reconnectTimeouts.get(name);
+        if (timeout) {
+          clearTimeout(timeout);
+          this.reconnectTimeouts.delete(name);
+        }
+        try {
+          await client.client.close();
+          if ("close" in client.transport && typeof client.transport.close === "function") {
+            await client.transport.close();
+          }
+        } catch (error) {
+          this.log(`Error closing client ${name}:`, error);
+        }
+        this.clients.delete(name);
+        this.log(`Disconnected from ${name}`);
+      }
+      /**
+       * Schedule a reconnection attempt
+       */
+      scheduleReconnect(name, config) {
+        if (this.reconnectTimeouts.has(name)) return;
+        const timeout = setTimeout(async () => {
+          this.reconnectTimeouts.delete(name);
+          this.log(`Attempting to reconnect to ${name}...`);
+          try {
+            await this.connectClient(config);
+          } catch (error) {
+            this.log(`Reconnection failed for ${name}`);
+          }
+        }, this.options.reconnectDelay);
+        this.reconnectTimeouts.set(name, timeout);
+      }
+      /**
+       * Call a tool on the appropriate MCP client
+       */
+      async callTool(toolName, args, options = {}) {
+        const timeout = options.timeout ?? this.options.toolTimeout;
+        let clientInfo;
+        let actualToolName = toolName;
+        if (options.namespace) {
+          clientInfo = this.clients.get(options.namespace);
+          if (!clientInfo) {
+            throw new Error(`Namespace '${options.namespace}' not found`);
+          }
+          const prefix = `${options.namespace}-`;
+          if (actualToolName.startsWith(prefix)) {
+            actualToolName = actualToolName.slice(prefix.length);
+          }
+          if (!clientInfo.tools.some((t) => t.name === actualToolName)) {
+            throw new Error(`Tool '${actualToolName}' not found in namespace '${options.namespace}'`);
+          }
+        } else {
+          for (const [, info] of this.clients) {
+            const tool = info.tools.find((t) => t.name === toolName);
+            if (tool) {
+              clientInfo = info;
+              break;
+            }
+          }
+        }
+        if (!clientInfo) {
+          throw new Error(`Tool '${toolName}' not found on any connected MCP server`);
+        }
+        const requestId = `req_${++this.requestId}`;
+        clientInfo.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
+        try {
+          this.log(`[${requestId}] Calling '${actualToolName}' on '${clientInfo.name}'`);
+          const result = await Promise.race([
+            clientInfo.client.request(
+              {
+                method: "tools/call",
+                params: {
+                  name: actualToolName,
+                  arguments: args
+                }
+              },
+              import_types.CallToolResultSchema
+            ),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error(`Tool call timeout after ${timeout}ms`)), timeout)
+            )
+          ]);
+          this.log(`[${requestId}] Completed successfully`);
+          return this.formatToolResult(result);
+        } catch (error) {
+          this.log(`[${requestId}] Failed:`, error instanceof Error ? error.message : error);
+          if (error instanceof import_types.McpError) {
+            throw new Error(`MCP Error (${toolName}): ${error.message} (code: ${error.code})`);
+          }
+          throw error;
+        }
+      }
+      /**
+       * Format MCP tool result for consistent output
+       */
+      formatToolResult(result) {
+        if (!result || !result.content) {
+          return "";
+        }
+        return result.content.map((item) => {
+          if (item.type === "text") {
+            return item.text || "";
+          } else if (item.type === "resource") {
+            return `[Resource: ${item.resource?.uri || "unknown"}]`;
+          } else if (item.type === "image") {
+            return `[Image: ${item.mimeType || "unknown"}]`;
+          } else if (item.type === "audio") {
+            return `[Audio: ${item.mimeType || "unknown"}]`;
+          } else {
+            return JSON.stringify(item);
+          }
+        }).join("\n");
+      }
+      /**
+       * Get all tools from all connected MCP clients
+       * Optionally with namespace prefix
+       */
+      getAllTools(options = {}) {
+        const allTools = [];
+        for (const [clientName, client] of this.clients) {
+          for (const tool of client.tools) {
+            if (options.namespacePrefix) {
+              allTools.push({
+                ...tool,
+                name: `${clientName}-${tool.name}`
+              });
+            } else {
+              allTools.push(tool);
+            }
+          }
+        }
+        return allTools;
+      }
+      /**
+       * Get tools from a specific client
+       */
+      getClientTools(clientName) {
+        const client = this.clients.get(clientName);
+        return client?.tools || [];
+      }
+      /**
+       * Get list of connected MCP clients
+       */
+      listClients() {
+        return Array.from(this.clients.entries()).map(([name, info]) => ({
+          name,
+          status: info.status,
+          toolCount: info.tools.length,
+          connectedAt: info.connectedAt,
+          lastUsed: info.lastUsed,
+          transportType: info.transportType
+        }));
+      }
+      /**
+       * Get client info by name
+       */
+      getClient(name) {
+        return this.clients.get(name);
+      }
+      /**
+       * Refresh tool lists from all connected clients
+       */
+      async refreshTools() {
+        for (const [name, client] of this.clients) {
+          try {
+            const toolsResult = await client.client.request(
+              {
+                method: "tools/list",
+                params: {}
+              },
+              import_types.ListToolsResultSchema
+            );
+            client.tools = toolsResult.tools.map((tool) => ({
+              name: tool.name,
+              description: tool.description || "",
+              inputSchema: tool.inputSchema,
+              serverName: name
+            }));
+            this.log(`Refreshed ${name}: ${client.tools.length} tools`);
+          } catch (error) {
+            this.log(`Failed to refresh tools for ${name}:`, error);
+            client.status = "error";
+            client.error = error instanceof Error ? error.message : String(error);
+          }
+        }
+      }
+      /**
+       * List resources from a specific client or all clients
+       */
+      async listResources(clientName) {
+        const results = [];
+        const clients = clientName ? [clientName] : Array.from(this.clients.keys());
+        for (const name of clients) {
+          const client = this.clients.get(name);
+          if (!client) continue;
+          try {
+            const result = await client.client.request(
+              {
+                method: "resources/list",
+                params: {}
+              },
+              import_types.ListResourcesResultSchema
+            );
+            results.push({
+              clientName: name,
+              resources: result.resources
+            });
+          } catch (error) {
+            this.log(`Failed to list resources for ${name}:`, error);
+          }
+        }
+        return results;
+      }
+      /**
+       * Read a resource from a specific client
+       */
+      async readResource(uri, clientName) {
+        if (clientName) {
+          const client = this.clients.get(clientName);
+          if (!client) {
+            throw new Error(`Client '${clientName}' not found`);
+          }
+          const result = await client.client.request(
+            {
+              method: "resources/read",
+              params: { uri }
+            },
+            import_types.ReadResourceResultSchema
+          );
+          return result;
+        } else {
+          for (const [name, client] of this.clients) {
+            try {
+              const result = await client.client.request(
+                {
+                  method: "resources/read",
+                  params: { uri }
+                },
+                import_types.ReadResourceResultSchema
+              );
+              return { clientName: name, ...result };
+            } catch {
+            }
+          }
+          throw new Error(`Resource '${uri}' not found on any client`);
+        }
+      }
+      /**
+       * List prompts from a specific client or all clients
+       */
+      async listPrompts(clientName) {
+        const results = [];
+        const clients = clientName ? [clientName] : Array.from(this.clients.keys());
+        for (const name of clients) {
+          const client = this.clients.get(name);
+          if (!client) continue;
+          try {
+            const result = await client.client.request(
+              {
+                method: "prompts/list",
+                params: {}
+              },
+              import_types.ListPromptsResultSchema
+            );
+            results.push({
+              clientName: name,
+              prompts: result.prompts
+            });
+          } catch (error) {
+            this.log(`Failed to list prompts for ${name}:`, error);
+          }
+        }
+        return results;
+      }
+      /**
+       * Get a prompt from a specific client
+       */
+      async getPrompt(name, args, clientName) {
+        if (clientName) {
+          const client = this.clients.get(clientName);
+          if (!client) {
+            throw new Error(`Client '${clientName}' not found`);
+          }
+          const result = await client.client.request(
+            {
+              method: "prompts/get",
+              params: { name, arguments: args }
+            },
+            import_types.GetPromptResultSchema
+          );
+          return result;
+        } else {
+          for (const [cName, client] of this.clients) {
+            try {
+              const result = await client.client.request(
+                {
+                  method: "prompts/get",
+                  params: { name, arguments: args }
+                },
+                import_types.GetPromptResultSchema
+              );
+              return { clientName: cName, ...result };
+            } catch {
+            }
+          }
+          throw new Error(`Prompt '${name}' not found on any client`);
+        }
+      }
+      /**
+       * Health check for all connected clients
+       */
+      async healthCheck() {
+        const results = /* @__PURE__ */ new Map();
+        for (const [name, client] of this.clients) {
+          try {
+            const startTime = Date.now();
+            await client.client.request(
+              {
+                method: "tools/list",
+                params: {}
+              },
+              import_types.ListToolsResultSchema
+            );
+            results.set(name, {
+              status: "healthy",
+              responseTime: Date.now() - startTime
+            });
+          } catch (error) {
+            results.set(name, {
+              status: "unhealthy",
+              responseTime: 0,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            if (this.options.autoReconnect) {
+              this.scheduleReconnect(name, client.config);
+            }
+          }
+        }
+        return results;
+      }
+      /**
+       * Start the automatic refresh timer
+       */
+      startRefreshTimer() {
+        if (this.refreshTimer) {
+          clearInterval(this.refreshTimer);
+        }
+        if (this.options.refreshInterval > 0) {
+          this.refreshTimer = setInterval(async () => {
+            try {
+              await this.refreshTools();
+            } catch (error) {
+              this.log("Auto-refresh failed:", error);
+            }
+          }, this.options.refreshInterval);
+        }
+      }
+      /**
+       * Print available tools for a client
+       */
+      printAvailableTools(clientName, tools) {
+        if (tools.length === 0) {
+          this.log(`  No tools available from ${clientName}`);
+          return;
+        }
+        this.log(`
+  --- ${clientName} Tools (${tools.length}) ---`);
+        for (const tool of tools) {
+          this.log(`    \u2022 ${tool.name}: ${tool.description.slice(0, 60)}${tool.description.length > 60 ? "..." : ""}`);
+        }
+      }
+      /**
+       * Debug logging
+       */
+      log(...args) {
+        if (this.options.debug) {
+          console.log("[MCP-Proxy]", ...args);
+        }
+      }
+      /**
+       * Get statistics about the MCP proxy hub
+       */
+      getStats() {
+        const clients = Array.from(this.clients.entries()).map(([name, info]) => ({
+          name,
+          toolCount: info.tools.length,
+          status: info.status,
+          transportType: info.transportType
+        }));
+        return {
+          totalClients: this.clients.size,
+          totalTools: clients.reduce((sum, c) => sum + c.toolCount, 0),
+          clients
+        };
+      }
+    };
+  }
+});
+
+// src/daemon/index.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  MCPProxyHub: () => MCPProxyHub,
+  RainfallDaemon: () => RainfallDaemon,
+  getDaemonInstance: () => getDaemonInstance,
+  getDaemonStatus: () => getDaemonStatus,
+  startDaemon: () => startDaemon,
+  stopDaemon: () => stopDaemon
+});
+async function startDaemon(config = {}) {
+  if (daemonInstance) {
+    console.log("Daemon already running");
+    return daemonInstance;
+  }
+  daemonInstance = new RainfallDaemon(config);
+  await daemonInstance.start();
+  return daemonInstance;
+}
+async function stopDaemon() {
+  if (!daemonInstance) {
+    console.log("Daemon not running");
+    return;
+  }
+  await daemonInstance.stop();
+  daemonInstance = null;
+}
+function getDaemonStatus() {
+  if (!daemonInstance) {
+    return null;
+  }
+  return daemonInstance.getStatus();
+}
+function getDaemonInstance() {
+  return daemonInstance;
+}
+var import_ws2, import_express, RainfallDaemon, daemonInstance;
+var init_daemon = __esm({
+  "src/daemon/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ws2 = require("ws");
+    import_express = __toESM(require("express"));
+    init_sdk();
+    init_networked();
+    init_context();
+    init_listeners();
+    init_mcp_proxy();
+    init_mcp_proxy();
+    RainfallDaemon = class {
+      wss;
+      openaiApp;
+      rainfall;
+      port;
+      openaiPort;
+      rainfallConfig;
+      tools = [];
+      toolSchemas = /* @__PURE__ */ new Map();
+      clients = /* @__PURE__ */ new Set();
+      debug;
+      // New services
+      networkedExecutor;
+      context;
+      listeners;
+      mcpProxy;
+      enableMcpProxy;
+      mcpNamespacePrefix;
+      constructor(config = {}) {
+        this.port = config.port || 8765;
+        this.openaiPort = config.openaiPort || 8787;
+        this.rainfallConfig = config.rainfallConfig;
+        this.debug = config.debug || false;
+        this.enableMcpProxy = config.enableMcpProxy ?? true;
+        this.mcpNamespacePrefix = config.mcpNamespacePrefix ?? true;
+        this.openaiApp = (0, import_express.default)();
+        this.openaiApp.use(import_express.default.json());
+      }
+      async start() {
+        this.log("\u{1F327}\uFE0F  Rainfall Daemon starting...");
+        await this.initializeRainfall();
+        if (!this.rainfall) {
+          throw new Error("Failed to initialize Rainfall SDK");
+        }
+        this.context = new RainfallDaemonContext(this.rainfall, {
+          maxLocalMemories: 1e3,
+          maxMessageHistory: 100,
+          ...this.rainfallConfig
+        });
+        await this.context.initialize();
+        this.networkedExecutor = new RainfallNetworkedExecutor(this.rainfall, {
+          wsPort: this.port,
+          httpPort: this.openaiPort,
+          hostname: process.env.HOSTNAME || "local-daemon",
+          capabilities: {
+            localExec: true,
+            fileWatch: true,
+            passiveListen: true
+          }
+        });
+        await this.networkedExecutor.registerEdgeNode();
+        await this.networkedExecutor.subscribeToResults((jobId, result, error) => {
+          this.log(`\u{1F4EC} Job ${jobId} ${error ? "failed" : "completed"}`, error || result);
+        });
+        this.listeners = new RainfallListenerRegistry(
+          this.rainfall,
+          this.context,
+          this.networkedExecutor
+        );
+        await this.loadTools();
+        if (this.enableMcpProxy) {
+          this.mcpProxy = new MCPProxyHub({ debug: this.debug });
+          await this.mcpProxy.initialize();
+          if (this.rainfallConfig?.mcpClients) {
+            for (const clientConfig of this.rainfallConfig.mcpClients) {
+              try {
+                await this.mcpProxy.connectClient(clientConfig);
+              } catch (error) {
+                this.log(`Failed to connect MCP client ${clientConfig.name}:`, error);
+              }
+            }
+          }
+        }
+        await this.startWebSocketServer();
+        await this.startOpenAIProxy();
+        console.log(`\u{1F680} Rainfall daemon running`);
+        console.log(`   WebSocket (MCP):     ws://localhost:${this.port}`);
+        console.log(`   OpenAI API:          http://localhost:${this.openaiPort}/v1/chat/completions`);
+        console.log(`   Health Check:        http://localhost:${this.openaiPort}/health`);
+        console.log(`   Edge Node ID:        ${this.networkedExecutor.getEdgeNodeId() || "local"}`);
+        console.log(`   Tools loaded:        ${this.tools.length}`);
+        console.log(`   Press Ctrl+C to stop`);
+        process.on("SIGINT", () => this.stop());
+        process.on("SIGTERM", () => this.stop());
+      }
+      async stop() {
+        this.log("\u{1F6D1} Shutting down Rainfall daemon...");
+        if (this.listeners) {
+          await this.listeners.stopAll();
+        }
+        if (this.networkedExecutor) {
+          await this.networkedExecutor.unregisterEdgeNode();
+        }
+        if (this.mcpProxy) {
+          await this.mcpProxy.shutdown();
+          this.mcpProxy = void 0;
+        }
+        for (const client of this.clients) {
+          client.close();
+        }
+        this.clients.clear();
+        if (this.wss) {
+          this.wss.close();
+          this.wss = void 0;
+        }
+        console.log("\u{1F44B} Rainfall daemon stopped");
+      }
+      /**
+       * Get the networked executor for distributed job management
+       */
+      getNetworkedExecutor() {
+        return this.networkedExecutor;
+      }
+      /**
+       * Get the context for memory/session management
+       */
+      getContext() {
+        return this.context;
+      }
+      /**
+       * Get the listener registry for passive triggers
+       */
+      getListenerRegistry() {
+        return this.listeners;
+      }
+      /**
+       * Get the MCP Proxy Hub for managing external MCP clients
+       */
+      getMCPProxy() {
+        return this.mcpProxy;
+      }
+      /**
+       * Connect an MCP client dynamically
+       */
+      async connectMCPClient(config) {
+        if (!this.mcpProxy) {
+          throw new Error("MCP Proxy Hub is not enabled");
+        }
+        return this.mcpProxy.connectClient(config);
+      }
+      /**
+       * Disconnect an MCP client
+       */
+      async disconnectMCPClient(name) {
+        if (!this.mcpProxy) {
+          throw new Error("MCP Proxy Hub is not enabled");
+        }
+        return this.mcpProxy.disconnectClient(name);
+      }
+      async initializeRainfall() {
+        if (this.rainfallConfig?.apiKey) {
+          this.rainfall = new Rainfall(this.rainfallConfig);
+        } else {
+          const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+          const config = loadConfig2();
+          if (config.apiKey) {
+            this.rainfall = new Rainfall({
+              apiKey: config.apiKey,
+              baseUrl: config.baseUrl
+            });
+          } else {
+            throw new Error("No API key configured. Run: rainfall auth login <api-key>");
+          }
+        }
+      }
+      async loadTools() {
+        if (!this.rainfall) return;
+        try {
+          this.tools = await this.rainfall.listTools();
+          this.log(`\u{1F4E6} Loaded ${this.tools.length} tools`);
+        } catch (error) {
+          console.warn("\u26A0\uFE0F  Failed to load tools:", error instanceof Error ? error.message : error);
+          this.tools = [];
+        }
+      }
+      async getToolSchema(toolId) {
+        if (this.toolSchemas.has(toolId)) {
+          return this.toolSchemas.get(toolId);
+        }
+        if (!this.rainfall) return null;
+        try {
+          const schema = await this.rainfall.getToolSchema(toolId);
+          this.toolSchemas.set(toolId, schema);
+          return schema;
+        } catch {
+          return null;
+        }
+      }
+      async startWebSocketServer() {
+        this.wss = new import_ws2.WebSocketServer({ port: this.port });
+        this.wss.on("connection", (ws) => {
+          this.log("\u{1F7E2} MCP client connected");
+          this.clients.add(ws);
+          ws.on("message", async (data) => {
+            try {
+              const message = JSON.parse(data.toString());
+              const response = await this.handleMCPMessage(message);
+              ws.send(JSON.stringify(response));
+            } catch (error) {
+              const errorResponse = {
+                jsonrpc: "2.0",
+                id: void 0,
+                error: {
+                  code: -32700,
+                  message: error instanceof Error ? error.message : "Parse error"
+                }
+              };
+              ws.send(JSON.stringify(errorResponse));
+            }
+          });
+          ws.on("close", () => {
+            this.log("\u{1F534} MCP client disconnected");
+            this.clients.delete(ws);
+          });
+          ws.on("error", (error) => {
+            console.error("WebSocket error:", error);
+            this.clients.delete(ws);
+          });
+        });
+      }
+      async handleMCPMessage(message) {
+        const { id, method, params } = message;
+        switch (method) {
+          case "initialize":
+            return {
+              jsonrpc: "2.0",
+              id,
+              result: {
+                protocolVersion: "2024-11-05",
+                capabilities: {
+                  tools: { listChanged: true }
+                },
+                serverInfo: {
+                  name: "rainfall-daemon",
+                  version: "0.1.0"
+                }
+              }
+            };
+          case "tools/list":
+            return {
+              jsonrpc: "2.0",
+              id,
+              result: {
+                tools: await this.getMCPTools()
+              }
+            };
+          case "tools/call": {
+            const toolName = params?.name;
+            const toolParams = params?.arguments;
+            try {
+              const startTime = Date.now();
+              const result = await this.executeToolWithMCP(toolName, toolParams);
+              const duration = Date.now() - startTime;
+              if (this.context) {
+                this.context.recordExecution(toolName, toolParams || {}, result, { duration });
+              }
+              return {
+                jsonrpc: "2.0",
+                id,
+                result: {
+                  content: [
+                    {
+                      type: "text",
+                      text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+                    }
+                  ]
+                }
+              };
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
+              if (this.context) {
+                this.context.recordExecution(toolName, toolParams || {}, null, {
+                  error: errorMessage,
+                  duration: 0
+                });
+              }
+              return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                  code: -32603,
+                  message: errorMessage
+                }
+              };
+            }
+          }
+          case "ping":
+            return {
+              jsonrpc: "2.0",
+              id,
+              result: {}
+            };
+          default:
+            return {
+              jsonrpc: "2.0",
+              id,
+              error: {
+                code: -32601,
+                message: `Method not found: ${method}`
+              }
+            };
+        }
+      }
+      async getMCPTools() {
+        const mcpTools = [];
+        for (const tool of this.tools) {
+          const schema = await this.getToolSchema(tool.id);
+          if (schema) {
+            const toolSchema = schema;
+            mcpTools.push({
+              name: tool.id,
+              description: toolSchema.description || tool.description,
+              inputSchema: toolSchema.parameters || { type: "object", properties: {} }
+            });
+          }
+        }
+        if (this.mcpProxy) {
+          const proxyTools = this.mcpProxy.getAllTools({ namespacePrefix: this.mcpNamespacePrefix });
+          for (const tool of proxyTools) {
+            mcpTools.push({
+              name: this.mcpNamespacePrefix ? `${tool.serverName}-${tool.name}` : tool.name,
+              description: tool.description,
+              inputSchema: tool.inputSchema || { type: "object", properties: {} }
+            });
+          }
+        }
+        return mcpTools;
+      }
+      async executeTool(toolId, params) {
+        if (!this.rainfall) {
+          throw new Error("Rainfall SDK not initialized");
+        }
+        return this.rainfall.executeTool(toolId, params);
+      }
+      /**
+       * Execute a tool, trying MCP proxy first, then falling back to Rainfall tools
+       */
+      async executeToolWithMCP(toolName, params) {
+        if (this.mcpProxy) {
+          try {
+            if (this.mcpNamespacePrefix && toolName.includes("-")) {
+              const namespace = toolName.split("-")[0];
+              const actualToolName = toolName.slice(namespace.length + 1);
+              if (this.mcpProxy.getClient(namespace)) {
+                return await this.mcpProxy.callTool(toolName, params || {}, {
+                  namespace
+                });
+              }
+            }
+            return await this.mcpProxy.callTool(toolName, params || {});
+          } catch (error) {
+            if (error instanceof Error && !error.message.includes("not found")) {
+              throw error;
+            }
+          }
+        }
+        return this.executeTool(toolName, params);
+      }
+      async startOpenAIProxy() {
+        this.openaiApp.get("/v1/models", async (_req, res) => {
+          try {
+            if (this.rainfall) {
+              const models = await this.rainfall.listModels();
+              res.json({
+                object: "list",
+                data: models.map((m) => ({
+                  id: m.id,
+                  object: "model",
+                  created: Math.floor(Date.now() / 1e3),
+                  owned_by: "rainfall"
+                }))
+              });
+            } else {
+              res.json({
+                object: "list",
+                data: [
+                  { id: "llama-3.3-70b-versatile", object: "model", created: Date.now(), owned_by: "groq" },
+                  { id: "gpt-4o", object: "model", created: Date.now(), owned_by: "openai" },
+                  { id: "claude-3-5-sonnet", object: "model", created: Date.now(), owned_by: "anthropic" },
+                  { id: "gemini-2.0-flash-exp", object: "model", created: Date.now(), owned_by: "gemini" }
+                ]
+              });
+            }
+          } catch (error) {
+            res.status(500).json({ error: "Failed to fetch models" });
+          }
+        });
+        this.openaiApp.post("/v1/chat/completions", async (req, res) => {
+          const body = req.body;
+          if (!body.messages || !Array.isArray(body.messages)) {
+            res.status(400).json({
+              error: {
+                message: "Missing required field: messages",
+                type: "invalid_request_error"
+              }
+            });
+            return;
+          }
+          if (!this.rainfall) {
+            res.status(503).json({
+              error: {
+                message: "Rainfall SDK not initialized",
+                type: "service_unavailable"
+              }
+            });
+            return;
+          }
+          try {
+            const me = await this.rainfall.getMe();
+            const subscriberId = me.id;
+            const localToolMap = await this.buildLocalToolMap();
+            let allTools = [];
+            if (body.tools && body.tools.length > 0) {
+              allTools = body.tools;
+            } else if (body.tool_choice) {
+              const openaiTools = await this.getOpenAITools();
+              allTools = openaiTools;
+            }
+            let messages = [...body.messages];
+            const maxToolIterations = 10;
+            let toolIterations = 0;
+            while (toolIterations < maxToolIterations) {
+              toolIterations++;
+              const llmResponse = await this.callLLM({
+                subscriberId,
+                model: body.model,
+                messages,
+                tools: allTools.length > 0 ? allTools : void 0,
+                tool_choice: body.tool_choice,
+                temperature: body.temperature,
+                max_tokens: body.max_tokens,
+                stream: false,
+                // Always non-streaming for tool loop
+                tool_priority: body.tool_priority,
+                enable_stacked: body.enable_stacked
+              });
+              const choice = llmResponse.choices?.[0];
+              let toolCalls = choice?.message?.tool_calls || [];
+              const content = choice?.message?.content || "";
+              const reasoningContent = choice?.message?.reasoning_content || "";
+              const fullContent = content + " " + reasoningContent;
+              const xmlToolCalls = this.parseXMLToolCalls(fullContent);
+              if (xmlToolCalls.length > 0) {
+                this.log(`\u{1F4CB} Parsed ${xmlToolCalls.length} XML tool calls from content`);
+                toolCalls = xmlToolCalls;
+              }
+              if (!toolCalls || toolCalls.length === 0) {
+                if (body.stream) {
+                  await this.streamResponse(res, llmResponse);
+                } else {
+                  res.json(llmResponse);
+                }
+                this.updateContext(body.messages, llmResponse);
+                return;
+              }
+              messages.push({
+                role: "assistant",
+                content: choice?.message?.content || "",
+                tool_calls: toolCalls
+              });
+              for (const toolCall of toolCalls) {
+                const toolName = toolCall.function?.name;
+                const toolArgsStr = toolCall.function?.arguments || "{}";
+                if (!toolName) continue;
+                this.log(`\u{1F527} Tool call: ${toolName}`);
+                let toolResult;
+                let toolError;
+                try {
+                  const localTool = this.findLocalTool(toolName, localToolMap);
+                  if (localTool) {
+                    this.log(`  \u2192 Executing locally`);
+                    const args = JSON.parse(toolArgsStr);
+                    toolResult = await this.executeLocalTool(localTool.id, args);
+                  } else if (this.mcpProxy) {
+                    this.log(`  \u2192 Trying MCP proxy`);
+                    const args = JSON.parse(toolArgsStr);
+                    toolResult = await this.executeToolWithMCP(toolName.replace(/_/g, "-"), args);
+                  } else {
+                    const shouldExecuteLocal = body.tool_priority === "local" || body.tool_priority === "stacked";
+                    if (shouldExecuteLocal) {
+                      try {
+                        const args = JSON.parse(toolArgsStr);
+                        toolResult = await this.rainfall.executeTool(toolName.replace(/_/g, "-"), args);
+                      } catch {
+                        toolResult = { _pending: true, tool: toolName, args: toolArgsStr };
+                      }
+                    } else {
+                      toolResult = { _pending: true, tool: toolName, args: toolArgsStr };
+                    }
+                  }
+                } catch (error) {
+                  toolError = error instanceof Error ? error.message : String(error);
+                  this.log(`  \u2192 Error: ${toolError}`);
+                }
+                messages.push({
+                  role: "tool",
+                  content: toolError ? JSON.stringify({ error: toolError }) : typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult),
+                  tool_call_id: toolCall.id
+                });
+                if (this.context) {
+                  this.context.recordExecution(
+                    toolName,
+                    JSON.parse(toolArgsStr || "{}"),
+                    toolResult,
+                    { error: toolError, duration: 0 }
+                  );
+                }
+              }
+            }
+            res.status(500).json({
+              error: {
+                message: "Maximum tool execution iterations reached",
+                type: "tool_execution_error"
+              }
+            });
+          } catch (error) {
+            this.log("Chat completions error:", error);
+            res.status(500).json({
+              error: {
+                message: error instanceof Error ? error.message : "Internal server error",
+                type: "internal_error"
+              }
+            });
+          }
+        });
+        this.openaiApp.get("/health", (_req, res) => {
+          const mcpStats = this.mcpProxy?.getStats();
+          res.json({
+            status: "ok",
+            daemon: "rainfall",
+            version: "0.2.0",
+            tools_loaded: this.tools.length,
+            mcp_clients: mcpStats?.totalClients || 0,
+            mcp_tools: mcpStats?.totalTools || 0,
+            edge_node_id: this.networkedExecutor?.getEdgeNodeId(),
+            clients_connected: this.clients.size
+          });
+        });
+        this.openaiApp.get("/v1/mcp/clients", (_req, res) => {
+          if (!this.mcpProxy) {
+            res.status(503).json({ error: "MCP proxy not enabled" });
+            return;
+          }
+          res.json(this.mcpProxy.listClients());
+        });
+        this.openaiApp.post("/v1/mcp/connect", async (req, res) => {
+          if (!this.mcpProxy) {
+            res.status(503).json({ error: "MCP proxy not enabled" });
+            return;
+          }
+          try {
+            const name = await this.mcpProxy.connectClient(req.body);
+            res.json({ success: true, client: name });
+          } catch (error) {
+            res.status(500).json({
+              error: error instanceof Error ? error.message : "Failed to connect MCP client"
+            });
+          }
+        });
+        this.openaiApp.post("/v1/mcp/disconnect", async (req, res) => {
+          if (!this.mcpProxy) {
+            res.status(503).json({ error: "MCP proxy not enabled" });
+            return;
+          }
+          const { name } = req.body;
+          if (!name) {
+            res.status(400).json({ error: "Missing required field: name" });
+            return;
+          }
+          await this.mcpProxy.disconnectClient(name);
+          res.json({ success: true });
+        });
+        this.openaiApp.get("/status", (_req, res) => {
+          res.json(this.getStatus());
+        });
+        this.openaiApp.post("/v1/queue", async (req, res) => {
+          const { tool_id, params, execution_mode = "any" } = req.body;
+          if (!tool_id) {
+            res.status(400).json({ error: "Missing required field: tool_id" });
+            return;
+          }
+          if (!this.networkedExecutor) {
+            res.status(503).json({ error: "Networked executor not available" });
+            return;
+          }
+          try {
+            const jobId = await this.networkedExecutor.queueToolExecution(
+              tool_id,
+              params || {},
+              { executionMode: execution_mode }
+            );
+            res.json({ job_id: jobId, status: "queued" });
+          } catch (error) {
+            res.status(500).json({
+              error: error instanceof Error ? error.message : "Failed to queue job"
+            });
+          }
+        });
+        return new Promise((resolve) => {
+          this.openaiApp.listen(this.openaiPort, () => {
+            resolve();
+          });
+        });
+      }
+      /**
+       * Build a map of local Rainfall tools for quick lookup
+       * Maps OpenAI-style underscore names to Rainfall tool IDs
+       */
+      async buildLocalToolMap() {
+        const map = /* @__PURE__ */ new Map();
+        for (const tool of this.tools) {
+          const openAiName = tool.id.replace(/-/g, "_");
+          map.set(openAiName, {
+            id: tool.id,
+            name: openAiName,
+            description: tool.description
+          });
+          map.set(tool.id, {
+            id: tool.id,
+            name: openAiName,
+            description: tool.description
+          });
+        }
+        return map;
+      }
+      /**
+       * Find a local Rainfall tool by name (OpenAI underscore format or original)
+       */
+      findLocalTool(toolName, localToolMap) {
+        if (localToolMap.has(toolName)) {
+          return localToolMap.get(toolName);
+        }
+        const dashedName = toolName.replace(/_/g, "-");
+        if (localToolMap.has(dashedName)) {
+          return localToolMap.get(dashedName);
+        }
+        return void 0;
+      }
+      /**
+       * Execute a local Rainfall tool
+       */
+      async executeLocalTool(toolId, args) {
+        if (!this.rainfall) {
+          throw new Error("Rainfall SDK not initialized");
+        }
+        const startTime = Date.now();
+        try {
+          const result = await this.rainfall.executeTool(toolId, args);
+          const duration = Date.now() - startTime;
+          this.log(`  \u2713 Completed in ${duration}ms`);
+          return result;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          this.log(`  \u2717 Failed after ${duration}ms`);
+          throw error;
+        }
+      }
+      /**
+       * Parse XML-style tool calls from model output
+       * Handles formats like: <function=name><parameter=key>value</parameter></function>
+       */
+      parseXMLToolCalls(content) {
+        const toolCalls = [];
+        const functionRegex = /<function=([^>]+)>([\s\S]*?)<\/function>/gi;
+        let match;
+        while ((match = functionRegex.exec(content)) !== null) {
+          const functionName = match[1].trim();
+          const paramsBlock = match[2];
+          const params = {};
+          const paramRegex = /<parameter=([^>]+)>([\s\S]*?)<\/parameter>/gi;
+          let paramMatch;
+          while ((paramMatch = paramRegex.exec(paramsBlock)) !== null) {
+            const paramName = paramMatch[1].trim();
+            const paramValue = paramMatch[2].trim();
+            params[paramName] = paramValue;
+          }
+          toolCalls.push({
+            id: `xml-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+            type: "function",
+            function: {
+              name: functionName,
+              arguments: JSON.stringify(params)
+            }
+          });
+          this.log(`\u{1F4CB} Parsed XML tool call: ${functionName}(${JSON.stringify(params)})`);
+        }
+        return toolCalls;
+      }
+      /**
+       * Call the LLM via Rainfall backend, LM Studio, RunPod, or other providers
+       * 
+       * Provider priority:
+       * 1. Config file (llm.provider, llm.baseUrl)
+       * 2. Environment variables (OPENAI_API_KEY, OLLAMA_HOST, etc.)
+       * 3. Default to Rainfall (credits-based)
+       */
+      async callLLM(params) {
+        if (!this.rainfall) {
+          throw new Error("Rainfall SDK not initialized");
+        }
+        const { loadConfig: loadConfig2, getProviderBaseUrl: getProviderBaseUrl2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+        const config = loadConfig2();
+        const provider = config.llm?.provider || "rainfall";
+        switch (provider) {
+          case "local":
+          case "ollama":
+          case "custom":
+            return this.callLocalLLM(params, config);
+          case "openai":
+          case "anthropic":
+            return this.callExternalLLM(params, config, provider);
+          case "rainfall":
+          default:
+            return this.rainfall.chatCompletions({
+              subscriber_id: params.subscriberId,
+              model: params.model,
+              messages: params.messages,
+              stream: params.stream || false,
+              temperature: params.temperature,
+              max_tokens: params.max_tokens,
+              tools: params.tools,
+              tool_choice: params.tool_choice,
+              tool_priority: params.tool_priority,
+              enable_stacked: params.enable_stacked
+            });
+        }
+      }
+      /**
+       * Call external LLM provider (OpenAI, Anthropic) via their OpenAI-compatible APIs
+       */
+      async callExternalLLM(params, config, provider) {
+        const { getProviderBaseUrl: getProviderBaseUrl2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+        const baseUrl = config.llm?.baseUrl || getProviderBaseUrl2({ llm: { provider } });
+        const apiKey = config.llm?.apiKey;
+        if (!apiKey) {
+          throw new Error(`${provider} API key not configured. Set via: rainfall config set llm.apiKey <key>`);
+        }
+        const model = params.model || config.llm?.model || (provider === "anthropic" ? "claude-3-5-sonnet-20241022" : "gpt-4o");
+        const url = `${baseUrl}/chat/completions`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${apiKey}`,
+            "User-Agent": "Rainfall-DevKit/1.0"
+          },
+          body: JSON.stringify({
+            model,
+            messages: params.messages,
+            tools: params.tools,
+            tool_choice: params.tool_choice,
+            temperature: params.temperature,
+            max_tokens: params.max_tokens,
+            stream: false
+            // Tool loop requires non-streaming
+          })
+        });
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`${provider} API error: ${error}`);
+        }
+        return response.json();
+      }
+      /**
+       * Call a local LLM (LM Studio, Ollama, etc.)
+       */
+      async callLocalLLM(params, config) {
+        const baseUrl = config.llm?.baseUrl || "http://localhost:1234/v1";
+        const apiKey = config.llm?.apiKey || "not-needed";
+        const model = params.model || config.llm?.model || "local-model";
+        const url = `${baseUrl}/chat/completions`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${apiKey}`,
+            "User-Agent": "Rainfall-DevKit/1.0"
+          },
+          body: JSON.stringify({
+            model,
+            messages: params.messages,
+            tools: params.tools,
+            tool_choice: params.tool_choice,
+            temperature: params.temperature,
+            max_tokens: params.max_tokens,
+            stream: false
+            // Tool loop requires non-streaming
+          })
+        });
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`Local LLM error: ${error}`);
+        }
+        return response.json();
+      }
+      /**
+       * Stream a response to the client (converts non-streaming to SSE format)
+       */
+      async streamResponse(res, response) {
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        const message = response.choices?.[0]?.message;
+        const id = response.id || `chatcmpl-${Date.now()}`;
+        const model = response.model || "unknown";
+        const created = Math.floor(Date.now() / 1e3);
+        res.write(`data: ${JSON.stringify({
+          id,
+          object: "chat.completion.chunk",
+          created,
+          model,
+          choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }]
+        })}
 
-// src/namespaces/ai.ts
-function createAI(client) {
-  return {
-    embeddings: {
-      document: (params) => client.executeTool("jina-document-embedding", params),
-      query: (params) => client.executeTool("jina-query-embedding", params),
-      image: (params) => client.executeTool("jina-image-embedding", { image: params.imageBase64 })
-    },
-    image: {
-      generate: (params) => client.executeTool("image-generation", params)
-    },
-    ocr: (params) => client.executeTool("ocr-text-extraction", { image: params.imageBase64 }),
-    vision: (params) => client.executeTool("llama-scout-vision", { image: params.imageBase64, prompt: params.prompt }),
-    chat: (params) => client.executeTool("xai-chat-completions", params),
-    complete: (params) => client.executeTool("fim", params),
-    classify: (params) => client.executeTool("jina-document-classifier", params),
-    segment: (params) => client.executeTool("jina-text-segmenter", params)
-  };
-}
+`);
+        const content = message?.content || "";
+        const chunkSize = 10;
+        for (let i = 0; i < content.length; i += chunkSize) {
+          const chunk = content.slice(i, i + chunkSize);
+          res.write(`data: ${JSON.stringify({
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{ index: 0, delta: { content: chunk }, finish_reason: null }]
+          })}
 
-// src/namespaces/data.ts
-function createData(client) {
-  return {
-    csv: {
-      query: (params) => client.executeTool("query-csv", params),
-      convert: (params) => client.executeTool("csv-convert", params)
-    },
-    scripts: {
-      create: (params) => client.executeTool("create-saved-script", params),
-      execute: (params) => client.executeTool("execute-saved-script", params),
-      list: () => client.executeTool("list-saved-scripts", {}),
-      update: (params) => client.executeTool("update-saved-script", params),
-      delete: (params) => client.executeTool("delete-saved-script", params)
-    },
-    similarity: {
-      search: (params) => client.executeTool("duck-db-similarity-search", params),
-      duckDbSearch: (params) => client.executeTool("duck-db-similarity-search", params)
-    }
-  };
-}
+`);
+        }
+        res.write(`data: ${JSON.stringify({
+          id,
+          object: "chat.completion.chunk",
+          created,
+          model,
+          choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
+        })}
 
-// src/namespaces/utils.ts
-function createUtils(client) {
-  return {
-    mermaid: (params) => client.executeTool("mermaid-diagram-generator", { mermaid: params.diagram }),
-    documentConvert: (params) => client.executeTool("document-format-converter", {
-      base64: `data:${params.mimeType};base64,${Buffer.from(params.document).toString("base64")}`,
-      format: params.format
-    }),
-    regex: {
-      match: (params) => client.executeTool("regex-match", params),
-      replace: (params) => client.executeTool("regex-replace", params)
-    },
-    jsonExtract: (params) => client.executeTool("json-extract", params),
-    digest: (params) => client.executeTool("digest-generator", { text: params.data }),
-    monteCarlo: (params) => client.executeTool("monte-carlo-simulation", params)
-  };
-}
+`);
+        res.write("data: [DONE]\n\n");
+        res.end();
+      }
+      /**
+       * Update context with conversation history
+       */
+      updateContext(originalMessages, response) {
+        if (!this.context) return;
+        const lastUserMessage = originalMessages.filter((m) => m.role === "user").pop();
+        if (lastUserMessage) {
+          this.context.addMessage("user", lastUserMessage.content);
+        }
+        const assistantContent = response.choices?.[0]?.message?.content;
+        if (assistantContent) {
+          this.context.addMessage("assistant", assistantContent);
+        }
+      }
+      async getOpenAITools() {
+        const tools = [];
+        for (const tool of this.tools.slice(0, 100)) {
+          const schema = await this.getToolSchema(tool.id);
+          if (schema) {
+            const toolSchema = schema;
+            let parameters = { type: "object", properties: {}, required: [] };
+            if (toolSchema.parameters && typeof toolSchema.parameters === "object") {
+              const rawParams = toolSchema.parameters;
+              parameters = {
+                type: rawParams.type || "object",
+                properties: rawParams.properties || {},
+                required: rawParams.required || []
+              };
+            }
+            tools.push({
+              type: "function",
+              function: {
+                name: tool.id.replace(/-/g, "_"),
+                // OpenAI requires underscore names
+                description: toolSchema.description || tool.description,
+                parameters
+              }
+            });
+          }
+        }
+        if (this.mcpProxy) {
+          const proxyTools = this.mcpProxy.getAllTools({ namespacePrefix: this.mcpNamespacePrefix });
+          for (const tool of proxyTools.slice(0, 28)) {
+            const inputSchema = tool.inputSchema || {};
+            tools.push({
+              type: "function",
+              function: {
+                name: this.mcpNamespacePrefix ? `${tool.serverName}_${tool.name}`.replace(/-/g, "_") : tool.name.replace(/-/g, "_"),
+                description: `[${tool.serverName}] ${tool.description}`,
+                parameters: {
+                  type: "object",
+                  properties: inputSchema.properties || {},
+                  required: inputSchema.required || []
+                }
+              }
+            });
+          }
+        }
+        return tools;
+      }
+      buildResponseContent() {
+        const edgeNodeId = this.networkedExecutor?.getEdgeNodeId();
+        const toolCount = this.tools.length;
+        return `Rainfall daemon online. Edge node: ${edgeNodeId || "local"}. ${toolCount} tools available. What would you like to execute locally or in the cloud?`;
+      }
+      getStatus() {
+        return {
+          running: !!this.wss,
+          port: this.port,
+          openaiPort: this.openaiPort,
+          toolsLoaded: this.tools.length,
+          clientsConnected: this.clients.size,
+          edgeNodeId: this.networkedExecutor?.getEdgeNodeId(),
+          context: this.context?.getStatus() || {
+            memoriesCached: 0,
+            activeSessions: 0,
+            executionHistorySize: 0
+          },
+          listeners: this.listeners?.getStatus() || {
+            fileWatchers: 0,
+            cronTriggers: 0,
+            recentEvents: 0
+          }
+        };
+      }
+      log(...args) {
+        if (this.debug) {
+          console.log(...args);
+        }
+      }
+    };
+    daemonInstance = null;
+  }
+});
 
-// src/sdk.ts
-var Rainfall = class {
-  client;
-  _integrations;
-  _memory;
-  _articles;
-  _web;
-  _ai;
-  _data;
-  _utils;
-  constructor(config) {
-    this.client = new RainfallClient(config);
+// src/cli/index.ts
+init_cjs_shims();
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_url = require("url");
+init_sdk();
+init_config();
+var import_child_process = require("child_process");
+
+// src/security/edge-node.ts
+init_cjs_shims();
+var sodium = __toESM(require("libsodium-wrappers"));
+var EdgeNodeSecurity = class {
+  sodiumReady;
+  backendSecret;
+  keyPair;
+  constructor(options = {}) {
+    this.sodiumReady = sodium.ready;
+    this.backendSecret = options.backendSecret;
+    this.keyPair = options.keyPair;
   }
   /**
-   * Integrations namespace - GitHub, Notion, Linear, Slack, Figma, Stripe
-   * 
-   * @example
-   * ```typescript
-   * // GitHub
-   * await rainfall.integrations.github.issues.create({
-   *   owner: 'facebook',
-   *   repo: 'react',
-   *   title: 'Bug report'
-   * });
-   * 
-   * // Slack
-   * await rainfall.integrations.slack.messages.send({
-   *   channelId: 'C123456',
-   *   text: 'Hello team!'
-   * });
-   * 
-   * // Linear
-   * const issues = await rainfall.integrations.linear.issues.list();
-   * ```
+   * Initialize libsodium
    */
-  get integrations() {
-    if (!this._integrations) {
-      this._integrations = createIntegrations(this.client);
-    }
-    return this._integrations;
+  async initialize() {
+    await this.sodiumReady;
   }
+  // ============================================================================
+  // JWT Token Management
+  // ============================================================================
   /**
-   * Memory namespace - Semantic memory storage and retrieval
-   * 
-   * @example
-   * ```typescript
-   * // Store a memory
-   * await rainfall.memory.create({
-   *   content: 'User prefers dark mode',
-   *   keywords: ['preference', 'ui']
-   * });
-   * 
-   * // Recall similar memories
-   * const memories = await rainfall.memory.recall({
-   *   query: 'user preferences',
-   *   topK: 5
-   * });
-   * ```
+   * Generate a JWT token for an edge node
+   * Note: In production, this is done by the backend. This is for testing.
    */
-  get memory() {
-    if (!this._memory) {
-      this._memory = createMemory(this.client);
+  generateJWT(edgeNodeId, subscriberId, expiresInDays = 30) {
+    if (!this.backendSecret) {
+      throw new Error("Backend secret not configured");
     }
-    return this._memory;
+    const now = Math.floor(Date.now() / 1e3);
+    const exp = now + expiresInDays * 24 * 60 * 60;
+    const jti = this.generateTokenId();
+    const payload = {
+      sub: edgeNodeId,
+      iss: "rainfall-backend",
+      iat: now,
+      exp,
+      jti,
+      scope: ["edge:heartbeat", "edge:claim", "edge:submit", "edge:queue"]
+    };
+    const header = { alg: "HS256", typ: "JWT" };
+    const encodedHeader = this.base64UrlEncode(JSON.stringify(header));
+    const encodedPayload = this.base64UrlEncode(JSON.stringify(payload));
+    const signature = this.hmacSha256(
+      `${encodedHeader}.${encodedPayload}`,
+      this.backendSecret
+    );
+    const encodedSignature = this.base64UrlEncode(signature);
+    return `${encodedHeader}.${encodedPayload}.${encodedSignature}`;
   }
   /**
-   * Articles namespace - News aggregation and article management
-   * 
-   * @example
-   * ```typescript
-   * // Search news
-   * const articles = await rainfall.articles.search({
-   *   query: 'artificial intelligence'
-   * });
-   * 
-   * // Create from URL
-   * const article = await rainfall.articles.createFromUrl({
-   *   url: 'https://example.com/article'
-   * });
-   * 
-   * // Summarize
-   * const summary = await rainfall.articles.summarize({
-   *   text: article.content
-   * });
-   * ```
+   * Validate a JWT token
    */
-  get articles() {
-    if (!this._articles) {
-      this._articles = createArticles(this.client);
+  validateJWT(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      throw new Error("Invalid JWT format");
     }
-    return this._articles;
-  }
-  /**
-   * Web namespace - Web search, scraping, and content extraction
-   * 
-   * @example
-   * ```typescript
-   * // Search with Exa
-   * const results = await rainfall.web.search.exa({
-   *   query: 'latest AI research'
-   * });
-   * 
-   * // Fetch and convert
-   * const html = await rainfall.web.fetch({ url: 'https://example.com' });
-   * const markdown = await rainfall.web.htmlToMarkdown({ html });
-   * 
-   * // Extract specific elements
-   * const links = await rainfall.web.extractHtml({
-   *   html,
-   *   selector: 'a[href]'
-   * });
-   * ```
-   */
-  get web() {
-    if (!this._web) {
-      this._web = createWeb(this.client);
+    const [encodedHeader, encodedPayload, encodedSignature] = parts;
+    if (this.backendSecret) {
+      const expectedSignature = this.hmacSha256(
+        `${encodedHeader}.${encodedPayload}`,
+        this.backendSecret
+      );
+      const expectedEncoded = this.base64UrlEncode(expectedSignature);
+      if (!this.timingSafeEqual(encodedSignature, expectedEncoded)) {
+        throw new Error("Invalid JWT signature");
+      }
+    }
+    const payload = JSON.parse(this.base64UrlDecode(encodedPayload));
+    const now = Math.floor(Date.now() / 1e3);
+    if (payload.exp < now) {
+      throw new Error("JWT token expired");
+    }
+    if (payload.iss !== "rainfall-backend") {
+      throw new Error("Invalid JWT issuer");
     }
-    return this._web;
+    return {
+      edgeNodeId: payload.sub,
+      subscriberId: payload.sub,
+      // Same as edge node ID for now
+      scopes: payload.scope,
+      expiresAt: payload.exp
+    };
   }
   /**
-   * AI namespace - Embeddings, image generation, OCR, vision, chat
-   * 
-   * @example
-   * ```typescript
-   * // Generate embeddings
-   * const embedding = await rainfall.ai.embeddings.document({
-   *   text: 'Hello world'
-   * });
-   * 
-   * // Generate image
-   * const image = await rainfall.ai.image.generate({
-   *   prompt: 'A serene mountain landscape'
-   * });
-   * 
-   * // OCR
-   * const text = await rainfall.ai.ocr({ imageBase64: '...' });
-   * 
-   * // Chat
-   * const response = await rainfall.ai.chat({
-   *   messages: [{ role: 'user', content: 'Hello!' }]
-   * });
-   * ```
+   * Extract bearer token from Authorization header
    */
-  get ai() {
-    if (!this._ai) {
-      this._ai = createAI(this.client);
-    }
-    return this._ai;
+  extractBearerToken(authHeader) {
+    if (!authHeader) return null;
+    const match = authHeader.match(/^Bearer\s+(.+)$/i);
+    return match ? match[1] : null;
   }
+  // ============================================================================
+  // ACL Enforcement
+  // ============================================================================
   /**
-   * Data namespace - CSV processing, scripts, similarity search
-   * 
-   * @example
-   * ```typescript
-   * // Query CSV with SQL
-   * const results = await rainfall.data.csv.query({
-   *   sql: 'SELECT * FROM data WHERE value > 100'
-   * });
-   * 
-   * // Execute saved script
-   * const result = await rainfall.data.scripts.execute({
-   *   name: 'my-script',
-   *   params: { input: 'data' }
-   * });
-   * ```
+   * Check if an edge node is allowed to perform an action on a job
+   * Rule: Edge nodes can only access jobs for their own subscriber
    */
-  get data() {
-    if (!this._data) {
-      this._data = createData(this.client);
+  checkACL(check) {
+    if (check.subscriberId !== check.jobSubscriberId) {
+      return {
+        allowed: false,
+        reason: `Edge node ${check.edgeNodeId} cannot access jobs from subscriber ${check.jobSubscriberId}`
+      };
+    }
+    const allowedActions = ["heartbeat", "claim", "submit", "queue"];
+    if (!allowedActions.includes(check.action)) {
+      return {
+        allowed: false,
+        reason: `Unknown action: ${check.action}`
+      };
     }
-    return this._data;
+    return { allowed: true };
   }
   /**
-   * Utils namespace - Mermaid diagrams, document conversion, regex, JSON extraction
-   * 
-   * @example
-   * ```typescript
-   * // Generate diagram
-   * const diagram = await rainfall.utils.mermaid({
-   *   diagram: 'graph TD; A-->B;'
-   * });
-   * 
-   * // Convert document
-   * const pdf = await rainfall.utils.documentConvert({
-   *   document: markdownContent,
-   *   mimeType: 'text/markdown',
-   *   format: 'pdf'
-   * });
-   * 
-   * // Extract JSON from text
-   * const json = await rainfall.utils.jsonExtract({
-   *   text: 'Here is some data: {"key": "value"}'
-   * });
-   * ```
+   * Middleware-style ACL check for job operations
    */
-  get utils() {
-    if (!this._utils) {
-      this._utils = createUtils(this.client);
+  requireSameSubscriber(edgeNodeSubscriberId, jobSubscriberId, operation) {
+    const result = this.checkACL({
+      edgeNodeId: edgeNodeSubscriberId,
+      subscriberId: edgeNodeSubscriberId,
+      jobSubscriberId,
+      action: operation
+    });
+    if (!result.allowed) {
+      throw new Error(result.reason);
     }
-    return this._utils;
   }
+  // ============================================================================
+  // Encryption (Libsodium)
+  // ============================================================================
   /**
-   * Get the underlying HTTP client for advanced usage
+   * Generate a new Ed25519 key pair for an edge node
    */
-  getClient() {
-    return this.client;
+  async generateKeyPair() {
+    await this.sodiumReady;
+    const keyPair = sodium.crypto_box_keypair();
+    return {
+      publicKey: this.bytesToBase64(keyPair.publicKey),
+      privateKey: this.bytesToBase64(keyPair.privateKey)
+    };
   }
   /**
-   * List all available tools
+   * Encrypt job parameters for a target edge node using its public key
    */
-  async listTools() {
-    return this.client.listTools();
+  async encryptForEdgeNode(plaintext, targetPublicKeyBase64) {
+    await this.sodiumReady;
+    if (!this.keyPair) {
+      throw new Error("Local key pair not configured");
+    }
+    const targetPublicKey = this.base64ToBytes(targetPublicKeyBase64);
+    const ephemeralKeyPair = sodium.crypto_box_keypair();
+    const nonce = sodium.randombytes_buf(sodium.crypto_box_NONCEBYTES);
+    const message = new TextEncoder().encode(plaintext);
+    const ciphertext = sodium.crypto_box_easy(
+      message,
+      nonce,
+      targetPublicKey,
+      ephemeralKeyPair.privateKey
+    );
+    return {
+      ciphertext: this.bytesToBase64(ciphertext),
+      nonce: this.bytesToBase64(nonce),
+      ephemeralPublicKey: this.bytesToBase64(ephemeralKeyPair.publicKey)
+    };
   }
   /**
-   * Get schema for a specific tool
+   * Decrypt job parameters received from the backend
    */
-  async getToolSchema(toolId) {
-    return this.client.getToolSchema(toolId);
+  async decryptFromBackend(encrypted) {
+    await this.sodiumReady;
+    if (!this.keyPair) {
+      throw new Error("Local key pair not configured");
+    }
+    const privateKey = this.base64ToBytes(this.keyPair.privateKey);
+    const ephemeralPublicKey = this.base64ToBytes(encrypted.ephemeralPublicKey);
+    const nonce = this.base64ToBytes(encrypted.nonce);
+    const ciphertext = this.base64ToBytes(encrypted.ciphertext);
+    const decrypted = sodium.crypto_box_open_easy(
+      ciphertext,
+      nonce,
+      ephemeralPublicKey,
+      privateKey
+    );
+    if (!decrypted) {
+      throw new Error("Decryption failed - invalid ciphertext or keys");
+    }
+    return new TextDecoder().decode(decrypted);
   }
   /**
-   * Execute any tool by ID (low-level access)
+   * Encrypt job parameters for local storage (using secretbox)
    */
-  async executeTool(toolId, params) {
-    return this.client.executeTool(toolId, params);
+  async encryptLocal(plaintext, key) {
+    await this.sodiumReady;
+    const keyBytes = this.deriveKey(key);
+    const nonce = sodium.randombytes_buf(sodium.crypto_secretbox_NONCEBYTES);
+    const message = new TextEncoder().encode(plaintext);
+    const ciphertext = sodium.crypto_secretbox_easy(message, nonce, keyBytes);
+    return {
+      ciphertext: this.bytesToBase64(ciphertext),
+      nonce: this.bytesToBase64(nonce)
+    };
   }
   /**
-   * Get current subscriber info and usage
+   * Decrypt locally stored job parameters
    */
-  async getMe() {
-    return this.client.getMe();
+  async decryptLocal(encrypted, key) {
+    await this.sodiumReady;
+    const keyBytes = this.deriveKey(key);
+    const nonce = this.base64ToBytes(encrypted.nonce);
+    const ciphertext = this.base64ToBytes(encrypted.ciphertext);
+    const decrypted = sodium.crypto_secretbox_open_easy(ciphertext, nonce, keyBytes);
+    if (!decrypted) {
+      throw new Error("Local decryption failed");
+    }
+    return new TextDecoder().decode(decrypted);
   }
-  /**
-   * Get current rate limit info
-   */
-  getRateLimitInfo() {
-    return this.client.getRateLimitInfo();
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  generateTokenId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
   }
-};
-
-// src/cli/index.ts
-var CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".rainfall");
-var CONFIG_FILE = (0, import_path.join)(CONFIG_DIR, "config.json");
-function loadConfig() {
-  if (!(0, import_fs.existsSync)(CONFIG_FILE)) {
-    return {};
+  base64UrlEncode(str) {
+    return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
   }
-  try {
-    return JSON.parse((0, import_fs.readFileSync)(CONFIG_FILE, "utf8"));
-  } catch {
-    return {};
+  base64UrlDecode(str) {
+    const padding = "=".repeat((4 - str.length % 4) % 4);
+    const base64 = str.replace(/-/g, "+").replace(/_/g, "/") + padding;
+    return atob(base64);
   }
-}
-function saveConfig(config) {
-  if (!(0, import_fs.existsSync)(CONFIG_DIR)) {
-    (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
+  hmacSha256(message, secret) {
+    const key = new TextEncoder().encode(secret);
+    const msg = new TextEncoder().encode(message);
+    const hash = sodium.crypto_auth(msg, key);
+    return this.bytesToBase64(hash);
   }
-  (0, import_fs.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-function getRainfall() {
-  const config = loadConfig();
-  if (!config.apiKey) {
-    console.error("Error: No API key configured. Run: rainfall auth login");
-    process.exit(1);
+  timingSafeEqual(a, b) {
+    if (a.length !== b.length) return false;
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+      result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return result === 0;
   }
-  return new Rainfall({
-    apiKey: config.apiKey,
-    baseUrl: config.baseUrl
-  });
+  bytesToBase64(bytes) {
+    const binString = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+    return btoa(binString);
+  }
+  base64ToBytes(base64) {
+    const binString = atob(base64);
+    return Uint8Array.from(binString, (m) => m.charCodeAt(0));
+  }
+  deriveKey(password) {
+    const passwordBytes = new TextEncoder().encode(password);
+    return sodium.crypto_generichash(32, passwordBytes, null);
+  }
+};
+async function createEdgeNodeSecurity(options = {}) {
+  const security = new EdgeNodeSecurity(options);
+  await security.initialize();
+  return security;
 }
+
+// src/cli/index.ts
 function printHelp() {
   console.log(`
 Rainfall CLI - 200+ tools, one key
@@ -832,28 +3560,72 @@ Commands:
   tools search <query>          Search for tools
   
   run <tool> [options]          Execute a tool
+
+  daemon start                  Start the Rainfall daemon
+  daemon stop                   Stop the Rainfall daemon
+  daemon restart                Restart the Rainfall daemon
+  daemon status                 Check daemon status
+  
+  workflow new                  Create a new workflow (interactive)
+  workflow run <workflow>       Run a saved workflow
   
   me                            Show account info and usage
   
   config get [key]              Get configuration value
   config set <key> <value>      Set configuration value
+  config llm                    Show LLM configuration
+  
+  edge generate-keys            Generate key pair for edge node encryption
+  edge status                   Show edge node security status
+  
+  version                       Show version information
+  upgrade                       Upgrade to the latest version
   
   help                          Show this help message
 
+Configuration keys:
+  llm.provider                  LLM provider (rainfall|openai|anthropic|ollama|local)
+  llm.baseUrl                   Base URL for the LLM API
+  llm.apiKey                    API key for the LLM provider
+  llm.model                     Default model to use
+
 Options for 'run':
   --params, -p <json>           Tool parameters as JSON
   --file, -f <path>             Read parameters from file
   --raw                         Output raw JSON
+  --<key> <value>               Pass individual parameters (e.g., --query "AI news")
+
+Options for 'daemon start':
+  --port <port>                 WebSocket port (default: 8765)
+  --openai-port <port>          OpenAI API port (default: 8787)
+  --mcp-proxy                   Enable MCP proxy hub (default: enabled)
+  --no-mcp-proxy                Disable MCP proxy hub
+  --secure                      Enable edge node security (JWT, ACLs, encryption)
+  --debug                       Enable verbose debug logging
 
 Examples:
   rainfall auth login
   rainfall tools list
   rainfall tools describe github-create-issue
   rainfall run exa-web-search -p '{"query": "AI news"}'
+  rainfall run exa-web-search --query "AI news"
+  rainfall run github-create-issue --owner facebook --repo react --title "Bug"
   rainfall run article-summarize -f ./article.json
+  rainfall daemon start
   echo '{"query": "hello"}' | rainfall run exa-web-search
 `);
 }
+function getRainfall() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    console.error("Error: No API key configured. Run: rainfall auth login");
+    process.exit(1);
+  }
+  return new Rainfall({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
 async function authLogin(args) {
   const apiKey = args[0] || process.env.RAINFALL_API_KEY;
   if (!apiKey) {
@@ -1018,16 +3790,20 @@ Options:
   -p, --params <json>    Tool parameters as JSON string
   -f, --file <path>      Read parameters from JSON file
   --raw                  Output raw JSON (no formatting)
+  --<key> <value>        Pass individual parameters (e.g., --query "AI news")
 
 Examples:
   rainfall run figma-users-getMe
   rainfall run exa-web-search -p '{"query": "AI news"}'
+  rainfall run exa-web-search --query "AI news"
+  rainfall run github-create-issue --owner facebook --repo react --title "Bug"
   rainfall run github-create-issue -f ./issue.json
   echo '{"query": "hello"}' | rainfall run exa-web-search
 `);
     return;
   }
   let params = {};
+  const rawArgs = [];
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--params" || arg === "-p") {
@@ -1049,12 +3825,26 @@ Examples:
         process.exit(1);
       }
       try {
-        params = JSON.parse((0, import_fs.readFileSync)(filePath, "utf8"));
+        params = JSON.parse((0, import_fs2.readFileSync)(filePath, "utf8"));
       } catch {
         console.error(`Error: Could not read or parse file: ${filePath}`);
         process.exit(1);
       }
     } else if (arg === "--raw") {
+    } else if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const value = args[++i];
+      if (value === void 0) {
+        console.error(`Error: ${arg} requires a value`);
+        process.exit(1);
+      }
+      try {
+        params[key] = JSON.parse(value);
+      } catch {
+        params[key] = value;
+      }
+    } else {
+      rawArgs.push(arg);
     }
   }
   if (!process.stdin.isTTY) {
@@ -1092,6 +3882,20 @@ Examples:
     }
   }
   const rainfall = getRainfall();
+  if (rawArgs.length === 1 && Object.keys(params).length === 0) {
+    try {
+      const schema = await rainfall.getToolSchema(toolId);
+      if (schema.parameters && typeof schema.parameters === "object") {
+        const paramEntries = Object.entries(schema.parameters);
+        const requiredParams = paramEntries.filter(([, p]) => !p.optional);
+        if (requiredParams.length === 1) {
+          const [paramName] = requiredParams[0];
+          params = { [paramName]: rawArgs[0] };
+        }
+      }
+    } catch {
+    }
+  }
   try {
     const result = await rainfall.executeTool(toolId, params);
     if (args.includes("--raw")) {
@@ -1118,7 +3922,16 @@ function configGet(args) {
   const key = args[0];
   const config = loadConfig();
   if (key) {
-    console.log(config[key] || "");
+    const parts = key.split(".");
+    let value = config;
+    for (const part of parts) {
+      value = value?.[part];
+    }
+    if (typeof value === "object" && value !== null) {
+      console.log(JSON.stringify(value, null, 2));
+    } else {
+      console.log(value ?? "");
+    }
   } else {
     console.log(JSON.stringify(config, null, 2));
   }
@@ -1129,13 +3942,306 @@ function configSet(args) {
   if (!key || !value) {
     console.error("Error: Both key and value required");
     console.error("\nUsage: rainfall config set <key> <value>");
+    console.error("\nExamples:");
+    console.error("  rainfall config set llm.provider local");
+    console.error("  rainfall config set llm.baseUrl http://localhost:1234/v1");
+    console.error("  rainfall config set llm.model llama-3.3-70b-versatile");
     process.exit(1);
   }
   const config = loadConfig();
-  config[key] = value;
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    config[key] = value;
+  } else {
+    let target = config;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!target[parts[i]] || typeof target[parts[i]] !== "object") {
+        target[parts[i]] = {};
+      }
+      target = target[parts[i]];
+    }
+    target[parts[parts.length - 1]] = value;
+  }
   saveConfig(config);
   console.log(`\u2713 Set ${key} = ${value}`);
 }
+function configLLM() {
+  const config = loadConfig();
+  const llm = config.llm || { provider: "rainfall" };
+  console.log("LLM Configuration:");
+  console.log(`  Provider: ${llm.provider}`);
+  console.log(`  Base URL: ${llm.baseUrl || "(default)"}`);
+  console.log(`  Model: ${llm.model || "(default)"}`);
+  console.log(`  API Key: ${llm.apiKey ? "****" + llm.apiKey.slice(-4) : "(none)"}`);
+  console.log();
+  console.log("Providers:");
+  console.log("  rainfall  - Use Rainfall backend (default, uses your credits)");
+  console.log("  openai    - Use OpenAI API directly");
+  console.log("  anthropic - Use Anthropic API directly");
+  console.log("  ollama    - Use local Ollama instance");
+  console.log("  local     - Use any OpenAI-compatible endpoint (LM Studio, etc.)");
+  console.log("  custom    - Use any custom OpenAI-compatible endpoint (RunPod, etc.)");
+  console.log();
+  console.log("Examples:");
+  console.log("  rainfall config set llm.provider local");
+  console.log("  rainfall config set llm.baseUrl http://localhost:1234/v1");
+  console.log("  rainfall config set llm.provider custom");
+  console.log("  rainfall config set llm.baseUrl https://your-runpod-endpoint.runpod.net/v1");
+  console.log("  rainfall config set llm.provider openai");
+  console.log("  rainfall config set llm.apiKey sk-...");
+}
+function getPackageJson() {
+  try {
+    const __filename2 = (0, import_url.fileURLToPath)(importMetaUrl);
+    const __dirname = (0, import_path2.dirname)(__filename2);
+    const packagePath = (0, import_path2.join)(__dirname, "..", "..", "package.json");
+    const content = (0, import_fs2.readFileSync)(packagePath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { version: "unknown", name: "@rainfall-devkit/sdk" };
+  }
+}
+function showVersion() {
+  const pkg = getPackageJson();
+  console.log(`${pkg.name} v${pkg.version}`);
+}
+async function upgrade() {
+  const pkg = getPackageJson();
+  console.log(`Upgrading ${pkg.name}...`);
+  const execPath = process.argv[0];
+  const isBun = execPath.includes("bun");
+  let command;
+  let args;
+  if (isBun) {
+    command = "bun";
+    args = ["add", "-g", `${pkg.name}@latest`];
+  } else {
+    command = "npm";
+    args = ["i", "-g", `${pkg.name}@latest`];
+  }
+  console.log(`Running: ${command} ${args.join(" ")}`);
+  console.log();
+  return new Promise((resolve, reject) => {
+    const child = (0, import_child_process.spawn)(command, args, {
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log();
+        console.log("\u2713 Upgrade complete");
+        resolve();
+      } else {
+        reject(new Error(`Upgrade failed with exit code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function daemonStart(args) {
+  let port;
+  let openaiPort;
+  let debug = false;
+  let enableMcpProxy = true;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) port = val;
+    } else if (arg === "--openai-port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) openaiPort = val;
+    } else if (arg === "--debug") {
+      debug = true;
+    } else if (arg === "--mcp-proxy") {
+      enableMcpProxy = true;
+    } else if (arg === "--no-mcp-proxy") {
+      enableMcpProxy = false;
+    }
+  }
+  const { startDaemon: startDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  try {
+    await startDaemon2({ port, openaiPort, debug, enableMcpProxy });
+    process.on("SIGINT", async () => {
+      console.log("\n");
+      const { stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+      await stopDaemon2();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      const { stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+      await stopDaemon2();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("Failed to start daemon:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function daemonStop() {
+  const { stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  await stopDaemon2();
+}
+async function daemonRestart(args) {
+  const { stopDaemon: stopDaemon2, startDaemon: startDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  let port;
+  let openaiPort;
+  let debug = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) port = val;
+    } else if (arg === "--openai-port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) openaiPort = val;
+    } else if (arg === "--debug") {
+      debug = true;
+    }
+  }
+  console.log("\u{1F504} Restarting daemon...");
+  try {
+    await stopDaemon2();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    await startDaemon2({ port, openaiPort, debug });
+    process.on("SIGINT", async () => {
+      console.log("\n");
+      const { stopDaemon: stop } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+      await stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      const { stopDaemon: stop } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+      await stop();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("Failed to restart daemon:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function daemonStatus() {
+  const { getDaemonStatus: getDaemonStatus2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  const status = getDaemonStatus2();
+  if (!status) {
+    console.log("Daemon not running");
+    console.log("Run: rainfall daemon start");
+    return;
+  }
+  console.log("Daemon status:");
+  console.log(`  Running: ${status.running ? "yes" : "no"}`);
+  console.log(`  WebSocket port: ${status.port}`);
+  console.log(`  OpenAI API port: ${status.openaiPort}`);
+  console.log(`  Tools loaded: ${status.toolsLoaded}`);
+  console.log(`  MCP clients: ${status.mcpClients || 0}`);
+  console.log(`  MCP tools: ${status.mcpTools || 0}`);
+  console.log(`  Clients connected: ${status.clientsConnected}`);
+  console.log(`  Edge Node ID: ${status.edgeNodeId || "local"}`);
+  console.log();
+  console.log("Context:");
+  console.log(`  Memories cached: ${status.context.memoriesCached}`);
+  console.log(`  Active sessions: ${status.context.activeSessions}`);
+  console.log(`  Current session: ${status.context.currentSession || "none"}`);
+  console.log(`  Execution history: ${status.context.executionHistorySize}`);
+  console.log();
+  console.log("Listeners:");
+  console.log(`  File watchers: ${status.listeners.fileWatchers}`);
+  console.log(`  Cron triggers: ${status.listeners.cronTriggers}`);
+  console.log(`  Recent events: ${status.listeners.recentEvents}`);
+}
+async function workflowNew() {
+  console.log("\u{1F6A7} Interactive workflow creation coming soon!");
+  console.log();
+  console.log("For now, create workflows using the SDK:");
+  console.log('  import { createFileWatcherWorkflow } from "@rainfall-devkit/sdk/daemon";');
+  console.log();
+  console.log("Example:");
+  console.log(`  const workflow = createFileWatcherWorkflow('pdf-processor', '~/Downloads', {`);
+  console.log(`    pattern: '*.pdf',`);
+  console.log(`    events: ['create'],`);
+  console.log(`    workflow: [`);
+  console.log(`      { toolId: 'ocr-pdf', params: {} },`);
+  console.log(`      { toolId: 'notion-create-page', params: { parent: '...' } },`);
+  console.log(`    ],`);
+  console.log(`  });`);
+}
+async function workflowRun(args) {
+  const workflowId = args[0];
+  if (!workflowId) {
+    console.error("Error: Workflow ID required");
+    console.error("\nUsage: rainfall workflow run <workflow-id>");
+    process.exit(1);
+  }
+  console.log(`\u{1F6A7} Running workflow: ${workflowId}`);
+  console.log("Workflow execution coming soon!");
+}
+async function edgeGenerateKeys() {
+  console.log("\u{1F510} Generating edge node key pair...\n");
+  try {
+    const security = await createEdgeNodeSecurity();
+    const keyPair = await security.generateKeyPair();
+    const configDir = getConfigDir();
+    const keysDir = (0, import_path2.join)(configDir, "keys");
+    if (!(0, import_fs2.existsSync)(keysDir)) {
+      (0, import_fs2.mkdirSync)(keysDir, { recursive: true });
+    }
+    const publicKeyPath = (0, import_path2.join)(keysDir, "edge-node.pub");
+    const privateKeyPath = (0, import_path2.join)(keysDir, "edge-node.key");
+    (0, import_fs2.writeFileSync)(publicKeyPath, keyPair.publicKey, { mode: 420 });
+    (0, import_fs2.writeFileSync)(privateKeyPath, keyPair.privateKey, { mode: 384 });
+    console.log("\u2705 Key pair generated successfully!\n");
+    console.log("Public key:", keyPair.publicKey);
+    console.log("\nKey files saved to:");
+    console.log("  Public:", publicKeyPath);
+    console.log("  Private:", privateKeyPath);
+    console.log("\n\u{1F4CB} To register this edge node:");
+    console.log("  1. Copy the public key above");
+    console.log("  2. Register with: rainfall edge register <public-key>");
+    console.log("  3. The backend will return an edgeNodeSecret (JWT)");
+    console.log("  4. Store the secret securely - it expires in 30 days");
+  } catch (error) {
+    console.error("\u274C Failed to generate keys:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function edgeStatus() {
+  const configDir = getConfigDir();
+  const keysDir = (0, import_path2.join)(configDir, "keys");
+  const publicKeyPath = (0, import_path2.join)(keysDir, "edge-node.pub");
+  const privateKeyPath = (0, import_path2.join)(keysDir, "edge-node.key");
+  console.log("\u{1F510} Edge Node Security Status\n");
+  const hasPublicKey = (0, import_fs2.existsSync)(publicKeyPath);
+  const hasPrivateKey = (0, import_fs2.existsSync)(privateKeyPath);
+  console.log("Key Pair:");
+  console.log("  Public key:", hasPublicKey ? "\u2705 Present" : "\u274C Missing");
+  console.log("  Private key:", hasPrivateKey ? "\u2705 Present" : "\u274C Missing");
+  if (hasPublicKey) {
+    const publicKey = (0, import_fs2.readFileSync)(publicKeyPath, "utf-8");
+    console.log("\nPublic Key:");
+    console.log("  " + publicKey.substring(0, 50) + "...");
+  }
+  const config = loadConfig();
+  if (config.edgeNodeId) {
+    console.log("\nRegistration:");
+    console.log("  Edge Node ID:", config.edgeNodeId);
+  }
+  if (config.edgeNodeSecret) {
+    console.log("  JWT Secret: \u2705 Present (expires: check with backend)");
+  } else {
+    console.log("  JWT Secret: \u274C Not configured");
+  }
+  console.log("\n\u{1F4DA} Next steps:");
+  if (!hasPublicKey) {
+    console.log("  1. Run: rainfall edge generate-keys");
+  } else if (!config.edgeNodeSecret) {
+    console.log("  1. Register your edge node with the backend");
+    console.log("  2. Store the returned edgeNodeSecret in config");
+  } else {
+    console.log("  Edge node is configured and ready for secure operation");
+  }
+}
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0];
@@ -1179,6 +4285,40 @@ async function main() {
     case "run":
       await runTool(args.slice(1));
       break;
+    case "daemon":
+      switch (subcommand) {
+        case "start":
+          await daemonStart(rest);
+          break;
+        case "stop":
+          await daemonStop();
+          break;
+        case "restart":
+          await daemonRestart(rest);
+          break;
+        case "status":
+          await daemonStatus();
+          break;
+        default:
+          console.error("Error: Unknown daemon subcommand");
+          console.error("\nUsage: rainfall daemon <start|stop|restart|status>");
+          process.exit(1);
+      }
+      break;
+    case "workflow":
+      switch (subcommand) {
+        case "new":
+          await workflowNew();
+          break;
+        case "run":
+          await workflowRun(rest);
+          break;
+        default:
+          console.error("Error: Unknown workflow subcommand");
+          console.error("\nUsage: rainfall workflow <new|run>");
+          process.exit(1);
+      }
+      break;
     case "me":
       await showMe();
       break;
@@ -1190,9 +4330,34 @@ async function main() {
         case "set":
           configSet(rest);
           break;
+        case "llm":
+          configLLM();
+          break;
         default:
           console.error("Error: Unknown config subcommand");
-          console.error("\nUsage: rainfall config <get|set>");
+          console.error("\nUsage: rainfall config <get|set|llm>");
+          process.exit(1);
+      }
+      break;
+    case "version":
+    case "--version":
+    case "-v":
+      showVersion();
+      break;
+    case "upgrade":
+      await upgrade();
+      break;
+    case "edge":
+      switch (subcommand) {
+        case "generate-keys":
+          await edgeGenerateKeys();
+          break;
+        case "status":
+          await edgeStatus();
+          break;
+        default:
+          console.error("Error: Unknown edge subcommand");
+          console.error("\nUsage: rainfall edge <generate-keys|status>");
           process.exit(1);
       }
       break;