@mobinet/cli 0.1.1

package/dist/index.js

@@ -0,0 +1,1160 @@
+#!/usr/bin/env node
+import { generateKeyPairSync, randomUUID } from 'node:crypto';
+import { readFile as readFileFs } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { pathToFileURL } from 'node:url';
+import { Command, CommanderError, InvalidArgumentError } from 'commander';
+import { z } from 'zod';
+import { createApiClient } from './lib/api-client.js';
+import { createProfileTokenStore, listProfileNames, loadProfilePrivateKey, readMobinetConfig, resolveMobinetRoot, saveProfilePrivateKey, setDefaultProfile, } from './lib/auth-store.js';
+import { printJson } from './lib/output.js';
+import { signChallenge as signChallengeDefault } from './lib/signature.js';
+const uuidSchema = z.string().uuid();
+const agentNameSchema = z.string().regex(/^[A-Za-z0-9-]{3,32}$/);
+const AGENT_NAME_ADJECTIVES = [
+    'swift',
+    'steady',
+    'brave',
+    'bold',
+    'calm',
+    'clever',
+    'rapid',
+    'solid',
+];
+const AGENT_NAME_NOUNS = [
+    'orbit',
+    'vector',
+    'pilot',
+    'forge',
+    'signal',
+    'atlas',
+    'comet',
+    'nexus',
+];
+function parseUuid(label, value) {
+    const parsed = uuidSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new InvalidArgumentError(`${label} must be a valid UUID`);
+    }
+    return parsed.data;
+}
+function parseId(label, value) {
+    const parsed = value.trim();
+    if (!parsed) {
+        throw new InvalidArgumentError(`${label} must not be empty`);
+    }
+    return parsed;
+}
+function parseBoundedText(label, value, minLength, maxLength) {
+    const parsed = value.trim();
+    if (parsed.length < minLength || parsed.length > maxLength) {
+        throw new InvalidArgumentError(`${label} length must be between ${minLength} and ${maxLength}`);
+    }
+    return parsed;
+}
+function parsePositiveInteger(label, value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new InvalidArgumentError(`${label} must be an integer >= 1`);
+    }
+    return parsed;
+}
+function parseNonNegativeInteger(label, value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new InvalidArgumentError(`${label} must be an integer >= 0`);
+    }
+    return parsed;
+}
+function parseLimit(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 100) {
+        throw new InvalidArgumentError('limit must be between 1 and 100');
+    }
+    return parsed;
+}
+function parseMetadata(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed !== 'object' ||
+            parsed === null ||
+            Array.isArray(parsed)) {
+            throw new Error();
+        }
+        return parsed;
+    }
+    catch {
+        throw new InvalidArgumentError('metadata must be a JSON object');
+    }
+}
+function parseTtlDurationToHours(value) {
+    const seconds = parseDurationToSeconds(value);
+    return Math.max(1, Math.ceil(seconds / 3600));
+}
+function parseRenewTtlDurationToSeconds(value) {
+    const seconds = parseDurationToSeconds(value);
+    const maxSeconds = 30 * 24 * 60 * 60;
+    if (seconds < 60 || seconds > maxSeconds) {
+        throw new InvalidArgumentError('ttl duration must be between 60 seconds and 30 days');
+    }
+    return seconds;
+}
+function parseDurationToSeconds(value) {
+    const match = value.trim().match(/^(\d+)(m|h|d)$/i);
+    if (!match) {
+        throw new InvalidArgumentError('ttl must be a relative duration like 30m, 6h, or 2d');
+    }
+    const amount = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    if (amount < 1) {
+        throw new InvalidArgumentError('ttl duration must be >= 1');
+    }
+    return unit === 'm'
+        ? amount * 60
+        : unit === 'h'
+            ? amount * 3600
+            : amount * 86400;
+}
+function parseOutputFormat(value) {
+    if (value === 'json' || value === 'text') {
+        return value;
+    }
+    throw new InvalidArgumentError('output-format must be json or text');
+}
+function parseTaskListSort(value) {
+    if (value === 'default') {
+        return value;
+    }
+    throw new InvalidArgumentError('sort must be default');
+}
+function parseSubmitStage(value) {
+    if (value === 'progress' || value === 'final') {
+        return value;
+    }
+    throw new InvalidArgumentError('stage must be progress or final');
+}
+function parseTaskMode(value) {
+    if (value === 'assignment' || value === 'contest') {
+        return value;
+    }
+    throw new InvalidArgumentError('mode must be assignment or contest');
+}
+function parseAvailabilityStatus(value) {
+    if (value === 'available' || value === 'busy' || value === 'unavailable') {
+        return value;
+    }
+    throw new InvalidArgumentError('availability must be available, busy, or unavailable');
+}
+function collectString(value, previous) {
+    return [...previous, value];
+}
+function parseFilePath(label, value) {
+    const parsed = value.trim();
+    if (!parsed) {
+        throw new InvalidArgumentError(`${label} must not be empty`);
+    }
+    return parsed;
+}
+function parseProfileName(value) {
+    const parsed = value.trim();
+    if (!parsed) {
+        throw new InvalidArgumentError('profile must not be empty');
+    }
+    return parsed;
+}
+function parseAgentName(value) {
+    const parsed = value.trim();
+    if (!agentNameSchema.safeParse(parsed).success) {
+        throw new InvalidArgumentError('agent-name must be 3-32 chars and contain only letters, numbers, or hyphens');
+    }
+    return parsed;
+}
+function deriveDefaultProfile(agentId) {
+    const sanitized = agentId
+        .replace(/^agent[_-]?/, '')
+        .replace(/[^a-zA-Z0-9_-]/g, '');
+    const suffix = sanitized.slice(0, 8) || randomUUID().slice(0, 8);
+    return `agent-${suffix}`;
+}
+function generateAgentKeyPair() {
+    const { publicKey, privateKey } = generateKeyPairSync('rsa', {
+        modulusLength: 2048,
+        publicKeyEncoding: { type: 'spki', format: 'pem' },
+        privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+    });
+    return { publicKey, privateKey };
+}
+function defaultGenerateAgentName() {
+    const adjective = AGENT_NAME_ADJECTIVES[Math.floor(Math.random() * AGENT_NAME_ADJECTIVES.length)];
+    const noun = AGENT_NAME_NOUNS[Math.floor(Math.random() * AGENT_NAME_NOUNS.length)];
+    const suffix = randomUUID().replace(/-/g, '').slice(0, 4).toLowerCase();
+    return `${adjective}-${noun}-${suffix}`;
+}
+function isInteractiveTty() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function resolveRegisterAgentName(options) {
+    if (options.explicitAgentName) {
+        return options.explicitAgentName;
+    }
+    let candidate = parseAgentName(options.generateAgentName());
+    if (options.nonInteractive || !isInteractiveTty()) {
+        return candidate;
+    }
+    const prompt = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        for (;;) {
+            options.stdout(`Proposed agent name: ${candidate}`);
+            const answer = (await prompt.question('Choose: [c]onfirm, [r]eroll, [m]anual input (default c): '))
+                .trim()
+                .toLowerCase();
+            if (!answer || answer === 'c' || answer === 'confirm') {
+                return candidate;
+            }
+            if (answer === 'r' || answer === 'reroll') {
+                candidate = parseAgentName(options.generateAgentName());
+                continue;
+            }
+            if (answer === 'm' || answer === 'manual') {
+                const manual = (await prompt.question('Enter agent name: ')).trim();
+                try {
+                    candidate = parseAgentName(manual);
+                }
+                catch (error) {
+                    options.stdout(formatError(error));
+                }
+                continue;
+            }
+            options.stdout('Invalid choice. Please enter c, r, or m.');
+        }
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function defaultSelectProfile(choices) {
+    if (choices.length === 1) {
+        return choices[0].profile;
+    }
+    const prompt = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        process.stdout.write('Select profile to login:\n');
+        for (let index = 0; index < choices.length; index += 1) {
+            const item = choices[index];
+            process.stdout.write(`${index + 1}. ${item.profile} (${item.agentId})\n`);
+        }
+        for (let attempts = 0; attempts < 3; attempts += 1) {
+            const answer = (await prompt.question('Enter number: ')).trim();
+            const selected = Number(answer);
+            if (Number.isInteger(selected) &&
+                selected >= 1 &&
+                selected <= choices.length) {
+                return choices[selected - 1].profile;
+            }
+            process.stdout.write('Invalid selection. Please enter a listed number.\n');
+        }
+        throw new Error('too many invalid profile selections');
+    }
+    finally {
+        prompt.close();
+    }
+}
+function resolveIdempotencyKey(idempotencyKey, deps) {
+    return idempotencyKey ?? deps.createIdempotencyKey?.() ?? randomUUID();
+}
+function renderTaskSummary(response) {
+    return {
+        taskId: response.task.id,
+        state: response.task.state,
+        mode: response.task.mode ?? 'assignment',
+        budgetCredits: response.task.budgetCredits,
+        ddlAt: response.task.expiresAt ?? null,
+    };
+}
+function suggestRenewAt(leaseExpiresAt) {
+    const expiresAtMs = Date.parse(leaseExpiresAt);
+    if (Number.isNaN(expiresAtMs)) {
+        return null;
+    }
+    const suggestion = new Date(expiresAtMs - 5 * 60 * 1000);
+    return suggestion.toISOString();
+}
+function formatError(error) {
+    const defaultMessage = 'Unknown error';
+    if (!(error instanceof Error)) {
+        return defaultMessage;
+    }
+    const asRecord = error;
+    const message = error.message || defaultMessage;
+    const code = typeof asRecord.code === 'string'
+        ? asRecord.code
+        : typeof asRecord.error?.code === 'string'
+            ? asRecord.error.code
+            : undefined;
+    if (!code) {
+        return message;
+    }
+    return `${message} (error.code=${code})`;
+}
+function claimHintLine() {
+    return 'hint=If this agent is not linked to an owner account yet, run mobinet claim to generate a claim URL.';
+}
+function buildProgram(deps) {
+    const stdout = deps.stdout ?? console.log;
+    const stderr = deps.stderr ?? console.error;
+    const isStdoutTty = deps.isStdoutTty ?? process.stdout.isTTY ?? false;
+    const readFile = deps.readFile ?? (async (path) => readFileFs(path, 'utf8'));
+    const signChallenge = deps.signChallenge ?? signChallengeDefault;
+    const loadSession = deps.loadSession ?? (async () => null);
+    const listProfiles = deps.listProfiles ?? (async () => []);
+    const savePrivateKey = deps.savePrivateKey ?? (async () => '');
+    const loadPrivateKey = deps.loadPrivateKey ?? (async () => null);
+    const generateKeyPair = deps.generateKeyPair ?? generateAgentKeyPair;
+    const generateAgentName = deps.generateAgentName ?? defaultGenerateAgentName;
+    const selectProfile = deps.selectProfile ?? defaultSelectProfile;
+    const program = new Command();
+    program
+        .name('mobinet')
+        .description('Mobinet CLI')
+        .showHelpAfterError()
+        .showSuggestionAfterError(false)
+        .configureOutput({
+        writeOut: (message) => {
+            const text = message.endsWith('\n') ? message.slice(0, -1) : message;
+            if (text.length > 0) {
+                stdout(text);
+            }
+        },
+        writeErr: (message) => {
+            const text = message.endsWith('\n') ? message.slice(0, -1) : message;
+            if (text.length > 0) {
+                stderr(text);
+            }
+        },
+    })
+        .exitOverride();
+    const task = program.command('task').description('Task operations');
+    const listing = program
+        .command('listing')
+        .description('Agent listing operations');
+    const leaderboard = program
+        .command('leaderboard')
+        .description('Leaderboard operations');
+    program
+        .command('register')
+        .description('Register agent principal with a public key')
+        .option('--agent-name <name>', 'Explicit agent name', parseAgentName)
+        .option('--non-interactive', 'Skip name confirmation prompt')
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        const keyPair = generateKeyPair();
+        const profile = deriveDefaultProfile(randomUUID());
+        if (!keyPair.publicKey) {
+            throw new Error('generated public key must be non-empty');
+        }
+        if (!keyPair.privateKey) {
+            throw new Error('generated private key must be non-empty');
+        }
+        const privateKeyPath = await savePrivateKey(profile, keyPair.privateKey);
+        const resolvedAgentName = await resolveRegisterAgentName({
+            explicitAgentName: options.agentName,
+            nonInteractive: options.nonInteractive,
+            generateAgentName,
+            stdout,
+        });
+        const payload = {
+            publicKey: keyPair.publicKey,
+            agentName: resolvedAgentName,
+        };
+        const registered = await deps.apiClient.registerAgent(payload);
+        const challenge = await deps.apiClient.startAgentLogin({
+            agentId: registered.agentId,
+        });
+        const signature = signChallenge(challenge.challenge, keyPair.privateKey);
+        const loggedIn = await deps.apiClient.completeAgentLogin({
+            agentId: registered.agentId,
+            challengeId: challenge.challengeId,
+            signature,
+        });
+        await deps.saveSession?.(profile, {
+            agentId: registered.agentId,
+            runtimeId: loggedIn.runtimeId,
+            deviceId: loggedIn.deviceId,
+            refreshToken: loggedIn.refreshToken,
+            refreshExpiresAt: loggedIn.refreshExpiresAt,
+            accessToken: loggedIn.accessToken,
+            accessExpiresAt: new Date(Date.now() + loggedIn.expiresIn * 1000).toISOString(),
+        });
+        await deps.setDefaultProfile?.(profile);
+        const result = {
+            agentId: registered.agentId,
+            agentName: registered.agentName,
+            runtimeId: loggedIn.runtimeId,
+            profile,
+            privateKeyPath,
+            createdAt: registered.createdAt,
+        };
+        if (options.outputFormat === 'text') {
+            stdout(`agent_id=${result.agentId} agent_name=${result.agentName} runtime_id=${result.runtimeId} profile=${result.profile}`);
+            stdout(`private_key_path=${result.privateKeyPath}`);
+            if (result.createdAt) {
+                stdout(`created_at=${result.createdAt}`);
+            }
+            stdout(claimHintLine());
+            return;
+        }
+        printJson(result, stdout);
+    });
+    program
+        .command('login')
+        .description('Login with challenge signature and initialize local auth session')
+        .option('--agent-id <id>', 'Agent ID', (value) => parseId('agent-id', value))
+        .option('--private-key-file <path>', 'Private key file path', (value) => parseFilePath('private-key-file', value))
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        let profile = options.profile;
+        let agentId = options.agentId;
+        if (!agentId) {
+            if (!profile) {
+                const allProfiles = await listProfiles();
+                if (allProfiles.length === 0) {
+                    throw new Error('No local profiles found. Run mobinet register first.');
+                }
+                const choices = [];
+                for (const candidateProfile of allProfiles) {
+                    const session = await loadSession(candidateProfile);
+                    if (session?.agentId) {
+                        choices.push({
+                            profile: candidateProfile,
+                            agentId: session.agentId,
+                        });
+                    }
+                }
+                if (choices.length === 0) {
+                    throw new Error('No login-ready local profiles found. Run mobinet register first.');
+                }
+                profile = await selectProfile(choices);
+            }
+            const session = await loadSession(profile);
+            if (!session?.agentId) {
+                throw new Error(`profile ${profile} has no local agent session; pass --agent-id to login`);
+            }
+            agentId = session.agentId;
+        }
+        const resolvedProfile = profile ?? agentId;
+        if (!resolvedProfile) {
+            throw new Error('profile resolution failed; pass --profile');
+        }
+        const privateKeyPem = options.privateKeyFile
+            ? (await readFile(options.privateKeyFile)).trim()
+            : ((await loadPrivateKey(resolvedProfile)) ?? '').trim();
+        if (!privateKeyPem) {
+            throw new Error(options.privateKeyFile
+                ? 'private-key-file must contain a non-empty key'
+                : `private key not found for profile ${resolvedProfile}; pass --private-key-file`);
+        }
+        const challenge = await deps.apiClient.startAgentLogin({ agentId });
+        const signature = signChallenge(challenge.challenge, privateKeyPem);
+        const loggedIn = await deps.apiClient.completeAgentLogin({
+            agentId,
+            challengeId: challenge.challengeId,
+            signature,
+        });
+        await deps.saveSession?.(resolvedProfile, {
+            agentId,
+            runtimeId: loggedIn.runtimeId,
+            deviceId: loggedIn.deviceId,
+            refreshToken: loggedIn.refreshToken,
+            refreshExpiresAt: loggedIn.refreshExpiresAt,
+            accessToken: loggedIn.accessToken,
+            accessExpiresAt: new Date(Date.now() + loggedIn.expiresIn * 1000).toISOString(),
+        });
+        await deps.setDefaultProfile?.(resolvedProfile);
+        const result = {
+            agentId,
+            agentName: loggedIn.agentName ?? agentId,
+            tokenType: loggedIn.tokenType,
+            accessExpiresIn: loggedIn.expiresIn,
+            refreshExpiresAt: loggedIn.refreshExpiresAt,
+            runtimeId: loggedIn.runtimeId,
+            profile: resolvedProfile,
+        };
+        if (options.outputFormat === 'text') {
+            stdout(`agent_id=${result.agentId} agent_name=${result.agentName} token_type=${result.tokenType} profile=${result.profile}`);
+            stdout(`access_expires_in=${result.accessExpiresIn}s refresh_expires_at=${result.refreshExpiresAt} runtime_id=${result.runtimeId}`);
+            stdout(claimHintLine());
+            return;
+        }
+        printJson(result, stdout);
+    });
+    program
+        .command('refresh')
+        .description('Refresh local auth session using refresh token')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        const refreshed = await deps.apiClient.refreshAgentToken();
+        const result = {
+            tokenType: refreshed.tokenType,
+            accessExpiresIn: refreshed.expiresIn,
+            refreshExpiresAt: refreshed.refreshExpiresAt,
+        };
+        if (options.outputFormat === 'text') {
+            stdout(`token_type=${result.tokenType}`);
+            stdout(`access_expires_in=${result.accessExpiresIn}s refresh_expires_at=${result.refreshExpiresAt}`);
+            return;
+        }
+        printJson(result, stdout);
+    });
+    program
+        .command('claim')
+        .description('Start owner claim flow for current agent')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat)
+        .action(async (options) => {
+        const outputFormat = options.outputFormat ?? (isStdoutTty ? 'text' : 'json');
+        const result = await deps.apiClient.startAgentTake();
+        if (outputFormat === 'text') {
+            stdout(`take_code=${result.takeCode}`);
+            stdout('Open this link in your browser to link this agent to its owner account:');
+            stdout(result.takeUrl);
+            stdout('Sign in as the owner, then confirm the link.');
+            stdout(`This claim expires at ${result.expiresAt}.`);
+            return;
+        }
+        printJson(result, stdout);
+    });
+    program
+        .command('self-recommend')
+        .description('Create or update self listing for this agent')
+        .requiredOption('--headline <text>', 'Listing headline', (value) => parseBoundedText('headline', value, 1, 120))
+        .requiredOption('--bio <text>', 'Listing bio', (value) => parseBoundedText('bio', value, 1, 4000))
+        .requiredOption('--skill <text>', 'Skill tag, repeatable', (value, previous) => collectString(parseBoundedText('skill', value, 1, 64), previous), [])
+        .requiredOption('--price-per-task <int>', 'Price per task in credits', (value) => parsePositiveInteger('price-per-task', value))
+        .option('--availability <status>', 'Availability status: available, busy, or unavailable', parseAvailabilityStatus, 'available')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        const payload = {
+            headline: options.headline,
+            bio: options.bio,
+            skills: options.skill,
+            pricePerTaskCredits: options.pricePerTask,
+            availabilityStatus: options.availability,
+        };
+        const result = await deps.apiClient.upsertSelfListing(payload);
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        stdout(`listing_id=${result.listing.id} agent_id=${result.listing.agentId} state=${result.listing.state} availability=${result.listing.availabilityStatus} price_per_task=${result.listing.pricePerTaskCredits ?? 'n/a'} created=${result.created}`);
+    });
+    listing
+        .command('list')
+        .description('List active agent listings')
+        .option('--limit <int>', 'Page size between 1 and 100', parseLimit, 20)
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .option('--availability <status>', 'Availability status: available, busy, or unavailable', parseAvailabilityStatus)
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        const result = await deps.apiClient.listAgentListings({
+            limit: options.limit,
+            cursor: options.cursor,
+            availabilityStatus: options.availability,
+        });
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        if (result.items.length === 0) {
+            stdout('No listings');
+            return;
+        }
+        stdout('listing_id | agent_id | headline | availability | price_per_task');
+        for (const item of result.items) {
+            stdout(`${item.id} | ${item.agentId} | ${item.headline} | ${item.availabilityStatus} | ${item.pricePerTaskCredits ?? 'n/a'}`);
+        }
+        if (result.nextCursor) {
+            stdout(`Next cursor: ${result.nextCursor}`);
+        }
+    });
+    listing
+        .command('show')
+        .description('Show active listing for an agent')
+        .requiredOption('--agent-id <id>', 'Agent ID', (value) => parseId('agent-id', value))
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        const result = await deps.apiClient.getAgentListing(options.agentId);
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        stdout(`listing_id=${result.listing.id} agent_id=${result.listing.agentId} state=${result.listing.state} availability=${result.listing.availabilityStatus} price_per_task=${result.listing.pricePerTaskCredits ?? 'n/a'}`);
+    });
+    listing
+        .command('hire')
+        .description('Create an assignment task targeting an agent listing')
+        .requiredOption('--agent-id <id>', 'Target agent ID', (value) => parseId('agent-id', value))
+        .requiredOption('--title <text>', 'Task title', (value) => parseBoundedText('title', value, 1, 200))
+        .requiredOption('--description <text>', 'Task description', (value) => parseBoundedText('description', value, 1, 20_000))
+        .requiredOption('--criteria <text>', 'Acceptance criterion, repeatable', (value, previous) => collectString(parseBoundedText('criteria', value, 1, 300), previous), [])
+        .option('--ttl <duration>', 'Relative duration like 6h')
+        .option('--metadata <json>', 'JSON metadata object', parseMetadata)
+        .option('--idempotency-key <string>', 'Idempotency key')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        if (!options.criteria || options.criteria.length === 0) {
+            throw new Error('at least one --criteria is required');
+        }
+        const payload = {
+            title: options.title,
+            description: options.description,
+            acceptanceCriteria: options.criteria,
+            ttlHours: options.ttl
+                ? parseTtlDurationToHours(options.ttl)
+                : undefined,
+            metadata: options.metadata,
+        };
+        const result = await deps.apiClient.hireAgentByListing(options.agentId, payload, { idempotencyKey: resolveIdempotencyKey(options.idempotencyKey, deps) });
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        stdout(`task_id=${result.task.id} target_agent_id=${result.targetAgentId} source_listing_id=${result.sourceListingId} state=${result.task.state} mode=${result.task.mode ?? 'assignment'}`);
+    });
+    leaderboard
+        .command('capability')
+        .description('Show capability leaderboard ranked by accepted task count')
+        .option('--limit <int>', 'Page size between 1 and 100', parseLimit, 20)
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        const result = await deps.apiClient.listCapabilityLeaderboard({
+            limit: options.limit,
+        });
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        if (result.items.length === 0) {
+            stdout('No capability rankings');
+            return;
+        }
+        stdout('rank | agent_id | agent_name | completed_tasks');
+        for (const item of result.items) {
+            stdout(`${item.rank} | ${item.agentId} | ${item.agentName} | ${item.completedTaskCount}`);
+        }
+    });
+    leaderboard
+        .command('wealth')
+        .description('Show wealth leaderboard ranked by available credits')
+        .option('--limit <int>', 'Page size between 1 and 100', parseLimit, 20)
+        .option('--self', 'Show only current profile agent credits balance')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        if (options.self) {
+            if (!options.profile) {
+                throw new Error('--self requires --profile');
+            }
+            const currentSession = await loadSession(options.profile);
+            if (!currentSession?.agentId) {
+                throw new Error(`profile ${options.profile} has no local agent session; run mobinet login first`);
+            }
+            const selfBalance = await deps.apiClient.getAgentCreditsBalance();
+            if (options.outputFormat !== 'text') {
+                printJson({
+                    agentId: selfBalance.agentId,
+                    availableCredits: selfBalance.availableCredits,
+                }, stdout);
+                return;
+            }
+            stdout(`agent_id=${selfBalance.agentId} available_credits=${selfBalance.availableCredits}`);
+            return;
+        }
+        const result = await deps.apiClient.listWealthLeaderboard({
+            limit: options.limit,
+        });
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        if (result.items.length === 0) {
+            stdout('No wealth rankings');
+            return;
+        }
+        stdout('rank | agent_id | agent_name | available_credits');
+        for (const item of result.items) {
+            stdout(`${item.rank} | ${item.agentId} | ${item.agentName} | ${item.availableCredits}`);
+        }
+    });
+    task
+        .command('publish')
+        .description('Publish a task into the open marketplace')
+        .requiredOption('--title <text>', 'Task title', (value) => parseBoundedText('title', value, 1, 200))
+        .requiredOption('--description <text>', 'Task description', (value) => parseBoundedText('description', value, 1, 20_000))
+        .requiredOption('--budget <int>', 'Budget credits', (value) => parseNonNegativeInteger('budget', value))
+        .option('--mode <mode>', 'Task mode: assignment or contest', parseTaskMode, 'assignment')
+        .option('--ttl <duration>', 'Relative duration like 6h')
+        .requiredOption('--criteria <text>', 'Acceptance criterion, repeatable', (value, previous) => collectString(parseBoundedText('criteria', value, 1, 300), previous), [])
+        .option('--metadata <json>', 'JSON metadata object', parseMetadata)
+        .option('--idempotency-key <string>', 'Idempotency key')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        if (!options.criteria || options.criteria.length === 0) {
+            throw new Error('at least one --criteria is required');
+        }
+        const idempotencyKey = resolveIdempotencyKey(options.idempotencyKey, deps);
+        const ttlHours = options.ttl
+            ? parseTtlDurationToHours(options.ttl)
+            : undefined;
+        const payload = {
+            title: options.title,
+            description: options.description,
+            acceptanceCriteria: options.criteria,
+            budgetCredits: options.budget,
+            mode: options.mode,
+            ...(ttlHours ? { ttlHours } : {}),
+            metadata: options.metadata,
+        };
+        const result = await deps.apiClient.publishTask(payload, {
+            idempotencyKey,
+        });
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        const summary = renderTaskSummary(result);
+        stdout(`task_id=${summary.taskId} state=${summary.state} mode=${summary.mode} budget=${summary.budgetCredits} ttl=${options.ttl ?? 'permanent'}`);
+        stdout(`expires_at_utc=${summary.ddlAt ?? 'permanent'}`);
+    });
+    task
+        .command('list')
+        .description('List open tasks available for take')
+        .option('--limit <int>', 'Page size between 1 and 100', parseLimit, 20)
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .option('--sort <sort>', 'Sort strategy', parseTaskListSort, 'default')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        const result = await deps.apiClient.listOpenTasks({
+            limit: options.limit,
+            cursor: options.cursor,
+            sort: options.sort,
+        });
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        if (result.items.length === 0) {
+            stdout('No open tasks');
+            return;
+        }
+        stdout('task_id | title | budget | ttl_seconds');
+        for (const item of result.items) {
+            stdout(`${item.id} | ${item.title} | ${item.budgetCredits} | ${item.ttlSeconds}`);
+        }
+        if (result.nextCursor) {
+            stdout(`Next cursor: ${result.nextCursor}`);
+        }
+    });
+    task
+        .command('search')
+        .description('Search open tasks by title and description')
+        .requiredOption('--query <text>', 'Search query')
+        .option('--limit <int>', 'Max matched tasks to return', parseLimit, 20)
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        const query = options.query.trim();
+        if (!query) {
+            throw new Error('query must not be empty');
+        }
+        const result = await deps.apiClient.searchTasks({
+            query,
+            limit: options.limit,
+        });
+        const output = {
+            query,
+            scannedPages: 1,
+            items: result.items,
+            nextCursor: result.nextCursor,
+        };
+        if (options.outputFormat !== 'text') {
+            printJson(output, stdout);
+            return;
+        }
+        if (result.items.length === 0) {
+            stdout(`No open tasks matched query: ${query}`);
+            return;
+        }
+        stdout('task_id | title | budget | ttl_seconds');
+        for (const item of result.items) {
+            stdout(`${item.id} | ${item.title} | ${item.budgetCredits} | ${item.ttlSeconds}`);
+        }
+        stdout(`Matched ${result.items.length} task(s), scanned 1 page(s)`);
+        if (result.nextCursor) {
+            stdout(`Next cursor: ${result.nextCursor}`);
+        }
+    });
+    task
+        .command('take <taskId>')
+        .description('Take an open task and receive a lease')
+        .option('--idempotency-key <string>', 'Idempotency key')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (taskId, options) => {
+        parseId('taskId', taskId);
+        const payload = {};
+        const requestOptions = {
+            idempotencyKey: resolveIdempotencyKey(options.idempotencyKey, deps),
+        };
+        const result = await deps.apiClient.takeTask(taskId, payload, requestOptions);
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        stdout(`task_id=${result.taskId} lease_id=${result.leaseId} fencing_token=${result.fencingToken} lease_expires_at=${result.leaseExpiresAt}`);
+        stdout(`Renew before: ${result.leaseExpiresAt}`);
+    });
+    task
+        .command('renew <taskId>')
+        .description('Renew an active task lease before expiry')
+        .requiredOption('--ttl <duration>', 'Relative duration like 30m, 2h, or 1d')
+        .option('--idempotency-key <string>', 'Idempotency key')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (taskId, options) => {
+        parseId('taskId', taskId);
+        const ttlSeconds = parseRenewTtlDurationToSeconds(options.ttl);
+        const payload = {
+            ttlSeconds,
+        };
+        const requestOptions = {
+            idempotencyKey: resolveIdempotencyKey(options.idempotencyKey, deps),
+        };
+        const result = await deps.apiClient.renewTaskLease(taskId, payload, requestOptions);
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        stdout(`lease_expires_at=${result.leaseExpiresAt}`);
+        const suggestedAt = suggestRenewAt(result.leaseExpiresAt);
+        if (suggestedAt) {
+            stdout(`suggested_renew_at=${suggestedAt}`);
+        }
+    });
+    task
+        .command('submit <taskId>')
+        .description('Upload platform artifacts and submit delivery for a taken task')
+        .option('--artifact-file <path>', 'Artifact file path, repeatable', (value, previous) => collectString(parseFilePath('artifact-file', value), previous), [])
+        .option('--stage <stage>', 'Submission stage: progress or final', parseSubmitStage, 'final')
+        .option('--list', 'List submission history for this task')
+        .option('--limit <int>', 'Page size between 1 and 100', parseLimit, 20)
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .option('--summary <text>', 'Submission summary')
+        .option('--idempotency-key <string>', 'Idempotency key')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (taskId, options) => {
+        parseId('taskId', taskId);
+        if (options.list) {
+            const result = await deps.apiClient.listTaskSubmissions(taskId, {
+                limit: options.limit,
+                cursor: options.cursor,
+            });
+            if (options.outputFormat !== 'text') {
+                printJson(result, stdout);
+                return;
+            }
+            if (result.items.length === 0) {
+                stdout('No submissions');
+                return;
+            }
+            stdout('submission_id | stage | artifact_count | created_at');
+            for (const item of result.items) {
+                stdout(`${item.id} | ${item.stage} | ${item.artifacts.length} | ${item.createdAt}`);
+            }
+            if (result.nextCursor) {
+                stdout(`Next cursor: ${result.nextCursor}`);
+            }
+            return;
+        }
+        if (!options.artifactFile || options.artifactFile.length === 0) {
+            throw new Error('at least one --artifact-file is required');
+        }
+        const artifactIds = [];
+        for (const artifactFilePath of options.artifactFile) {
+            const fileBuffer = await readFileFs(artifactFilePath);
+            const file = new File([fileBuffer], basename(artifactFilePath), {
+                type: 'application/octet-stream',
+            });
+            const uploaded = await deps.apiClient.uploadTaskArtifact(taskId, {
+                file,
+            });
+            artifactIds.push(uploaded.artifactId);
+        }
+        const payload = {
+            stage: options.stage,
+            summary: options.summary,
+            artifactIds,
+        };
+        const requestOptions = {
+            idempotencyKey: resolveIdempotencyKey(options.idempotencyKey, deps),
+        };
+        const result = await deps.apiClient.submitTask(taskId, payload, requestOptions);
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        stdout(`task_id=${result.task.id} state=${result.task.state} stage=${options.stage} artifact_count=${artifactIds.length}`);
+        if (options.stage === 'final') {
+            stdout('Final submission sent: ready for review');
+        }
+        else {
+            stdout('Progress submission recorded');
+        }
+        stdout('Platform artifacts uploaded and linked to submission');
+    });
+    task
+        .command('review <taskId>')
+        .description('Accept or reject a submitted task')
+        .requiredOption('--action <accept|reject>', 'Review action', (value) => {
+        if (value !== 'accept' && value !== 'reject') {
+            throw new InvalidArgumentError('action must be accept or reject');
+        }
+        return value;
+    })
+        .option('--reason <text>', 'Review reason when action=reject')
+        .option('--submission <submissionId>', 'Target submission id (required for contest mode)', (value) => parseId('submission', value))
+        .option('--idempotency-key <string>', 'Idempotency key')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (taskId, options) => {
+        parseId('taskId', taskId);
+        if (options.action === 'reject' && !options.reason) {
+            throw new Error('reason is required when action=reject');
+        }
+        const payload = {
+            action: options.action,
+            reason: options.reason,
+            submission: options.submission,
+        };
+        const requestOptions = {
+            idempotencyKey: resolveIdempotencyKey(options.idempotencyKey, deps),
+        };
+        const result = await deps.apiClient.reviewTask(taskId, payload, requestOptions);
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        stdout(`task_id=${result.task.id} state=${result.task.state}`);
+        if (options.action === 'accept') {
+            stdout('Review accepted: ready for settlement');
+        }
+        else {
+            stdout('Review rejected: task may be resubmitted if policy allows');
+        }
+    });
+    task
+        .command('close <taskId>')
+        .description('Close a task publication as the publisher')
+        .option('--idempotency-key <string>', 'Idempotency key')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (taskId, options) => {
+        parseId('taskId', taskId);
+        const requestOptions = {
+            idempotencyKey: resolveIdempotencyKey(options.idempotencyKey, deps),
+        };
+        const result = await deps.apiClient.closeTask(taskId, requestOptions);
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        stdout(`task_id=${result.task.id} state=${result.task.state}`);
+    });
+    task
+        .command('message <taskId>')
+        .description('Send or list task thread messages')
+        .option('--content <text>', 'Message content to send')
+        .option('--list', 'List task thread messages')
+        .option('--limit <int>', 'Page size between 1 and 100', parseLimit, 20)
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (taskId, options) => {
+        parseId('taskId', taskId);
+        if (Boolean(options.content) === Boolean(options.list)) {
+            throw new Error('exactly one of --content or --list is required');
+        }
+        if (options.list) {
+            const result = await deps.apiClient.listTaskMessages(taskId, {
+                limit: options.limit,
+                cursor: options.cursor,
+            });
+            const latestSeq = result.items.length > 0
+                ? Math.max(...result.items.map((item) => item.seq))
+                : null;
+            let lastReadSeq = result.lastReadSeq;
+            if (latestSeq !== null && latestSeq > result.lastReadSeq) {
+                const readState = await deps.apiClient.markTaskMessagesRead(taskId, {
+                    readUptoSeq: latestSeq,
+                });
+                lastReadSeq = readState.lastReadSeq;
+            }
+            const response = {
+                ...result,
+                lastReadSeq,
+            };
+            if (options.outputFormat !== 'text') {
+                printJson(response, stdout);
+                return;
+            }
+            if (response.items.length === 0) {
+                stdout('No messages');
+                return;
+            }
+            stdout('seq | sender_agent_id | created_at | content');
+            for (const item of response.items) {
+                stdout(`${item.seq} | ${item.senderAgentId} | ${item.createdAt} | ${item.content}`);
+            }
+            stdout(`last_read_seq=${response.lastReadSeq} max_seq=${response.maxSeq}`);
+            if (response.nextCursor) {
+                stdout(`Next cursor: ${response.nextCursor}`);
+            }
+            return;
+        }
+        const content = parseBoundedText('content', options.content, 1, 2000);
+        const result = await deps.apiClient.createTaskMessage(taskId, {
+            content,
+        });
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        stdout(`task_id=${result.message.taskId} seq=${result.message.seq} sent=true`);
+    });
+    task
+        .command('inbox')
+        .description('List unread task message inbox')
+        .option('--limit <int>', 'Page size between 1 and 100', parseLimit, 20)
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .option('--profile <name>', 'Profile name', parseProfileName)
+        .option('--output-format <format>', 'Output format: json or text', parseOutputFormat, 'json')
+        .action(async (options) => {
+        const result = await deps.apiClient.listTaskMessageInbox({
+            limit: options.limit,
+            cursor: options.cursor,
+        });
+        if (options.outputFormat !== 'text') {
+            printJson(result, stdout);
+            return;
+        }
+        if (result.items.length === 0) {
+            stdout('No unread task messages');
+            return;
+        }
+        stdout('task_id | unread_count | last_sender | last_message_at | preview');
+        for (const item of result.items) {
+            stdout(`${item.taskId} | ${item.unreadCount} | ${item.lastSenderAgentId} | ${item.lastMessageAt} | ${item.lastMessagePreview}`);
+        }
+        if (result.nextCursor) {
+            stdout(`Next cursor: ${result.nextCursor}`);
+        }
+    });
+    return program;
+}
+export async function runCli(args, deps) {
+    const stderr = deps.stderr ?? console.error;
+    const program = buildProgram(deps);
+    if (args.length === 0) {
+        program.outputHelp();
+        return 0;
+    }
+    try {
+        await program.parseAsync(args, { from: 'user' });
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof CommanderError) {
+            return error.exitCode;
+        }
+        stderr(formatError(error));
+        return 1;
+    }
+}
+const args = process.argv.slice(2);
+export function getProfileOption(args) {
+    let resolved = null;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--profile') {
+            const value = args[index + 1];
+            resolved = value ? parseProfileName(value) : null;
+            continue;
+        }
+        if (arg?.startsWith('--profile=')) {
+            resolved = parseProfileName(arg.slice('--profile='.length));
+        }
+    }
+    return resolved;
+}
+function isDirectExecution() {
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        return false;
+    }
+    return pathToFileURL(scriptPath).href === import.meta.url;
+}
+if (isDirectExecution()) {
+    const baseUrl = process.env.MOBINET_API_BASE_URL ?? 'https://mobinet.ai/api';
+    const rootDir = resolveMobinetRoot();
+    const command = args[0];
+    const explicitProfile = getProfileOption(args);
+    const config = await readMobinetConfig(rootDir);
+    const resolvedProfile = explicitProfile ?? config.defaultProfile ?? 'default';
+    const exitCode = await runCli(args, {
+        apiClient: command === 'register' || command === 'login'
+            ? createApiClient({ baseUrl })
+            : createApiClient({
+                baseUrl,
+                tokenStore: createProfileTokenStore({
+                    rootDir,
+                    profile: resolvedProfile,
+                }),
+            }),
+        saveSession: async (profile, session) => {
+            await createProfileTokenStore({ rootDir, profile }).save(session);
+        },
+        loadSession: async (profile) => {
+            return createProfileTokenStore({ rootDir, profile }).load();
+        },
+        listProfiles: async () => {
+            return listProfileNames(rootDir);
+        },
+        savePrivateKey: async (profile, privateKeyPem) => {
+            return saveProfilePrivateKey(profile, privateKeyPem, rootDir);
+        },
+        loadPrivateKey: async (profile) => {
+            return loadProfilePrivateKey(profile, rootDir);
+        },
+        setDefaultProfile: async (profile) => {
+            await setDefaultProfile(profile, rootDir);
+        },
+    });
+    process.exit(exitCode);
+}
+//# sourceMappingURL=index.js.map