aquaman-plugin 0.2.0 → 0.2.2

package/index.ts

@@ -22,6 +22,7 @@ import { HttpInterceptor, createHttpInterceptor } from "./src/http-interceptor.j
 
 let proxyProcess: ChildProcess | null = null;
 let httpInterceptor: HttpInterceptor | null = null;
+let clientToken: string | null = null;
 const proxyPort = 8081;
 const services = ["anthropic", "openai"];
 
@@ -33,6 +34,13 @@ function getExternalProxyUrl(): string | null {
   return process.env.AQUAMAN_PROXY_URL || null;
 }
 
+/**
+ * Get external client token from environment (for Docker two-container mode).
+ */
+function getExternalClientToken(): string | null {
+  return process.env.AQUAMAN_CLIENT_TOKEN || null;
+}
+
 /**
  * Check if aquaman CLI is installed
  */
@@ -62,11 +70,33 @@ async function startProxy(port: number, log: OpenClawPluginApi["logger"]): Promi
     }
 
     let started = false;
+    let stdoutBuffer = "";
 
     proxyProcess.stdout?.on("data", (data: Buffer) => {
-      const output = data.toString();
-      log.debug(`[aquaman] ${output.trim()}`);
-      if (output.includes("listening") || output.includes("started")) {
+      stdoutBuffer += data.toString();
+      log.debug(`[aquaman] ${data.toString().trim()}`);
+      if (started) return;
+
+      // Try to parse JSON connection info from stdout
+      const lines = stdoutBuffer.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{")) continue;
+        try {
+          const info = JSON.parse(trimmed);
+          if (info.ready === true) {
+            started = true;
+            clientToken = info.token || null;
+            resolve(true);
+            return;
+          }
+        } catch {
+          // Not valid JSON yet, keep buffering
+        }
+      }
+
+      // Fall back to string matching for backward compat
+      if (stdoutBuffer.includes("listening") || stdoutBuffer.includes("started")) {
         started = true;
         resolve(true);
       }
@@ -111,6 +141,7 @@ function stopProxy(): void {
     proxyProcess.kill("SIGTERM");
     proxyProcess = null;
   }
+  clientToken = null;
 }
 
 /**
@@ -124,6 +155,8 @@ function activateHttpInterceptor(log: OpenClawPluginApi["logger"]): void {
     ['api.anthropic.com', 'anthropic'],
     ['api.openai.com', 'openai'],
     ['api.github.com', 'github'],
+    ['api.x.ai', 'xai'],
+    ['gateway.ai.cloudflare.com', 'cloudflare-ai'],
     // Channel APIs
     ['slack.com', 'slack'],
     ['*.slack.com', 'slack'],
@@ -152,6 +185,7 @@ function activateHttpInterceptor(log: OpenClawPluginApi["logger"]): void {
   httpInterceptor = createHttpInterceptor({
     proxyBaseUrl: baseUrl,
     hostMap,
+    clientToken: clientToken || undefined,
     log: (msg) => log.info(msg),
   });
 
@@ -243,6 +277,7 @@ export default function register(api: OpenClawPluginApi): void {
   // External proxy mode (Docker two-container architecture)
   if (externalUrl) {
     api.logger.info(`External proxy mode: ${externalUrl}`);
+    clientToken = getExternalClientToken();
     configureEnvironment(api.logger);
 
     if (api.registerLifecycle) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aquaman-plugin",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Credential isolation plugin for OpenClaw",
   "type": "module",
   "scripts": {

package/src/http-interceptor.ts

@@ -15,6 +15,8 @@ export interface HttpInterceptorOptions {
   proxyBaseUrl: string;
   /** Map of hostname (or *.domain wildcard) → service name */
   hostMap: Map<string, string>;
+  /** Client authentication token for the proxy */
+  clientToken?: string;
   /** Optional logger */
   log?: (msg: string) => void;
 }
@@ -23,6 +25,7 @@ export class HttpInterceptor {
   private proxyBaseUrl: string;
   private proxyHost: string;
   private hostMap: Map<string, string>;
+  private clientToken: string | null;
   private originalFetch: typeof globalThis.fetch | null = null;
   private active = false;
   private log: (msg: string) => void;
@@ -30,6 +33,7 @@ export class HttpInterceptor {
   constructor(options: HttpInterceptorOptions) {
     this.proxyBaseUrl = options.proxyBaseUrl.replace(/\/$/, '');
     this.hostMap = options.hostMap;
+    this.clientToken = options.clientToken || null;
     this.log = options.log || (() => {});
 
     // Extract proxy hostname to avoid intercepting requests to the proxy itself
@@ -51,9 +55,11 @@ export class HttpInterceptor {
     const origFetch = this.originalFetch;
     const proxyBase = this.proxyBaseUrl;
     const proxyHostname = this.proxyHost;
+    const token = this.clientToken;
     const matchHost = this.matchHost.bind(this);
     const extractUrl = this.extractUrl.bind(this);
     const stripAuthHeaders = this.stripAuthHeaders.bind(this);
+    const injectToken = this.injectTokenHeader.bind(this);
     const logFn = this.log;
 
     globalThis.fetch = (
@@ -65,8 +71,12 @@ export class HttpInterceptor {
         return origFetch.call(globalThis, input, init);
       }
 
-      // Don't intercept requests to the proxy itself
+      // Requests to the proxy itself (SDK traffic via env vars) — inject token, pass through
       if (url.hostname === proxyHostname || url.hostname === 'localhost') {
+        if (token) {
+          const tokenInit = injectToken(init, token);
+          return origFetch.call(globalThis, input, tokenInit);
+        }
         return origFetch.call(globalThis, input, init);
       }
 
@@ -86,6 +96,11 @@ export class HttpInterceptor {
         newInit = { ...init, headers: stripped };
       }
 
+      // Inject client token for proxy authentication
+      if (token) {
+        newInit = injectToken(newInit, token);
+      }
+
       return origFetch.call(globalThis, proxyUrl, newInit);
     };
 
@@ -138,6 +153,28 @@ export class HttpInterceptor {
     return null;
   }
 
+  private injectTokenHeader(init: RequestInit | undefined, token: string): RequestInit {
+    const base = init || {};
+    const headers = base.headers;
+
+    if (!headers) {
+      return { ...base, headers: { 'x-aquaman-token': token } };
+    }
+
+    if (headers instanceof Headers) {
+      const h = new Headers(headers);
+      h.set('x-aquaman-token', token);
+      return { ...base, headers: h };
+    }
+
+    if (Array.isArray(headers)) {
+      return { ...base, headers: [...headers, ['x-aquaman-token', token]] };
+    }
+
+    // Plain object
+    return { ...base, headers: { ...headers, 'x-aquaman-token': token } };
+  }
+
   private stripAuthHeaders(headers: HeadersInit): HeadersInit {
     if (headers instanceof Headers) {
       const h = new Headers(headers);

package/src/proxy-manager.ts

@@ -17,6 +17,7 @@ export interface ProxyConnectionInfo {
   baseUrl: string;
   services: string[];
   backend: string;
+  token?: string;
 }
 
 export interface ProxyManagerOptions {
@@ -193,6 +194,13 @@ export class ProxyManager {
     return this.connectionInfo;
   }
 
+  /**
+   * Get client authentication token
+   */
+  getClientToken(): string | null {
+    return this.connectionInfo?.token || null;
+  }
+
   /**
    * Get base URL for a service
    */