web5-cli 0.1.0

package/dist/utils/pds.js

@@ -0,0 +1,331 @@
+import { error, success, hexFromBytes, bytesFromHex } from './common.js';
+import { AtpAgent } from 'web5-api';
+import { CID } from 'multiformats';
+import * as cbor from '@ipld/dag-cbor';
+import { Secp256k1Keypair } from '@atproto/crypto';
+import { readFile, writeFile } from 'fs/promises';
+function createAgent(pds) {
+    return new AtpAgent({ service: `https://${pds}` });
+}
+function checkUsernameFormat(username) {
+    if (username.length < 4 || username.length > 18) {
+        return false;
+    }
+    const usernameRegex = /^[a-zA-Z][a-zA-Z0-9-]*[a-zA-Z0-9]$/;
+    return usernameRegex.test(username);
+}
+export const pdsManager = {
+    async checkUsername(username) {
+        const isValid = checkUsernameFormat(username);
+        success(isValid ? 'valid' : 'invalid');
+    },
+    async getDidByUsername(username, pds) {
+        try {
+            const handle = `${username.toLowerCase()}.${pds}`;
+            const url = `https://${handle}/.well-known/atproto-did`;
+            const response = await fetch(url);
+            const text = await response.text();
+            if (text.trim().startsWith('did:ckb')) {
+                success(text.trim());
+            }
+            else if (text.includes('User not found')) {
+                success('');
+            }
+            else {
+                error('Failed to fetch DID');
+            }
+        }
+        catch (e) {
+            error(`Failed to get DID: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async createAccount(pds, username, didKey, did, ckbAddress, signKey) {
+        try {
+            const agent = createAgent(pds);
+            const handle = `${username.toLowerCase()}.${pds}`;
+            const res = await agent.fans.web5.ckb.preCreateAccount({
+                handle,
+                signingKey: didKey,
+                did,
+            });
+            if (!res.success) {
+                error('Pre-create account failed');
+                return;
+            }
+            const uncommit = {
+                did: res.data.did,
+                version: 3,
+                rev: res.data.rev,
+                prev: null,
+                data: CID.parse(res.data.data),
+            };
+            const encoded = cbor.encode(uncommit);
+            const unSignBytesHex = hexFromBytes(encoded).slice(2);
+            if (unSignBytesHex !== res.data.unSignBytes) {
+                error('Sign bytes not consistent');
+                return;
+            }
+            const keypair = await Secp256k1Keypair.import(bytesFromHex(signKey));
+            const sig = await keypair.sign(encoded);
+            const params = {
+                handle,
+                password: '',
+                signingKey: didKey,
+                ckbAddr: ckbAddress,
+                root: {
+                    did: res.data.did,
+                    version: 3,
+                    rev: res.data.rev,
+                    prev: res.data.prev,
+                    data: res.data.data,
+                    signedBytes: hexFromBytes(sig),
+                },
+            };
+            const createRes = await agent.web5CreateAccount(params);
+            if (!createRes.success) {
+                error('Create account failed');
+                return;
+            }
+            const userInfo = {
+                accessJwt: createRes.data.accessJwt,
+                refreshJwt: createRes.data.refreshJwt,
+                handle: createRes.data.handle,
+                did: createRes.data.did,
+            };
+            success(userInfo);
+        }
+        catch (e) {
+            error(`Failed to create account: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async deleteAccount(pds, didKey, did, ckbAddress, signKey) {
+        try {
+            const agent = createAgent(pds);
+            const preDelete = await agent.fans.web5.ckb.preIndexAction({
+                did,
+                ckbAddr: ckbAddress,
+                index: { $type: 'fans.web5.ckb.preIndexAction#deleteAccount' },
+            });
+            const keypair = await Secp256k1Keypair.import(bytesFromHex(signKey));
+            const sig = await keypair.sign(new TextEncoder().encode(preDelete.data.message));
+            const deleteInfo = await agent.fans.web5.ckb.indexAction({
+                did,
+                message: preDelete.data.message,
+                signingKey: didKey,
+                signedBytes: hexFromBytes(sig),
+                ckbAddr: ckbAddress,
+                index: { $type: 'fans.web5.ckb.indexAction#deleteAccount' },
+            });
+            success(deleteInfo.success);
+        }
+        catch (e) {
+            error(`Failed to delete account: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async login(pds, didKey, did, ckbAddress, signKey) {
+        try {
+            const agent = createAgent(pds);
+            const preLogin = await agent.fans.web5.ckb.preIndexAction({
+                did,
+                ckbAddr: ckbAddress,
+                index: { $type: 'fans.web5.ckb.preIndexAction#createSession' },
+            });
+            const keypair = await Secp256k1Keypair.import(bytesFromHex(signKey));
+            const sig = await keypair.sign(new TextEncoder().encode(preLogin.data.message));
+            const loginInfo = await agent.web5Login({
+                did,
+                message: preLogin.data.message,
+                signingKey: didKey,
+                signedBytes: hexFromBytes(sig),
+                ckbAddr: ckbAddress,
+                index: { $type: 'fans.web5.ckb.indexAction#createSession' },
+            });
+            if (!loginInfo.success) {
+                error('Login failed');
+                return;
+            }
+            const loginInfoData = loginInfo.data.result;
+            const sessionInfo = {
+                accessJwt: loginInfoData.accessJwt,
+                refreshJwt: loginInfoData.refreshJwt,
+                handle: loginInfoData.handle,
+                did: loginInfoData.did,
+                didMetadata: JSON.stringify(loginInfoData.didDoc),
+            };
+            success(sessionInfo);
+        }
+        catch (e) {
+            error(`Failed to login: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async write(pds, accessJwt, didKey, did, data, signKey, rkey, type) {
+        try {
+            const agent = createAgent(pds);
+            agent.setHeader('Authorization', `Bearer ${accessJwt}`);
+            const record = JSON.parse(data);
+            const newRecord = {
+                created: new Date().toISOString(),
+                ...record,
+            };
+            const { TID } = await import('@atproto/common-web');
+            const recordRkey = rkey || TID.next().toString();
+            // Determine write type, default to 'create'
+            const writeType = type || 'create';
+            const preWriteType = `fans.web5.ckb.preDirectWrites#${writeType}`;
+            const directWriteType = `fans.web5.ckb.directWrites#${writeType}`;
+            const preWriteRes = await agent.fans.web5.ckb.preDirectWrites({
+                repo: did,
+                writes: [{
+                        $type: preWriteType,
+                        collection: newRecord.$type,
+                        rkey: recordRkey,
+                        value: newRecord,
+                    }],
+                validate: false,
+            });
+            const preWriterData = preWriteRes.data;
+            const uncommit = {
+                did: preWriterData.did,
+                version: 3,
+                rev: preWriterData.rev,
+                prev: preWriterData.prev ? CID.parse(preWriterData.prev) : null,
+                data: CID.parse(preWriterData.data),
+            };
+            const unSignBytes = cbor.encode(uncommit);
+            const unSignBytesHex = hexFromBytes(unSignBytes).slice(2);
+            if (unSignBytesHex !== preWriterData.unSignBytes) {
+                error('Sign bytes not consistent');
+                return;
+            }
+            const keypair = await Secp256k1Keypair.import(bytesFromHex(signKey));
+            const sig = await keypair.sign(unSignBytes);
+            const writeRes = await agent.fans.web5.ckb.directWrites({
+                repo: did,
+                validate: false,
+                signingKey: didKey,
+                writes: [{
+                        $type: directWriteType,
+                        collection: newRecord.$type,
+                        rkey: recordRkey,
+                        value: newRecord,
+                    }],
+                root: {
+                    did: preWriterData.did,
+                    version: 3,
+                    rev: preWriterData.rev,
+                    prev: preWriterData.prev,
+                    data: preWriterData.data,
+                    signedBytes: hexFromBytes(sig),
+                },
+            });
+            success(writeRes.success);
+        }
+        catch (e) {
+            error(`Failed to write data: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async repo(pds, did) {
+        try {
+            const url = new URL(`https://${pds}/xrpc/com.atproto.repo.describeRepo`);
+            url.searchParams.append('repo', did);
+            const response = await fetch(url.toString(), {
+                headers: { 'Content-Type': 'application/json; charset=utf-8' },
+            });
+            if (!response.ok) {
+                error(`Failed to fetch repo info: ${response.status} ${response.statusText}`);
+                return;
+            }
+            const repoInfo = await response.json();
+            success(repoInfo);
+        }
+        catch (e) {
+            error(`Failed to fetch repo info: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async records(pds, did, collection, limit, cursor) {
+        try {
+            const url = new URL(`https://${pds}/xrpc/com.atproto.repo.listRecords`);
+            url.searchParams.append('repo', did);
+            url.searchParams.append('collection', collection);
+            url.searchParams.append('limit', (limit || 10).toString());
+            if (cursor) {
+                url.searchParams.append('cursor', cursor);
+            }
+            const response = await fetch(url.toString(), {
+                headers: { 'Content-Type': 'application/json; charset=utf-8' },
+            });
+            if (!response.ok) {
+                error(`Failed to fetch records: ${response.status} ${response.statusText}`);
+                return;
+            }
+            const data = await response.json();
+            success(data);
+        }
+        catch (e) {
+            error(`Failed to fetch records: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async blobs(pds, did, limit, cursor) {
+        try {
+            const url = new URL(`https://${pds}/xrpc/com.atproto.sync.listBlobs`);
+            url.searchParams.append('did', did);
+            url.searchParams.append('limit', (limit || 10).toString());
+            if (cursor) {
+                url.searchParams.append('cursor', cursor);
+            }
+            const response = await fetch(url.toString(), {
+                headers: { 'Content-Type': 'application/json; charset=utf-8' },
+            });
+            if (!response.ok) {
+                error(`Failed to fetch blobs: ${response.status} ${response.statusText}`);
+                return;
+            }
+            const data = await response.json();
+            success(data);
+        }
+        catch (e) {
+            error(`Failed to fetch blobs: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async exportRepo(pds, did, dataFile, since) {
+        try {
+            const url = new URL(`https://${pds}/xrpc/com.atproto.sync.getRepo`);
+            url.searchParams.append('did', did);
+            if (since) {
+                url.searchParams.append('since', since);
+            }
+            const response = await fetch(url.toString(), {
+                headers: { 'Content-Type': 'application/json; charset=utf-8' },
+            });
+            if (!response.ok) {
+                error(`Failed to export repo: ${response.status} ${response.statusText}`);
+                return;
+            }
+            const data = await response.arrayBuffer();
+            await writeFile(dataFile, Buffer.from(data));
+            success(true);
+        }
+        catch (e) {
+            error(`Failed to export repo: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async importRepo(pds, did, accessJwt, dataFile) {
+        try {
+            const car = await readFile(dataFile);
+            const url = new URL(`https://${pds}/xrpc/com.atproto.repo.importRepo`);
+            url.searchParams.append('did', did);
+            const response = await fetch(url.toString(), {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${accessJwt}`,
+                    'Content-Type': 'application/vnd.ipld.car',
+                },
+                body: car,
+            });
+            success(response.ok);
+        }
+        catch (e) {
+            error(`Failed to import repo: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+};

package/dist/utils/wallet.d.ts

@@ -0,0 +1,12 @@
+export type TransactionStatus = 'sent' | 'pending' | 'proposed' | 'committed' | 'unknown' | 'rejected';
+export interface WalletManager {
+    newWallet(): Promise<void>;
+    importWallet(sk: string): Promise<void>;
+    clean(): Promise<void>;
+    getAddress(): Promise<void>;
+    sendTx(txPath: string): Promise<void>;
+    checkTx(txHash: string): Promise<void>;
+    balance(): Promise<void>;
+}
+export declare const walletManager: WalletManager;
+export declare const walletManagerWithExit: WalletManager;

package/dist/utils/wallet.js

@@ -0,0 +1,148 @@
+import { CKB_SK_PATH, keyExists, readKey, writeKey, removeKey, error, success, hexFromBytes, readJsonFile } from './common.js';
+import { ccc } from '@ckb-ccc/ccc';
+function getNetwork() {
+    const network = process.env.CKB_NETWORK;
+    if (network === 'ckb')
+        return 'ckb';
+    return 'ckb_testnet';
+}
+async function getClient() {
+    const network = getNetwork();
+    if (network === 'ckb') {
+        return new ccc.ClientPublicMainnet();
+    }
+    return new ccc.ClientPublicTestnet();
+}
+async function getSigner() {
+    const privateKey = await readKey(CKB_SK_PATH);
+    if (!privateKey)
+        return null;
+    const client = await getClient();
+    return new ccc.SignerCkbPrivateKey(client, privateKey);
+}
+function generatePrivateKey() {
+    const bytes = crypto.getRandomValues(new Uint8Array(32));
+    return hexFromBytes(bytes);
+}
+function exitAfter(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        finally {
+            process.exit(0);
+        }
+    };
+}
+export const walletManager = {
+    async newWallet() {
+        if (keyExists(CKB_SK_PATH)) {
+            error('Wallet already exists. Use "clean" first to remove it.');
+            return;
+        }
+        try {
+            const privateKey = generatePrivateKey();
+            const client = await getClient();
+            const signer = new ccc.SignerCkbPrivateKey(client, privateKey);
+            const address = await signer.getRecommendedAddress();
+            await writeKey(CKB_SK_PATH, privateKey);
+            success(address);
+        }
+        catch (e) {
+            error(`Failed to create wallet: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async importWallet(sk) {
+        if (keyExists(CKB_SK_PATH)) {
+            error('Wallet already exists. Use "clean" first to remove it.');
+            return;
+        }
+        try {
+            const client = await getClient();
+            const signer = new ccc.SignerCkbPrivateKey(client, sk);
+            const address = await signer.getRecommendedAddress();
+            await writeKey(CKB_SK_PATH, sk);
+            success(address);
+        }
+        catch (e) {
+            error(`Failed to import wallet: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async clean() {
+        const result = await removeKey(CKB_SK_PATH);
+        success(result);
+    },
+    async getAddress() {
+        const signer = await getSigner();
+        if (!signer) {
+            error('No wallet found. Use "new" or "import" first.');
+            return;
+        }
+        try {
+            const address = await signer.getRecommendedAddress();
+            success(address);
+        }
+        catch (e) {
+            error(`Failed to get address: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async sendTx(txPath) {
+        const signer = await getSigner();
+        if (!signer) {
+            error('No wallet found. Use "new" or "import" first.');
+            return;
+        }
+        try {
+            const txData = await readJsonFile(txPath);
+            if (!txData) {
+                error('Failed to read transaction file');
+                return;
+            }
+            const tx = ccc.Transaction.from(txData);
+            const txHash = await signer.sendTransaction(tx);
+            success(txHash);
+        }
+        catch (e) {
+            error(`Failed to send transaction: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async checkTx(txHash) {
+        const signer = await getSigner();
+        if (!signer) {
+            error('No wallet found. Use "new" or "import" first.');
+            return;
+        }
+        try {
+            const tx = await signer.client.getTransaction(txHash);
+            success(tx?.status ?? 'unknown');
+        }
+        catch (e) {
+            error(`Failed to check transaction: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async balance() {
+        const signer = await getSigner();
+        if (!signer) {
+            error('No wallet found. Use "new" or "import" first.');
+            return;
+        }
+        try {
+            const balance = await signer.getBalance();
+            const balanceInCKB = ccc.fixedPointToString(balance);
+            success(`${balanceInCKB} CKB`);
+        }
+        catch (e) {
+            error(`Failed to get balance: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+};
+// Wrap methods that need process exit
+export const walletManagerWithExit = {
+    newWallet: exitAfter(walletManager.newWallet),
+    importWallet: exitAfter(walletManager.importWallet),
+    clean: exitAfter(walletManager.clean),
+    getAddress: exitAfter(walletManager.getAddress),
+    sendTx: exitAfter(walletManager.sendTx),
+    checkTx: exitAfter(walletManager.checkTx),
+    balance: exitAfter(walletManager.balance),
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "web5-cli",
+  "version": "0.1.0",
+  "description": "Web5 CLI tool for decentralized identity and data management",
+  "type": "module",
+  "bin": {
+    "web5-cli": "./bin/web5-cli.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "eslint .",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@atproto/crypto": "^0.4.5",
+    "@ckb-ccc/ccc": "0.0.0-canary-20260109065952",
+    "@scure/base": "^2.0.0",
+    "@atproto/common-web": "^0.4.13",
+    "@atproto/repo": "^0.8.12",
+    "@ipld/dag-cbor": "^9.2.5",
+    "multiformats": "^13.4.2",
+    "web5-api": "^0.0.27",
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/node": "^24.10.1",
+    "@types/commander": "^2.12.5",
+    "eslint": "^9.39.1",
+    "globals": "^16.5.0",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.46.4"
+  }
+}