withub-cli 0.1.0

package/dist/commands/fetch.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAction = fetchAction;
+const client_1 = require("@mysten/sui/client");
+const ui_1 = require("../lib/ui");
+const walrus_1 = require("../lib/walrus");
+const suiRepo_1 = require("../lib/suiRepo");
+const schema_1 = require("../lib/schema");
+const manifest_1 = require("../lib/manifest");
+const serialize_1 = require("../lib/serialize");
+const state_1 = require("../lib/state");
+const repo_1 = require("../lib/repo");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+async function fetchAction() {
+    const witPath = await (0, repo_1.requireWitDir)();
+    const repoCfg = await (0, repo_1.readRepoConfig)(witPath);
+    if (!repoCfg.repo_id) {
+        throw new Error('Missing repo_id in .wit/config.json. Cannot fetch.');
+    }
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.header('Fetching remote metadata...'));
+    const resolved = await (0, walrus_1.resolveWalrusConfig)(process.cwd());
+    const suiClient = new client_1.SuiClient({ url: resolved.suiRpcUrl });
+    const walrusSvc = await walrus_1.WalrusService.fromRepo();
+    const onchain = await (0, suiRepo_1.fetchRepositoryStateWithRetry)(suiClient, repoCfg.repo_id);
+    if (!onchain.headCommit || !onchain.headManifest || !onchain.headQuilt) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.yellow('Remote repository has no head; nothing to fetch.'));
+        return;
+    }
+    if (onchain.sealPolicyId && repoCfg.seal_policy_id !== onchain.sealPolicyId) {
+        repoCfg.seal_policy_id = onchain.sealPolicyId;
+        await promises_1.default.writeFile(path_1.default.join(witPath, 'config.json'), JSON.stringify(repoCfg, null, 2) + '\n', 'utf8');
+    }
+    // Download manifest and commit for validation/cache
+    const manifest = await loadManifestCached(walrusSvc, witPath, onchain.headManifest);
+    const computedRoot = (0, manifest_1.computeRootHash)(Object.fromEntries(Object.entries(manifest.files).map(([rel, meta]) => [
+        rel,
+        { hash: meta.hash, size: meta.size, mode: meta.mode, mtime: meta.mtime },
+    ])));
+    if (computedRoot !== manifest.root_hash) {
+        throw new Error('Manifest root_hash mismatch; aborting fetch.');
+    }
+    const commit = await loadCommitCached(walrusSvc, witPath, onchain.headCommit);
+    if (commit.tree.root_hash !== manifest.root_hash) {
+        throw new Error('Commit root_hash does not match manifest; aborting fetch.');
+    }
+    // Download commit chain (and manifests) for history
+    const map = await readCommitIdMapSafe(witPath);
+    await downloadCommitChain(walrusSvc, onchain.headCommit, witPath, map);
+    await (0, state_1.writeCommitIdMap)(witPath, map);
+    // Update remote refs/state
+    await (0, repo_1.writeRemoteRef)(witPath, onchain.headCommit);
+    await (0, repo_1.writeRemoteState)(witPath, {
+        repo_id: repoCfg.repo_id,
+        head_commit: onchain.headCommit,
+        head_manifest: onchain.headManifest,
+        head_quilt: onchain.headQuilt,
+        version: onchain.version,
+    });
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.green('Fetch complete (worktree unchanged).'));
+    // eslint-disable-next-line no-console
+    console.log(`Head: ${ui_1.colors.hash(onchain.headCommit)}`);
+    // eslint-disable-next-line no-console
+    console.log(`Manifest: ${ui_1.colors.hash(onchain.headManifest)}`);
+    // eslint-disable-next-line no-console
+    console.log(`Quilt: ${ui_1.colors.hash(onchain.headQuilt)}`);
+}
+async function cacheJson(filePath, content) {
+    await promises_1.default.mkdir(path_1.default.dirname(filePath), { recursive: true });
+    await promises_1.default.writeFile(filePath, content, 'utf8');
+}
+function parseRemoteCommit(buf) {
+    const parsed = JSON.parse(buf.toString('utf8'));
+    if (!parsed?.tree?.root_hash || !parsed?.tree?.manifest_id) {
+        throw new Error('Invalid remote commit object');
+    }
+    return parsed;
+}
+async function readCommitIdMapSafe(witPath) {
+    try {
+        return await (0, state_1.readCommitIdMap)(witPath);
+    }
+    catch {
+        return {};
+    }
+}
+async function loadManifestCached(walrusSvc, witPath, manifestId) {
+    const file = path_1.default.join(witPath, 'objects', 'manifests', `${(0, state_1.idToFileName)(manifestId)}.json`);
+    try {
+        const raw = await promises_1.default.readFile(file, 'utf8');
+        return schema_1.ManifestSchema.parse(JSON.parse(raw));
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT') {
+            // fall through to re-download if parse failed
+        }
+    }
+    const buf = Buffer.from(await walrusSvc.readBlob(manifestId));
+    const manifest = schema_1.ManifestSchema.parse(JSON.parse(buf.toString('utf8')));
+    await cacheJson(file, (0, serialize_1.canonicalStringify)(manifest));
+    return manifest;
+}
+async function loadCommitCached(walrusSvc, witPath, commitId) {
+    const file = path_1.default.join(witPath, 'objects', 'commits', `${(0, state_1.idToFileName)(commitId)}.json`);
+    try {
+        const raw = await promises_1.default.readFile(file, 'utf8');
+        return parseRemoteCommit(Buffer.from(raw, 'utf8'));
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT') {
+            // fall through to re-download if parse failed
+        }
+    }
+    const buf = Buffer.from(await walrusSvc.readBlob(commitId));
+    const commit = parseRemoteCommit(buf);
+    await cacheJson(file, buf.toString('utf8'));
+    return commit;
+}
+async function downloadCommitChain(walrusSvc, startId, witPath, map) {
+    const seen = new Set();
+    let current = startId;
+    while (current && !seen.has(current)) {
+        seen.add(current);
+        const commit = await loadCommitCached(walrusSvc, witPath, current);
+        if (!map[current]) {
+            map[current] = current;
+        }
+        if (commit.tree?.manifest_id) {
+            await ensureManifestCached(walrusSvc, witPath, commit.tree.manifest_id, commit.tree.root_hash);
+        }
+        current = commit.parent;
+    }
+}
+async function ensureManifestCached(walrusSvc, witPath, manifestId, expectedRoot) {
+    const file = path_1.default.join(witPath, 'objects', 'manifests', `${(0, state_1.idToFileName)(manifestId)}.json`);
+    try {
+        await promises_1.default.access(file);
+        const raw = await promises_1.default.readFile(file, 'utf8');
+        const manifest = schema_1.ManifestSchema.parse(JSON.parse(raw));
+        const computed = (0, manifest_1.computeRootHash)(Object.fromEntries(Object.entries(manifest.files).map(([rel, meta]) => [
+            rel,
+            { hash: meta.hash, size: meta.size, mode: meta.mode, mtime: meta.mtime },
+        ])));
+        if (computed === expectedRoot)
+            return;
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT') {
+            // fall through to refetch
+        }
+    }
+    // Fetch from Walrus
+    const buf = Buffer.from(await walrusSvc.readBlob(manifestId));
+    const manifest = schema_1.ManifestSchema.parse(JSON.parse(buf.toString('utf8')));
+    const computed = (0, manifest_1.computeRootHash)(Object.fromEntries(Object.entries(manifest.files).map(([rel, meta]) => [
+        rel,
+        { hash: meta.hash, size: meta.size, mode: meta.mode, mtime: meta.mtime },
+    ])));
+    if (computed !== expectedRoot) {
+        throw new Error('Fetched manifest root_hash mismatch; aborting.');
+    }
+    await cacheJson(file, (0, serialize_1.canonicalStringify)(manifest));
+}

package/dist/commands/init.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAction = initAction;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const keys_1 = require("../lib/keys");
+const DEFAULT_RELAYS = ['https://upload-relay.testnet.walrus.space'];
+const DEFAULT_NETWORK = 'testnet';
+const IGNORE_ENTRIES = ['.wit/', '~/.wit/keys', '.env.local', '*.pem', '.wit/seal'];
+async function initAction(name, options) {
+    const cwd = process.cwd();
+    const repoName = name || path_1.default.basename(cwd);
+    const witDir = path_1.default.join(cwd, '.wit');
+    await promises_1.default.mkdir(witDir, { recursive: true });
+    await ensureLayout(witDir);
+    const globalCfg = await readGlobalConfig();
+    const activeAddress = await (0, keys_1.readActiveAddress)();
+    const repoCfg = buildRepoConfig(repoName, globalCfg, activeAddress);
+    const wantsPrivate = options?.private || Boolean(options?.sealPolicy || options?.sealSecret);
+    if (wantsPrivate) {
+        // We mark it as pending. The actual policy ID will be generated on-chain during 'wit push'.
+        repoCfg.seal_policy_id = 'pending';
+        // eslint-disable-next-line no-console
+        console.log('Initialized as PRIVATE repository. Encryption will be enabled on first push.');
+    }
+    await writeConfigIfMissing(path_1.default.join(witDir, 'config.json'), repoCfg);
+    await ensureFile(path_1.default.join(witDir, 'HEAD'), 'refs/heads/main\n');
+    await ensureFile(path_1.default.join(witDir, 'refs', 'heads', 'main'), '');
+    await ensureFile(path_1.default.join(witDir, 'index'), '{}\n');
+    await ensureIgnoreFile(path_1.default.join(cwd, '.gitignore'), IGNORE_ENTRIES);
+    await ensureIgnoreFile(path_1.default.join(cwd, '.witignore'), IGNORE_ENTRIES);
+    // eslint-disable-next-line no-console
+    console.log(`Initialized wit repo scaffold in ${witDir}`);
+}
+async function ensureLayout(witDir) {
+    const subdirs = [
+        'refs/heads',
+        'refs/remotes',
+        'objects/blobs',
+        'objects/commits',
+        'objects/manifests',
+        'objects/quilts',
+        'objects/maps',
+        'state',
+    ];
+    await Promise.all(subdirs.map((dir) => promises_1.default.mkdir(path_1.default.join(witDir, dir), { recursive: true })));
+}
+async function readGlobalConfig() {
+    const home = process.env.HOME;
+    if (!home)
+        return {};
+    const file = path_1.default.join(home, '.witconfig');
+    try {
+        const raw = await promises_1.default.readFile(file, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return {};
+        // eslint-disable-next-line no-console
+        console.warn(`Warning: could not read ${file}: ${err.message}`);
+        return {};
+    }
+}
+function buildRepoConfig(repoName, globalCfg, activeAddress) {
+    return {
+        repo_name: repoName,
+        repo_id: null,
+        network: globalCfg.network || DEFAULT_NETWORK,
+        relays: globalCfg.relays?.length ? globalCfg.relays : DEFAULT_RELAYS,
+        author: globalCfg.author || 'unknown',
+        key_alias: globalCfg.key_alias || 'default',
+        seal_policy_id: null,
+        created_at: new Date().toISOString(),
+    };
+}
+async function writeConfigIfMissing(file, cfg) {
+    try {
+        await promises_1.default.access(file);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT') {
+            await promises_1.default.writeFile(file, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+        }
+        else {
+            throw err;
+        }
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(`Config already exists, left untouched: ${file}`);
+}
+async function ensureFile(file, content = '') {
+    try {
+        await promises_1.default.access(file);
+        return;
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT')
+            throw err;
+    }
+    await promises_1.default.writeFile(file, content, 'utf8');
+}
+async function ensureIgnoreFile(file, entries) {
+    let existing = [];
+    try {
+        const raw = await promises_1.default.readFile(file, 'utf8');
+        existing = raw.split(/\r?\n/);
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT')
+            throw err;
+    }
+    const lines = existing.filter((line) => line.trim() !== '');
+    for (const entry of entries) {
+        if (!lines.includes(entry)) {
+            lines.push(entry);
+        }
+    }
+    const content = lines.join('\n') + '\n';
+    await promises_1.default.writeFile(file, content, 'utf8');
+}

package/dist/commands/invite.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inviteAction = inviteAction;
+const client_1 = require("@mysten/sui/client");
+const ui_1 = require("../lib/ui");
+const repo_1 = require("../lib/repo");
+const walrus_1 = require("../lib/walrus");
+const keys_1 = require("../lib/keys");
+const suiRepo_1 = require("../lib/suiRepo");
+async function inviteAction(address) {
+    if (!address) {
+        throw new Error('Usage: wit invite <address>');
+    }
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.header('Adding collaborator...'));
+    let witPath;
+    try {
+        witPath = await (0, repo_1.requireWitDir)();
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.red(err?.message || 'Not a wit repository. Run `wit init` first.'));
+        return;
+    }
+    const repoCfg = await (0, repo_1.readRepoConfig)(witPath);
+    if (!repoCfg.repo_id) {
+        throw new Error('Missing repo_id. Run `wit push` once to create the remote repository.');
+    }
+    const signerInfo = await (0, keys_1.loadSigner)();
+    const resolved = await (0, walrus_1.resolveWalrusConfig)(process.cwd());
+    const suiClient = new client_1.SuiClient({ url: resolved.suiRpcUrl });
+    // Check if repo is private by fetching on-chain state
+    // We could rely on local config, but on-chain is truth.
+    let whitelistId;
+    try {
+        const state = await (0, suiRepo_1.fetchRepositoryState)(suiClient, repoCfg.repo_id);
+        if (state.sealPolicyId) {
+            whitelistId = state.sealPolicyId;
+            // Update local config if missing
+            if (repoCfg.seal_policy_id !== whitelistId) {
+                repoCfg.seal_policy_id = whitelistId;
+                await (0, repo_1.writeRepoConfig)(witPath, repoCfg);
+            }
+        }
+    }
+    catch (err) {
+        // ignore fetch error, assume public or will fail later
+    }
+    try {
+        await (0, suiRepo_1.addCollaborator)(suiClient, signerInfo.signer, {
+            repoId: repoCfg.repo_id,
+            collaborator: address,
+            whitelistId
+        });
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.green(`Added ${ui_1.colors.hash(address)} as collaborator.`));
+        if (whitelistId) {
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.cyan(`User added to Whitelist (${whitelistId}). They can now decrypt the repository.`));
+        }
+    }
+    catch (err) {
+        const msg = err?.message || String(err);
+        if (msg.includes('ENotAuthorized') || msg.includes('NotAuthorized')) {
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.red('Add failed: current account is not authorized (owner or collaborator required).'));
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.red(`Add collaborator failed: ${msg}`));
+    }
+}

package/dist/commands/list.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAction = listAction;
+const client_1 = require("@mysten/sui/client");
+const keys_1 = require("../lib/keys");
+const walrus_1 = require("../lib/walrus");
+const constants_1 = require("../lib/constants");
+const suiRepo_1 = require("../lib/suiRepo");
+async function listAction(options) {
+    const signer = await (0, keys_1.loadSigner)();
+    const address = signer.address;
+    console.log(`Listing repositories for ${address}...`);
+    const config = await (0, walrus_1.resolveWalrusConfig)();
+    const client = new client_1.SuiClient({ url: config.suiRpcUrl });
+    const repos = new Map();
+    // Helper to fetch events
+    const fetchEvents = async (query) => {
+        let cursor = null;
+        let hasNextPage = true;
+        const results = [];
+        while (hasNextPage) {
+            const resp = await client.queryEvents({
+                query,
+                cursor,
+                limit: 50,
+            });
+            results.push(...resp.data);
+            cursor = resp.nextCursor;
+            hasNextPage = resp.hasNextPage;
+        }
+        return results;
+    };
+    // 1. Fetch Owned Repos (Filter by Sender = Me)
+    if (!options.collaborated) {
+        try {
+            const createdEvents = await fetchEvents({
+                Sender: address,
+            });
+            const ownershipEvents = await fetchEvents({
+                MoveEventType: `${constants_1.WIT_PACKAGE_ID}::${constants_1.WIT_MODULE_NAME}::OwnershipTransferredEvent`,
+            });
+            for (const event of createdEvents) {
+                if (event.type === `${constants_1.WIT_PACKAGE_ID}::${constants_1.WIT_MODULE_NAME}::RepositoryCreatedEvent`) {
+                    const parsed = event.parsedJson;
+                    repos.set(parsed.repo_id, {
+                        id: parsed.repo_id,
+                        name: (0, suiRepo_1.decodeVecAsString)(parsed.name) || 'Unknown',
+                        role: 'Owner',
+                    });
+                }
+            }
+            for (const event of ownershipEvents) {
+                const parsed = event.parsedJson;
+                if (parsed.new_owner !== address)
+                    continue;
+                const repoId = parsed.repo_id;
+                const existing = repos.get(repoId);
+                if (existing) {
+                    existing.role = 'Owner';
+                }
+                else {
+                    repos.set(repoId, {
+                        id: repoId,
+                        name: 'Loading...',
+                        role: 'Owner',
+                    });
+                }
+            }
+        }
+        catch (e) {
+            console.warn('Failed to fetch owned repositories:', e);
+        }
+    }
+    // 2. Collaborators: process add/remove events to derive membership
+    if (!options.owned) {
+        try {
+            const addedEvents = await fetchEvents({
+                MoveEventType: `${constants_1.WIT_PACKAGE_ID}::${constants_1.WIT_MODULE_NAME}::CollaboratorAddedEvent`,
+            });
+            const removedEvents = await fetchEvents({
+                MoveEventType: `${constants_1.WIT_PACKAGE_ID}::${constants_1.WIT_MODULE_NAME}::CollaboratorRemovedEvent`,
+            });
+            const events = [];
+            for (const e of addedEvents) {
+                const parsed = e.parsedJson;
+                if (parsed.user_address !== address)
+                    continue;
+                events.push({
+                    kind: 'add',
+                    repoId: parsed.repo_id,
+                    ts: Number(e.timestampMs ?? 0),
+                    tx: e.id?.txDigest ?? '',
+                    seq: BigInt(e.id?.eventSeq ?? 0),
+                });
+            }
+            for (const e of removedEvents) {
+                const parsed = e.parsedJson;
+                if (parsed.user_address !== address)
+                    continue;
+                events.push({
+                    kind: 'remove',
+                    repoId: parsed.repo_id,
+                    ts: Number(e.timestampMs ?? 0),
+                    tx: e.id?.txDigest ?? '',
+                    seq: BigInt(e.id?.eventSeq ?? 0),
+                });
+            }
+            events.sort((a, b) => {
+                if (a.ts !== b.ts)
+                    return a.ts - b.ts;
+                if (a.tx !== b.tx)
+                    return a.tx.localeCompare(b.tx);
+                return a.seq < b.seq ? -1 : a.seq > b.seq ? 1 : 0;
+            });
+            const membership = new Map();
+            for (const ev of events) {
+                if (ev.kind === 'add')
+                    membership.set(ev.repoId, true);
+                else
+                    membership.set(ev.repoId, false);
+            }
+            for (const [repoId, present] of membership.entries()) {
+                if (!present)
+                    continue;
+                if (!repos.has(repoId)) {
+                    repos.set(repoId, {
+                        id: repoId,
+                        name: 'Loading...', // Placeholder, will fetch below
+                        role: 'Collaborator',
+                    });
+                }
+            }
+        }
+        catch (e) {
+            console.warn('Failed to fetch collaborated repositories:', e);
+        }
+    }
+    // 3. Fetch missing names for collaborated repos
+    const missingNames = Array.from(repos.values()).filter((r) => r.name === 'Loading...');
+    if (missingNames.length > 0) {
+        const ids = missingNames.map((r) => r.id);
+        const chunkSize = 50;
+        for (let i = 0; i < ids.length; i += chunkSize) {
+            const chunk = ids.slice(i, i + chunkSize);
+            try {
+                const objects = await client.multiGetObjects({
+                    ids: chunk,
+                    options: { showContent: true },
+                });
+                for (const obj of objects) {
+                    if (obj.data?.content?.dataType === 'moveObject') {
+                        const fields = obj.data.content.fields;
+                        const name = (0, suiRepo_1.decodeVecAsString)(fields.name) || 'Unknown';
+                        const r = repos.get(obj.data.objectId);
+                        if (r)
+                            r.name = name;
+                    }
+                }
+            }
+            catch (e) {
+                console.warn('Failed to fetch repo details:', e);
+            }
+        }
+    }
+    // 4. Re-evaluate roles against current on-chain state (handles ownership transfer/removal)
+    const allRepoIds = Array.from(repos.keys());
+    if (allRepoIds.length) {
+        const chunkSize = 50;
+        for (let i = 0; i < allRepoIds.length; i += chunkSize) {
+            const chunk = allRepoIds.slice(i, i + chunkSize);
+            try {
+                const objects = await client.multiGetObjects({
+                    ids: chunk,
+                    options: { showContent: true },
+                });
+                for (const obj of objects) {
+                    const rec = repos.get(obj.data?.objectId || '');
+                    if (!rec)
+                        continue;
+                    if (obj.data?.content?.dataType !== 'moveObject') {
+                        repos.delete(rec.id);
+                        continue;
+                    }
+                    const fields = obj.data.content.fields;
+                    const owner = fields.owner;
+                    const collaborators = fields.collaborators || [];
+                    const isOwner = owner === address;
+                    const isCollab = collaborators.includes(address);
+                    if (isOwner) {
+                        rec.role = 'Owner';
+                    }
+                    else if (isCollab) {
+                        rec.role = 'Collaborator';
+                    }
+                    else {
+                        repos.delete(rec.id);
+                    }
+                    if ((!rec.name || rec.name === 'Loading...') && fields.name) {
+                        rec.name = (0, suiRepo_1.decodeVecAsString)(fields.name) || rec.name;
+                    }
+                }
+            }
+            catch (e) {
+                console.warn('Failed to reconcile roles from objects:', e);
+            }
+        }
+    }
+    if (repos.size === 0) {
+        console.log('No repositories found.');
+        return;
+    }
+    const list = Array.from(repos.values()).sort((a, b) => a.name.localeCompare(b.name));
+    console.table(list);
+}

package/dist/commands/plumbing.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushBlobAction = pushBlobAction;
+exports.pullBlobAction = pullBlobAction;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const ui_1 = require("../lib/ui");
+const walrus_1 = require("../lib/walrus");
+const keys_1 = require("../lib/keys");
+async function pushBlobAction(filePath, opts) {
+    const fullPath = path_1.default.resolve(process.cwd(), filePath);
+    try {
+        await promises_1.default.access(fullPath);
+    }
+    catch {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const content = await promises_1.default.readFile(fullPath);
+    const hash = (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+    const size = content.length;
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.gray(`File: ${filePath} (${size} bytes)`));
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.gray(`SHA-256: ${hash}`));
+    const { signer, address } = await (0, keys_1.loadSigner)();
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.gray(`Signer: ${ui_1.colors.hash(address)}`));
+    const resources = await (0, keys_1.checkResources)(address);
+    if (resources.error) {
+        console.warn(ui_1.colors.yellow(`Warning: Failed to check resources: ${resources.error}`));
+    }
+    else if (resources.hasMinSui === false) {
+        throw new Error(`Insufficient SUI balance. Need at least 1 SUI.`);
+    }
+    const epochs = opts.epochs ? parseInt(opts.epochs, 10) : 1;
+    if (isNaN(epochs) || epochs < 1) {
+        throw new Error('Epochs must be a positive integer.');
+    }
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.blue(`Uploading to Walrus (epochs=${epochs})...`));
+    const service = await walrus_1.WalrusService.fromRepo();
+    const result = await service.writeBlob({
+        blob: content,
+        signer,
+        epochs,
+    });
+    const blobId = result.blobId;
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.green(`Blob ID: ${blobId}`));
+    if (result.blobObject?.id?.id) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.gray(`Sui Object: ${result.blobObject.id.id}`));
+    }
+}
+async function pullBlobAction(blobId, opts) {
+    if (!blobId) {
+        throw new Error('Blob ID is required.');
+    }
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.blue(`Downloading blob ${blobId}...`));
+    const service = await walrus_1.WalrusService.fromRepo();
+    let content;
+    try {
+        content = await service.readBlob(blobId);
+    }
+    catch (err) {
+        throw new Error(`Failed to download blob: ${err.message}`);
+    }
+    const hash = (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.gray(`Downloaded ${content.length} bytes`));
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.gray(`SHA-256: ${hash}`));
+    if (opts.out) {
+        const outPath = path_1.default.resolve(process.cwd(), opts.out);
+        await promises_1.default.writeFile(outPath, content);
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.green(`Saved to ${opts.out}`));
+    }
+    else {
+        // Try to detect if binary
+        const isBinary = content.some((b) => b === 0);
+        if (isBinary) {
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.yellow('Binary content suppressed. Use --out to save to file.'));
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.header('Content:'));
+            // eslint-disable-next-line no-console
+            console.log(new TextDecoder().decode(content));
+        }
+    }
+}