x402storage 1.0.0

package/README.md

@@ -0,0 +1,52 @@
+# x402store
+
+Upload files to permanent IPFS storage from the command line. Pay-per-use with x402 payment protocol.
+
+## Installation
+
+```bash
+# From npm (when published)
+npm install -g x402store-cli
+
+# From source
+git clone https://github.com/user/x402store-cli
+cd x402store-cli
+npm install
+npm run build
+npm link
+```
+
+## Setup
+
+Export your Base wallet private key:
+
+```bash
+export X402_PRIVATE_KEY=0x...
+```
+
+Need a wallet? Create one at https://x402.storage
+
+## Usage
+
+```bash
+# Upload a file
+x402store myfile.txt
+
+# Output on success:
+# Success! File stored permanently.
+# URL: https://x402.storage/bafybeig...
+# CID: bafybeig...
+```
+
+## Pricing
+
+$0.01 per upload (paid in USDC on Base).
+
+## Requirements
+
+- Node.js 18+
+- Base wallet with USDC balance
+
+## License
+
+MIT

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Environment validation and configuration for x402store CLI
+ */
+/**
+ * Validates that required environment variables are set.
+ * Exits with code 1 and helpful error message if X402_PRIVATE_KEY is missing.
+ */
+export declare function validateEnvironment(): void;
+/**
+ * Gets the private key from environment.
+ * Should only be called after validateEnvironment().
+ */
+export declare function getPrivateKey(): `0x${string}`;

package/dist/config.js

@@ -0,0 +1,23 @@
+/**
+ * Environment validation and configuration for x402store CLI
+ */
+/**
+ * Validates that required environment variables are set.
+ * Exits with code 1 and helpful error message if X402_PRIVATE_KEY is missing.
+ */
+export function validateEnvironment() {
+    if (!process.env.X402_PRIVATE_KEY) {
+        console.error('Error: X402_PRIVATE_KEY not set.\n\n' +
+            'Export your Base wallet private key:\n' +
+            '  export X402_PRIVATE_KEY=0x...\n\n' +
+            'Need a wallet? Create one at https://x402.storage');
+        process.exit(1);
+    }
+}
+/**
+ * Gets the private key from environment.
+ * Should only be called after validateEnvironment().
+ */
+export function getPrivateKey() {
+    return process.env.X402_PRIVATE_KEY;
+}

package/dist/errors.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Custom error classes for x402store CLI
+ */
+/**
+ * Error thrown when the specified file does not exist
+ */
+export declare class FileNotFoundError extends Error {
+    constructor(filePath: string);
+}
+/**
+ * Error types for upload failures
+ */
+export type UploadErrorType = 'network_error' | 'payment_failed' | 'upload_failed' | 'insufficient_balance';
+/**
+ * Error thrown when upload fails
+ */
+export declare class UploadError extends Error {
+    readonly type: UploadErrorType;
+    constructor(message: string, type: UploadErrorType);
+}

package/dist/errors.js

@@ -0,0 +1,23 @@
+/**
+ * Custom error classes for x402store CLI
+ */
+/**
+ * Error thrown when the specified file does not exist
+ */
+export class FileNotFoundError extends Error {
+    constructor(filePath) {
+        super(`File not found: ${filePath}`);
+        this.name = 'FileNotFoundError';
+    }
+}
+/**
+ * Error thrown when upload fails
+ */
+export class UploadError extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        this.name = 'UploadError';
+        this.type = type;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { resolve } from 'node:path';
+import { validateEnvironment, getPrivateKey } from './config.js';
+import { uploadFile } from './upload.js';
+import { FileNotFoundError, UploadError } from './errors.js';
+// Validate environment at startup - fail fast with clear error
+validateEnvironment();
+const program = new Command();
+program
+    .name('x402')
+    .description('Upload files to x402.storage with permanent IPFS storage')
+    .version('1.0.0')
+    .argument('<file>', 'file path to upload')
+    .action(async (filePath) => {
+    try {
+        // Resolve to absolute path (handles relative paths)
+        const resolvedPath = resolve(filePath);
+        const privateKey = getPrivateKey();
+        const result = await uploadFile(resolvedPath, privateKey);
+        console.log('Success! File stored permanently.');
+        console.log(`URL: ${result.gateway}`);
+        console.log(`CID: ${result.cid}`);
+        process.exit(0);
+    }
+    catch (error) {
+        if (error instanceof FileNotFoundError) {
+            console.error(`Error: File not found: ${filePath}`);
+            process.exit(1);
+        }
+        if (error instanceof UploadError) {
+            if (error.type === 'insufficient_balance') {
+                console.error('Error: Insufficient balance.\n');
+                console.error('Fund your wallet at https://x402.storage or transfer USDC on Base.');
+                process.exit(1);
+            }
+            if (error.type === 'network_error') {
+                console.error('Error: Network error. Check your connection and try again.');
+                process.exit(1);
+            }
+            // payment_failed or upload_failed
+            console.error(`Error: Upload failed: ${error.message}`);
+            process.exit(1);
+        }
+        // Unknown error
+        const message = error instanceof Error ? error.message : 'Unknown error occurred';
+        console.error(`Error: ${message}`);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/placeholder.d.ts

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

package/dist/placeholder.js

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

package/dist/upload.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Upload logic with x402 payment integration
+ */
+/**
+ * Response from the upload API
+ */
+interface UploadResponse {
+    cid: string;
+    gateway: string;
+}
+/**
+ * Uploads a file to api.x402.storage with automatic payment handling
+ *
+ * @param filePath - Path to the file to upload
+ * @param privateKey - Private key for x402 payment signing
+ * @returns Object containing CID and gateway URL
+ * @throws FileNotFoundError if file doesn't exist
+ * @throws UploadError on network, payment, or upload failures
+ */
+export declare function uploadFile(filePath: string, privateKey: string): Promise<UploadResponse>;
+export {};

package/dist/upload.js

@@ -0,0 +1,96 @@
+/**
+ * Upload logic with x402 payment integration
+ */
+import { x402Client } from '@x402/core/client';
+import { x402HTTPClient } from '@x402/core/http';
+import { ExactEvmScheme } from '@x402/evm/exact/client';
+import { wrapFetchWithPayment } from '@x402/fetch';
+import { privateKeyToAccount } from 'viem/accounts';
+import { openAsBlob } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { FileNotFoundError, UploadError } from './errors.js';
+/**
+ * Creates an x402 payment client with the given private key
+ */
+function createPaymentClient(privateKey) {
+    const signer = privateKeyToAccount(privateKey);
+    const coreClient = new x402Client().register('eip155:*', new ExactEvmScheme(signer));
+    return new x402HTTPClient(coreClient);
+}
+/**
+ * Uploads a file to api.x402.storage with automatic payment handling
+ *
+ * @param filePath - Path to the file to upload
+ * @param privateKey - Private key for x402 payment signing
+ * @returns Object containing CID and gateway URL
+ * @throws FileNotFoundError if file doesn't exist
+ * @throws UploadError on network, payment, or upload failures
+ */
+export async function uploadFile(filePath, privateKey) {
+    // Check file exists
+    try {
+        await stat(filePath);
+    }
+    catch {
+        throw new FileNotFoundError(filePath);
+    }
+    // Create payment client and wrap fetch
+    const client = createPaymentClient(privateKey);
+    const fetchWithPayment = wrapFetchWithPayment(fetch, client);
+    // Read file as blob
+    const blob = await openAsBlob(filePath);
+    const fileName = basename(filePath);
+    // Create FormData with file
+    const formData = new FormData();
+    formData.append('file', blob, fileName);
+    // Upload to api.x402.storage (root endpoint, not /store)
+    let response;
+    try {
+        response = await fetchWithPayment('https://api.x402.storage', {
+            method: 'POST',
+            body: formData,
+            // Do NOT set Content-Type header - let Node.js set boundary
+        });
+    }
+    catch (error) {
+        // Network or payment errors during fetch
+        const message = error instanceof Error ? error.message : 'Unknown network error';
+        // Check for payment-related errors
+        if (message.toLowerCase().includes('insufficient')) {
+            throw new UploadError(message, 'insufficient_balance');
+        }
+        if (message.toLowerCase().includes('payment') ||
+            message.toLowerCase().includes('402')) {
+            throw new UploadError(message, 'payment_failed');
+        }
+        throw new UploadError(message, 'network_error');
+    }
+    // Handle non-OK responses
+    if (!response.ok) {
+        let errorMessage = `Upload failed: ${response.status} ${response.statusText}`;
+        try {
+            const errorBody = (await response.json());
+            if (errorBody.error) {
+                errorMessage = errorBody.error;
+            }
+        }
+        catch {
+            // Ignore JSON parse errors, use status message
+        }
+        // Determine error type from status code
+        if (response.status === 402) {
+            throw new UploadError(errorMessage, 'payment_failed');
+        }
+        if (response.status >= 500) {
+            throw new UploadError(errorMessage, 'network_error');
+        }
+        throw new UploadError(errorMessage, 'upload_failed');
+    }
+    // Parse successful response
+    const result = (await response.json());
+    return {
+        cid: result.cid,
+        gateway: result.gateway,
+    };
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "x402storage",
+  "version": "1.0.0",
+  "description": "Upload files to x402.storage from the command line",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rawgroundbeef/x402.storage"
+  },
+  "bin": {
+    "x402": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "x402",
+    "ipfs",
+    "storage",
+    "cli",
+    "upload",
+    "permanent"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@x402/core": "^2.2.0",
+    "@x402/evm": "latest",
+    "@x402/fetch": "latest",
+    "commander": "^12.0.0",
+    "viem": "^2.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.7.0"
+  }
+}