withub-cli 0.1.0

package/dist/commands/pull.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pullAction = pullAction;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const ui_1 = require("../lib/ui");
+const repo_1 = require("../lib/repo");
+const fetch_1 = require("./fetch");
+const checkout_1 = require("./checkout");
+const state_1 = require("../lib/state");
+const fs_1 = require("../lib/fs");
+const schema_1 = require("../lib/schema");
+const manifest_1 = require("../lib/manifest");
+const walrus_1 = require("../lib/walrus");
+async function pullAction() {
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.header('Starting pull...'));
+    const witPath = await (0, repo_1.requireWitDir)();
+    const headRefPathInitial = await (0, state_1.readHeadRefPath)(witPath);
+    const localHeadInitial = await (0, state_1.readRef)(headRefPathInitial);
+    const cleanResult = await ensureCleanWorktree(witPath, localHeadInitial);
+    if (!cleanResult.ok) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.red(cleanResult.reason));
+        return;
+    }
+    // Update remote metadata
+    await (0, fetch_1.fetchAction)();
+    const headRefPath = await (0, state_1.readHeadRefPath)(witPath);
+    const localHead = await (0, state_1.readRef)(headRefPath);
+    const remoteHead = await (0, repo_1.readRemoteRef)(witPath);
+    if (!remoteHead) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.yellow('Remote has no head; nothing to pull.'));
+        return;
+    }
+    if (localHead === remoteHead) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.green('Already up to date.'));
+        return;
+    }
+    const canFastForward = !localHead || (await isAncestor(witPath, localHead, remoteHead));
+    if (!canFastForward) {
+        throw new Error('Local history diverged; pull requires fast-forward. Please reset or clone.');
+    }
+    // Fast-forward by checking out remote head
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`Fast-forwarding to ${remoteHead} ...`));
+    const ok = await (0, checkout_1.checkoutAction)(remoteHead);
+    if (!ok) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.red('Pull aborted (checkout failed).'));
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.green('Pull complete.'));
+}
+async function ensureCleanWorktree(witPath, localHead) {
+    const indexPath = path_1.default.join(witPath, 'index');
+    const index = await (0, fs_1.readIndex)(indexPath);
+    const ig = await (0, fs_1.buildIgnore)(process.cwd());
+    const tracked = new Set(Object.keys(index));
+    const workspaceFiles = await (0, fs_1.walkFiles)(process.cwd(), ig, process.cwd(), tracked);
+    const workspaceMeta = {};
+    for (const file of workspaceFiles) {
+        const rel = (0, fs_1.pathToPosix)(path_1.default.relative(process.cwd(), file));
+        workspaceMeta[rel] = await (0, fs_1.computeFileMeta)(file);
+    }
+    for (const [rel, meta] of Object.entries(workspaceMeta)) {
+        const indexed = index[rel];
+        if (!indexed)
+            return { ok: false, reason: 'Worktree has untracked files; clean or commit before pull.' };
+        if (indexed.hash !== meta.hash || indexed.size !== meta.size || indexed.mode !== meta.mode) {
+            return { ok: false, reason: 'Worktree has modifications; clean or commit before pull.' };
+        }
+    }
+    for (const rel of Object.keys(index)) {
+        if (!workspaceMeta[rel]) {
+            return { ok: false, reason: 'Worktree has deletions; clean or commit before pull.' };
+        }
+    }
+    // Ensure index matches local HEAD (no staged changes)
+    if (localHead) {
+        const headCommit = await (0, state_1.readCommitById)(witPath, localHead);
+        const headFiles = await loadHeadFiles(witPath, headCommit);
+        if (headFiles && !sameFiles(index, headFiles)) {
+            return { ok: false, reason: 'Index differs from HEAD; clean or reset before pull.' };
+        }
+    }
+    return { ok: true };
+}
+function sameFiles(a, b) {
+    const keysA = Object.keys(a).sort();
+    const keysB = Object.keys(b).sort();
+    if (keysA.length !== keysB.length)
+        return false;
+    for (let i = 0; i < keysA.length; i += 1) {
+        if (keysA[i] !== keysB[i])
+            return false;
+        const ma = a[keysA[i]];
+        const mb = b[keysA[i]];
+        if (!mb || ma.hash !== mb.hash || ma.size !== mb.size || ma.mode !== mb.mode)
+            return false;
+    }
+    return true;
+}
+async function isAncestor(witPath, ancestorId, descendantId) {
+    let current = descendantId;
+    const visited = new Set();
+    while (current && !visited.has(current)) {
+        if (current === ancestorId)
+            return true;
+        visited.add(current);
+        const commit = await (0, state_1.readCommitById)(witPath, current);
+        current = commit.parent;
+    }
+    return false;
+}
+async function loadHeadFiles(witPath, commit) {
+    if (commit.tree?.files && Object.keys(commit.tree.files).length) {
+        return commit.tree.files;
+    }
+    const manifestId = commit.tree?.manifest_id;
+    if (!manifestId)
+        return null;
+    const file = path_1.default.join(witPath, 'objects', 'manifests', `${manifestIdToFile(manifestId)}.json`);
+    let manifest = null;
+    try {
+        const raw = await promises_1.default.readFile(file, 'utf8');
+        manifest = schema_1.ManifestSchema.parse(JSON.parse(raw));
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT')
+            throw err;
+    }
+    if (!manifest) {
+        const walrusSvc = await walrus_1.WalrusService.fromRepo();
+        const buf = Buffer.from(await walrusSvc.readBlob(manifestId));
+        manifest = schema_1.ManifestSchema.parse(JSON.parse(buf.toString('utf8')));
+        await promises_1.default.mkdir(path_1.default.dirname(file), { recursive: true });
+        await promises_1.default.writeFile(file, canonicalManifest(manifest), '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 (commit.tree?.root_hash && commit.tree.root_hash !== computed) {
+        return null;
+    }
+    return manifest.files;
+}
+function manifestIdToFile(id) {
+    return id.replace(/\//g, '_').replace(/\+/g, '-');
+}
+function canonicalManifest(m) {
+    return JSON.stringify(m, null, 2) + '\n';
+}

package/dist/commands/push.js

@@ -0,0 +1,371 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushAction = pushAction;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const client_1 = require("@mysten/sui/client");
+const walrus_1 = require("@mysten/walrus");
+const ui_1 = require("../lib/ui");
+const manifest_1 = require("../lib/manifest");
+const serialize_1 = require("../lib/serialize");
+const fs_1 = require("../lib/fs");
+const state_1 = require("../lib/state");
+const repo_1 = require("../lib/repo");
+const walrus_2 = require("../lib/walrus");
+const keys_1 = require("../lib/keys");
+const suiRepo_1 = require("../lib/suiRepo");
+const schema_1 = require("../lib/schema");
+const seal_1 = require("../lib/seal");
+const constants_1 = require("../lib/constants");
+async function pushAction() {
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.header('Starting push...'));
+    const witPath = await (0, repo_1.requireWitDir)();
+    const repoCfg = await (0, repo_1.readRepoConfig)(witPath);
+    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, keys_1.loadSigner)();
+    await ensureAuthorOrSetDefault(witPath, repoCfg, signerInfo.address);
+    const resourcesOk = await assertResourcesOk(signerInfo.address);
+    if (!resourcesOk)
+        return;
+    const headCommit = await (0, state_1.readCommitById)(witPath, headId);
+    const computedRoot = (0, manifest_1.computeRootHash)(headCommit.tree.files);
+    if (computedRoot !== headCommit.tree.root_hash) {
+        throw new Error('HEAD root_hash does not match file list. Re-commit or fix index.');
+    }
+    const commitMap = await (0, state_1.readCommitIdMap)(witPath);
+    const { chain, baseRemoteId } = await collectChain(witPath, headId, commitMap);
+    const resolved = await (0, walrus_2.resolveWalrusConfig)(process.cwd());
+    const suiClient = new client_1.SuiClient({ url: resolved.suiRpcUrl });
+    let createdRepo = false;
+    let repoId = repoCfg.repo_id;
+    if (!repoId) {
+        const isPrivate = repoCfg.seal_policy_id === 'pending' || !!repoCfg.seal_policy_id;
+        repoId = await (0, suiRepo_1.createRepository)(suiClient, signerInfo.signer, {
+            name: repoCfg.repo_name,
+            description: repoCfg.repo_name,
+            isPrivate: isPrivate,
+        });
+        repoCfg.repo_id = repoId;
+        createdRepo = true;
+        await (0, repo_1.writeRepoConfig)(witPath, repoCfg);
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.green(`Created on-chain repository ${repoId}`));
+    }
+    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;
+        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;
+    if (onchainState.headCommit && baseRemoteId !== onchainState.headCommit) {
+        throw new Error('Remote head diverges from local history; run `wit pull`/`fetch` or reset first.');
+    }
+    const existingHeadRemote = commitMap[headId];
+    if (existingHeadRemote && onchainState.headCommit === existingHeadRemote) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.green('Remote already up to date; nothing to push.'));
+        return;
+    }
+    // Align parent expectations with on-chain head when possible
+    const parentRemoteHint = headCommit.parent ? commitMap[headCommit.parent] : null;
+    let parentAnchor = baseRemoteId;
+    if (onchainState.headCommit) {
+        if (!parentAnchor && parentRemoteHint === onchainState.headCommit) {
+            parentAnchor = onchainState.headCommit;
+        }
+        else if (parentAnchor && parentAnchor !== onchainState.headCommit) {
+            throw new Error('Remote head diverges from local history; run `wit pull`/`fetch` or reset first.');
+        }
+    }
+    const walrusSvc = await walrus_2.WalrusService.fromRepo();
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`Commits to upload: ${chain.length}`));
+    let parentRemoteId = parentAnchor ?? onchainState.headCommit ?? null;
+    let lastManifestId = null;
+    let lastQuiltId = null;
+    let lastCommitRemoteId = null;
+    const nextMap = { ...commitMap };
+    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}`));
+        const uploaded = await uploadCommitSnapshot(witPath, item.id, item.commit, parentRemoteId, walrusSvc, signerInfo.signer, currentPolicyId, suiClient);
+        if (!uploaded) {
+            // Upload failed with friendly message already printed
+            return;
+        }
+        nextMap[item.id] = uploaded.commitId;
+        parentRemoteId = uploaded.commitId;
+        lastManifestId = uploaded.manifestId;
+        lastQuiltId = uploaded.quiltId;
+        lastCommitRemoteId = uploaded.commitId;
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.green(`Uploaded commit ${item.id} -> ${uploaded.commitId}`));
+    }
+    if (!lastCommitRemoteId || !lastManifestId || !lastQuiltId) {
+        throw new Error('Missing push artifacts; cannot update remote head.');
+    }
+    await (0, state_1.writeCommitIdMap)(witPath, nextMap);
+    await (0, suiRepo_1.updateRepositoryHead)(suiClient, signerInfo.signer, {
+        repoId,
+        commitId: lastCommitRemoteId,
+        manifestId: lastManifestId,
+        quiltId: lastQuiltId,
+        expectedVersion: onchainState.version,
+        parentCommit: onchainState.headCommit,
+    });
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan('On-chain head updated'));
+    const updatedRemote = {
+        repo_id: repoId,
+        head_commit: lastCommitRemoteId,
+        head_manifest: lastManifestId,
+        head_quilt: lastQuiltId,
+        version: 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 complete'));
+    // eslint-disable-next-line no-console
+    console.log(`Remote head: ${ui_1.colors.hash(lastCommitRemoteId)}`);
+    // eslint-disable-next-line no-console
+    console.log(`Manifest: ${ui_1.colors.hash(lastManifestId)}`);
+    // eslint-disable-next-line no-console
+    console.log(`Quilt: ${ui_1.colors.hash(lastQuiltId)}`);
+    if (createdRepo) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.cyan('Initial push: repository created on chain and remote state recorded.'));
+    }
+}
+async function collectChain(witPath, headId, map) {
+    const chain = [];
+    let cursor = headId;
+    let baseRemoteId = null;
+    while (cursor) {
+        const commit = await (0, state_1.readCommitById)(witPath, cursor);
+        chain.unshift({ id: cursor, commit });
+        if (!commit.parent) {
+            baseRemoteId = null;
+            break;
+        }
+        const mapped = map[commit.parent];
+        if (mapped) {
+            baseRemoteId = mapped;
+            break;
+        }
+        cursor = commit.parent;
+    }
+    return { chain, baseRemoteId };
+}
+async function uploadCommitSnapshot(witPath, localCommitId, commit, parentRemoteId, walrusSvc, signer, policyId, suiClient) {
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan('  Building and verifying file snapshot...'));
+    const entries = Object.entries(commit.tree.files).sort((a, b) => a[0].localeCompare(b[0]));
+    const files = [];
+    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} (${meta.hash}); ensure index is complete.`);
+        }
+        const computed = (0, serialize_1.sha256Base64)(buf);
+        if (computed !== meta.hash || buf.length !== meta.size) {
+            throw new Error(`File verification failed for ${rel}; re-add and retry.`);
+        }
+        files.push({ rel, meta, data: buf });
+    }
+    // Prepare blobs (encrypt if policyId is present)
+    const walrusBlobs = await Promise.all(files.map(async ({ rel, data, meta }) => {
+        let contents = data;
+        let enc;
+        if (policyId) {
+            const encrypted = await (0, seal_1.encryptWithSeal)(data, policyId, constants_1.WIT_PACKAGE_ID, suiClient);
+            contents = encrypted.cipher;
+            enc = encrypted.meta;
+        }
+        return {
+            contents,
+            identifier: rel,
+            tags: {
+                hash: meta.hash,
+                size: String(meta.size),
+                mode: meta.mode,
+                mtime: String(meta.mtime),
+                ...(enc
+                    ? {
+                        enc_alg: enc.alg,
+                        enc_iv: enc.iv,
+                        enc_tag: enc.tag,
+                        enc_policy: enc.policy_id,
+                        enc_package: enc.package_id,
+                        enc_sealed_key: enc.sealed_session_key,
+                        enc_size: String(contents.length),
+                    }
+                    : {}),
+            },
+            enc,
+        };
+    }));
+    const encMetas = walrusBlobs.map((b) => b.enc);
+    const walrusInputs = walrusBlobs.map(({ contents, identifier, tags }) => ({ contents, identifier, tags }));
+    const quiltRes = await tryWithRetry(() => walrusSvc.writeQuilt({
+        blobs: walrusInputs,
+        signer,
+        epochs: 1,
+        deletable: true,
+    }));
+    if (!quiltRes)
+        return null;
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`  Quilt uploaded: ${quiltRes.quiltId}`));
+    const walrusFiles = walrusBlobs.map((b) => walrus_1.WalrusFile.from({
+        contents: b.contents,
+        identifier: b.identifier,
+        tags: b.tags,
+    }));
+    const filesRes = await tryWithRetry(() => walrusSvc.getClient().writeFiles({ files: walrusFiles, signer, epochs: 1, deletable: true }));
+    if (!filesRes)
+        return null;
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan('  File index written to Walrus'));
+    const rootHash = (0, manifest_1.computeRootHash)(commit.tree.files);
+    if (rootHash !== commit.tree.root_hash) {
+        throw new Error(`Commit ${localCommitId} root_hash mismatch; recommit or fix index.`);
+    }
+    const manifest = schema_1.ManifestSchema.parse({
+        version: 1,
+        quilt_id: quiltRes.quiltId,
+        root_hash: rootHash,
+        files: Object.fromEntries(files.map(({ rel, meta }, idx) => {
+            const enc = encMetas[idx];
+            return [
+                rel,
+                {
+                    ...meta,
+                    id: filesRes[idx]?.id || filesRes[idx]?.blobId || filesRes[idx]?.blob_id || '',
+                    ...(enc ? { enc: enc } : {}),
+                },
+            ];
+        })),
+    });
+    const manifestSerialized = (0, serialize_1.canonicalStringify)(manifest);
+    const manifestUpload = await walrusSvc.writeBlob({
+        blob: Buffer.from(manifestSerialized),
+        signer,
+        epochs: 1,
+        deletable: true,
+    });
+    const manifestId = manifestUpload.blobId;
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`  Manifest uploaded: ${manifestId}`));
+    await cacheJson(path_1.default.join(witPath, 'objects', 'manifests', `${(0, state_1.idToFileName)(manifestId)}.json`), manifestSerialized);
+    const remoteCommit = {
+        tree: {
+            root_hash: commit.tree.root_hash,
+            manifest_id: manifestId,
+            quilt_id: quiltRes.quiltId,
+        },
+        parent: parentRemoteId,
+        author: commit.author,
+        message: commit.message,
+        timestamp: commit.timestamp,
+        extras: {
+            ...(commit.extras || { patch_id: null, tags: {} }),
+            tags: {
+                ...(commit.extras?.tags || {}),
+                ...(policyId ? { seal_policy_id: policyId } : {}),
+            },
+        },
+    };
+    const remoteSerialized = (0, serialize_1.canonicalStringify)(remoteCommit);
+    const commitUpload = await walrusSvc.writeBlob({
+        blob: Buffer.from(remoteSerialized),
+        signer,
+        epochs: 1,
+        deletable: true,
+    });
+    const remoteCommitId = commitUpload.blobId;
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`  Remote commit uploaded: ${remoteCommitId}`));
+    await cacheJson(path_1.default.join(witPath, 'objects', 'commits', `${(0, state_1.idToFileName)(remoteCommitId)}.json`), remoteSerialized);
+    return { manifestId, quiltId: quiltRes.quiltId, commitId: remoteCommitId };
+}
+async function tryWithRetry(fn, attempts = 3, delayMs = 1200) {
+    let lastErr;
+    for (let i = 0; i < attempts; i += 1) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.yellow(`Walrus upload attempt ${i + 1}/${attempts} failed: ${err?.message || err}`));
+            if (i < attempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+    }
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.red(`Walrus upload failed after ${attempts} attempts: ${lastErr?.message || lastErr}. Please check network/relay and retry (push is safe to re-run).`));
+    return null;
+}
+async function cacheJson(filePath, content) {
+    await (0, fs_1.ensureDirForFile)(filePath);
+    await promises_1.default.writeFile(filePath, content, 'utf8');
+}
+async function ensureAuthorOrSetDefault(witPath, repoCfg, signerAddress) {
+    const current = (repoCfg.author || '').trim().toLowerCase();
+    const signer = signerAddress.toLowerCase();
+    if (!current || current === 'unknown') {
+        const next = { ...repoCfg, author: signerAddress };
+        await (0, repo_1.writeRepoConfig)(witPath, next);
+        // 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.`);
+    }
+}
+async function assertResourcesOk(address) {
+    const res = await (0, keys_1.checkResources)(address);
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`Using account ${address}`));
+    const fmt = (amt) => (amt !== undefined ? amt.toString() : 'unknown');
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`  SUI: ${fmt(res.suiBalance)} (min ${res.minSui})`));
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`  WAL: ${res.walError ? 'query failed' : fmt(res.walBalance)} (min ${res.minWal})`));
+    if (res.error) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.red(`Failed to query balances: ${res.error}`));
+        return false;
+    }
+    if (res.walError) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.red(`Failed to query WAL balance: ${res.walError}. Please fund or switch account.`));
+        return false;
+    }
+    if (res.hasMinSui === false) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.red(`Insufficient SUI balance (need at least ${res.minSui} MIST). Please fund or switch account.`));
+        return false;
+    }
+    if (res.hasMinWal === false) {
+        // eslint-disable-next-line no-console
+        console.warn(`Warning: WAL balance below threshold (${res.minWal} min).`);
+    }
+    return true;
+}