withub-cli 0.1.0 → 0.2.0

package/dist/commands/push.js

@@ -20,7 +20,22 @@ const suiRepo_1 = require("../lib/suiRepo");
 const schema_1 = require("../lib/schema");
 const seal_1 = require("../lib/seal");
 const constants_1 = require("../lib/constants");
+const evmRepo_1 = require("../lib/evmRepo");
+const evmProvider_1 = require("../lib/evmProvider");
+const lit_1 = require("../lib/lit");
+const lighthouse_1 = require("../lib/lighthouse");
+const crypto_1 = require("../lib/crypto");
 async function pushAction() {
+    const witPath = await (0, repo_1.requireWitDir)();
+    const repoCfg = await (0, repo_1.readRepoConfig)(witPath);
+    if (repoCfg.chain === 'mantle') {
+        return mantlePushAction(witPath, repoCfg);
+    }
+    else {
+        return suiPushAction();
+    }
+}
+async function suiPushAction() {
     // eslint-disable-next-line no-console
     console.log(ui_1.colors.header('Starting push...'));
     const witPath = await (0, repo_1.requireWitDir)();
@@ -47,7 +62,8 @@ async function pushAction() {
     let createdRepo = false;
     let repoId = repoCfg.repo_id;
     if (!repoId) {
-        const isPrivate = repoCfg.seal_policy_id === 'pending' || !!repoCfg.seal_policy_id;
+        const sealPolicyId = (0, repo_1.resolveSuiSealPolicyId)(repoCfg);
+        const isPrivate = sealPolicyId === 'pending' || !!sealPolicyId;
         repoId = await (0, suiRepo_1.createRepository)(suiClient, signerInfo.signer, {
             name: repoCfg.repo_name,
             description: repoCfg.repo_name,
@@ -61,13 +77,15 @@ async function pushAction() {
     }
     const onchainState = await (0, suiRepo_1.fetchRepositoryStateWithRetry)(suiClient, repoId);
     // Update local seal policy ID if it was pending or changed
-    if (onchainState.sealPolicyId && repoCfg.seal_policy_id !== onchainState.sealPolicyId) {
-        repoCfg.seal_policy_id = onchainState.sealPolicyId;
+    const localPolicyId = (0, repo_1.resolveSuiSealPolicyId)(repoCfg);
+    if (onchainState.sealPolicyId && onchainState.sealPolicyId !== localPolicyId) {
+        (0, repo_1.setSuiSealPolicyId)(repoCfg, onchainState.sealPolicyId);
         await (0, repo_1.writeRepoConfig)(witPath, repoCfg);
         // eslint-disable-next-line no-console
         console.log(ui_1.colors.cyan(`Seal policy updated from chain: ${onchainState.sealPolicyId}`));
     }
-    const currentPolicyId = repoCfg.seal_policy_id === 'pending' ? null : repoCfg.seal_policy_id;
+    const updatedPolicyId = (0, repo_1.resolveSuiSealPolicyId)(repoCfg);
+    const currentPolicyId = updatedPolicyId === 'pending' ? null : updatedPolicyId;
     if (onchainState.headCommit && baseRemoteId !== onchainState.headCommit) {
         throw new Error('Remote head diverges from local history; run `wit pull`/`fetch` or reset first.');
     }
@@ -325,18 +343,18 @@ async function cacheJson(filePath, content) {
     await promises_1.default.writeFile(filePath, content, 'utf8');
 }
 async function ensureAuthorOrSetDefault(witPath, repoCfg, signerAddress) {
-    const current = (repoCfg.author || '').trim().toLowerCase();
+    const current = (0, repo_1.resolveChainAuthor)(repoCfg).trim().toLowerCase();
     const signer = signerAddress.toLowerCase();
     if (!current || current === 'unknown') {
-        const next = { ...repoCfg, author: signerAddress };
-        await (0, repo_1.writeRepoConfig)(witPath, next);
+        (0, repo_1.setChainAuthor)(repoCfg, repoCfg.chain, signerAddress);
+        await (0, repo_1.writeRepoConfig)(witPath, repoCfg);
         // eslint-disable-next-line no-console
         console.log(ui_1.colors.cyan(`Author set to active address ${signerAddress}`));
         return;
     }
     if (current !== signer) {
         // eslint-disable-next-line no-console
-        console.warn(`Warning: author (${repoCfg.author}) differs from signer (${signerAddress}). Push will use signer.`);
+        console.warn(`Warning: author (${(0, repo_1.resolveChainAuthor)(repoCfg)}) differs from signer (${signerAddress}). Push will use signer.`);
     }
 }
 async function assertResourcesOk(address) {
@@ -369,3 +387,201 @@ async function assertResourcesOk(address) {
     }
     return true;
 }
+async function mantlePushAction(witPath, repoCfg) {
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.header('Starting push (Mantle Mainnet)...'));
+    // 1. Prepare environment
+    const headRefPath = await (0, state_1.readHeadRefPath)(witPath);
+    const headId = await (0, state_1.readRef)(headRefPath);
+    if (!headId) {
+        throw new Error('No commits to push. Run `wit commit` first.');
+    }
+    const signerInfo = await (0, evmProvider_1.loadMantleSigner)(repoCfg.network);
+    const evmRepo = new evmRepo_1.EvmRepoService(signerInfo);
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`Using account ${signerInfo.address}`));
+    // 2. Check/Create Repo
+    let repoIdStr = repoCfg.repo_id;
+    let createdRepo = false;
+    let onchainState;
+    let repoId = BigInt(0);
+    if (repoIdStr && (/^\d+$/.test(repoIdStr) || /^0x[0-9a-fA-F]+$/.test(repoIdStr))) {
+        repoId = BigInt(repoIdStr);
+        try {
+            onchainState = await evmRepo.getRepoState(repoId);
+        }
+        catch (e) {
+            throw e; // Repository not found
+        }
+    }
+    else {
+        // Create new repo
+        const isPrivate = repoCfg.isPrivate === true;
+        repoId = await evmRepo.createRepo(repoCfg.repo_name || 'WitRepo', repoCfg.repo_name || 'WitRepo', isPrivate);
+        // Store as formatted hex string
+        repoCfg.repo_id = (0, evmRepo_1.formatRepoId)(repoId);
+        await (0, repo_1.writeRepoConfig)(witPath, repoCfg);
+        createdRepo = true;
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.green(`Created on-chain repository ${repoCfg.repo_id} (Mantle Mainnet)`));
+        onchainState = {
+            headCommit: '',
+            version: 0n,
+            isPrivate,
+            headManifest: '',
+            headSnapshot: '',
+            rootHash: '',
+            parentCommit: '',
+            id: repoId,
+            name: repoCfg.repo_name || '',
+            description: '',
+            owner: signerInfo.address,
+        };
+    }
+    // 3. Collect Commits
+    const commitMap = await (0, state_1.readCommitIdMap)(witPath);
+    const { chain, baseRemoteId } = await collectChain(witPath, headId, commitMap);
+    if (onchainState.headCommit && onchainState.headCommit !== '' && baseRemoteId !== onchainState.headCommit) {
+        throw new Error('Remote head diverges from local history; run `wit pull`/`fetch` or reset first.');
+    }
+    if (commitMap[headId] && onchainState.headCommit === commitMap[headId]) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.green('Remote already up to date.'));
+        return;
+    }
+    // 4. Lit + Upload Loop
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`Found ${chain.length} commit(s) to push.`));
+    let parentRemoteId = onchainState.headCommit || null;
+    if (parentRemoteId === '')
+        parentRemoteId = null;
+    let lastManifestId = null;
+    let lastCommitRemoteId = null;
+    let lastRootHash = '';
+    const nextMap = { ...commitMap };
+    // Initialize Lit Service
+    const litService = new lit_1.LitService();
+    const contractAddress = evmRepo.getAddress();
+    // Use user-provided CID for Lit Action (optimization)
+    const litActionCid = lit_1.LIT_ACTION_CID;
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.gray(`  Using Lit Action CID: ${litActionCid}`));
+    for (let i = 0; i < chain.length; i += 1) {
+        const item = chain[i];
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.cyan(`Uploading commit ${i + 1}/${chain.length}: ${item.id}`));
+        // Upload logic
+        const entries = Object.entries(item.commit.tree.files).sort((a, b) => a[0].localeCompare(b[0]));
+        const filesStats = [];
+        // Process files (Encryption + Upload)
+        const isPrivateRepo = onchainState.isPrivate || repoCfg.isPrivate;
+        if (isPrivateRepo) {
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.gray(`  Encrypting ${entries.length} files (AES-256-GCM) & sealing with Lit Protocol...`));
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.gray(`  Uploading ${entries.length} files (Public, no encryption)...`));
+        }
+        for (const [rel, meta] of entries) {
+            const buf = await (0, fs_1.readBlob)(witPath, meta.hash);
+            if (!buf)
+                throw new Error(`Missing blob for ${rel}`);
+            // Encryption
+            let contentToUpload = buf;
+            let encMetadata = undefined;
+            if (isPrivateRepo) {
+                // Generate Session Key
+                const sessionKey = (0, crypto_1.generateSessionKey)();
+                // Encrypt Content
+                const { ciphertext, iv, authTag } = (0, crypto_1.encryptBuffer)(buf, sessionKey);
+                contentToUpload = ciphertext;
+                // Lit Encrypt Session Key
+                const acc = litService.getAccessControlConditions(repoId.toString(), contractAddress);
+                const { ciphertext: litKey, dataToEncryptHash } = await litService.encryptSessionKey(sessionKey, acc);
+                encMetadata = {
+                    alg: 'lit-aes-256-gcm',
+                    lit_encrypted_key: litKey,
+                    unified_access_control_conditions: acc,
+                    lit_chain: 'mantle',
+                    iv: iv.toString('hex'),
+                    tag: authTag.toString('hex'),
+                    lit_hash: dataToEncryptHash
+                };
+            }
+            // Upload to Lighthouse
+            const uploadRes = await (0, lighthouse_1.uploadBufferToLighthouse)(contentToUpload);
+            const cid = uploadRes.cid;
+            filesStats.push({
+                rel,
+                meta,
+                cid,
+                enc: encMetadata,
+                size: contentToUpload.length
+            });
+        }
+        const rootHash = (0, manifest_1.computeRootHash)(item.commit.tree.files);
+        lastRootHash = rootHash;
+        // Construct Manifest
+        const manifestFiles = {};
+        filesStats.forEach(f => {
+            manifestFiles[f.rel] = {
+                ...f.meta,
+                cid: f.cid,
+                ...(f.enc ? { enc: f.enc } : {})
+            };
+        });
+        const manifest = schema_1.ManifestSchema.parse({
+            version: 1,
+            root_hash: rootHash,
+            files: manifestFiles,
+        });
+        const manifestJson = (0, serialize_1.canonicalStringify)(manifest);
+        const manifestUpload = await (0, lighthouse_1.uploadTextToLighthouse)(manifestJson, `manifest-${item.id}`);
+        lastManifestId = manifestUpload.cid;
+        // Cache Manifest
+        await cacheJson(path_1.default.join(witPath, 'objects', 'manifests', `${(0, state_1.idToFileName)(lastManifestId)}.json`), manifestJson);
+        // Construct Remote Commit
+        const remoteCommit = {
+            tree: {
+                root_hash: rootHash,
+                manifest_cid: lastManifestId,
+            },
+            parent: parentRemoteId,
+            author: item.commit.author,
+            message: item.commit.message,
+            timestamp: item.commit.timestamp,
+            extras: { ...item.commit.extras }
+        };
+        const remoteJson = (0, serialize_1.canonicalStringify)(remoteCommit);
+        const commitUpload = await (0, lighthouse_1.uploadTextToLighthouse)(remoteJson, `commit-${item.id}`);
+        lastCommitRemoteId = commitUpload.cid;
+        // Cache Commit
+        await cacheJson(path_1.default.join(witPath, 'objects', 'commits', `${(0, state_1.idToFileName)(lastCommitRemoteId)}.json`), remoteJson);
+        // Update local map
+        nextMap[item.id] = lastCommitRemoteId;
+        parentRemoteId = lastCommitRemoteId;
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.green(`Uploaded commit ${item.id} -> ${lastCommitRemoteId}`));
+    }
+    if (!lastCommitRemoteId || !lastManifestId) {
+        throw new Error("Push produced no commits.");
+    }
+    // 5. Update Contract
+    await (0, state_1.writeCommitIdMap)(witPath, nextMap);
+    await evmRepo.updateHead(repoId, lastCommitRemoteId, lastManifestId, '', lastRootHash, onchainState.version, onchainState.headCommit || '');
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan('On-chain head updated'));
+    const updatedRemote = {
+        repo_id: repoId.toString(),
+        head_commit: lastCommitRemoteId,
+        head_manifest: lastManifestId,
+        head_quilt: '',
+        version: Number(onchainState.version) + 1,
+    };
+    await (0, repo_1.writeRemoteState)(witPath, updatedRemote);
+    await (0, repo_1.writeRemoteRef)(witPath, lastCommitRemoteId);
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.green('Push (Mantle) complete.'));
+    await litService.disconnect();
+}

package/dist/commands/registerCommands.js

@@ -18,6 +18,55 @@ const walrusQuilt_1 = require("./walrusQuilt");
 const list_1 = require("./list");
 const transfer_1 = require("./transfer");
 const removeUser_1 = require("./removeUser");
+const chain_1 = require("./chain");
+const chain_2 = require("../lib/chain");
+const repo_1 = require("../lib/repo");
+const ipfsCar_1 = require("./ipfsCar");
+const lighthouse_1 = require("./lighthouse");
+const lighthouseDownload_1 = require("./lighthouseDownload");
+const lighthousePin_1 = require("./lighthousePin");
+function shouldSkipChainCheck(cmd) {
+    const parent = cmd.parent;
+    if (!parent)
+        return false;
+    if (parent.name() !== 'chain')
+        return false;
+    const name = cmd.name();
+    return name === 'list' || name === 'use' || name === 'current';
+}
+async function enforceRepoChain(cmd) {
+    if (shouldSkipChainCheck(cmd))
+        return;
+    let witPath;
+    try {
+        witPath = await (0, repo_1.requireWitDir)();
+    }
+    catch (err) {
+        if (err?.message?.includes('Not a wit repository'))
+            return;
+        throw err;
+    }
+    let repoCfg;
+    try {
+        repoCfg = await (0, repo_1.readRepoConfig)(witPath);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return;
+        throw err;
+    }
+    const mismatch = await (0, repo_1.getRepoChainMismatch)(repoCfg);
+    if (!mismatch)
+        return;
+    if ('error' in mismatch) {
+        // eslint-disable-next-line no-console
+        console.error(ui_1.colors.red(mismatch.error));
+        process.exit(1);
+    }
+    // eslint-disable-next-line no-console
+    console.error(ui_1.colors.red((0, chain_2.formatChainMismatchMessage)(mismatch.repoChain, mismatch.activeChain)));
+    process.exit(1);
+}
 function registerCommands(program) {
     // Global options (propagate to subcommands)
     program.option('--color', 'force color output').option('--no-color', 'disable color output');
@@ -94,7 +143,8 @@ function registerCommands(program) {
         .description('Add a collaborator to the repository')
         .option('--seal-policy <id>', 'Seal policy id to apply (defaults to repo config)')
         .option('--seal-secret <secret>', 'Seal secret to save locally when setting policy')
-        .action((address) => (0, invite_1.inviteAction)(address));
+        .option('-r, --repo <repoId>', 'Repository ID (Mantle)')
+        .action(invite_1.inviteAction);
     program
         .command('transfer <new_owner>')
         .description('Transfer repository ownership to a new address')
@@ -102,6 +152,7 @@ function registerCommands(program) {
     program
         .command('remove-user <address>')
         .description('Remove a collaborator from the repository')
+        .option('-r, --repo <repoId>', 'Repository ID (Mantle)')
         .action(removeUser_1.removeUserAction);
     program
         .command('push-blob <path>')
@@ -150,12 +201,61 @@ function registerCommands(program) {
         .command('pull-quilt-legacy <blob_id> <out_dir>')
         .description('Download legacy archive and restore files (hash/root_hash verified)')
         .action((blobId, outDir) => (0, walrusQuilt_1.pullQuiltLegacyAction)(blobId, outDir));
+    program
+        .command('car-pack <input>')
+        .description('Pack a directory or file into a CAR snapshot')
+        .option('-o, --out <path>', 'output CAR file path')
+        .option('--no-wrap', 'do not wrap input with a directory')
+        .option('--root-out <path>', 'write root CID to a file')
+        .action((input, opts) => (0, ipfsCar_1.carPackAction)(input, opts));
+    program
+        .command('car-unpack <car_file> <out_dir>')
+        .description('Unpack a CAR snapshot to a directory')
+        .action((carFile, outDir) => (0, ipfsCar_1.carUnpackAction)(carFile, outDir));
+    program
+        .command('car-map <car_file>')
+        .description('Generate a path -> CID map from a CAR snapshot')
+        .option('-o, --out <path>', 'output JSON path (prints to stdout if omitted)')
+        .option('--no-strip-root', 'keep the top-level CAR root segment in paths')
+        .action((carFile, opts) => (0, ipfsCar_1.carMapAction)(carFile, opts));
+    program
+        .command('lighthouse-upload <file>')
+        .description('Upload a file to Lighthouse and print CID')
+        .option('--cid-version <n>', 'CID version (default 1)', (v) => parseInt(v, 10), 1)
+        .option('--progress', 'show upload progress')
+        .option('--retries <n>', 'retry attempts (default 3)', (v) => parseInt(v, 10), 3)
+        .option('--retry-delay <ms>', 'base retry delay in ms (default 1000)', (v) => parseInt(v, 10), 1000)
+        .option('--no-cache', 'disable local upload cache')
+        .action((file, opts) => (0, lighthouse_1.lighthouseUploadAction)(file, opts));
+    program
+        .command('lighthouse-download <cid>')
+        .description('Download a CID from Lighthouse gateway')
+        .option('-o, --out <path>', 'output file path (defaults to <cid>[.car])')
+        .option('--car', 'download as CAR (format=car)')
+        .option('--no-verify', 'disable CID verification (default true)')
+        .option('--retries <n>', 'retry attempts (default 3)', (v) => parseInt(v, 10), 3)
+        .option('--retry-delay <ms>', 'base retry delay in ms (default 500)', (v) => parseInt(v, 10), 500)
+        .option('--timeout <ms>', 'request timeout in ms (default 30000)', (v) => parseInt(v, 10), 30000)
+        .option('--gateway <url>', 'override gateway URL')
+        .action((cid, opts) => (0, lighthouseDownload_1.lighthouseDownloadAction)(cid, opts));
+    program
+        .command('lighthouse-pin <cid>')
+        .description('Pin a CID using Lighthouse API')
+        .option('--pin-url <url>', 'override Lighthouse pin URL')
+        .option('--retries <n>', 'retry attempts (default 3)', (v) => parseInt(v, 10), 3)
+        .option('--retry-delay <ms>', 'base retry delay in ms (default 1000)', (v) => parseInt(v, 10), 1000)
+        .option('--timeout <ms>', 'request timeout in ms (default 30000)', (v) => parseInt(v, 10), 30000)
+        .action((cid, opts) => (0, lighthousePin_1.lighthousePinAction)(cid, opts));
     program
         .command('list')
         .description('List repositories you own or collaborate on')
         .option('--owned', 'Show only owned repositories')
         .option('--collaborated', 'Show only collaborated repositories')
         .action(list_1.listAction);
+    const chain = program.command('chain').description('Manage active chain');
+    chain.command('list').description('List supported chains').action(chain_1.chainListAction);
+    chain.command('use <chain>').description('Set active chain').action(chain_1.chainUseAction);
+    chain.command('current').description('Show active chain').action(chain_1.chainCurrentAction);
     const account = program.command('account').description('Manage wit accounts (keys, active address)');
     account.command('list').description('List locally stored accounts (keys) and show active').action(account_1.accountListAction);
     account.command('use <address>').description('Set active account address (updates ~/.witconfig, author if unknown)').action(account_1.accountUseAction);
@@ -164,12 +264,17 @@ function registerCommands(program) {
         .option('--alias <name>', 'alias to record in key file (defaults to "default")')
         .description('Generate a new account (keypair), set as active, and update author if unknown')
         .action(account_1.accountGenerateAction);
+    account
+        .command('import <private_key>')
+        .option('--alias <name>', 'alias to record in key file (defaults to "default")')
+        .description('Import a private key for the active chain and set as active')
+        .action((privateKey, opts) => (0, account_1.accountImportAction)(privateKey, opts));
     account
         .command('balance')
         .argument('[address]', 'Address to query (defaults to active)')
         .description('Show SUI/WAL balance for the address (defaults to active)')
         .action((address) => (0, account_1.accountBalanceAction)(address));
-    program.hook('preAction', (cmd) => {
+    program.hook('preAction', async (cmd) => {
         const opts = cmd.optsWithGlobals ? cmd.optsWithGlobals() : program.opts();
         const envDefault = process.env.WIT_NO_COLOR === undefined &&
             process.env.NO_COLOR === undefined &&
@@ -179,5 +284,6 @@ function registerCommands(program) {
         if (!desired && (0, ui_1.colorsEnabled)()) {
             (0, ui_1.setColorsEnabled)(false);
         }
+        await enforceRepoChain(cmd);
     });
 }

package/dist/commands/remove-user.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUserAction = removeUserAction;
+const evmRepo_1 = require("../lib/evmRepo");
+const evmProvider_1 = require("../lib/evmProvider");
+const repo_1 = require("../lib/repo");
+const ui_1 = require("../lib/ui");
+async function removeUserAction(address, options) {
+    try {
+        // 1. Resolve Config
+        let repoIdStr = options.repo;
+        if (!repoIdStr) {
+            // Try to load from current directory
+            try {
+                const witPath = await (0, repo_1.requireWitDir)(process.cwd());
+                const config = await (0, repo_1.readRepoConfig)(witPath);
+                if (config.chain !== 'mantle') {
+                    throw new Error('This command is only supported for Mantle repositories.');
+                }
+                repoIdStr = config.repo_id || undefined;
+            }
+            catch (e) {
+                // Ignore, rely on argument
+            }
+        }
+        if (!repoIdStr) {
+            // eslint-disable-next-line no-console
+            console.error(ui_1.colors.red('Error: Repository ID is required. Run inside a wit repo or use --repo <id>.'));
+            process.exit(1);
+        }
+        // Normalization
+        if (repoIdStr.startsWith('mantle:')) {
+            repoIdStr = repoIdStr.split(':').pop();
+        }
+        const repoId = BigInt(repoIdStr);
+        // 2. Connect to Mantle
+        const signerCtx = await (0, evmProvider_1.loadMantleSigner)();
+        const repoService = new evmRepo_1.EvmRepoService(signerCtx);
+        // 3. Remove Collaborator
+        await repoService.removeCollaborator(repoId, address);
+    }
+    catch (err) {
+        console.error(ui_1.colors.red(`Command failed: ${err.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/removeUser.js

@@ -7,9 +7,14 @@ const walrus_1 = require("../lib/walrus");
 const suiRepo_1 = require("../lib/suiRepo");
 const repo_1 = require("../lib/repo");
 const ui_1 = require("../lib/ui");
-async function removeUserAction(addressToRemove) {
+const evmRepo_1 = require("../lib/evmRepo");
+const evmProvider_1 = require("../lib/evmProvider");
+async function removeUserAction(addressToRemove, options) {
     const witPath = await (0, repo_1.requireWitDir)();
     const repoCfg = await (0, repo_1.readRepoConfig)(witPath);
+    if (repoCfg.chain === 'mantle') {
+        return removeUserActionMantle(addressToRemove, options, repoCfg);
+    }
     if (!repoCfg.repo_id) {
         throw new Error('Repository not initialized on chain. Run `wit push` first.');
     }
@@ -61,3 +66,27 @@ async function removeUserAction(addressToRemove) {
         process.exit(1);
     }
 }
+async function removeUserActionMantle(address, options, config) {
+    try {
+        let repoIdStr = options.repo || config.repo_id;
+        if (!repoIdStr) {
+            // eslint-disable-next-line no-console
+            console.error(ui_1.colors.red('Error: Repository ID is required. Run inside a wit repo or use --repo <id>.'));
+            process.exit(1);
+        }
+        // Normalization
+        if (repoIdStr.startsWith('mantle:')) {
+            repoIdStr = repoIdStr.split(':').pop();
+        }
+        const repoId = BigInt(repoIdStr);
+        // 2. Connect to Mantle
+        const signerCtx = await (0, evmProvider_1.loadMantleSigner)();
+        const repoService = new evmRepo_1.EvmRepoService(signerCtx);
+        // 3. Remove Collaborator
+        await repoService.removeCollaborator(repoId, address);
+    }
+    catch (err) {
+        console.error(ui_1.colors.red(`Command failed: ${err.message}`));
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -15,6 +15,21 @@ if (!Array.prototype.toReversed) {
         return [...this].reverse();
     };
 }
+// Polyfill for global crypto (Node environment for Lit SDK)
+const crypto_1 = __importDefault(require("crypto"));
+if (!globalThis.crypto) {
+    globalThis.crypto = crypto_1.default;
+}
+// Suppress noisy Lit SDK deprecation warnings
+const originalWarn = console.warn;
+console.warn = (...args) => {
+    if (args.length > 0 &&
+        typeof args[0] === 'string' &&
+        args[0].includes('deprecated LogLevel is deprecated')) {
+        return;
+    }
+    originalWarn(...args);
+};
 const VERSION = package_json_1.default.version || '0.0.0';
 async function run(argv = process.argv) {
     const program = new commander_1.Command();

package/dist/lib/chain.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSupportedChains = listSupportedChains;
+exports.readActiveChain = readActiveChain;
+exports.setActiveChain = setActiveChain;
+exports.normalizeChain = normalizeChain;
+exports.formatChainMismatchMessage = formatChainMismatchMessage;
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const CHAINS = [
+    { id: 'sui', label: 'Sui Testnet' },
+    { id: 'mantle', label: 'Mantle Mainnet' },
+];
+const DEFAULT_CHAIN = 'sui';
+const GLOBAL_CONFIG_PATH = path_1.default.join(os_1.default.homedir(), '.witconfig');
+function listSupportedChains() {
+    return [...CHAINS];
+}
+async function readActiveChain() {
+    const cfg = await readGlobalConfig();
+    const normalized = normalizeChainMaybe(cfg.active_chain);
+    return normalized ?? DEFAULT_CHAIN;
+}
+async function setActiveChain(chain) {
+    await updateGlobalConfig((cfg) => ({ ...cfg, active_chain: chain }));
+}
+function normalizeChain(input) {
+    const normalized = normalizeChainMaybe(input);
+    if (!normalized) {
+        const choices = CHAINS.map((chain) => chain.id).join(', ');
+        throw new Error(`Unknown chain "${input}". Supported: ${choices}.`);
+    }
+    return normalized;
+}
+function formatChainMismatchMessage(repoChain, activeChain) {
+    return (`Repository chain is ${repoChain}, but active chain is ${activeChain}. ` +
+        `Run \`wit chain use ${repoChain}\` and retry.`);
+}
+function normalizeChainMaybe(input) {
+    if (!input)
+        return null;
+    const value = input.trim().toLowerCase();
+    if (value === 'sui')
+        return 'sui';
+    if (value === 'mantle')
+        return 'mantle';
+    if (value === 'mantle-testnet')
+        return 'mantle';
+    return null;
+}
+async function readGlobalConfig() {
+    try {
+        const raw = await promises_1.default.readFile(GLOBAL_CONFIG_PATH, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return {};
+        // eslint-disable-next-line no-console
+        console.warn(`Warning: could not read ${GLOBAL_CONFIG_PATH}: ${err.message}`);
+        return {};
+    }
+}
+async function updateGlobalConfig(mutator) {
+    const cfg = await readGlobalConfig();
+    const next = mutator(cfg);
+    await promises_1.default.writeFile(GLOBAL_CONFIG_PATH, JSON.stringify(next, null, 2) + '\n', 'utf8');
+}