@autonoelle/wsg-active 0.1.0

package/dist/index.js

@@ -0,0 +1,712 @@
+#!/usr/bin/env node
+import { Command, CommanderError } from 'commander';
+import { resolveGlobalOptions, toActiveBaseOpts, toActiveOpts, toGameDataOpts, toGqlOpts, } from './args.js';
+import { errorFromUnknown, exitWith, success } from './output.js';
+import { CliError } from './errors.js';
+import { createWritePlan, readJsonObject } from './writeWorkflow.js';
+import { storeTypes } from './configTypes.js';
+import * as authCmd from './commands/auth.js';
+import * as accountCmd from './commands/account.js';
+import * as battleMapCmd from './commands/battleMap.js';
+import * as configCmd from './commands/config.js';
+import * as discoveryCmd from './commands/discovery.js';
+import * as missionCmd from './commands/mission.js';
+import * as sessionCmd from './commands/session.js';
+import * as shipPipeCmd from './commands/shipPipe.js';
+import * as snapshotCmd from './commands/snapshot.js';
+import * as storeCmd from './commands/store.js';
+import * as functionsCmd from './commands/functions.js';
+function parseOptionalNumber(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed < 0 || parsed.toString() !== value.trim()) {
+        throw new Error(`Invalid ${name}: ${value}`);
+    }
+    return parsed;
+}
+function parseCsv(value) {
+    if (!value) {
+        return undefined;
+    }
+    const items = value.split(',').map((item) => item.trim()).filter(Boolean);
+    return items.length > 0 ? items : undefined;
+}
+const program = new Command()
+    .name('autonoelle-wsg-active')
+    .description('AutoNoelle WSG Active CLI')
+    .option('--query-url <url>', 'GraphQL endpoint (UserConfig)', process.env.AUTO_NOELLE_QUERY_URL)
+    .option('--active-url <url>', 'Active API base URL', process.env.AUTO_NOELLE_ACTIVE_URL)
+    .option('--data-url <url>', 'GameData GraphQL endpoint', process.env.AUTO_NOELLE_DATA_URL)
+    .option('--k <key>', 'User key')
+    .option('--scope <scope>', 'Region scope (CN|JP)', process.env.AUTO_NOELLE_SCOPE ?? 'CN')
+    .option('--timeout <ms>', 'HTTP timeout in milliseconds', process.env.AUTO_NOELLE_TIMEOUT_MS)
+    .showHelpAfterError(true)
+    .exitOverride();
+const auth = program.command('auth');
+auth
+    .command('login')
+    .description('Login and verify the AutoNoelle user key (credential is redacted in output)')
+    .option('--username <name>', 'Login username')
+    .option('--password <password>', 'Login password')
+    .option('--servername <name>', 'Server name')
+    .action(async (opts) => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const username = opts.username ?? process.env.AUTO_NOELLE_USERNAME;
+        const password = opts.password ?? process.env.AUTO_NOELLE_PASSWORD;
+        const servername = opts.servername ?? process.env.AUTO_NOELLE_SERVERNAME;
+        if (!username)
+            throw new Error('Missing username. Use --username or AUTO_NOELLE_USERNAME.');
+        if (!password)
+            throw new Error('Missing password. Use --password or AUTO_NOELLE_PASSWORD.');
+        if (!servername)
+            throw new Error('Missing servername. Use --servername or AUTO_NOELLE_SERVERNAME.');
+        const data = await authCmd.login(toActiveBaseOpts(g), { username, password, servername });
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+const config = program.command('config');
+config
+    .command('types')
+    .description('List supported config and store types')
+    .action(async () => {
+    try {
+        exitWith(success(await configCmd.listTypes()));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+config
+    .command('schema')
+    .description('Describe configuration fields, semantics, credential rules, and ID types')
+    .option('--type <name>', 'MissionBattleConfig, ShipPipe, TeamPipe, BattleMapConfig, credentials, or ids')
+    .action((opts) => {
+    try {
+        exitWith(success(discoveryCmd.schema(opts.type)));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+config
+    .command('get')
+    .description('Get a config object')
+    .requiredOption('--type <name>', 'Config type name')
+    .action(async (opts) => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await configCmd.getConfig(await toGqlOpts(g), opts.type);
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+config
+    .command('set')
+    .description('Safely merge and set a config object from a JSON file')
+    .requiredOption('--type <name>', 'Config type name')
+    .requiredOption('--file <path>', 'JSON file path')
+    .option('--dry-run', 'Read, merge, and validate without writing')
+    .option('--replace', 'Replace instead of preserving fields omitted from the input')
+    .option('--expect-current-hash <sha256>', 'Reject the write if the server value changed')
+    .action(async (opts) => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await configCmd.setConfig(await toGqlOpts(g), opts.type, opts.file, {
+            dryRun: Boolean(opts.dryRun),
+            replace: Boolean(opts.replace),
+            expectedCurrentHash: opts.expectCurrentHash,
+        });
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+const store = program.command('store');
+for (const [typeName, def] of Object.entries(storeTypes)) {
+    const key = typeName;
+    const api = storeCmd.storeApi[key];
+    const sub = store.command(typeName)
+        .description(def.description);
+    sub
+        .command('list')
+        .description('列出所有条目')
+        .action(async () => {
+        try {
+            const g = resolveGlobalOptions(program.opts());
+            const data = await api.list(await toGqlOpts(g));
+            exitWith(success(data));
+        }
+        catch (e) {
+            exitWith(errorFromUnknown(e));
+        }
+    });
+    sub
+        .command('get')
+        .description('获取一个条目')
+        .requiredOption('--id <guid>', '条目 UUID')
+        .action(async (opts) => {
+        try {
+            const g = resolveGlobalOptions(program.opts());
+            const data = await api.get(await toGqlOpts(g), opts.id);
+            exitWith(success(data));
+        }
+        catch (e) {
+            exitWith(errorFromUnknown(e));
+        }
+    });
+    sub
+        .command('set')
+        .description('安全创建或更新条目（从 JSON 文件）')
+        .requiredOption('--file <path>', 'JSON 文件路径')
+        .option('--dry-run', '读取、合并并校验，不写入')
+        .option('--replace', '替换，而不是保留输入中省略的字段')
+        .option('--expect-current-hash <sha256>', '服务端值变化时拒绝写入')
+        .action(async (opts) => {
+        try {
+            const g = resolveGlobalOptions(program.opts());
+            const data = await api.set(await toGqlOpts(g), opts.file, {
+                dryRun: Boolean(opts.dryRun),
+                replace: Boolean(opts.replace),
+                expectedCurrentHash: opts.expectCurrentHash,
+            });
+            exitWith(success(data));
+        }
+        catch (e) {
+            exitWith(errorFromUnknown(e));
+        }
+    });
+    sub
+        .command('remove')
+        .description('安全删除一个条目（支持预检和并发保护）')
+        .requiredOption('--id <guid>', '条目 UUID')
+        .option('--dry-run', '读取并校验删除计划，不写入')
+        .option('--expect-current-hash <sha256>', '服务端值变化时拒绝删除')
+        .option('--force', '即使仍被其他配置引用也删除（高风险）')
+        .action(async (opts) => {
+        try {
+            const g = resolveGlobalOptions(program.opts());
+            const gqlOpts = await toGqlOpts(g);
+            const references = await storeCmd.findReferences(gqlOpts, typeName, opts.id);
+            if (references.length > 0 && !opts.force) {
+                throw new CliError('STORE_ITEM_REFERENCED', `${typeName} cannot be removed while other configurations reference it.`, {
+                    category: 'conflict',
+                    details: { id: opts.id, references, dryRun: Boolean(opts.dryRun) },
+                    suggestion: 'Update and verify every owner first. Use --force only with explicit approval and a recovery plan.',
+                });
+            }
+            const data = await api.remove(gqlOpts, opts.id, {
+                dryRun: Boolean(opts.dryRun),
+                expectedCurrentHash: opts.expectCurrentHash,
+            });
+            exitWith(success({ ...data, references, forced: Boolean(opts.force) }));
+        }
+        catch (e) {
+            exitWith(errorFromUnknown(e));
+        }
+    });
+    if (typeName === 'ShipPipe') {
+        sub
+            .command('preview')
+            .description('Preview which owned ship instances a ShipPipe matches')
+            .option('--id <guid>', 'Read an existing ShipPipe by UUID')
+            .option('--file <path>', 'Preview a complete ShipPipe JSON file')
+            .option('--first <number>', 'Maximum returned matches, default 20', '20')
+            .option('--all', 'Return all matching ships')
+            .option('--fields <csv>', 'Return selected owned-ship fields')
+            .action(async (opts) => {
+            try {
+                if (Boolean(opts.id) === Boolean(opts.file)) {
+                    throw new CliError('PIPE_SOURCE_REQUIRED', 'Specify exactly one of --id or --file.', {
+                        category: 'usage',
+                        details: { expected: ['--id <guid>', '--file <path>'] },
+                    });
+                }
+                const g = resolveGlobalOptions(program.opts());
+                const pipe = opts.id
+                    ? await api.get(await toGqlOpts(g), opts.id)
+                    : shipPipeCmd.readShipPipeFile(opts.file);
+                if (pipe === null || pipe === undefined) {
+                    throw new CliError('SHIP_PIPE_NOT_FOUND', `ShipPipe not found: ${opts.id}`, {
+                        category: 'not_found',
+                        field: 'id',
+                    });
+                }
+                const data = await shipPipeCmd.preview(await toActiveOpts(g), toGameDataOpts(g), pipe, {
+                    first: parseOptionalNumber(opts.first, 'first'),
+                    all: Boolean(opts.all),
+                    fields: parseCsv(opts.fields),
+                });
+                exitWith(success(data));
+            }
+            catch (e) {
+                exitWith(errorFromUnknown(e));
+            }
+        });
+    }
+    if (typeName === 'BattleMapConfig') {
+        sub
+            .command('validate')
+            .description('Validate a BattleMapConfig against GameData map nodes and backend behavior')
+            .option('--id <guid>', 'Read an existing BattleMapConfig by UUID')
+            .option('--file <path>', 'Validate a complete BattleMapConfig JSON file')
+            .action(async (opts) => {
+            try {
+                if (Boolean(opts.id) === Boolean(opts.file)) {
+                    throw new CliError('MAP_CONFIG_SOURCE_REQUIRED', 'Specify exactly one of --id or --file.', {
+                        category: 'usage',
+                        details: { expected: ['--id <guid>', '--file <path>'] },
+                    });
+                }
+                const g = resolveGlobalOptions(program.opts());
+                const configValue = opts.id
+                    ? await api.get(await toGqlOpts(g), opts.id)
+                    : battleMapCmd.readBattleMapFile(opts.file);
+                if (configValue === null || configValue === undefined) {
+                    throw new CliError('BATTLE_MAP_CONFIG_NOT_FOUND', `BattleMapConfig not found: ${opts.id}`, {
+                        category: 'not_found',
+                        field: 'id',
+                    });
+                }
+                exitWith(success(await battleMapCmd.validateBattleMapConfig(toGameDataOpts(g), configValue)));
+            }
+            catch (e) {
+                exitWith(errorFromUnknown(e));
+            }
+        });
+    }
+}
+const session = program.command('session');
+session
+    .command('info')
+    .description('Get session info')
+    .action(async () => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await sessionCmd.info(await toActiveOpts(g));
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+session
+    .command('reconnect')
+    .description('Reconnect session')
+    .action(async () => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await sessionCmd.reconnect(await toActiveOpts(g));
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+session
+    .command('disconnect')
+    .description('Disconnect session')
+    .action(async () => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await sessionCmd.disconnect(await toActiveOpts(g));
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+session
+    .command('unlock')
+    .description('Unlock login')
+    .action(async () => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await sessionCmd.unlock(await toActiveOpts(g));
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+session
+    .command('autologin')
+    .description('Set auto-login state')
+    .requiredOption('--state <bool>', 'true or false')
+    .action(async (opts) => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const state = opts.state === 'true' || opts.state === true;
+        const data = await sessionCmd.setAutoLogin(await toActiveOpts(g), state);
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+const mission = program.command('mission');
+mission
+    .command('list')
+    .description('List mission states')
+    .action(async () => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await missionCmd.list(await toActiveOpts(g));
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+mission
+    .command('validate')
+    .description('Run pre-start dependency validation for a mission')
+    .requiredOption('--type <name>', 'Mission config type name')
+    .option('--file <path>', 'Validate a proposed partial/full config without writing')
+    .action(async (opts) => {
+    try {
+        if (opts.type !== 'MissionBattleConfig') {
+            throw new CliError('MISSION_VALIDATOR_UNAVAILABLE', `No dedicated preflight validator is available for ${opts.type}.`, {
+                category: 'validation',
+                field: 'type',
+                details: { supported: ['MissionBattleConfig'] },
+            });
+        }
+        const g = resolveGlobalOptions(program.opts());
+        const gqlOpts = await toGqlOpts(g);
+        let proposed;
+        let proposal = null;
+        if (opts.file) {
+            const current = await configCmd.getConfig(gqlOpts, 'MissionBattleConfig');
+            const plan = createWritePlan(current, readJsonObject(opts.file));
+            proposed = plan.proposed;
+            proposal = {
+                mode: 'merge',
+                changed: plan.changed,
+                currentHash: plan.currentHash,
+                proposedHash: plan.proposedHash,
+                changedPaths: plan.changedPaths,
+            };
+        }
+        const data = await missionCmd.validateBattleStart(await toActiveOpts(g), gqlOpts, toGameDataOpts(g), proposed);
+        data.proposal = proposal;
+        if (data.valid !== true) {
+            throw new CliError('MISSION_PREFLIGHT_FAILED', 'MissionBattleConfig is not safe to start.', {
+                category: 'validation',
+                details: data,
+                suggestion: 'Resolve every preflight error, safely write and verify dependencies, then validate again.',
+            });
+        }
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+mission
+    .command('enable')
+    .description('Validate, enable, and reread a mission state')
+    .requiredOption('--type <name>', 'Mission config type name')
+    .option('--dry-run', 'Run preflight without changing mission state')
+    .action(async (opts) => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const activeOpts = await toActiveOpts(g);
+        let preflight = null;
+        if (opts.type === 'MissionBattleConfig') {
+            preflight = await missionCmd.validateBattleStart(activeOpts, await toGqlOpts(g), toGameDataOpts(g));
+            if (preflight.valid !== true) {
+                throw new CliError('MISSION_PREFLIGHT_FAILED', 'MissionBattleConfig is not safe to start.', {
+                    category: 'validation',
+                    details: preflight,
+                    suggestion: 'Resolve every preflight error before enabling the mission.',
+                });
+            }
+        }
+        else if (opts.dryRun) {
+            throw new CliError('MISSION_VALIDATOR_UNAVAILABLE', `Dry-run validation is not implemented for ${opts.type}.`, {
+                category: 'validation',
+                details: { supported: ['MissionBattleConfig'] },
+            });
+        }
+        if (opts.dryRun) {
+            exitWith(success({ operation: 'validate-enable', type: opts.type, changed: false, preflight }));
+            return;
+        }
+        const state = await missionCmd.setState(activeOpts, opts.type, true);
+        exitWith(success({ operation: 'enable', preflight, state }));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+mission
+    .command('disable')
+    .description('Disable a mission')
+    .requiredOption('--type <name>', 'Mission config type name')
+    .action(async (opts) => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await missionCmd.setState(await toActiveOpts(g), opts.type, false);
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+const account = program.command('account')
+    .description('Read account resources and owned objects with AI-friendly summaries');
+account
+    .command('summary')
+    .description('Return resource, capacity, and account-object counts')
+    .action(async () => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        exitWith(success(await accountCmd.summary(await toActiveOpts(g))));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+account
+    .command('ships')
+    .description('Query owned ship instances enriched with GameData definitions')
+    .option('--id <number>', 'Exact owned ship instance ID')
+    .option('--cid <number>', 'Exact catalog/configuration CID')
+    .option('--title <name>', 'Exact catalog title or custom name')
+    .option('--title-contains <text>', 'Catalog title or custom name contains text')
+    .option('--ship-type <csv>', 'ShipType values, comma-separated (OR within this option)')
+    .option('--country <csv>', 'ShipCountry values, comma-separated (OR within this option)')
+    .option('--level-min <number>', 'Minimum level')
+    .option('--level-max <number>', 'Maximum level')
+    .option('--locked', 'Only locked ships')
+    .option('--unlocked', 'Only unlocked ships')
+    .option('--married', 'Only married ships')
+    .option('--unmarried', 'Only unmarried ships')
+    .option('--evolved', 'Only retrofit/evolved definitions')
+    .option('--base', 'Only base/non-evolved definitions')
+    .option('--available', 'Only ships available to the backend team selector')
+    .option('--occupied', 'Only ships unavailable to the backend team selector')
+    .option('--offset <number>', 'Zero-based result offset', '0')
+    .option('--first <number>', 'Maximum returned items, default 20', '20')
+    .option('--all', 'Return all matching items after offset')
+    .option('--fields <csv>', 'Return selected fields only')
+    .action(async (opts) => {
+    try {
+        if (opts.locked && opts.unlocked)
+            throw new CliError('CONFLICTING_FILTERS', '--locked and --unlocked are mutually exclusive.', { category: 'usage' });
+        if (opts.married && opts.unmarried)
+            throw new CliError('CONFLICTING_FILTERS', '--married and --unmarried are mutually exclusive.', { category: 'usage' });
+        if (opts.evolved && opts.base)
+            throw new CliError('CONFLICTING_FILTERS', '--evolved and --base are mutually exclusive.', { category: 'usage' });
+        if (opts.available && opts.occupied)
+            throw new CliError('CONFLICTING_FILTERS', '--available and --occupied are mutually exclusive.', { category: 'usage' });
+        const g = resolveGlobalOptions(program.opts());
+        const data = await accountCmd.ownedShips(await toActiveOpts(g), toGameDataOpts(g), {
+            id: parseOptionalNumber(opts.id, 'id'),
+            cid: parseOptionalNumber(opts.cid, 'cid'),
+            title: opts.title,
+            titleContains: opts.titleContains,
+            shipTypes: parseCsv(opts.shipType)?.map((item) => item.toUpperCase()),
+            countries: parseCsv(opts.country)?.map((item) => item.toUpperCase()),
+            levelMin: parseOptionalNumber(opts.levelMin, 'level-min'),
+            levelMax: parseOptionalNumber(opts.levelMax, 'level-max'),
+            locked: opts.locked ? true : opts.unlocked ? false : undefined,
+            married: opts.married ? true : opts.unmarried ? false : undefined,
+            evolved: opts.evolved ? true : opts.base ? false : undefined,
+            available: opts.available ? true : opts.occupied ? false : undefined,
+            offset: parseOptionalNumber(opts.offset, 'offset'),
+            first: parseOptionalNumber(opts.first, 'first'),
+            all: Boolean(opts.all),
+            fields: parseCsv(opts.fields),
+        });
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+for (const [commandName, partName, description] of [
+    ['resources', 'resources', 'Return player resource fields'],
+    ['equips', 'equips', 'Return owned equipment instances'],
+    ['teams', 'teams', 'Return account fleets and teams'],
+    ['items', 'items', 'Return account item inventory'],
+    ['tasks', 'tasks', 'Return player task state'],
+    ['maps', 'maps', 'Return player map progress'],
+    ['expeditions', 'expeditions', 'Return expedition state'],
+    ['dock', 'dock', 'Return repair/build dock state'],
+    ['battle', 'battle', 'Return current battle state'],
+]) {
+    account
+        .command(commandName)
+        .description(description)
+        .option('--id <id>', 'Return one item by instance ID')
+        .option('--first <number>', 'Maximum returned items, default 20')
+        .option('--all', 'Return all items')
+        .option('--fields <csv>', 'Return selected fields only')
+        .action(async (opts) => {
+        try {
+            const g = resolveGlobalOptions(program.opts());
+            const data = await snapshotCmd.getPart(await toActiveOpts(g), partName, {
+                id: opts.id,
+                first: parseOptionalNumber(opts.first, 'first'),
+                all: Boolean(opts.all),
+                fields: parseCsv(opts.fields),
+            });
+            exitWith(success(data));
+        }
+        catch (e) {
+            exitWith(errorFromUnknown(e));
+        }
+    });
+}
+const snapshot = program.command('snapshot');
+// ── active-info parent (no action — just groups sub-commands) ──
+const ai = snapshot.command('active-info');
+ai
+    .command('full')
+    .description('Return the full ActiveUserInfoData as-is')
+    .action(async () => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await snapshotCmd.getFullActiveInfo(await toActiveOpts(g));
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+ai
+    .command('parts')
+    .description('List known ActiveUserInfoData parts')
+    .action(() => {
+    exitWith(success(snapshotCmd.listParts()));
+});
+ai
+    .command('summary')
+    .description('Return part names and counts without fetching full data')
+    .action(async () => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await snapshotCmd.getSummary(await toActiveOpts(g));
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+// ── generic part access ──
+ai
+    .command('get')
+    .description('Return one part (ships, equips, teams, resources, …)')
+    .argument('<part>', 'Part name or alias')
+    .option('--id <id>', 'Return one item by id/uid')
+    .option('--first <number>', 'Limit items, default 20')
+    .option('--all', 'Return all items from the part')
+    .option('--fields <csv>', 'Keep selected fields, comma-separated')
+    .action(async (part, opts) => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const data = await snapshotCmd.getPart(await toActiveOpts(g), part, {
+            id: opts.id,
+            first: parseOptionalNumber(opts.first, 'first'),
+            all: Boolean(opts.all),
+            fields: parseCsv(opts.fields),
+        });
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+// ── ships sub-command with extra filters ──
+ai
+    .command('ships')
+    .description('Return owned ships, with optional filters')
+    .option('--cid <number>', 'Filter by ship config ID (Cid)')
+    .option('--level-min <number>', 'Minimum level')
+    .option('--level-max <number>', 'Maximum level')
+    .option('--locked', 'Only locked ships')
+    .option('--unlocked', 'Only unlocked ships')
+    .option('--married', 'Only married ships')
+    .option('--unmarried', 'Only unmarried ships')
+    .option('--id <id>', 'Return one ship by instance uid')
+    .option('--first <number>', 'Limit items, default 20')
+    .option('--all', 'Return all matching ships')
+    .option('--fields <csv>', 'Keep selected fields, comma-separated')
+    .action(async (opts) => {
+    try {
+        if (opts.locked && opts.unlocked) {
+            throw new Error('--locked and --unlocked are mutually exclusive.');
+        }
+        if (opts.married && opts.unmarried) {
+            throw new Error('--married and --unmarried are mutually exclusive.');
+        }
+        const g = resolveGlobalOptions(program.opts());
+        const data = await snapshotCmd.getShips(await toActiveOpts(g), {
+            cid: parseOptionalNumber(opts.cid, 'cid'),
+            levelMin: parseOptionalNumber(opts.levelMin, 'level-min'),
+            levelMax: parseOptionalNumber(opts.levelMax, 'level-max'),
+            locked: opts.locked === 'true' || opts.locked === true ? true : undefined,
+            unlocked: opts.unlocked === 'true' || opts.unlocked === true ? true : undefined,
+            married: opts.married === 'true' || opts.married === true ? true : undefined,
+            unmarried: opts.unmarried === 'true' || opts.unmarried === true ? true : undefined,
+            id: opts.id,
+            first: parseOptionalNumber(opts.first, 'first'),
+            all: Boolean(opts.all),
+            fields: parseCsv(opts.fields),
+        });
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+const functions = program.command('functions')
+    .description('Common utility functions');
+functions
+    .command('check-archive')
+    .description('Check dock/archive consistency — requires --k')
+    .action(async () => {
+    try {
+        const g = resolveGlobalOptions(program.opts());
+        const activeOpts = await toActiveOpts(g);
+        const gameDataOpts = toGameDataOpts(g);
+        const data = await functionsCmd.checkArchive(activeOpts, gameDataOpts);
+        exitWith(success(data));
+    }
+    catch (e) {
+        exitWith(errorFromUnknown(e));
+    }
+});
+if (process.argv.length <= 2) {
+    program.outputHelp();
+    process.exit(0);
+}
+try {
+    await program.parseAsync(process.argv);
+}
+catch (value) {
+    if (value instanceof CommanderError && (value.code === 'commander.helpDisplayed' || value.code === 'commander.version')) {
+        process.exitCode = 0;
+    }
+    else if (value instanceof CommanderError) {
+        exitWith(errorFromUnknown(new CliError('ARGUMENT_ERROR', value.message, {
+            category: 'usage',
+            suggestion: 'Run the same command with --help to inspect accepted arguments.',
+            cause: value,
+        })));
+    }
+    else {
+        exitWith(errorFromUnknown(value));
+    }
+}
+//# sourceMappingURL=index.js.map