withub-cli 0.1.0

package/dist/commands/registerCommands.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCommands = registerCommands;
+const init_1 = require("./init");
+const commit_1 = require("./commit");
+const checkout_1 = require("./checkout");
+const diff_1 = require("./diff");
+const workspace_1 = require("./workspace");
+const push_1 = require("./push");
+const clone_1 = require("./clone");
+const fetch_1 = require("./fetch");
+const pull_1 = require("./pull");
+const invite_1 = require("./invite");
+const ui_1 = require("../lib/ui");
+const account_1 = require("./account");
+const walrusBlob_1 = require("./walrusBlob");
+const walrusQuilt_1 = require("./walrusQuilt");
+const list_1 = require("./list");
+const transfer_1 = require("./transfer");
+const removeUser_1 = require("./removeUser");
+function registerCommands(program) {
+    // Global options (propagate to subcommands)
+    program.option('--color', 'force color output').option('--no-color', 'disable color output');
+    program
+        .command('init [name]')
+        .description('Initialize a wit repository (creates .wit, config, ignores)')
+        .option('--private', 'Initialize as private repository (generate seal policy + secret)')
+        .option('--seal-policy <id>', 'Use existing seal policy id for private repo')
+        .option('--seal-secret <secret>', 'Explicit seal secret (otherwise auto-generated/stored)')
+        .action((name, opts) => (0, init_1.initAction)(name, { private: opts.private, sealPolicy: opts.sealPolicy, sealSecret: opts.sealSecret }));
+    program
+        .command('status')
+        .description('Show workspace vs index status')
+        .action(workspace_1.statusAction);
+    program
+        .command('add [paths...]')
+        .option('-A, --all', 'add all changes (equivalent to add .)')
+        .description('Add file(s) to the wit index')
+        .action(workspace_1.addAction);
+    program
+        .command('reset [paths...]')
+        .option('-A, --all', 'unstage all entries from the wit index')
+        .description('Reset index entries for paths (like git reset -- <paths>)')
+        .action(workspace_1.resetAction);
+    program
+        .command('restore')
+        .option('--staged', 'unstage paths from the index (alias of reset)')
+        .argument('[paths...]')
+        .description('Restore worktree files from index or unstage when using --staged')
+        .action((paths, opts) => {
+        if (opts.staged) {
+            return (0, workspace_1.resetAction)(paths, { staged: true });
+        }
+        return (0, workspace_1.resetAction)(paths, { staged: false });
+    });
+    program
+        .command('commit')
+        .option('-m, --message <message>', 'commit message')
+        .description('Create a local commit (single-branch)')
+        .action(commit_1.commitAction);
+    program
+        .command('checkout <commit_id>')
+        .description('Checkout a commit snapshot to the worktree (updates index and HEAD ref)')
+        .action(async (commitId) => {
+        await (0, checkout_1.checkoutAction)(commitId);
+    });
+    program
+        .command('push')
+        .description('Upload manifest/quilt/commit to Walrus and update Sui head')
+        .action(push_1.pushAction);
+    program
+        .command('clone <repo_id>')
+        .description('Clone a wit repository from Sui/Walrus')
+        .action(clone_1.cloneAction);
+    program
+        .command('diff')
+        .option('--cached', 'compare against index instead of worktree')
+        .description('Show diffs between worktree/index/commit')
+        .action(diff_1.diffAction);
+    program
+        .command('log')
+        .description('Show commit history (local, single-branch)')
+        .action(commit_1.logAction);
+    program
+        .command('fetch')
+        .description('Update remote mirror (head/manifest/commit) without changing worktree')
+        .action(fetch_1.fetchAction);
+    program
+        .command('pull')
+        .description('Fetch and fast-forward to remote head when possible')
+        .action(pull_1.pullAction);
+    program
+        .command('invite <address>')
+        .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));
+    program
+        .command('transfer <new_owner>')
+        .description('Transfer repository ownership to a new address')
+        .action(transfer_1.transferAction);
+    program
+        .command('remove-user <address>')
+        .description('Remove a collaborator from the repository')
+        .action(removeUser_1.removeUserAction);
+    program
+        .command('push-blob <path>')
+        .description('Upload a single blob to Walrus (hash-verified)')
+        .option('--epochs <n>', 'epochs to store blob for (default 1)', (v) => parseInt(v, 10), 1)
+        .option('--deletable', 'mark blob deletable (default true)', true)
+        .action((pathArg, opts) => (0, walrusBlob_1.pushBlobAction)(pathArg, opts));
+    program
+        .command('pull-blob <blob_id> <out_path>')
+        .description('Download a Walrus blob and verify hash')
+        .action((blobId, outPath) => (0, walrusBlob_1.pullBlobAction)(blobId, outPath));
+    program
+        .command('push-quilt <dir>')
+        .description('Upload a directory as Walrus files (tags + hash), emits local manifest')
+        .option('--epochs <n>', 'epochs to store quilt for (default 1)', (v) => parseInt(v, 10), 1)
+        .option('--deletable', 'mark quilt deletable (default true)', true)
+        .option('--manifest-out <path>', 'where to write manifest (default ./quilt-manifest.json)')
+        .action((dir, opts) => (0, walrusQuilt_1.pushQuiltAction)(dir, opts));
+    program
+        .command('pull-quilt <manifest_path> <out_dir>')
+        .description('Download files from Walrus using manifest produced by push-quilt (hash/root_hash verified)')
+        .action((manifestPath, outDir) => (0, walrusQuilt_1.pullQuiltAction)(manifestPath, outDir));
+    program
+        .command('quilt-cat <manifest_path> <identifier>')
+        .description('Fetch a single file from a quilt (by identifier) and print to stdout')
+        .action(async (manifestPath, identifier) => {
+        const { fetchQuiltFile } = await import('./walrusQuilt.js');
+        const { bytes } = await fetchQuiltFile(manifestPath, identifier);
+        process.stdout.write(Buffer.from(bytes));
+    });
+    program
+        .command('quilt-ls <quilt_id>')
+        .description('List identifiers inside a quilt (no manifest needed)')
+        .action((quiltId) => (0, walrusQuilt_1.listQuiltIdentifiersCommand)(quiltId));
+    program
+        .command('quilt-cat-id <quilt_id> <identifier>')
+        .description('Fetch a single file from a quilt by quilt_id + identifier (no manifest needed)')
+        .action((quiltId, identifier) => (0, walrusQuilt_1.catQuiltFileById)(quiltId, identifier));
+    program
+        .command('push-quilt-legacy <dir>')
+        .description('Upload directory as legacy archive (single blob with embedded manifest)')
+        .option('--epochs <n>', 'epochs to store archive for (default 1)', (v) => parseInt(v, 10), 1)
+        .option('--deletable', 'mark archive deletable (default true)', true)
+        .action((dir, opts) => (0, walrusQuilt_1.pushQuiltLegacyAction)(dir, opts));
+    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('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 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);
+    account
+        .command('generate')
+        .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('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) => {
+        const opts = cmd.optsWithGlobals ? cmd.optsWithGlobals() : program.opts();
+        const envDefault = process.env.WIT_NO_COLOR === undefined &&
+            process.env.NO_COLOR === undefined &&
+            (process.env.FORCE_COLOR === undefined || process.env.FORCE_COLOR !== '0');
+        const desired = opts.color ? true : opts.noColor ? false : envDefault;
+        (0, ui_1.setColorsEnabled)(desired);
+        if (!desired && (0, ui_1.colorsEnabled)()) {
+            (0, ui_1.setColorsEnabled)(false);
+        }
+    });
+}

package/dist/commands/removeUser.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUserAction = removeUserAction;
+const client_1 = require("@mysten/sui/client");
+const keys_1 = require("../lib/keys");
+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 witPath = await (0, repo_1.requireWitDir)();
+    const repoCfg = await (0, repo_1.readRepoConfig)(witPath);
+    if (!repoCfg.repo_id) {
+        throw new Error('Repository not initialized on chain. Run `wit push` first.');
+    }
+    const signer = await (0, keys_1.loadSigner)();
+    const address = signer.address;
+    // Basic validation
+    if (!addressToRemove.startsWith('0x')) {
+        throw new Error('Invalid address format. Must start with 0x.');
+    }
+    console.log(ui_1.colors.header(`Removing collaborator ${addressToRemove} from ${repoCfg.repo_id}...`));
+    const res = await (0, keys_1.checkResources)(address);
+    if (res.hasMinSui === false) {
+        throw new Error(`Insufficient SUI balance. Need at least ${res.minSui} MIST.`);
+    }
+    const config = await (0, walrus_1.resolveWalrusConfig)();
+    const client = new client_1.SuiClient({ url: config.suiRpcUrl });
+    let whitelistId;
+    try {
+        const state = await (0, suiRepo_1.fetchRepositoryState)(client, repoCfg.repo_id);
+        if (state.sealPolicyId) {
+            whitelistId = state.sealPolicyId;
+        }
+    }
+    catch (err) {
+        // ignore
+    }
+    try {
+        await (0, suiRepo_1.removeCollaborator)(client, signer.signer, {
+            repoId: repoCfg.repo_id,
+            collaborator: addressToRemove,
+            whitelistId
+        });
+        console.log(ui_1.colors.green(`Collaborator ${addressToRemove} removed successfully.`));
+        if (whitelistId) {
+            console.log(ui_1.colors.yellow('IMPORTANT: Key Rotation Triggered.'));
+            console.log(ui_1.colors.yellow('The next `wit push` will automatically generate a new session key.'));
+            console.log(ui_1.colors.yellow('This ensures the removed user cannot decrypt future commits.'));
+            // TODO: We could force a re-key commit here, but for MVP we rely on next push.
+            // To ensure rotation, we can delete any cached session key if we were caching it (we aren't currently).
+            // Since `wit push` generates a fresh key every time, rotation is implicit!
+            // We just need to inform the user.
+        }
+    }
+    catch (err) {
+        console.error(ui_1.colors.red(`Removal failed: ${err.message}`));
+        if (err.message.includes('ENotAuthorized')) {
+            console.error(ui_1.colors.yellow('Hint: Only the owner can remove collaborators.'));
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/stub.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStubAction = makeStubAction;
+function makeStubAction(commandName, detail) {
+    return async () => {
+        const React = await import('react');
+        const ink = await import('ink');
+        const { render, Box, Text } = ink;
+        render(React.createElement(Box, { flexDirection: 'column' }, React.createElement(Text, { color: 'cyan' }, `wit ${commandName}`), detail ? React.createElement(Text, { dimColor: true }, detail) : null, React.createElement(Text, { dimColor: true }, 'Scaffold placeholder (Stage 1).')));
+    };
+}

package/dist/commands/transfer.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transferAction = transferAction;
+const client_1 = require("@mysten/sui/client");
+const keys_1 = require("../lib/keys");
+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 transferAction(newOwner) {
+    const witPath = await (0, repo_1.requireWitDir)();
+    const repoCfg = await (0, repo_1.readRepoConfig)(witPath);
+    if (!repoCfg.repo_id) {
+        throw new Error('Repository not initialized on chain. Run `wit push` first.');
+    }
+    const signer = await (0, keys_1.loadSigner)();
+    const address = signer.address;
+    // Basic validation
+    if (!newOwner.startsWith('0x')) {
+        throw new Error('Invalid address format. Must start with 0x.');
+    }
+    console.log(ui_1.colors.header(`Transferring ownership of ${repoCfg.repo_id} to ${newOwner}...`));
+    const res = await (0, keys_1.checkResources)(address);
+    if (res.hasMinSui === false) {
+        throw new Error(`Insufficient SUI balance. Need at least ${res.minSui} MIST.`);
+    }
+    const config = await (0, walrus_1.resolveWalrusConfig)();
+    const client = new client_1.SuiClient({ url: config.suiRpcUrl });
+    try {
+        await (0, suiRepo_1.transferOwnership)(client, signer.signer, {
+            repoId: repoCfg.repo_id,
+            newOwner,
+        });
+        console.log(ui_1.colors.green('Ownership transferred successfully!'));
+        console.log(ui_1.colors.cyan(`You are now a collaborator. ${newOwner} is the new owner.`));
+        // Update local config author just in case, though strictly not required as author != owner
+        // But we might want to warn user if they try to do owner-only things later
+    }
+    catch (err) {
+        console.error(ui_1.colors.red(`Transfer failed: ${err.message}`));
+        if (err.message.includes('ENotAuthorized')) {
+            console.error(ui_1.colors.yellow('Hint: Only the current owner can transfer ownership.'));
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/walrusBlob.js

@@ -0,0 +1,50 @@
+"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 walrus_1 = require("../lib/walrus");
+const serialize_1 = require("../lib/serialize");
+const ui_1 = require("../lib/ui");
+async function pushBlobAction(filePath, opts) {
+    const absPath = path_1.default.resolve(filePath);
+    const data = await promises_1.default.readFile(absPath);
+    const hash = (0, serialize_1.sha256Base64)(data);
+    const svc = await walrus_1.WalrusService.fromRepo();
+    const signerInfo = await maybeLoadSigner();
+    const epochs = opts.epochs && opts.epochs > 0 ? opts.epochs : 1;
+    const res = await svc.writeBlob({
+        blob: data,
+        signer: signerInfo.signer,
+        epochs,
+        deletable: opts.deletable !== false,
+        attributes: { hash },
+    });
+    // eslint-disable-next-line no-console
+    console.log(`${ui_1.colors.green('Uploaded')} ${absPath}`);
+    // eslint-disable-next-line no-console
+    console.log(`  blobId: ${ui_1.colors.hash(res.blobId)}`);
+    // eslint-disable-next-line no-console
+    console.log(`  hash:   ${ui_1.colors.hash(hash)}`);
+}
+async function pullBlobAction(blobId, outPath) {
+    const svc = await walrus_1.WalrusService.fromRepo();
+    const bytes = await svc.readBlob(blobId);
+    const hash = (0, serialize_1.sha256Base64)(Buffer.from(bytes));
+    await promises_1.default.mkdir(path_1.default.dirname(path_1.default.resolve(outPath)), { recursive: true });
+    await promises_1.default.writeFile(outPath, bytes);
+    // eslint-disable-next-line no-console
+    console.log(`${ui_1.colors.green('Downloaded')} -> ${outPath}`);
+    // eslint-disable-next-line no-console
+    console.log(`  blobId: ${ui_1.colors.hash(blobId)}`);
+    // eslint-disable-next-line no-console
+    console.log(`  hash:   ${ui_1.colors.hash(hash)}`);
+}
+async function maybeLoadSigner() {
+    const { loadSigner } = await import('../lib/keys.js');
+    return loadSigner();
+}

package/dist/commands/walrusQuilt.js

@@ -0,0 +1,282 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushQuiltAction = pushQuiltAction;
+exports.pullQuiltAction = pullQuiltAction;
+exports.fetchQuiltFile = fetchQuiltFile;
+exports.listQuiltIdentifiersCommand = listQuiltIdentifiersCommand;
+exports.catQuiltFileById = catQuiltFileById;
+exports.pushQuiltLegacyAction = pushQuiltLegacyAction;
+exports.pullQuiltLegacyAction = pullQuiltLegacyAction;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const walrus_1 = require("../lib/walrus");
+const ui_1 = require("../lib/ui");
+const fs_1 = require("../lib/fs");
+const manifest_1 = require("../lib/manifest");
+const schema_1 = require("../lib/schema");
+const serialize_1 = require("../lib/serialize");
+const quilt_1 = require("../lib/quilt");
+const walrus_2 = require("@mysten/walrus");
+// Step 1: Native quilt upload using writeQuilt (identifier + tags)
+async function pushQuiltAction(dir, opts) {
+    const cwd = process.cwd();
+    const absDir = path_1.default.resolve(dir);
+    const entries = await collectFiles(absDir);
+    if (!entries.length) {
+        throw new Error(`Directory is empty: ${absDir}`);
+    }
+    const files = await Promise.all(entries.map(async (rel) => {
+        const abs = path_1.default.join(absDir, rel);
+        const meta = await (0, fs_1.computeFileMeta)(abs);
+        const data = await promises_1.default.readFile(abs);
+        return { rel: (0, fs_1.pathToPosix)(rel), meta, data };
+    }));
+    const walrusBlobs = files.map(({ rel, data, meta }) => ({
+        contents: data,
+        identifier: rel,
+        tags: {
+            hash: meta.hash,
+            size: String(meta.size),
+            mode: meta.mode,
+            mtime: String(meta.mtime),
+        },
+    }));
+    const svc = await walrus_1.WalrusService.fromRepo(cwd);
+    const signerInfo = await maybeLoadSigner();
+    const epochs = opts.epochs && opts.epochs > 0 ? opts.epochs : 1;
+    // Native quilt upload
+    const quiltRes = await svc.writeQuilt({ blobs: walrusBlobs, signer: signerInfo.signer, epochs, deletable: opts.deletable !== false });
+    const quiltId = quiltRes.quiltId;
+    // Per-file ids for pull: store via writeFiles
+    const walrusFiles = walrusBlobs.map((b) => walrus_2.WalrusFile.from({
+        contents: b.contents,
+        identifier: b.identifier,
+        tags: b.tags,
+    }));
+    const filesRes = await svc.getClient().writeFiles({ files: walrusFiles, signer: signerInfo.signer, epochs, deletable: opts.deletable !== false });
+    const manifest = schema_1.ManifestSchema.parse({
+        version: 1,
+        quilt_id: quiltId,
+        root_hash: (0, manifest_1.computeRootHash)(Object.fromEntries(files.map(({ rel, meta }) => [rel, meta]))),
+        files: Object.fromEntries(files.map(({ rel, meta }, idx) => [
+            rel,
+            {
+                ...meta,
+                id: filesRes[idx]?.id || '',
+            },
+        ])),
+    });
+    const manifestPath = opts.manifestOut ? path_1.default.resolve(opts.manifestOut) : path_1.default.resolve(cwd, 'quilt-manifest.json');
+    await promises_1.default.writeFile(manifestPath, (0, serialize_1.canonicalStringify)(manifest), 'utf8');
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.green(`Uploaded quilt from ${absDir}`));
+    // eslint-disable-next-line no-console
+    console.log(`  quiltId: ${ui_1.colors.hash(quiltId)}`);
+    // eslint-disable-next-line no-console
+    console.log(`  manifest: ${manifestPath}`);
+    // eslint-disable-next-line no-console
+    console.log(`  root_hash: ${ui_1.colors.hash(manifest.root_hash)}`);
+}
+// Step 2 will implement pull-quilt using Quilt index (pending)
+async function pullQuiltAction(manifestPath, outDir) {
+    const manifestRaw = await promises_1.default.readFile(manifestPath, 'utf8');
+    const manifest = schema_1.ManifestSchema.parse(JSON.parse(manifestRaw));
+    if (!manifest.files || !Object.keys(manifest.files).length) {
+        throw new Error('Manifest has no files');
+    }
+    const entries = Object.entries(manifest.files);
+    const svc = await walrus_1.WalrusService.fromRepo();
+    const fetched = {};
+    for (const [identifier, expected] of entries) {
+        let content = null;
+        if (manifest.quilt_id) {
+            try {
+                content = Buffer.from(await svc.readQuiltFile(manifest.quilt_id, identifier));
+            }
+            catch {
+                // fallback to file id if available
+            }
+        }
+        if (!content) {
+            if (!expected.id) {
+                throw new Error(`Manifest missing Walrus file id for ${identifier}`);
+            }
+            const files = await svc.getClient().getFiles({ ids: [expected.id] });
+            content = Buffer.from(await files[0].bytes());
+            const tags = await files[0].getTags();
+            if (tags?.hash && tags.hash !== expected.hash) {
+                throw new Error(`Tag hash mismatch for ${identifier}`);
+            }
+        }
+        const computed = { hash: (0, serialize_1.sha256Base64)(content), size: content.length };
+        if (expected.hash !== computed.hash || expected.size !== computed.size) {
+            throw new Error(`Hash/size mismatch for ${identifier}`);
+        }
+        fetched[identifier] = content;
+    }
+    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(`root_hash mismatch: manifest=${manifest.root_hash}, computed=${computedRoot}`);
+    }
+    for (const [rel, data] of Object.entries(fetched)) {
+        const outPath = path_1.default.join(outDir, rel);
+        await promises_1.default.mkdir(path_1.default.dirname(outPath), { recursive: true });
+        await promises_1.default.writeFile(outPath, data);
+        const meta = manifest.files[rel];
+        const mode = parseInt(meta.mode, 10);
+        if (!Number.isNaN(mode)) {
+            await promises_1.default.chmod(outPath, mode & 0o777);
+        }
+    }
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.green(`Downloaded quilt to ${outDir}`));
+    // eslint-disable-next-line no-console
+    console.log(`  manifest root_hash: ${ui_1.colors.hash(manifest.root_hash)}`);
+}
+// On-demand fetch for a single identifier (web/explorer reuse)
+async function fetchQuiltFile(manifestPath, identifier) {
+    const manifestRaw = await promises_1.default.readFile(manifestPath, 'utf8');
+    const manifest = schema_1.ManifestSchema.parse(JSON.parse(manifestRaw));
+    const idNormalized = (0, fs_1.pathToPosix)(identifier);
+    const entry = findEntry(manifest, idNormalized);
+    if (!entry || !entry.id) {
+        throw new Error(`Identifier not found in manifest: ${identifier}`);
+    }
+    return (0, quilt_1.fetchQuiltFileById)(entry.id, idNormalized);
+}
+function findEntry(manifest, identifier) {
+    if (manifest.files[identifier])
+        return manifest.files[identifier];
+    // If caller passed a prefixed path (e.g., dir/a.txt) but manifest stored a.txt, try stripping leading segments.
+    const parts = identifier.split('/');
+    while (parts.length > 1) {
+        parts.shift();
+        const candidate = parts.join('/');
+        if (manifest.files[candidate])
+            return manifest.files[candidate];
+    }
+    return null;
+}
+// Direct quilt access (no manifest): list identifiers and fetch a single file
+async function listQuiltIdentifiersCommand(quiltId) {
+    const ids = await (await import('../lib/quilt.js')).listQuiltIdentifiers(quiltId);
+    if (!ids.length) {
+        // eslint-disable-next-line no-console
+        console.log('No identifiers found in quilt.');
+        return;
+    }
+    for (const id of ids) {
+        // eslint-disable-next-line no-console
+        console.log(id);
+    }
+}
+async function catQuiltFileById(quiltId, identifier) {
+    const { fetchQuiltFileById } = await import('../lib/quilt.js');
+    const { bytes } = await fetchQuiltFileById(quiltId, (0, fs_1.pathToPosix)(identifier));
+    process.stdout.write(Buffer.from(bytes));
+}
+async function collectFiles(baseDir) {
+    const result = [];
+    async function walk(cur, relPrefix = '') {
+        const entries = await promises_1.default.readdir(cur, { withFileTypes: true });
+        for (const e of entries) {
+            const rel = path_1.default.join(relPrefix, e.name);
+            const abs = path_1.default.join(cur, e.name);
+            if (e.isDirectory()) {
+                await walk(abs, rel);
+            }
+            else if (e.isFile()) {
+                result.push(rel.replace(/\\/g, '/'));
+            }
+        }
+    }
+    await walk(baseDir, '');
+    return result.sort();
+}
+async function maybeLoadSigner() {
+    const { loadSigner } = await import('../lib/keys.js');
+    return loadSigner();
+}
+// Legacy fallback: archive all files into a single blob (manifest + base64 contents)
+async function pushQuiltLegacyAction(dir, opts) {
+    const cwd = process.cwd();
+    const absDir = path_1.default.resolve(dir);
+    const entries = await collectFiles(absDir);
+    if (!entries.length)
+        throw new Error(`Directory is empty: ${absDir}`);
+    const files = {};
+    for (const rel of entries) {
+        const abs = path_1.default.join(absDir, rel);
+        const meta = await (0, fs_1.computeFileMeta)(abs);
+        const data = await promises_1.default.readFile(abs);
+        files[(0, fs_1.pathToPosix)(rel)] = { data, meta };
+    }
+    const manifest = schema_1.ManifestSchema.parse({
+        version: 1,
+        quilt_id: 'legacy-archive',
+        root_hash: (0, manifest_1.computeRootHash)(Object.fromEntries(Object.entries(files).map(([rel, info]) => [rel, info.meta]))),
+        files: Object.fromEntries(Object.entries(files).map(([rel, info]) => [rel, info.meta])),
+    });
+    const archive = {
+        manifest,
+        files: Object.fromEntries(Object.entries(files).map(([rel, info]) => [rel, info.data.toString('base64')])),
+    };
+    const payload = Buffer.from(JSON.stringify(archive));
+    const svc = await walrus_1.WalrusService.fromRepo(cwd);
+    const signerInfo = await maybeLoadSigner();
+    const epochs = opts.epochs && opts.epochs > 0 ? opts.epochs : 1;
+    const res = await svc.writeBlob({
+        blob: payload,
+        signer: signerInfo.signer,
+        epochs,
+        deletable: opts.deletable !== false,
+        attributes: { root_hash: manifest.root_hash, kind: 'quilt-archive' },
+    });
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.green(`Uploaded legacy quilt archive from ${absDir}`));
+    // eslint-disable-next-line no-console
+    console.log(`  archive blobId: ${ui_1.colors.hash(res.blobId)}`);
+    // eslint-disable-next-line no-console
+    console.log(`  root_hash: ${ui_1.colors.hash(manifest.root_hash)}`);
+}
+async function pullQuiltLegacyAction(blobId, outDir) {
+    const svc = await walrus_1.WalrusService.fromRepo();
+    const bytes = await svc.readBlob(blobId);
+    const archive = JSON.parse(Buffer.from(bytes).toString('utf8'));
+    const manifest = schema_1.ManifestSchema.parse(archive.manifest);
+    const index = {};
+    for (const [rel, b64] of Object.entries(archive.files)) {
+        const data = Buffer.from(b64, 'base64');
+        const computed = { hash: (0, serialize_1.sha256Base64)(data), size: data.length };
+        const expected = manifest.files[rel];
+        if (!expected)
+            throw new Error(`Manifest missing entry for ${rel}`);
+        if (expected.hash !== computed.hash || expected.size !== computed.size)
+            throw new Error(`Hash/size mismatch for ${rel}`);
+        index[rel] = expected;
+    }
+    const computedRoot = (0, manifest_1.computeRootHash)(index);
+    if (computedRoot !== manifest.root_hash) {
+        throw new Error(`root_hash mismatch: manifest=${manifest.root_hash} computed=${computedRoot}`);
+    }
+    for (const [rel, b64] of Object.entries(archive.files)) {
+        const data = Buffer.from(b64, 'base64');
+        const outPath = path_1.default.join(outDir, rel);
+        await promises_1.default.mkdir(path_1.default.dirname(outPath), { recursive: true });
+        await promises_1.default.writeFile(outPath, data);
+        const meta = manifest.files[rel];
+        const mode = parseInt(meta.mode, 10);
+        if (!Number.isNaN(mode))
+            await promises_1.default.chmod(outPath, mode & 0o777);
+    }
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.green(`Downloaded legacy quilt archive to ${outDir}`));
+    // eslint-disable-next-line no-console
+    console.log(`  manifest root_hash: ${ui_1.colors.hash(manifest.root_hash)}`);
+}