@reclaimprotocol/agent 0.1.0-dev.1

package/lib/cdp/tabs.js

@@ -0,0 +1,10 @@
+export async function listTabs(port) {
+    const res = await fetch(`http://127.0.0.1:${port}/json/list`);
+    if (!res.ok) {
+        throw new Error(`CDP /json/list returned ${res.status}`);
+    }
+    const targets = (await res.json());
+    return targets
+        .filter((t) => t.type === 'page')
+        .map((t) => ({ tabId: t.id, url: t.url, title: t.title }));
+}

package/lib/cli/args.d.ts

@@ -0,0 +1,14 @@
+export declare function parseCliArgs(argv: string[]): {
+    values: {
+        [longOption: string]: string | boolean | undefined;
+    } & {
+        'base-url'?: string | boolean | undefined;
+        token?: string | boolean | undefined;
+        param?: (string | boolean)[] | undefined;
+        query?: (string | boolean)[] | undefined;
+        body?: string | boolean | undefined;
+        help?: string | boolean | undefined;
+        version?: string | boolean | undefined;
+    };
+    positionals: string[];
+};

package/lib/cli/args.js

@@ -0,0 +1,19 @@
+import { parseArgs as nodeParseArgs } from 'node:util';
+// Placeholder. Final shape decided once the backend openapi stabilises and
+// the CLI surface is fleshed out (see AGENTS.md → "CLI").
+export function parseCliArgs(argv) {
+    return nodeParseArgs({
+        args: argv,
+        options: {
+            'base-url': { type: 'string' },
+            token: { type: 'string' },
+            param: { type: 'string', multiple: true },
+            query: { type: 'string', multiple: true },
+            body: { type: 'string' },
+            help: { type: 'boolean', short: 'h' },
+            version: { type: 'boolean', short: 'v' },
+        },
+        allowPositionals: true,
+        strict: false,
+    });
+}

package/lib/cli/commands.d.ts

@@ -0,0 +1 @@
+export declare function run(argv: string[]): Promise<void>;

package/lib/cli/commands.js

@@ -0,0 +1,19 @@
+import { notImplemented } from '@hapi/boom';
+import { DESCRIPTION, NAME, VERSION } from "../pkg.js";
+import { parseCliArgs } from "./args.js";
+// Entry point for the `reclaim` bin. Placeholder until backend openapi
+// finalises — `--version` and `--help` work; everything else throws.
+export async function run(argv) {
+    const parsed = parseCliArgs(argv);
+    if (parsed.values['version']) {
+        process.stdout.write(`${NAME} ${VERSION}\n`);
+        return;
+    }
+    if (parsed.values['help']) {
+        process.stdout.write(`${NAME} ${VERSION}\n${DESCRIPTION}\n\n` +
+            'Usage: reclaim call <OperationId> ' +
+            '[--param k=v] [--query k=v] [--body <json>]\n');
+        return;
+    }
+    throw notImplemented('reclaim CLI: pending @reclaimprotocol/app spec finalisation');
+}

package/lib/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { run } from "./cli/commands.js";
+import { LOGGER } from "./logger.js";
+run(process.argv.slice(2)).catch((err) => {
+    LOGGER.error({ err }, 'cli failed');
+    process.exitCode = 1;
+});

package/lib/config/store.d.ts

@@ -0,0 +1,45 @@
+import type { CachedCredential } from '../mcp/tools/credentials/cache.ts';
+import type { CachedSession } from '../mcp/tools/credentials/session-cache.ts';
+import type { OldIdentity } from '../old/client.ts';
+export interface ReclaimAgentConfig {
+    attachMode: 'dedicated' | 'attach';
+    port: number;
+}
+/**
+ * The single on-disk document at `~/.reclaim/config.json`. Each top-level
+ * key is an independent section owned by a different subsystem:
+ *   - `browser_agent` — Chrome attach mode/port (the agent tools)
+ *   - `credentials`   — cached app key-pairs (the credential tools)
+ *   - `session`       — the auth bearer token (authenticate)
+ *   - `old_devtools`  — externally-supplied identity for OLD-devtools mode
+ *                       (USE_OLD_DEVTOOLS); independent of `session`'s
+ *                       builder token. Deletable with the rest of `src/old/`.
+ * Sections are persisted independently via `ConfigStore.write`, which
+ * merges rather than replaces, so one subsystem never clobbers another's.
+ */
+export interface ReclaimConfig {
+    version: 1;
+    browser_agent?: ReclaimAgentConfig;
+    credentials?: CachedCredential[];
+    session?: CachedSession;
+    old_devtools?: OldIdentity;
+}
+/**
+ * Read/write the unified Reclaim config document. The file holds secrets
+ * (a bearer token and private keys), so it is always locked to `0600` and
+ * its directory to `0700` — the `~/.ssh` posture. `read()` returns
+ * `undefined` when the file is missing or unparseable; callers layer their
+ * own validation (token expiry, credential shape) on top.
+ */
+export declare class ConfigStore {
+    #private;
+    constructor(path?: string);
+    read(): ReclaimConfig | undefined;
+    /**
+     * Shallow-merge `patch` over the current document and persist the
+     * result, preserving every section not named in `patch` so concurrent
+     * subsystems don't overwrite each other's keys.
+     */
+    write(patch: Partial<ReclaimConfig>): ReclaimConfig;
+}
+export declare function defaultConfigPath(): string;

package/lib/config/store.js

@@ -0,0 +1,46 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { reclaimHomeDirPath } from "../paths.js";
+/**
+ * Read/write the unified Reclaim config document. The file holds secrets
+ * (a bearer token and private keys), so it is always locked to `0600` and
+ * its directory to `0700` — the `~/.ssh` posture. `read()` returns
+ * `undefined` when the file is missing or unparseable; callers layer their
+ * own validation (token expiry, credential shape) on top.
+ */
+export class ConfigStore {
+    #path;
+    constructor(path = defaultConfigPath()) {
+        this.#path = path;
+    }
+    read() {
+        if (!existsSync(this.#path)) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(readFileSync(this.#path, 'utf8'));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Shallow-merge `patch` over the current document and persist the
+     * result, preserving every section not named in `patch` so concurrent
+     * subsystems don't overwrite each other's keys.
+     */
+    write(patch) {
+        const next = { ...this.read(), ...patch, version: 1 };
+        const dir = dirname(this.#path);
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        chmodSync(dir, 0o700);
+        writeFileSync(this.#path, JSON.stringify(next, null, 2) + '\n', {
+            mode: 0o600,
+        });
+        chmodSync(this.#path, 0o600);
+        return next;
+    }
+}
+export function defaultConfigPath() {
+    return join(reclaimHomeDirPath(), 'config.json');
+}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from '@reclaimprotocol/client';
+export { buildAgentTools, } from './mcp/tools/agent/build.ts';
+export type { AgentState } from './mcp/tools/agent/build.ts';

package/lib/index.js

@@ -0,0 +1,7 @@
+// Package entry — SDK re-exports + agent public API.
+// The CLI lives at ./cli.ts, the MCP server bin at ./mcp-bin.ts.
+// SDK — re-export everything from @reclaimprotocol/client so consumers
+// only need one package for both the typed HTTP client and the agent tools.
+export * from '@reclaimprotocol/client';
+// Agent — Chrome CDP capture, provider synthesis, replay, proof.
+export { buildAgentTools, } from "./mcp/tools/agent/build.js";

package/lib/logger.d.ts

@@ -0,0 +1,2 @@
+import pino from 'pino';
+export declare const LOGGER: pino.Logger<never, boolean>;

package/lib/logger.js

@@ -0,0 +1,7 @@
+import pino, { stdTimeFunctions } from 'pino';
+export const LOGGER = pino({
+    name: '@reclaimprotocol/agent',
+    timestamp: stdTimeFunctions.isoTime,
+    base: { hostname: undefined, pid: undefined },
+});
+LOGGER.level = process.env.LOG_LEVEL || 'info';

package/lib/mcp/api/operations.gen.d.ts

@@ -0,0 +1,152 @@
+export declare const MCP_TOOLS: {
+    AddOrgMember: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    AdminOrgs: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    AdminProviders: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    AdminReviews: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    CancelPublicListingRequest: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    CreateAttachSession: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    CreateOrg: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    CreateProvider: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    CreateProviderVersion: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    DecideProviderVersionReview: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    DeleteProvider: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    DeleteProviderVersion: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    GetAttachSession: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    GetCredential: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    GetCredentialByAddress: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    GetMe: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    GetOrg: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    GetOrgBilling: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    GetProvider: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    GetProviderVersion: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    GetUser: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    LinkCredential: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    ListOrgCredentials: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    ListOrgs: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    ListProviderVersions: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    MakePrivate: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    Providers: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    PublishProviderVersion: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    RequestPublicListing: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    RevokeCredential: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    SubmitProviderVersionForReview: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    TransferProvider: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    UpdateMe: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    UpdateOrg: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    UpdateOrgBilling: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    UpdateProvider: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+    UpdateProviderVersion: {
+        description: string;
+        inputSchema: import("zod").ZodTypeAny;
+    };
+};
+export type McpToolName = keyof typeof MCP_TOOLS;
+export type McpToolShape = (typeof MCP_TOOLS)[McpToolName];