explorbot 0.4.2 → 0.4.3

package/src/api/xhr-capture.ts

@@ -60,26 +60,25 @@ export class XhrCapture {
       this.store.addFailedRequest(failure);
     }
 
-    if (!WRITE_METHODS.has(method)) return;
-
     const contentType = response.headers()['content-type'] || '';
     if (!JSON_CONTENT_TYPES.test(contentType)) return;
 
+    if (method === 'GET') {
+      if (status !== 200) return;
+      this.captureReadEndpoint(request, response);
+      return;
+    }
+
+    if (!WRITE_METHODS.has(method)) return;
+
     if (status === 304) return;
 
     const parsedUrl = new URL(url);
     const origin = parsedUrl.pathname + parsedUrl.search;
     const id = generateRequestId(method, parsedUrl.pathname, 'xhr_');
 
-    const requestHeaders: Record<string, string> = {};
-    for (const [k, v] of Object.entries(request.headers())) {
-      requestHeaders[k] = String(v);
-    }
-
-    const responseHeaders: Record<string, string> = {};
-    for (const [k, v] of Object.entries(response.headers())) {
-      responseHeaders[k] = String(v);
-    }
+    const requestHeaders = this.toHeaderMap(request.headers());
+    const responseHeaders = this.toHeaderMap(response.headers());
 
     let rawBody = '';
     try {
@@ -115,4 +114,33 @@ export class XhrCapture {
 
     this.store.addCapturedRequest(result);
   }
+
+  private captureReadEndpoint(request: any, response: any): void {
+    const parsedUrl = new URL(request.url());
+    const requestHeaders = this.toHeaderMap(request.headers());
+
+    const result = new RequestResult({
+      id: generateRequestId('GET', parsedUrl.pathname, 'xhr_'),
+      method: 'GET',
+      path: parsedUrl.pathname,
+      fullUrl: parsedUrl.pathname + parsedUrl.search,
+      requestHeaders,
+      status: response.status(),
+      statusText: response.statusText(),
+      responseHeaders: {},
+      timing: 0,
+      timestamp: new Date(),
+    });
+    result.rawResponseBodyValue = '';
+
+    this.store.addReadRequest(result);
+  }
+
+  private toHeaderMap(headers: Record<string, unknown>): Record<string, string> {
+    const map: Record<string, string> = {};
+    for (const [k, v] of Object.entries(headers)) {
+      map[k] = String(v);
+    }
+    return map;
+  }
 }

package/src/commands/help-json-command.ts

@@ -0,0 +1,74 @@
+import type { Command } from 'commander';
+import { EXPLORBOT_ENV_VARS } from '../config.js';
+
+const DESCRIPTION = 'Print command definitions as JSON for agents and tools';
+
+export class HelpJsonCommand {
+  static register(program: Command): void {
+    program
+      .command('help-json [command...]')
+      .description(DESCRIPTION)
+      .action(async (names: string[]) => {
+        const target = HelpJsonCommand.find(program, names);
+        if (!target) {
+          console.error(`Unknown command: ${names.join(' ')}`);
+          process.exit(1);
+        }
+        const json = JSON.stringify(HelpJsonCommand.data(target, target === program), null, 2);
+        await new Promise<void>((resolve) => process.stdout.write(`${json}\n`, () => resolve()));
+      });
+  }
+
+  static data(cmd: Command, root = false): CommandDefinition {
+    const helper = cmd.createHelp();
+    const definition: CommandDefinition = {
+      name: cmd.name(),
+      description: cmd.description(),
+      aliases: cmd.aliases(),
+      arguments: cmd.registeredArguments.map((argument) => ({
+        name: argument.name(),
+        description: argument.description,
+        required: argument.required,
+        variadic: argument.variadic,
+      })),
+      options: helper.visibleOptions(cmd).map((option) => ({
+        flags: option.flags,
+        description: option.description,
+        default: option.defaultValue,
+        choices: option.argChoices,
+      })),
+      commands: helper.visibleCommands(cmd).map((sub) => HelpJsonCommand.data(sub)),
+    };
+
+    if (!root) return definition;
+
+    definition.version = cmd.version();
+    definition.env = EXPLORBOT_ENV_VARS.map((variable) => ({
+      name: variable.name,
+      description: variable.description,
+      required: !!variable.required,
+    }));
+    return definition;
+  }
+
+  private static find(cmd: Command, names: string[]): Command | undefined {
+    let target = cmd;
+    for (const name of names) {
+      const sub = target.commands.find((candidate) => candidate.name() === name || candidate.aliases().includes(name));
+      if (!sub) return undefined;
+      target = sub;
+    }
+    return target;
+  }
+}
+
+interface CommandDefinition {
+  name: string;
+  description: string;
+  aliases: string[];
+  version?: string;
+  arguments: { name: string; description: string; required: boolean; variadic: boolean }[];
+  options: { flags: string; description: string; default?: unknown; choices?: string[] }[];
+  commands: CommandDefinition[];
+  env?: { name: string; description: string; required: boolean }[];
+}

package/dist/src/ai/fisherman-tools.d.ts

@@ -1,147 +0,0 @@
-import type { ApiClient } from '../api/api-client.js';
-import type { RequestStore } from '../api/request-store.js';
-import type { RequestHaul } from './fisherman/request-haul.js';
-export declare function createFishermanTools(apiClient: ApiClient, requestStore: RequestStore, haul: RequestHaul, opts: {
-    spec?: any;
-    baseEndpoint?: string;
-}): {
-    tools: {
-        getEndpointSpec: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
-            method: any;
-            path: any;
-        }, {
-            source: string;
-            method: any;
-            path: any;
-            definition: string;
-            rejectedCapture: {
-                status: number;
-                requestBody: any;
-            };
-            usable?: undefined;
-            rejectedRequestBody?: undefined;
-            status?: undefined;
-            requestBody?: undefined;
-            error?: undefined;
-        } | {
-            source: string;
-            method: any;
-            path: any;
-            usable: boolean;
-            rejectedRequestBody: any;
-            status: number;
-            definition?: undefined;
-            rejectedCapture?: undefined;
-            requestBody?: undefined;
-            error?: undefined;
-        } | {
-            source: string;
-            method: string;
-            path: string;
-            status: number;
-            requestBody: any;
-            definition?: undefined;
-            rejectedCapture?: undefined;
-            usable?: undefined;
-            rejectedRequestBody?: undefined;
-            error?: undefined;
-        } | {
-            source: string;
-            definition: string;
-            method?: undefined;
-            path?: undefined;
-            rejectedCapture?: undefined;
-            usable?: undefined;
-            rejectedRequestBody?: undefined;
-            status?: undefined;
-            requestBody?: undefined;
-            error?: undefined;
-        } | {
-            source: string;
-            error: any;
-            method?: undefined;
-            path?: undefined;
-            definition?: undefined;
-            rejectedCapture?: undefined;
-            usable?: undefined;
-            rejectedRequestBody?: undefined;
-            status?: undefined;
-            requestBody?: undefined;
-        }, import("@ai-sdk/provider-utils").Context>>;
-        request: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<any, {
-            success: boolean;
-            error: string;
-            status?: undefined;
-            statusText?: undefined;
-            category?: undefined;
-            errorPreview?: undefined;
-            extracted?: undefined;
-        } | {
-            success: boolean;
-            status: number;
-            statusText: string;
-            category: ResponseCategory;
-            errorPreview: string;
-            error?: undefined;
-            extracted?: undefined;
-        } | {
-            success: boolean;
-            status: number;
-            extracted: Record<string, any>;
-            error?: undefined;
-            statusText?: undefined;
-            category?: undefined;
-            errorPreview?: undefined;
-        }, import("@ai-sdk/provider-utils").Context>>;
-        finish: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
-            summary: string;
-            created: {
-                type: string;
-                id?: string | number;
-                title?: string;
-            }[];
-            failed?: {
-                type: string;
-                reason: string;
-            }[];
-        }, {
-            finished: boolean;
-            error: string;
-        } | {
-            finished: boolean;
-            error?: undefined;
-        }, import("@ai-sdk/provider-utils").Context>>;
-        stop: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
-            reason: any;
-        }, {
-            stopped: boolean;
-        }, import("@ai-sdk/provider-utils").Context>>;
-    };
-    getResult: () => FishermanResult;
-    isFinished: () => boolean;
-    finishFromText: (text?: string) => void;
-};
-export declare function verifyFinish(haul: RequestHaul, input: {
-    summary: string;
-    created: FishermanResult['created'];
-    failed?: FishermanResult['failed'];
-}): {
-    result: FishermanResult | null;
-    error?: string;
-};
-export interface FishermanResult {
-    success: boolean;
-    summary: string;
-    created: Array<{
-        type: string;
-        id?: string | number;
-        title?: string;
-        request?: string;
-    }>;
-    failed: Array<{
-        type: string;
-        reason: string;
-    }>;
-}
-type ResponseCategory = 'validation' | 'authorization' | 'not_found' | 'conflict' | 'temporary' | 'server' | 'client';
-export {};