neozip-cli 0.80.0 → 0.95.0

package/dist/src/connect/command.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectUsage = connectUsage;
+exports.runConnectCommand = runConnectCommand;
+/**
+ * neozip connect — Token Service account setup (vendored from neozip-mcp connect-cli).
+ */
+const onboarding_1 = require("../connection/onboarding");
+const funding_1 = require("../connection/funding");
+const dump_1 = require("../connection/dump");
+const reset_1 = require("../connection/reset");
+const interactive_1 = require("../connection/interactive");
+const status_report_1 = require("../connection/status-report");
+const cli_settings_1 = require("../connection/cli-settings");
+function parseConnectArgs(argv) {
+    const flags = { json: false };
+    const positional = [];
+    let command = null;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--json') {
+            flags.json = true;
+        }
+        else if (arg === '--token-service-url' && argv[i + 1]) {
+            flags.tokenServiceUrl = argv[++i];
+        }
+        else if (arg === '--label' && argv[i + 1]) {
+            flags.label = argv[++i];
+        }
+        else if (arg === '--email' && argv[i + 1]) {
+            flags.email = argv[++i];
+        }
+        else if (arg === '--code' && argv[i + 1]) {
+            flags.code = argv[++i];
+        }
+        else if (arg === '--phone' && argv[i + 1]) {
+            flags.phone = argv[++i];
+        }
+        else if (arg === '--mnemonic' && argv[i + 1]) {
+            flags.mnemonic = argv[++i];
+        }
+        else if (arg === '--private-key' && argv[i + 1]) {
+            flags.privateKey = argv[++i];
+        }
+        else if (arg === '--ack-backup') {
+            flags.ackBackup = true;
+        }
+        else if (arg === '--create-wallet') {
+            flags.createWallet = true;
+        }
+        else if (arg === '--force') {
+            flags.force = true;
+        }
+        else if (arg === '--verbose' || arg === '-v') {
+            flags.verbose = true;
+        }
+        else if (arg === '--resend') {
+            flags.resend = true;
+        }
+        else if (arg === '--magic-token' && argv[i + 1]) {
+            flags.magicToken = argv[++i];
+        }
+        else if (arg === '--connection-id' && argv[i + 1]) {
+            flags.connectionId = argv[++i];
+        }
+        else if (arg === '--network' && argv[i + 1]) {
+            flags.network = argv[++i];
+        }
+        else if (arg === '--chain' && argv[i + 1]) {
+            flags.chain = argv[++i];
+        }
+        else if (arg === '--help' || arg === '-h') {
+            command = 'help';
+        }
+        else if (arg.startsWith('-')) {
+            throw new Error(`Unknown flag: ${arg}`);
+        }
+        else if (command === null) {
+            command = arg;
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return { command: command ?? 'interactive', flags, positional };
+}
+function printResult(res, json) {
+    if (json) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+    }
+    const lines = [`Phase: ${res.phase}`];
+    if (res.tokenServiceOrigin)
+        lines.push(`Token Service: ${res.tokenServiceOrigin}`);
+    if (res.connectionId)
+        lines.push(`Connection: ${res.connectionId}`);
+    if (res.message)
+        lines.push(res.message);
+    if (res.nextCommand)
+        lines.push(`Next: ${res.nextCommand}`);
+    if (res.accounts?.length) {
+        lines.push('');
+        lines.push((0, status_report_1.formatVerboseStatusText)(res.accounts));
+    }
+    console.log(lines.join('\n'));
+}
+function connectUsage() {
+    console.error(`NeoZip Connect — Token Service account setup
+
+Usage:
+  neozip connect                              Interactive wizard (default)
+  neozip connect wizard                       Same as running with no subcommand
+  neozip connect status [--verbose] [--json] [--token-service-url URL]
+  neozip connect select --connection-id ID [--json]
+  neozip connect rename --label NAME [--connection-id ID] [--json]
+  neozip connect dump [--connection-id ID]   Print manifest + public.json (no secrets)
+  neozip connect register --email EMAIL [--resend] [--json] [--token-service-url URL] [--label NAME]
+  neozip connect verify --email EMAIL --code CODE [--json] [--token-service-url URL]
+  neozip connect verify --magic-token LINK_OR_TOKEN [--email EMAIL] [--json]
+  neozip connect refresh [--email EMAIL]                Renew an expired access token (sends a code)
+  neozip connect refresh --email EMAIL --code CODE      Complete the token refresh
+  neozip connect refresh --magic-token LINK_OR_TOKEN [--json]
+  neozip connect fund [request|status|policy] [--network NAME | --chain ID] [--json]
+                                              Request native gas for your Data Wallet (default: request)
+  neozip connect phone request --phone +14155551234 [--json] [--token-service-url URL]
+  neozip connect phone verify --phone +14155551234 --code CODE [--json] [--token-service-url URL]
+  neozip connect wallet create --ack-backup [--json] [--token-service-url URL]
+  neozip connect wallet import-mnemonic --mnemonic "word1 word2 ..." [--force] [--json]
+  neozip connect wallet import-key --private-key 0x... [--force] [--json]
+  neozip connect finish [--create-wallet] [--json] [--token-service-url URL]
+  neozip connect setup --email EMAIL --code CODE [--json] [--token-service-url URL]
+  neozip connect logout [--json]
+  neozip connect delete [--json] [--connection-id ID]
+  neozip connect settings              Change on-chain prefs (network, RPC, gas)
+  neozip connect migrate [--json]
+  neozip connect reset [--force]     Remove connection data (re-run setup)
+
+Environment:
+  NEOZIP_UNLOCK_PASSPHRASE — optional custom passphrase (default: machine-local key)
+  NEOZIP_CONNECTION_DIR — override connection store path (~/.neozip/connection/)
+`);
+}
+/**
+ * Run connect subcommand. Pass argv after "connect" (e.g. ['status'] or [] for wizard).
+ */
+async function runConnectCommand(connectArgv) {
+    const { command, flags, positional } = parseConnectArgs(connectArgv);
+    const json = Boolean(flags.json);
+    const tokenServiceUrl = typeof flags.tokenServiceUrl === 'string' ? flags.tokenServiceUrl : undefined;
+    const label = typeof flags.label === 'string' ? flags.label : undefined;
+    let res;
+    switch (command) {
+        case 'interactive':
+        case 'wizard':
+            if (json) {
+                throw new Error('Interactive setup requires a TTY; omit --json or use subcommands (register, verify, finish).');
+            }
+            if (!process.stdin.isTTY) {
+                throw new Error('Interactive setup requires a TTY. Use subcommands with --json for scripted setup.');
+            }
+            res = await (0, interactive_1.runInteractiveConnect)({ tokenServiceUrl, label });
+            return res.success ? 0 : 1;
+        case 'status':
+            res = await (0, onboarding_1.connectStatus)({
+                tokenServiceUrl,
+                autoMigrate: true,
+                verbose: Boolean(flags.verbose),
+            });
+            break;
+        case 'select': {
+            const connectionId = String(flags.connectionId || '');
+            if (!connectionId)
+                throw new Error('--connection-id is required');
+            res = (0, onboarding_1.connectSelect)({ connectionId });
+            break;
+        }
+        case 'rename': {
+            const renameLabel = String(flags.label || '');
+            if (!renameLabel)
+                throw new Error('--label is required');
+            const connectionId = typeof flags.connectionId === 'string' ? flags.connectionId : undefined;
+            res = (0, onboarding_1.connectRename)({ label: renameLabel, connectionId });
+            break;
+        }
+        case 'dump': {
+            const connectionId = typeof flags.connectionId === 'string' ? flags.connectionId : undefined;
+            const snapshot = (0, dump_1.buildConnectionDump)({ connectionId });
+            console.log((0, dump_1.formatConnectionDump)(snapshot));
+            return 0;
+        }
+        case 'register': {
+            const email = String(flags.email || '');
+            if (!email)
+                throw new Error('--email is required');
+            res = await (0, onboarding_1.connectRegister)({
+                email,
+                tokenServiceUrl,
+                label,
+                resend: Boolean(flags.resend),
+            });
+            break;
+        }
+        case 'verify': {
+            const email = typeof flags.email === 'string' ? flags.email : undefined;
+            const code = typeof flags.code === 'string' ? flags.code : undefined;
+            const magicToken = typeof flags.magicToken === 'string' ? flags.magicToken : undefined;
+            if (!magicToken && (!email || !code)) {
+                throw new Error('Provide --email and --code, or --magic-token (optionally with --email)');
+            }
+            res = await (0, onboarding_1.connectVerify)({ email, code, magicToken, tokenServiceUrl });
+            break;
+        }
+        case 'refresh': {
+            const email = typeof flags.email === 'string' ? flags.email : undefined;
+            const code = typeof flags.code === 'string' ? flags.code : undefined;
+            const magicToken = typeof flags.magicToken === 'string' ? flags.magicToken : undefined;
+            res = await (0, onboarding_1.connectRefresh)({ email, code, magicToken, tokenServiceUrl });
+            break;
+        }
+        case 'fund': {
+            const sub = positional[0];
+            const allowed = ['request', 'status', 'policy'];
+            const action = sub && allowed.includes(sub) ? sub : 'request';
+            if (sub && !allowed.includes(sub)) {
+                throw new Error('Usage: neozip connect fund [request|status|policy] [--network NAME | --chain ID]');
+            }
+            const network = typeof flags.network === 'string' ? flags.network : undefined;
+            const chainRaw = typeof flags.chain === 'string' ? flags.chain : undefined;
+            const chainId = chainRaw ? Number.parseInt(chainRaw, 10) : undefined;
+            if (chainRaw && (!Number.isFinite(chainId) || chainId <= 0)) {
+                throw new Error(`Invalid --chain value: ${chainRaw}`);
+            }
+            const fundRes = await (0, funding_1.connectFund)({ action, network, chainId, tokenServiceUrl });
+            if (json) {
+                console.log(JSON.stringify(fundRes, null, 2));
+            }
+            else {
+                console.log((0, funding_1.formatFundResult)(fundRes));
+            }
+            return fundRes.success ? 0 : 1;
+        }
+        case 'phone': {
+            const action = positional[0];
+            const phone = String(flags.phone || '');
+            if (action === 'request') {
+                if (!phone)
+                    throw new Error('--phone is required');
+                res = await (0, onboarding_1.connectPhoneRequest)({ phone, tokenServiceUrl });
+            }
+            else if (action === 'verify') {
+                const code = String(flags.code || '');
+                if (!phone || !code)
+                    throw new Error('--phone and --code are required');
+                res = await (0, onboarding_1.connectPhoneVerify)({ phone, code, tokenServiceUrl });
+            }
+            else {
+                throw new Error('Usage: neozip connect phone request|verify ...');
+            }
+            break;
+        }
+        case 'wallet': {
+            const action = positional[0];
+            if (action === 'create') {
+                res = await (0, onboarding_1.connectWalletCreate)({
+                    ackBackup: Boolean(flags.ackBackup),
+                    tokenServiceUrl,
+                });
+            }
+            else if (action === 'import-mnemonic') {
+                const mnemonic = String(flags.mnemonic || '');
+                if (!mnemonic)
+                    throw new Error('--mnemonic is required');
+                res = await (0, onboarding_1.connectWalletImportMnemonic)({
+                    mnemonic,
+                    force: Boolean(flags.force),
+                    tokenServiceUrl,
+                });
+            }
+            else if (action === 'import-key') {
+                const privateKey = String(flags.privateKey || '');
+                if (!privateKey)
+                    throw new Error('--private-key is required');
+                res = await (0, onboarding_1.connectWalletImportKey)({
+                    privateKey,
+                    force: Boolean(flags.force),
+                    tokenServiceUrl,
+                });
+            }
+            else {
+                throw new Error('Usage: neozip connect wallet create|import-mnemonic|import-key ...');
+            }
+            break;
+        }
+        case 'finish':
+            res = await (0, onboarding_1.connectFinish)({
+                tokenServiceUrl,
+                createWallet: Boolean(flags.createWallet),
+            });
+            break;
+        case 'setup': {
+            const email = String(flags.email || '');
+            const code = String(flags.code || '');
+            if (!email || !code)
+                throw new Error('--email and --code are required');
+            res = await (0, onboarding_1.connectSetup)({ email, code, tokenServiceUrl, label });
+            break;
+        }
+        case 'logout':
+            res = (0, onboarding_1.connectLogout)();
+            break;
+        case 'delete': {
+            const connectionId = typeof flags.connectionId === 'string' ? flags.connectionId : undefined;
+            res = (0, onboarding_1.connectDelete)({ connectionId });
+            break;
+        }
+        case 'settings':
+            if (json) {
+                throw new Error('Interactive settings requires a TTY; omit --json.');
+            }
+            if (!process.stdin.isTTY) {
+                throw new Error('Interactive settings requires a TTY.');
+            }
+            return await (0, cli_settings_1.runConnectSettingsInteractive)();
+        case 'migrate':
+            res = (0, onboarding_1.connectMigrate)();
+            break;
+        case 'reset': {
+            const force = connectArgv.includes('--force') || connectArgv.includes('-f');
+            if (!force && process.stdin.isTTY) {
+                console.error('This removes all NeoZip connection data.', 'Run: neozip connect reset --force');
+                return 1;
+            }
+            const out = (0, reset_1.resetConnectionStore)();
+            res = {
+                success: out.removedConnection || out.removedLegacy,
+                phase: 'no_profile',
+                message: [
+                    out.removedConnection ? `Removed ${out.connectionDir}` : null,
+                    out.removedLegacy ? `Removed ${out.legacyMcpDir}` : null,
+                    'Run neozip connect to set up again.',
+                ]
+                    .filter(Boolean)
+                    .join(' '),
+            };
+            if (!json) {
+                console.error(res.message);
+                return 0;
+            }
+            break;
+        }
+        case 'help':
+            connectUsage();
+            return 0;
+        default:
+            connectUsage();
+            throw new Error(`Unknown command: ${command}`);
+    }
+    printResult(res, json);
+    if (!res.success && res.phase !== 'awaiting_code') {
+        return 1;
+    }
+    return 0;
+}
+//# sourceMappingURL=command.js.map

package/dist/src/connection/bootstrap.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrapConnectionContext = bootstrapConnectionContext;
+exports.readCliConnectionCredentials = readCliConnectionCredentials;
+exports.getTokenServiceRuntimeOptions = getTokenServiceRuntimeOptions;
+exports.resolveVerifyServerUrl = resolveVerifyServerUrl;
+const credentials_1 = require("./credentials");
+const promote_active_1 = require("./promote-active");
+const store_1 = require("./store");
+const phase_1 = require("./phase");
+/** Non-blocking first-pass: promote ready account if needed, read connection store. */
+function bootstrapConnectionContext() {
+    try {
+        (0, promote_active_1.promoteReadyActiveConnection)();
+        (0, store_1.applyActiveConnectionToEnv)();
+    }
+    catch {
+        // Ignore promotion errors — normal zip ops must still run
+    }
+    const creds = (0, credentials_1.readConnectionCredentials)();
+    const phase = (0, phase_1.computeConnectionPhase)();
+    return {
+        applied: creds.connectionId !== null,
+        connectionId: creds.connectionId,
+        phase,
+        creds,
+    };
+}
+function readCliConnectionCredentials() {
+    return (0, credentials_1.readConnectionCredentials)();
+}
+function getTokenServiceRuntimeOptions(debug = false) {
+    const creds = (0, credentials_1.readConnectionCredentials)();
+    if (!creds.tokenServiceUrl || !creds.recipientEmail) {
+        return null;
+    }
+    return {
+        serverUrl: creds.tokenServiceUrl,
+        recipientEmail: creds.recipientEmail,
+        debug,
+    };
+}
+/** Server URL for verifyDigest: archive metadata first, then active connection. */
+function resolveVerifyServerUrl(metadataServerUrl) {
+    if (metadataServerUrl?.trim()) {
+        return metadataServerUrl.trim();
+    }
+    return (0, credentials_1.readConnectionCredentials)().tokenServiceUrl ?? undefined;
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/src/connection/cli-guidance.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTokenServiceConfigured = isTokenServiceConfigured;
+exports.formatConnectGuidance = formatConnectGuidance;
+exports.formatTokenExpiredGuidance = formatTokenExpiredGuidance;
+exports.requireConnectionReady = requireConnectionReady;
+exports.requireTimestampReady = requireTimestampReady;
+exports.requireWalletReady = requireWalletReady;
+const token_service_1 = require("neozip-blockchain/token-service");
+const credentials_1 = require("./credentials");
+const phase_1 = require("./phase");
+const store_1 = require("./store");
+const token_auth_1 = require("./token-auth");
+const incomplete_setup_1 = require("./incomplete-setup");
+function isTokenServiceConfigured() {
+    if ((0, phase_1.computeConnectionPhase)() === 'ready')
+        return true;
+    const meta = (0, store_1.getActiveConnection)();
+    const secrets = (0, store_1.readActiveConnectionSecrets)();
+    if (meta?.emailVerified && secrets?.accessToken?.trim()) {
+        if ((0, token_auth_1.isAccessTokenExpired)(secrets))
+            return false;
+        return true;
+    }
+    return false;
+}
+function formatConnectGuidance(ability) {
+    const phase = (0, phase_1.computeConnectionPhase)();
+    const next = (0, incomplete_setup_1.recommendedConnectCommand)();
+    const creds = (0, credentials_1.readConnectionCredentials)();
+    const infoUrl = creds.tokenServiceUrl
+        ? `${(0, token_service_1.getTokenServiceUrl)({ serverUrl: creds.tokenServiceUrl }).replace(/\/+$/, '')}/info`
+        : 'https://testnet.token-service.neozip.io/info';
+    return [
+        `${ability} requires Token Service setup via neozip connect (current phase: ${phase}).`,
+        '',
+        'Run:',
+        `  ${next}`,
+        '',
+        'Or check status:',
+        '  neozip connect status',
+        '',
+        `More information: ${infoUrl}`,
+    ].join('\n');
+}
+/**
+ * Guidance for the specific case where the account is otherwise set up but the
+ * Token Service access token has expired. Points at `neozip connect refresh`
+ * rather than the generic setup flow.
+ */
+function formatTokenExpiredGuidance(ability) {
+    const email = (0, store_1.getActiveConnection)()?.email ?? null;
+    const refreshCmd = email
+        ? `neozip connect refresh --email ${email}`
+        : 'neozip connect refresh';
+    return [
+        `${ability} needs a current Token Service access token, but the saved token has expired.`,
+        '',
+        'Refresh it (a 6-digit code is emailed to you):',
+        `  ${refreshCmd}`,
+        `  ${refreshCmd} --code 123456`,
+        '',
+        'Or check status:',
+        '  neozip connect status',
+    ].join('\n');
+}
+/** Unified preflight for -b, -ts, mint, and other gated blockchain operations. */
+function requireConnectionReady(ability, kind = 'tokenService') {
+    const phase = (0, phase_1.computeConnectionPhase)();
+    if (phase !== 'ready') {
+        return formatConnectGuidance(ability);
+    }
+    const creds = (0, credentials_1.readConnectionCredentials)();
+    // Every gated operation needs the local wallet key (phase 'ready' guarantees
+    // it exists, but a one-off connection without it should still be caught).
+    if (!creds.walletKey?.trim()) {
+        return formatConnectGuidance(ability);
+    }
+    // Token Service requirements apply only to Token Service operations. On-chain
+    // operations (-b, mint) sign locally and do not use the access token, so an
+    // expired/absent Token Service token must not block them.
+    if (kind === 'tokenService') {
+        const secrets = (0, store_1.readActiveConnectionSecrets)();
+        if ((0, token_auth_1.isAccessTokenExpired)(secrets)) {
+            return formatTokenExpiredGuidance(ability);
+        }
+        if (!creds.recipientEmail?.trim() || !creds.tokenServiceUrl?.trim()) {
+            return formatConnectGuidance(ability);
+        }
+    }
+    return null;
+}
+/** @deprecated Use requireConnectionReady */
+function requireTimestampReady() {
+    return requireConnectionReady('Blockchain timestamp (-ts)', 'tokenService');
+}
+/** @deprecated Use requireConnectionReady */
+function requireWalletReady() {
+    return requireConnectionReady('On-chain blockchain operation', 'wallet');
+}
+//# sourceMappingURL=cli-guidance.js.map