withub-cli 0.1.0

package/dist/lib/suiRepo.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8ToVec = utf8ToVec;
+exports.decodeVecAsString = decodeVecAsString;
+exports.createRepository = createRepository;
+exports.updateRepositoryHead = updateRepositoryHead;
+exports.decodeVecAsHex = decodeVecAsHex;
+exports.fetchRepositoryState = fetchRepositoryState;
+exports.fetchRepositoryStateWithRetry = fetchRepositoryStateWithRetry;
+exports.addCollaborator = addCollaborator;
+exports.transferOwnership = transferOwnership;
+exports.removeCollaborator = removeCollaborator;
+const transactions_1 = require("@mysten/sui/transactions");
+const constants_1 = require("./constants");
+function utf8ToVec(input) {
+    return Array.from(Buffer.from(input, 'utf8'));
+}
+function decodeVecAsString(raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    if (typeof raw === 'string') {
+        if (raw.startsWith('0x')) {
+            return Buffer.from(raw.slice(2), 'hex').toString('utf8');
+        }
+        return raw;
+    }
+    if (Array.isArray(raw)) {
+        if (!raw.length)
+            return null;
+        if (raw.every((v) => typeof v === 'number')) {
+            return Buffer.from(raw).toString('utf8');
+        }
+        if (raw.length === 1) {
+            return decodeVecAsString(raw[0]);
+        }
+        return Buffer.from(String(raw[0])).toString('utf8');
+    }
+    if (typeof raw === 'object') {
+        const asRec = raw;
+        if (asRec.vec !== undefined)
+            return decodeVecAsString(asRec.vec);
+        if (asRec.fields !== undefined)
+            return decodeVecAsString(asRec.fields);
+    }
+    return String(raw);
+}
+function getSignerAddress(signer) {
+    // @ts-ignore Signer is implemented by Ed25519Keypair
+    return signer.getPublicKey().toSuiAddress();
+}
+async function createRepository(client, signer, params) {
+    const pkg = params.packageId || constants_1.WIT_PACKAGE_ID;
+    const mod = params.moduleName || constants_1.WIT_MODULE_NAME;
+    const tx = new transactions_1.Transaction();
+    tx.setSenderIfNotSet(getSignerAddress(signer));
+    tx.moveCall({
+        target: `${pkg}::${mod}::create_repo`,
+        arguments: [
+            tx.pure.vector('u8', utf8ToVec(params.name)),
+            tx.pure.vector('u8', utf8ToVec(params.description || '')),
+            tx.pure.bool(params.isPrivate),
+        ],
+    });
+    const res = await client.signAndExecuteTransaction({
+        signer,
+        transaction: tx,
+        options: { showEffects: true, showObjectChanges: true }
+    });
+    const changes = res.objectChanges || [];
+    const repoType = `${pkg}::${mod}::Repository`;
+    // Find the created Repository object with the correct type
+    const repoObj = changes.find((c) => c.type === 'created' && c.objectType === repoType);
+    if (!repoObj || !('objectId' in repoObj)) {
+        // Fallback logic for older versions
+        const created = res?.effects?.created || [];
+        // Try to find the Repository by looking for the second shared object if private
+        const sharedObjects = created.filter((c) => c?.owner?.Shared !== undefined);
+        const fallbackId = sharedObjects[sharedObjects.length - 1]?.reference?.objectId ||
+            sharedObjects[sharedObjects.length - 1]?.reference?.object_id;
+        if (fallbackId)
+            return fallbackId;
+        throw new Error(`create_repo did not return a repository object of type ${repoType}`);
+    }
+    return repoObj.objectId;
+}
+async function updateRepositoryHead(client, signer, params) {
+    const pkg = params.packageId || constants_1.WIT_PACKAGE_ID;
+    const mod = params.moduleName || constants_1.WIT_MODULE_NAME;
+    const tx = new transactions_1.Transaction();
+    tx.setSenderIfNotSet(getSignerAddress(signer));
+    tx.moveCall({
+        target: `${pkg}::${mod}::update_head`,
+        arguments: [
+            tx.object(params.repoId),
+            tx.pure.vector('u8', utf8ToVec(params.commitId)),
+            tx.pure.vector('u8', utf8ToVec(params.manifestId)),
+            tx.pure.vector('u8', utf8ToVec(params.quiltId)),
+            tx.pure.u64(params.expectedVersion),
+            tx.pure.option('vector<u8>', params.parentCommit ? utf8ToVec(params.parentCommit) : null),
+        ],
+    });
+    await client.signAndExecuteTransaction({ signer, transaction: tx, options: { showEffects: true } });
+}
+function decodeVecAsHex(raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    if (typeof raw === 'string') {
+        return raw.startsWith('0x') ? raw : `0x${raw}`;
+    }
+    if (Array.isArray(raw)) {
+        if (!raw.length)
+            return null;
+        if (raw.every((v) => typeof v === 'number')) {
+            return `0x${Buffer.from(raw).toString('hex')}`;
+        }
+        if (raw.length === 1) {
+            return decodeVecAsHex(raw[0]);
+        }
+        // Should not happen for vector<u8>
+        return null;
+    }
+    if (typeof raw === 'object') {
+        const asRec = raw;
+        if (asRec.vec !== undefined)
+            return decodeVecAsHex(asRec.vec);
+        if (asRec.fields !== undefined)
+            return decodeVecAsHex(asRec.fields);
+    }
+    return null;
+}
+async function fetchRepositoryState(client, repoId) {
+    const resp = await client.getObject({ id: repoId, options: { showContent: true } });
+    const data = resp?.data;
+    if (!data?.content || data.content.dataType !== 'moveObject') {
+        throw new Error('Repository object not found or not a Move object.');
+    }
+    const fields = data.content.fields || {};
+    return {
+        repoId,
+        owner: fields.owner ? decodeVecAsString(fields.owner) || undefined : undefined,
+        headCommit: decodeVecAsString(fields.head_commit),
+        headManifest: decodeVecAsString(fields.head_manifest),
+        headQuilt: decodeVecAsString(fields.head_quilt),
+        version: Number(fields.version || 0),
+        sealPolicyId: decodeVecAsHex(fields.seal_policy_id),
+    };
+}
+async function fetchRepositoryStateWithRetry(client, repoId, attempts = 3, delayMs = 1200) {
+    let lastErr;
+    for (let i = 0; i < attempts; i += 1) {
+        try {
+            return await fetchRepositoryState(client, repoId);
+        }
+        catch (err) {
+            lastErr = err;
+            if (i < attempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+                continue;
+            }
+        }
+    }
+    throw lastErr;
+}
+async function addCollaborator(client, signer, params) {
+    const pkg = params.packageId || constants_1.WIT_PACKAGE_ID;
+    const mod = params.moduleName || constants_1.WIT_MODULE_NAME;
+    const tx = new transactions_1.Transaction();
+    tx.setSenderIfNotSet(getSignerAddress(signer));
+    if (params.whitelistId) {
+        tx.moveCall({
+            target: `${pkg}::${mod}::add_private_collaborator`,
+            arguments: [tx.object(params.repoId), tx.object(params.whitelistId), tx.pure.address(params.collaborator)],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: `${pkg}::${mod}::add_collaborator`,
+            arguments: [tx.object(params.repoId), tx.pure.address(params.collaborator)],
+        });
+    }
+    await client.signAndExecuteTransaction({ signer, transaction: tx, options: { showEffects: true } });
+}
+async function transferOwnership(client, signer, params) {
+    const pkg = params.packageId || constants_1.WIT_PACKAGE_ID;
+    const mod = params.moduleName || constants_1.WIT_MODULE_NAME;
+    const tx = new transactions_1.Transaction();
+    tx.setSenderIfNotSet(getSignerAddress(signer));
+    if (params.whitelistId) {
+        tx.moveCall({
+            target: `${pkg}::${mod}::transfer_ownership_private`,
+            arguments: [tx.object(params.repoId), tx.object(params.whitelistId), tx.pure.address(params.newOwner)],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: `${pkg}::${mod}::transfer_ownership`,
+            arguments: [tx.object(params.repoId), tx.pure.address(params.newOwner)],
+        });
+    }
+    await client.signAndExecuteTransaction({ signer, transaction: tx, options: { showEffects: true } });
+}
+async function removeCollaborator(client, signer, params) {
+    const pkg = params.packageId || constants_1.WIT_PACKAGE_ID;
+    const mod = params.moduleName || constants_1.WIT_MODULE_NAME;
+    const tx = new transactions_1.Transaction();
+    tx.setSenderIfNotSet(getSignerAddress(signer));
+    if (params.whitelistId) {
+        tx.moveCall({
+            target: `${pkg}::${mod}::remove_private_collaborator`,
+            arguments: [tx.object(params.repoId), tx.object(params.whitelistId), tx.pure.address(params.collaborator)],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: `${pkg}::${mod}::remove_collaborator`,
+            arguments: [tx.object(params.repoId), tx.pure.address(params.collaborator)],
+        });
+    }
+    await client.signAndExecuteTransaction({ signer, transaction: tx, options: { showEffects: true } });
+}

package/dist/lib/ui.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+exports.setColorsEnabled = setColorsEnabled;
+exports.colorsEnabled = colorsEnabled;
+exports.theme = theme;
+const chalk_1 = __importDefault(require("chalk"));
+let enabled = isColorDefaultOn();
+let chalkInstance = new chalk_1.default.Instance({ level: enabled ? 3 : 0 });
+function isColorDefaultOn() {
+    return (process.env.WIT_NO_COLOR === undefined &&
+        process.env.NO_COLOR === undefined &&
+        (process.env.FORCE_COLOR === undefined || process.env.FORCE_COLOR !== '0'));
+}
+function updateInstance() {
+    chalkInstance = new chalk_1.default.Instance({ level: enabled ? 3 : 0 });
+}
+const wrap = (style) => (text) => style(chalkInstance)(text);
+function setColorsEnabled(flag) {
+    enabled = flag;
+    updateInstance();
+}
+function colorsEnabled() {
+    return enabled;
+}
+// Access to the underlying chalk instance (for chainable styles if needed)
+function theme() {
+    return chalkInstance;
+}
+exports.colors = {
+    red: wrap((c) => c.red),
+    green: wrap((c) => c.green),
+    yellow: wrap((c) => c.yellow),
+    blue: wrap((c) => c.blue),
+    cyan: wrap((c) => c.cyan),
+    gray: wrap((c) => c.gray),
+    bold: wrap((c) => c.bold),
+    header: wrap((c) => c.bold.white),
+    commit: wrap((c) => c.yellow),
+    author: wrap((c) => c.blue),
+    date: wrap((c) => c.green),
+    hash: wrap((c) => c.yellow),
+    added: wrap((c) => c.green),
+    deleted: wrap((c) => c.red),
+    modified: wrap((c) => c.red),
+    staged: wrap((c) => c.green),
+    untracked: wrap((c) => c.red),
+};

package/dist/lib/validate.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateManifest = validateManifest;
+const schema_1 = require("./schema");
+const manifest_1 = require("./manifest");
+function validateManifest(manifest) {
+    const parsed = schema_1.ManifestSchema.parse(manifest);
+    const computed = (0, manifest_1.computeRootHash)(parsed.files);
+    if (computed !== parsed.root_hash) {
+        throw new Error(`Manifest root_hash mismatch (expected ${parsed.root_hash}, computed ${computed})`);
+    }
+    return parsed;
+}

package/dist/lib/walrus.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalrusService = void 0;
+exports.resolveWalrusConfig = resolveWalrusConfig;
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const walrus_1 = require("@mysten/walrus");
+// Walrus SDK expects a global crypto; Node 18+ provides crypto.webcrypto.
+if (typeof globalThis.crypto === 'undefined' && crypto_1.default?.webcrypto) {
+    globalThis.crypto = crypto_1.default.webcrypto;
+}
+const DEFAULT_NETWORK = 'testnet';
+const DEFAULT_RELAYS = {
+    mainnet: ['https://upload-relay.mainnet.walrus.space'],
+    testnet: ['https://upload-relay.testnet.walrus.space'],
+};
+const DEFAULT_AGGREGATORS = {
+    mainnet: 'https://aggregator.walrus.space',
+    testnet: 'https://aggregator.walrus-testnet.walrus.space',
+};
+const DEFAULT_SUI_RPC = {
+    mainnet: 'https://fullnode.mainnet.sui.io:443',
+    testnet: 'https://fullnode.testnet.sui.io:443',
+};
+async function readJsonIfExists(file) {
+    try {
+        const raw = await promises_1.default.readFile(file, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+function normalizeNetwork(network) {
+    if (network === 'mainnet')
+        return 'mainnet';
+    return 'testnet';
+}
+function pickRelays(network, repoCfg, globalCfg) {
+    const fromRepo = repoCfg?.relays?.filter(Boolean) ?? [];
+    if (fromRepo.length)
+        return fromRepo;
+    const fromGlobal = globalCfg?.relays?.filter(Boolean) ?? [];
+    if (fromGlobal.length)
+        return fromGlobal;
+    return DEFAULT_RELAYS[network];
+}
+function pickPrimaryRelay(network, relays, repoCfg, globalCfg) {
+    if (repoCfg?.upload_relay)
+        return repoCfg.upload_relay;
+    if (repoCfg?.uploadRelay)
+        return repoCfg.uploadRelay;
+    if (globalCfg?.upload_relay)
+        return globalCfg.upload_relay;
+    if (globalCfg?.uploadRelay)
+        return globalCfg.uploadRelay;
+    return relays[0] || DEFAULT_RELAYS[network][0];
+}
+function pickSuiRpc(network, repoCfg, globalCfg) {
+    const repoRpc = repoCfg?.sui_rpc || repoCfg?.suiRpc;
+    if (repoRpc)
+        return repoRpc;
+    const globalRpc = globalCfg?.sui_rpc || globalCfg?.suiRpc;
+    if (globalRpc)
+        return globalRpc;
+    return DEFAULT_SUI_RPC[network];
+}
+function pickAggregatorHost(network, repoCfg, globalCfg) {
+    if (repoCfg?.aggregator)
+        return repoCfg.aggregator;
+    if (globalCfg?.aggregator)
+        return globalCfg.aggregator;
+    return DEFAULT_AGGREGATORS[network];
+}
+async function resolveWalrusConfig(cwd = process.cwd()) {
+    const witDir = path_1.default.join(cwd, '.wit');
+    const repoCfg = await readJsonIfExists(path_1.default.join(witDir, 'config.json'));
+    if (!repoCfg) {
+        throw new Error('Not a wit repository (missing .wit/config.json). Run `wit init` first.');
+    }
+    const globalCfg = await readJsonIfExists(path_1.default.join(os_1.default.homedir(), '.witconfig'));
+    const network = normalizeNetwork(repoCfg.network || globalCfg?.network || DEFAULT_NETWORK);
+    const relays = pickRelays(network, repoCfg, globalCfg);
+    const primaryRelay = pickPrimaryRelay(network, relays, repoCfg, globalCfg);
+    const suiRpcUrl = pickSuiRpc(network, repoCfg, globalCfg);
+    const aggregatorHost = pickAggregatorHost(network, repoCfg, globalCfg);
+    return { network, relays, primaryRelay, suiRpcUrl, aggregatorHost };
+}
+function buildClientConfig(resolved) {
+    return {
+        network: resolved.network,
+        suiRpcUrl: resolved.suiRpcUrl,
+        uploadRelay: {
+            host: resolved.primaryRelay,
+            // Relay requires tip headers (nonce/tx_id) even if tip is 0.
+            // We set a max tip to enable this behavior.
+            sendTip: { max: 1000 },
+        },
+    };
+}
+/**
+ * Minimal Walrus client wrapper (single relay) for Stage 2 v1.
+ * - Resolves config from .wit/config.json + ~/.witconfig + defaults
+ * - Lazily constructs WalrusClient
+ * - Uses Aggregator for reads when available (faster than direct relay)
+ */
+class WalrusService {
+    constructor(config) {
+        this.config = config;
+        this.client = null;
+    }
+    static async fromRepo(cwd = process.cwd()) {
+        const resolved = await resolveWalrusConfig(cwd);
+        return new WalrusService(resolved);
+    }
+    getResolvedConfig() {
+        return this.config;
+    }
+    getClient() {
+        if (!this.client) {
+            this.client = new walrus_1.WalrusClient(buildClientConfig(this.config));
+        }
+        return this.client;
+    }
+    async readBlob(blobId) {
+        return this.readBlobFast(blobId);
+    }
+    /**
+     * Fast path: prefer Aggregator for reads, fallback to relay SDK
+     */
+    async readBlobFast(blobId) {
+        if (this.config.aggregatorHost) {
+            try {
+                return await fetchBlobFromAggregator(this.config.aggregatorHost, blobId);
+            }
+            catch (err) {
+                // fall back to relay
+            }
+        }
+        return this.getClient().readBlob({ blobId });
+    }
+    /**
+     * Fetch multiple blobs concurrently (fast path via Aggregator).
+     */
+    async readBlobs(ids, concurrency = 6) {
+        if (!ids.length)
+            return [];
+        if (this.config.aggregatorHost) {
+            try {
+                return await fetchMany(ids, concurrency, (id) => fetchBlobFromAggregator(this.config.aggregatorHost, id));
+            }
+            catch {
+                // fall through to relay fetch below
+            }
+        }
+        const files = await this.getClient().getFiles({ ids });
+        return Promise.all(files.map((f) => f.bytes()));
+    }
+    /**
+     * Read a file from a quilt using quiltId + identifier (fast path via Aggregator).
+     */
+    async readQuiltFile(quiltId, identifier) {
+        if (this.config.aggregatorHost) {
+            try {
+                return await fetchQuiltFileFromAggregator(this.config.aggregatorHost, quiltId, identifier);
+            }
+            catch {
+                // fall back to relay
+            }
+        }
+        const blob = await this.getClient().getBlob({ blobId: quiltId });
+        const files = await blob.files({ identifiers: [identifier] });
+        if (files.length) {
+            return files[0].bytes();
+        }
+        // last resort: treat identifier as blob id
+        const alt = await this.getClient().getFiles({ ids: [identifier] });
+        if (alt.length) {
+            return alt[0].bytes();
+        }
+        throw new Error(`Identifier not found in quilt: ${identifier}`);
+    }
+    async writeBlob(params) {
+        const { blob, signer, epochs, deletable = true, owner, attributes } = params;
+        return this.getClient().writeBlob({ blob, signer, epochs, deletable, owner, attributes });
+    }
+    async writeQuilt(params) {
+        const { blobs, signer, epochs, deletable = true } = params;
+        const res = await this.getClient().writeQuilt({ blobs, signer, epochs, deletable });
+        // Walrus returns both quilt index info and blobId; use blobId as quiltId handle.
+        return { quiltId: res.blobId, blobId: res.blobId };
+    }
+}
+exports.WalrusService = WalrusService;
+async function fetchBlobFromAggregator(host, blobId) {
+    const base = host.endsWith('/') ? host.slice(0, -1) : host;
+    const res = await fetch(`${base}/v1/blobs/${encodeURIComponent(blobId)}`);
+    if (!res.ok) {
+        throw new Error(`Aggregator fetch failed: ${res.status} ${res.statusText}`);
+    }
+    const buf = await res.arrayBuffer();
+    return new Uint8Array(buf);
+}
+async function fetchQuiltFileFromAggregator(host, quiltId, identifier) {
+    const base = host.endsWith('/') ? host.slice(0, -1) : host;
+    const pathId = encodeURIComponent(quiltId);
+    // identifier may contain slashes; encodeURIComponent is sufficient for path segment
+    const pathIdent = encodeURIComponent(identifier);
+    const res = await fetch(`${base}/v1/blobs/by-quilt-id/${pathId}/${pathIdent}`);
+    if (!res.ok) {
+        throw new Error(`Aggregator quilt fetch failed: ${res.status} ${res.statusText}`);
+    }
+    const buf = await res.arrayBuffer();
+    return new Uint8Array(buf);
+}
+async function fetchMany(items, concurrency, fn) {
+    const results = new Array(items.length);
+    let index = 0;
+    const workers = new Array(Math.min(concurrency, items.length)).fill(null).map(async () => {
+        while (true) {
+            const i = index;
+            if (i >= items.length)
+                break;
+            index += 1;
+            results[i] = await fn(items[i]);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "withub-cli",
+  "version": "0.1.0",
+  "description": "wit CLI (Commander + Ink) skeleton",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CatKevin/wit.git",
+    "directory": "wit/cli"
+  },
+  "homepage": "https://github.com/CatKevin/wit#readme",
+  "bugs": {
+    "url": "https://github.com/CatKevin/wit/issues"
+  },
+  "author": "CatKevin",
+  "bin": {
+    "wit": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "test:smoke": "NO_COLOR=1 bash scripts/smoke.sh",
+    "prepublishOnly": "npm run build && npm run test:smoke"
+  },
+  "dependencies": {
+    "@mysten/seal": "^0.9.4",
+    "@mysten/sui": "^1.45.0",
+    "@mysten/walrus": "^0.8.4",
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "diff": "^5.2.0",
+    "ignore": "^5.3.1",
+    "ink": "^4.4.1",
+    "isbinaryfile": "^5.0.2",
+    "react": "^18.2.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/diff": "^5.2.0",
+    "@types/node": "^20.12.12",
+    "@types/react": "^18.2.46",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "Apache-2.0",
+  "files": [
+    "dist/**",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}