apinow-sdk 0.16.0 → 0.17.0

package/dist/cli.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { createClient } from './index.js';
+import { privateKeyToAccount } from 'viem/accounts';
 const API_BASE = 'https://apinow.fun';
 const program = new Command();
 program
     .name('apinow')
     .description('CLI for APINow.fun — search, inspect, and call pay-per-request APIs')
-    .version('0.16.0');
+    .version('0.17.0');
 // ─── Helpers ───
 function getPrivateKey(opts) {
     const raw = opts.key || process.env.APINOW_WALLET_PKEY || process.env.PRIVATE_KEY;
@@ -42,6 +43,14 @@ function printTable(rows) {
 function truncate(s, max) {
     return s.length > max ? s.slice(0, max - 1) + '…' : s;
 }
+function getWallet(opts) {
+    const privateKey = getPrivateKey(opts);
+    const account = privateKeyToAccount(privateKey);
+    return { privateKey, address: account.address };
+}
+function walletHeaders(address) {
+    return { 'Content-Type': 'application/json', 'x-wallet-address': address };
+}
 // ─── search ───
 program
     .command('search <query>')
@@ -312,4 +321,194 @@ program
         process.exit(1);
     }
 });
+// ─── factory-balance ───
+program
+    .command('factory-balance')
+    .description('Check $APINOW token balance and factory access')
+    .option('-k, --key <privateKey>', 'Wallet private key')
+    .action(async (opts) => {
+    try {
+        const { address } = getWallet(opts);
+        const data = await fetchJson(`${API_BASE}/api/user-factory/check-balance`, {
+            headers: walletHeaders(address),
+        });
+        console.log(`\n  Wallet:   ${address}`);
+        console.log(`  Balance:  ${data.balance} $APINOW`);
+        console.log(`  Required: ${data.required}`);
+        console.log(`  Access:   ${data.hasAccess ? 'YES' : 'NO'}\n`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});
+// ─── factory-list ───
+program
+    .command('factory-list')
+    .description('List your user-factory endpoints')
+    .option('-k, --key <privateKey>', 'Wallet private key')
+    .action(async (opts) => {
+    try {
+        const { address } = getWallet(opts);
+        const data = await fetchJson(`${API_BASE}/api/user-factory`, {
+            headers: walletHeaders(address),
+        });
+        const endpoints = data.endpoints || [];
+        if (!endpoints.length) {
+            console.log('No factory endpoints found.');
+            return;
+        }
+        const rows = [['ENDPOINT', 'MODEL', 'COST', 'STATUS']];
+        for (const ep of endpoints) {
+            rows.push([
+                `${ep.namespace}/${ep.endpointName}`,
+                ep.model || '—',
+                formatUsd(ep.paymentOptions),
+                ep.status || '—',
+            ]);
+        }
+        printTable(rows);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});
+// ─── factory-generate ───
+program
+    .command('factory-generate <idea>')
+    .description('Generate endpoint config from a natural-language idea')
+    .option('-k, --key <privateKey>', 'Wallet private key')
+    .action(async (idea, opts) => {
+    try {
+        const { address } = getWallet(opts);
+        console.error('Generating endpoint config…');
+        const data = await fetchJson(`${API_BASE}/api/user-factory/generate`, {
+            method: 'POST',
+            headers: walletHeaders(address),
+            body: JSON.stringify({ idea }),
+        });
+        console.log(JSON.stringify(data, null, 2));
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});
+// ─── factory-create ───
+program
+    .command('factory-create')
+    .description('Create an LLM endpoint via user-factory')
+    .requiredOption('--name <name>', 'Endpoint name')
+    .requiredOption('--prompt <prompt>', 'System prompt for the LLM')
+    .option('--namespace <ns>', 'Namespace (defaults to u-<wallet>)')
+    .option('--description <desc>', 'Endpoint description')
+    .option('--model <model>', 'LLM model', 'google/gemini-2.0-flash-001')
+    .option('--price <usdc>', 'USDC price per call', '0.01')
+    .option('--recipient <wallet>', 'Payment recipient wallet')
+    .option('--input-params <json>', 'Input params JSON array')
+    .option('--output-params <json>', 'Output params JSON array')
+    .option('-k, --key <privateKey>', 'Wallet private key')
+    .action(async (opts) => {
+    try {
+        const { address } = getWallet(opts);
+        const body = {
+            name: opts.name,
+            prompt: opts.prompt,
+            model: opts.model,
+            usdcPrice: opts.price,
+        };
+        if (opts.namespace)
+            body.namespace = opts.namespace;
+        if (opts.description)
+            body.description = opts.description;
+        if (opts.recipient)
+            body.recipientWallet = opts.recipient;
+        if (opts.inputParams)
+            body.inputParams = JSON.parse(opts.inputParams);
+        if (opts.outputParams)
+            body.outputParams = JSON.parse(opts.outputParams);
+        console.error(`Creating endpoint "${opts.name}"…`);
+        const data = await fetchJson(`${API_BASE}/api/user-factory`, {
+            method: 'POST',
+            headers: walletHeaders(address),
+            body: JSON.stringify(body),
+        });
+        const ep = data.endpoint;
+        console.log(`\n  Created: ${ep.namespace}/${ep.endpointName}`);
+        console.log(`  Model:   ${ep.model}`);
+        console.log(`  Price:   $${ep.price} USDC`);
+        console.log(`  Try:     https://apinow.fun${ep.tryUrl}`);
+        console.log(`  API:     https://apinow.fun${ep.apiUrl}\n`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});
+// ─── factory-markup ───
+program
+    .command('factory-markup <endpointId>')
+    .description('Create a markup workflow that wraps an existing endpoint')
+    .option('--markup <percent>', 'Markup percentage', '20')
+    .option('--name <name>', 'Workflow name')
+    .option('-k, --key <privateKey>', 'Wallet private key')
+    .action(async (endpointId, opts) => {
+    try {
+        const { address } = getWallet(opts);
+        const body = { endpointId, markupPercent: Number(opts.markup) };
+        if (opts.name)
+            body.workflowName = opts.name;
+        console.error(`Creating markup workflow (${opts.markup}%)…`);
+        const data = await fetchJson(`${API_BASE}/api/user-factory/markup`, {
+            method: 'POST',
+            headers: walletHeaders(address),
+            body: JSON.stringify(body),
+        });
+        const w = data.workflow;
+        console.log(`\n  Created: ${w.name}`);
+        console.log(`  ID:      ${w.workflowId}`);
+        console.log(`  Base:    $${w.basePrice} USDC`);
+        console.log(`  Markup:  ${w.markupPercent}%`);
+        console.log(`  Total:   $${w.totalPrice} USDC`);
+        console.log(`  View:    https://apinow.fun${w.viewUrl}\n`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});
+// ─── factory-test ───
+program
+    .command('factory-test <endpoint>')
+    .description('Test-call an endpoint without payment')
+    .option('-d, --data <json>', 'JSON input')
+    .option('--save', 'Save as example')
+    .option('-k, --key <privateKey>', 'Wallet private key')
+    .action(async (endpoint, opts) => {
+    try {
+        if (!endpoint.includes('/'))
+            throw new Error('Format: namespace/endpoint-name');
+        const { address } = getWallet(opts);
+        const [namespace, endpointName] = endpoint.split('/');
+        const body = { namespace, endpointName };
+        if (opts.data)
+            body.input = JSON.parse(opts.data);
+        if (opts.save)
+            body.saveExample = true;
+        console.error(`Testing ${endpoint}…`);
+        const data = await fetchJson(`${API_BASE}/api/user-factory/test-call`, {
+            method: 'POST',
+            headers: walletHeaders(address),
+            body: JSON.stringify(body),
+        });
+        console.log(JSON.stringify(data.output, null, 2));
+        if (data.saved)
+            console.error('(saved as example)');
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+});
 program.parse();

package/dist/index.d.ts

@@ -46,6 +46,57 @@ export declare function createClient(config: ApinowConfig): {
      * const result = await apinow.runWorkflow('90931d9c8fb94df9', { query: 'hello world' });
      */
     runWorkflow(workflowId: string, input: Record<string, any>): Promise<any>;
+    /**
+     * Check $APINOW token balance and factory access.
+     */
+    factoryBalance(): Promise<any>;
+    /**
+     * List your user-factory endpoints.
+     */
+    factoryList(): Promise<any>;
+    /**
+     * Generate endpoint config from a natural-language idea.
+     */
+    factoryGenerate(idea: string): Promise<any>;
+    /**
+     * Create an LLM endpoint via user-factory.
+     */
+    factoryCreate(config: {
+        name: string;
+        prompt: string;
+        namespace?: string;
+        description?: string;
+        model?: string;
+        usdcPrice?: string;
+        recipientWallet?: string;
+        inputParams?: Array<{
+            name: string;
+            type: string;
+            description?: string;
+        }>;
+        outputParams?: Array<{
+            name: string;
+            type: string;
+            description?: string;
+        }>;
+    }): Promise<any>;
+    /**
+     * Create a markup workflow wrapping an existing endpoint.
+     */
+    factoryMarkup(opts: {
+        endpointId: string;
+        markupPercent?: number;
+        workflowName?: string;
+    }): Promise<any>;
+    /**
+     * Test-call an endpoint without payment (free, server-side LLM call).
+     */
+    factoryTestCall(opts: {
+        namespace: string;
+        endpointName: string;
+        input?: any;
+        saveExample?: boolean;
+    }): Promise<any>;
     /**
      * The underlying x402-wrapped fetch, for advanced use.
      */

package/dist/index.js

@@ -96,6 +96,87 @@ export function createClient(config) {
                 body: input,
             });
         },
+        // ─── User Factory ───
+        /**
+         * Check $APINOW token balance and factory access.
+         */
+        async factoryBalance() {
+            const res = await fetch(`${baseUrl}/api/user-factory/check-balance`, {
+                headers: { 'x-wallet-address': account.address },
+            });
+            if (!res.ok)
+                throw new Error(`Failed to check balance: ${res.status}`);
+            return res.json();
+        },
+        /**
+         * List your user-factory endpoints.
+         */
+        async factoryList() {
+            const res = await fetch(`${baseUrl}/api/user-factory`, {
+                headers: { 'x-wallet-address': account.address },
+            });
+            if (!res.ok)
+                throw new Error(`Failed to list factory endpoints: ${res.status}`);
+            return res.json();
+        },
+        /**
+         * Generate endpoint config from a natural-language idea.
+         */
+        async factoryGenerate(idea) {
+            const res = await fetch(`${baseUrl}/api/user-factory/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'x-wallet-address': account.address },
+                body: JSON.stringify({ idea }),
+            });
+            if (!res.ok)
+                throw new Error(`Failed to generate: ${res.status}`);
+            return res.json();
+        },
+        /**
+         * Create an LLM endpoint via user-factory.
+         */
+        async factoryCreate(config) {
+            const res = await fetch(`${baseUrl}/api/user-factory`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'x-wallet-address': account.address },
+                body: JSON.stringify(config),
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`Failed to create endpoint: ${res.status} ${text}`);
+            }
+            return res.json();
+        },
+        /**
+         * Create a markup workflow wrapping an existing endpoint.
+         */
+        async factoryMarkup(opts) {
+            const res = await fetch(`${baseUrl}/api/user-factory/markup`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'x-wallet-address': account.address },
+                body: JSON.stringify(opts),
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`Failed to create markup: ${res.status} ${text}`);
+            }
+            return res.json();
+        },
+        /**
+         * Test-call an endpoint without payment (free, server-side LLM call).
+         */
+        async factoryTestCall(opts) {
+            const res = await fetch(`${baseUrl}/api/user-factory/test-call`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'x-wallet-address': account.address },
+                body: JSON.stringify(opts),
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`Failed to test call: ${res.status} ${text}`);
+            }
+            return res.json();
+        },
         /**
          * The underlying x402-wrapped fetch, for advanced use.
          */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apinow-sdk",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Pay-per-call API SDK & CLI for APINow.fun — endpoints + workflows, wraps x402 so you don't have to",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,7 +26,8 @@
     "llm",
     "cli",
     "workflow",
-    "dag"
+    "dag",
+    "user-factory"
   ],
   "author": "ApiNow.fun",
   "license": "MIT",