web5-cli 0.1.0

package/bin/web5-cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import('../dist/index.js').catch(console.error)

package/dist/commands/did.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createDidCommand(): Command;

package/dist/commands/did.js

@@ -0,0 +1,59 @@
+import { Command } from 'commander';
+import { didManagerWithExit } from '../utils/did.js';
+export function createDidCommand() {
+    const command = new Command('did')
+        .description('Manage DID operations');
+    command
+        .command('build-create-tx')
+        .description('Build transaction to create a new DID')
+        .requiredOption('--username <username>', 'Username for the DID')
+        .requiredOption('--pds <pds>', 'PDS host (e.g., web5.bbsfans.dev)')
+        .requiredOption('--didkey <didkey>', 'DID key for atproto verification')
+        .requiredOption('--output-path <path>', 'Output path for transaction JSON')
+        .action(async (options) => {
+        await didManagerWithExit.buildCreateTx(options.username, options.pds, options.didkey, options.outputPath);
+    });
+    command
+        .command('build-destroy-tx')
+        .description('Build transaction to destroy a DID')
+        .requiredOption('--args <args>', 'DID args (type script args)')
+        .requiredOption('--output-path <path>', 'Output path for transaction JSON')
+        .action(async (options) => {
+        await didManagerWithExit.buildDestroyTx(options.args, options.outputPath);
+    });
+    command
+        .command('build-update-didkey-tx')
+        .description('Build transaction to update DID key')
+        .requiredOption('--args <args>', 'DID args (type script args)')
+        .requiredOption('--new-didkey <didKey>', 'New DID key')
+        .requiredOption('--output-path <path>', 'Output path for transaction JSON')
+        .action(async (options) => {
+        await didManagerWithExit.buildUpdateDidKeyTx(options.args, options.newDidkey, options.outputPath);
+    });
+    command
+        .command('build-update-handle-tx')
+        .description('Build transaction to update DID handle')
+        .requiredOption('--args <args>', 'DID args (type script args)')
+        .requiredOption('--new-handle <handle>', 'New handle (e.g., david1.web5.bbsfans.dev)')
+        .requiredOption('--output-path <path>', 'Output path for transaction JSON')
+        .action(async (options) => {
+        await didManagerWithExit.buildUpdateHandleTx(options.args, options.newHandle, options.outputPath);
+    });
+    command
+        .command('build-transfer-tx')
+        .description('Build transaction to transfer DID')
+        .requiredOption('--args <args>', 'DID args (type script args)')
+        .requiredOption('--receiver <address>', 'Receiver CKB address')
+        .requiredOption('--output-path <path>', 'Output path for transaction JSON')
+        .action(async (options) => {
+        await didManagerWithExit.buildTransferTx(options.args, options.receiver, options.outputPath);
+    });
+    command
+        .command('list')
+        .description('List DID cells for a CKB address')
+        .requiredOption('--ckb-addr <address>', 'CKB address')
+        .action(async (options) => {
+        await didManagerWithExit.list(options.ckbAddr);
+    });
+    return command;
+}

package/dist/commands/keystore.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createKeystoreCommand(): Command;

package/dist/commands/keystore.js

@@ -0,0 +1,48 @@
+import { Command } from 'commander';
+import { keystoreManager } from '../utils/keystore.js';
+export function createKeystoreCommand() {
+    const command = new Command('keystore')
+        .description('Manage DID signing keys');
+    command
+        .command('new')
+        .description('Create a new keypair')
+        .action(async () => {
+        await keystoreManager.newKey();
+    });
+    command
+        .command('import')
+        .description('Import an existing private key')
+        .requiredOption('--sk <privateKey>', 'Private key to import (hex format)')
+        .action(async (options) => {
+        await keystoreManager.importKey(options.sk);
+    });
+    command
+        .command('clean')
+        .description('Remove the existing keypair')
+        .action(async () => {
+        await keystoreManager.clean();
+    });
+    command
+        .command('get')
+        .description('Get the DID key')
+        .action(async () => {
+        await keystoreManager.getDIDKey();
+    });
+    command
+        .command('sign')
+        .description('Sign a message')
+        .requiredOption('--message <message>', 'Message to sign (hex format)')
+        .action(async (options) => {
+        await keystoreManager.sign(options.message);
+    });
+    command
+        .command('verify')
+        .description('Verify a signature')
+        .requiredOption('--message <message>', 'Original message (hex format)')
+        .requiredOption('--signature <signature>', 'Signature to verify (hex format)')
+        .option('--didkey <didKey>', 'DID key (if not provided, uses local keypair)')
+        .action(async (options) => {
+        await keystoreManager.verify(options.message, options.signature, options.didkey);
+    });
+    return command;
+}

package/dist/commands/pds.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createPdsCommand(): Command;

package/dist/commands/pds.js

@@ -0,0 +1,144 @@
+import { Command } from 'commander';
+import { pdsManager } from '../utils/pds.js';
+import { SIGNKEY_PATH, readKey } from '../utils/common.js';
+async function getSignKey() {
+    return readKey(SIGNKEY_PATH);
+}
+export function createPdsCommand() {
+    const command = new Command('pds')
+        .description('Interact with PDS servers');
+    command
+        .command('check-username')
+        .description('Check if username is valid')
+        .requiredOption('--username <username>', 'Username to check')
+        .action(async (options) => {
+        await pdsManager.checkUsername(options.username);
+    });
+    command
+        .command('get-did-by-username')
+        .description('Get DID by username')
+        .requiredOption('--username <username>', 'Username')
+        .requiredOption('--pds <pds>', 'PDS host (e.g., web5.bbsfans.dev)')
+        .action(async (options) => {
+        await pdsManager.getDidByUsername(options.username, options.pds);
+    });
+    command
+        .command('create-account')
+        .description('Create an account on PDS')
+        .requiredOption('--pds <pds>', 'PDS host')
+        .requiredOption('--username <username>', 'Username')
+        .requiredOption('--didkey <didKey>', 'DID key')
+        .requiredOption('--did <did>', 'DID')
+        .requiredOption('--ckb-address <address>', 'CKB address')
+        .action(async (options) => {
+        const signKey = await getSignKey();
+        if (!signKey) {
+            console.log(JSON.stringify({ success: false, error: 'No signkey found. Use "keystore new" or "keystore import" first.' }, null, 2));
+            return;
+        }
+        await pdsManager.createAccount(options.pds, options.username, options.didkey, options.did, options.ckbAddress, signKey);
+    });
+    command
+        .command('delete-account')
+        .description('Delete an account on PDS')
+        .requiredOption('--pds <pds>', 'PDS host')
+        .requiredOption('--didkey <didKey>', 'DID key')
+        .requiredOption('--did <did>', 'DID')
+        .requiredOption('--ckb-address <address>', 'CKB address')
+        .action(async (options) => {
+        const signKey = await getSignKey();
+        if (!signKey) {
+            console.log(JSON.stringify({ success: false, error: 'No signkey found. Use "keystore new" or "keystore import" first.' }, null, 2));
+            return;
+        }
+        await pdsManager.deleteAccount(options.pds, options.didkey, options.did, options.ckbAddress, signKey);
+    });
+    command
+        .command('login')
+        .description('Login to PDS')
+        .requiredOption('--pds <pds>', 'PDS host')
+        .requiredOption('--didkey <didKey>', 'DID key')
+        .requiredOption('--did <did>', 'DID')
+        .requiredOption('--ckb-address <address>', 'CKB address')
+        .action(async (options) => {
+        const signKey = await getSignKey();
+        if (!signKey) {
+            console.log(JSON.stringify({ success: false, error: 'No signkey found. Use "keystore new" or "keystore import" first.' }, null, 2));
+            return;
+        }
+        await pdsManager.login(options.pds, options.didkey, options.did, options.ckbAddress, signKey);
+    });
+    command
+        .command('write')
+        .description('Write data to PDS')
+        .requiredOption('--pds <pds>', 'PDS host')
+        .requiredOption('--accessJwt <token>', 'Access JWT token')
+        .requiredOption('--didkey <didKey>', 'DID key')
+        .requiredOption('--did <did>', 'DID')
+        .requiredOption('--data <json>', 'Data to write (JSON string)')
+        .option('--rkey <rkey>', 'Record key (optional)')
+        .option('--type <type>', 'Write type: create, update, or delete (default: create)')
+        .action(async (options) => {
+        const signKey = await getSignKey();
+        if (!signKey) {
+            console.log(JSON.stringify({ success: false, error: 'No signkey found. Use "keystore new" or "keystore import" first.' }, null, 2));
+            return;
+        }
+        const writeType = options.type || 'create';
+        if (!['create', 'update', 'delete'].includes(writeType)) {
+            console.log(JSON.stringify({ success: false, error: 'Invalid type. Must be one of: create, update, delete' }, null, 2));
+            return;
+        }
+        await pdsManager.write(options.pds, options.accessJwt, options.didkey, options.did, options.data, signKey, options.rkey, writeType);
+    });
+    command
+        .command('repo')
+        .description('Get repo information')
+        .requiredOption('--pds <pds>', 'PDS host')
+        .requiredOption('--did <did>', 'DID')
+        .action(async (options) => {
+        await pdsManager.repo(options.pds, options.did);
+    });
+    command
+        .command('records')
+        .description('Get repo records')
+        .requiredOption('--pds <pds>', 'PDS host')
+        .requiredOption('--did <did>', 'DID')
+        .requiredOption('--collection <collection>', 'Collection name')
+        .option('--limit <limit>', 'Limit', '20')
+        .option('--cursor <cursor>', 'Cursor for pagination')
+        .action(async (options) => {
+        await pdsManager.records(options.pds, options.did, options.collection, parseInt(options.limit), options.cursor);
+    });
+    command
+        .command('blobs')
+        .description('Get repo blobs')
+        .requiredOption('--pds <pds>', 'PDS host')
+        .requiredOption('--did <did>', 'DID')
+        .option('--limit <limit>', 'Limit', '20')
+        .option('--cursor <cursor>', 'Cursor for pagination')
+        .action(async (options) => {
+        await pdsManager.blobs(options.pds, options.did, parseInt(options.limit), options.cursor);
+    });
+    command
+        .command('export')
+        .description('Export repo to CAR file')
+        .requiredOption('--pds <pds>', 'PDS host')
+        .requiredOption('--did <did>', 'DID')
+        .requiredOption('--data-file <path>', 'Output file path')
+        .option('--since <since>', 'Since CID (optional)')
+        .action(async (options) => {
+        await pdsManager.exportRepo(options.pds, options.did, options.dataFile, options.since);
+    });
+    command
+        .command('import')
+        .description('Import repo from CAR file')
+        .requiredOption('--pds <pds>', 'PDS host')
+        .requiredOption('--did <did>', 'DID')
+        .requiredOption('--accessJwt <token>', 'Access JWT token')
+        .requiredOption('--data-file <path>', 'Input file path')
+        .action(async (options) => {
+        await pdsManager.importRepo(options.pds, options.did, options.accessJwt, options.dataFile);
+    });
+    return command;
+}

package/dist/commands/wallet.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createWalletCommand(): Command;

package/dist/commands/wallet.js

@@ -0,0 +1,52 @@
+import { Command } from 'commander';
+import { walletManagerWithExit } from '../utils/wallet.js';
+export function createWalletCommand() {
+    const command = new Command('wallet')
+        .description('Manage CKB wallet');
+    command
+        .command('new')
+        .description('Create a new CKB wallet')
+        .action(async () => {
+        await walletManagerWithExit.newWallet();
+    });
+    command
+        .command('import')
+        .description('Import an existing private key')
+        .requiredOption('--sk <privateKey>', 'Private key to import (hex format)')
+        .action(async (options) => {
+        await walletManagerWithExit.importWallet(options.sk);
+    });
+    command
+        .command('clean')
+        .description('Remove the existing wallet')
+        .action(async () => {
+        await walletManagerWithExit.clean();
+    });
+    command
+        .command('get')
+        .description('Get the CKB address')
+        .action(async () => {
+        await walletManagerWithExit.getAddress();
+    });
+    command
+        .command('send-tx')
+        .description('Send a transaction')
+        .requiredOption('--tx-path <path>', 'Path to the transaction JSON file')
+        .action(async (options) => {
+        await walletManagerWithExit.sendTx(options.txPath);
+    });
+    command
+        .command('check-tx')
+        .description('Check transaction status')
+        .requiredOption('--tx-hash <txHash>', 'Transaction hash')
+        .action(async (options) => {
+        await walletManagerWithExit.checkTx(options.txHash);
+    });
+    command
+        .command('balance')
+        .description('Check account balance')
+        .action(async () => {
+        await walletManagerWithExit.balance();
+    });
+    return command;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createKeystoreCommand } from './commands/keystore.js';
+import { createWalletCommand } from './commands/wallet.js';
+import { createDidCommand } from './commands/did.js';
+import { createPdsCommand } from './commands/pds.js';
+const program = new Command();
+program
+    .name('web5-cli')
+    .description('Web5 CLI tool for interacting with Web5 infrastructure')
+    .version('0.0.1');
+program.addCommand(createKeystoreCommand());
+program.addCommand(createWalletCommand());
+program.addCommand(createDidCommand());
+program.addCommand(createPdsCommand());
+program.parse();

package/dist/utils/common.d.ts

@@ -0,0 +1,20 @@
+export declare const CLI_DIR: string;
+export declare const SIGNKEY_PATH: string;
+export declare const CKB_SK_PATH: string;
+export interface Output {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+export declare function outputJSON(result: Output): void;
+export declare function success(data?: unknown): void;
+export declare function error(message: string): void;
+export declare function ensureDir(): Promise<void>;
+export declare function readKey(path: string): Promise<string | null>;
+export declare function writeKey(path: string, key: string): Promise<void>;
+export declare function removeKey(path: string): Promise<boolean>;
+export declare function keyExists(path: string): boolean;
+export declare function bytesFromHex(hex: string): Uint8Array;
+export declare function hexFromBytes(bytes: Uint8Array): string;
+export declare function writeJsonFile(path: string, data: unknown): Promise<void>;
+export declare function readJsonFile(path: string): Promise<unknown | null>;

package/dist/utils/common.js

@@ -0,0 +1,75 @@
+import { mkdir, readFile, writeFile, unlink } from 'fs/promises';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+export const CLI_DIR = join(homedir(), '.web5-cli');
+export const SIGNKEY_PATH = join(CLI_DIR, 'signkey');
+export const CKB_SK_PATH = join(CLI_DIR, 'ckb-sk');
+export function outputJSON(result) {
+    console.log(JSON.stringify(result, null, 2));
+}
+export function success(data) {
+    outputJSON({ success: true, data });
+}
+export function error(message) {
+    outputJSON({ success: false, error: message });
+}
+export async function ensureDir() {
+    if (!existsSync(CLI_DIR)) {
+        await mkdir(CLI_DIR, { recursive: true });
+    }
+}
+export async function readKey(path) {
+    try {
+        const data = await readFile(path, 'utf-8');
+        return data.trim();
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeKey(path, key) {
+    await ensureDir();
+    await writeFile(path, key, 'utf-8');
+}
+export async function removeKey(path) {
+    try {
+        await unlink(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function keyExists(path) {
+    return existsSync(path);
+}
+export function bytesFromHex(hex) {
+    if (hex.startsWith('0x')) {
+        hex = hex.slice(2);
+    }
+    const match = hex.match(/.{1,2}/g);
+    if (!match) {
+        return new Uint8Array();
+    }
+    return new Uint8Array(match.map((byte) => parseInt(byte, 16)));
+}
+export function hexFromBytes(bytes) {
+    return '0x' + Array.from(bytes).map((byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+export async function writeJsonFile(path, data) {
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    await writeFile(path, JSON.stringify(data, null, 2), 'utf-8');
+}
+export async function readJsonFile(path) {
+    try {
+        const data = await readFile(path, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/did.d.ts

@@ -0,0 +1,18 @@
+export interface didCkbCellInfo {
+    txHash: string;
+    index: number;
+    args: string;
+    capacity: string;
+    did: string;
+    didMetadata: string;
+}
+export interface DidManager {
+    buildCreateTx(username: string, pds: string, didkey: string, outputPath: string): Promise<void>;
+    buildDestroyTx(args: string, outputPath: string): Promise<void>;
+    buildUpdateDidKeyTx(args: string, newDidKey: string, outputPath: string): Promise<void>;
+    buildUpdateHandleTx(args: string, newHandle: string, outputPath: string): Promise<void>;
+    buildTransferTx(args: string, receiver: string, outputPath: string): Promise<void>;
+    list(ckbAddr: string): Promise<void>;
+}
+export declare const didManager: DidManager;
+export declare const didManagerWithExit: DidManager;