@assethub/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) AssetHub
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# @assethub/cli
+
+Command line interface for AssetHub.
+
+```sh
+export ASSETHUB_API_KEY=ah_live_xxx
+
+assethub models list
+assethub models list --domain meshGen --ids-only
+assethub files import https://example.com/input.png --media-type image
+assethub image generate --prompt "stylized prop concept" --wait
+assethub mesh generate --file ./input.png --model-id meshGen.hunyuan31 --wait
+assethub jobs watch job_123
+assethub production analyze --image-url https://example.com/input.png --agent-version ah_part_extractor_v65
+```
+
+Configuration:
+
+- `ASSETHUB_API_KEY`: optional when a profile was saved with `auth login`.
+- `ASSETHUB_API_BASE_URL`: optional, defaults to `https://app.assethub.io`.
+- `ASSETHUB_CLI_CONFIG`: optional auth config path.
+
+Agent-friendly login:
+
+```sh
+printf '%s' "$ASSETHUB_API_KEY" | assethub auth login --api-key-stdin
+assethub image generate --prompt "small stylized game asset chest" --wait --interval-ms 5000 --timeout-ms 900000
+assethub mesh generate --source-url https://example.com/input.png --model-id meshGen.hunyuan31 --wait --interval-ms 5000 --timeout-ms 900000
+```
+
+Image generation defaults to the deployed `v1` endpoint. Pass `--api-version v2`
+only when the `v2` image endpoint is available in the target environment.
+
+The CLI only uses AssetHub's public API surface and is designed so this package
+can be published independently from the private application monorepo.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,594 @@
+#!/usr/bin/env node
+import { chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { argv, env, exit, stdin, stderr, stdout } from 'node:process';
+import { AssetHubApiError, createAssetHubClient, } from '@assethub/api-client';
+const defaultBaseUrl = 'https://app.assethub.io';
+const defaultImageModelId = 'imageGen.nanoBanana.pro.openrouter';
+const defaultMeshModelId = 'meshGen.hunyuan31';
+const defaultProfileName = 'default';
+const usage = `AssetHub CLI
+
+Usage:
+  assethub auth login --api-key <key> [--base-url <url>] [--profile <name>]
+  assethub auth login --api-key-stdin [--base-url <url>] [--profile <name>]
+  assethub auth status [--profile <name>]
+  assethub auth logout [--profile <name>]
+  assethub models list [--domain <domain>] [--ids-only] [--limit <n>]
+  assethub models get <model-id>
+  assethub files import <url> --media-type image|mesh
+  assethub files upload <file> --media-type image|mesh
+  assethub image generate --prompt <text> [--file <path> | --source-url <url>] [--model-id <id>] [--batch-size <n>] [--wait] [--api-version v1|v2]
+  assethub image generate --prompt <text> --source-resource-id <id> --api-version v2 [--model-id <id>] [--batch-size <n>] [--wait]
+  assethub mesh generate (--file <path> | --source-url <url> | --source-resource-id <id> | --file-ref-json <json>) [--model-id <id>] [--name <name>] [--wait]
+  assethub mesh retopo (--source-resource-id <id> | --source-url <url> | --file-ref-json <json>) --model-id <id> [--wait]
+  assethub jobs get <job-id>
+  assethub jobs watch <job-id> [--interval-ms <ms>] [--timeout-ms <ms>]
+  assethub production analyze --image-url <url> --agent-version <id> [--name <name>]
+  assethub production status <order-id>
+  assethub production execute --order-id <id> --mission-id <id> --task-id <id> [--task-id <id>...] --agent-version <id> [--part-extraction-mode fast|quality]
+
+Global options:
+  --api-key <key>       Overrides saved auth and ASSETHUB_API_KEY.
+  --base-url <url>      Defaults to ASSETHUB_API_BASE_URL, saved auth, or ${defaultBaseUrl}.
+  --profile <name>      Saved auth profile name. Defaults to ${defaultProfileName}.
+  --config <path>       Auth config path. Defaults to ~/.assethub/config.json.
+  --help                Show help.
+
+Examples:
+  ASSETHUB_API_KEY=ah_live_xxx assethub models list
+  assethub auth login --api-key-stdin
+  assethub models list --domain meshGen --ids-only
+  assethub files upload ./input.png --media-type image
+  assethub image generate --prompt "stylized prop concept" --wait
+  assethub mesh generate --file ./input.png --model-id meshGen.hunyuan31 --wait
+`;
+const print = (value) => {
+    stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+};
+const parseArgs = (args) => {
+    const positionals = [];
+    const flags = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        const withoutPrefix = arg.slice(2);
+        const [rawKey, inlineValue] = withoutPrefix.split(/=(.*)/s, 2);
+        const key = rawKey.trim();
+        if (key.length === 0) {
+            throw new Error(`Invalid flag: ${arg}`);
+        }
+        const next = args[index + 1];
+        const value = inlineValue != null
+            ? inlineValue
+            : next != null && !next.startsWith('--')
+                ? (index += 1, next)
+                : true;
+        const previous = flags[key];
+        if (previous == null) {
+            flags[key] = value;
+        }
+        else if (Array.isArray(previous)) {
+            previous.push(String(value));
+        }
+        else {
+            flags[key] = [String(previous), String(value)];
+        }
+    }
+    return { positionals, flags };
+};
+const getFlag = (flags, name) => {
+    const value = flags[name];
+    if (value == null || value === false) {
+        return undefined;
+    }
+    if (value === true) {
+        return 'true';
+    }
+    if (Array.isArray(value)) {
+        return value[value.length - 1];
+    }
+    return value;
+};
+const getFlagValues = (flags, name) => {
+    const value = flags[name];
+    if (value == null || value === false) {
+        return [];
+    }
+    if (value === true) {
+        return ['true'];
+    }
+    return Array.isArray(value) ? value : [value];
+};
+const hasFlag = (flags, name) => flags[name] != null;
+const requireFlag = (flags, name) => {
+    const value = getFlag(flags, name);
+    if (value == null || value.trim().length === 0 || value === 'true') {
+        throw new Error(`Missing required flag: --${name}`);
+    }
+    return value;
+};
+const parsePositiveIntegerFlag = (flags, name, fallback) => {
+    const raw = getFlag(flags, name);
+    if (raw == null) {
+        return fallback;
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`--${name} must be a positive number`);
+    }
+    return Math.floor(parsed);
+};
+const parseBooleanFlag = (flags, name) => {
+    const raw = getFlag(flags, name);
+    if (raw == null) {
+        return undefined;
+    }
+    if (raw === 'true') {
+        return true;
+    }
+    if (raw === 'false') {
+        return false;
+    }
+    throw new Error(`--${name} must be true or false`);
+};
+const parseMediaType = (value) => {
+    if (value === 'image' || value === 'mesh') {
+        return value;
+    }
+    throw new Error('--media-type must be "image" or "mesh"');
+};
+const getProfileName = (flags) => getFlag(flags, 'profile') ?? defaultProfileName;
+const getConfigPath = (flags) => getFlag(flags, 'config') ??
+    env.ASSETHUB_CLI_CONFIG ??
+    join(homedir(), '.assethub', 'config.json');
+const readAuthConfig = async (configPath) => {
+    try {
+        const raw = await readFile(configPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return {
+            defaultProfile: parsed.defaultProfile,
+            profiles: parsed.profiles ?? {},
+        };
+    }
+    catch (error) {
+        if (error != null &&
+            typeof error === 'object' &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return { profiles: {} };
+        }
+        throw error;
+    }
+};
+const writeAuthConfig = async (configPath, config) => {
+    await mkdir(dirname(configPath), { recursive: true, mode: 0o700 });
+    await writeFile(`${configPath}.tmp`, `${JSON.stringify(config, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    await chmod(`${configPath}.tmp`, 0o600);
+    await rename(`${configPath}.tmp`, configPath);
+    await chmod(configPath, 0o600);
+};
+const readStdin = async () => await new Promise((resolve, reject) => {
+    let value = '';
+    stdin.setEncoding('utf8');
+    stdin.on('data', chunk => {
+        value += chunk;
+    });
+    stdin.on('end', () => resolve(value));
+    stdin.on('error', reject);
+});
+const resolveAuth = async (flags) => {
+    const profile = getProfileName(flags);
+    const baseUrlFromFlags = getFlag(flags, 'base-url');
+    const apiKeyFromFlags = getFlag(flags, 'api-key');
+    if (apiKeyFromFlags != null && apiKeyFromFlags !== 'true') {
+        return {
+            apiKey: apiKeyFromFlags,
+            baseUrl: baseUrlFromFlags ?? env.ASSETHUB_API_BASE_URL ?? defaultBaseUrl,
+            profile,
+            source: 'flag',
+        };
+    }
+    if (env.ASSETHUB_API_KEY != null && env.ASSETHUB_API_KEY.trim() !== '') {
+        return {
+            apiKey: env.ASSETHUB_API_KEY,
+            baseUrl: baseUrlFromFlags ?? env.ASSETHUB_API_BASE_URL ?? defaultBaseUrl,
+            profile,
+            source: 'env',
+        };
+    }
+    const config = await readAuthConfig(getConfigPath(flags));
+    const fallbackProfileName = profile === defaultProfileName ? config.defaultProfile : undefined;
+    const storedProfile = config.profiles?.[profile] ??
+        (fallbackProfileName != null
+            ? config.profiles?.[fallbackProfileName]
+            : undefined);
+    if (storedProfile != null) {
+        return {
+            apiKey: storedProfile.apiKey,
+            baseUrl: baseUrlFromFlags ?? env.ASSETHUB_API_BASE_URL ?? storedProfile.baseUrl,
+            profile: config.profiles?.[profile] != null ? profile : (fallbackProfileName ?? profile),
+            source: 'profile',
+        };
+    }
+    throw new Error('Missing API key. Run "assethub auth login --api-key-stdin", set ASSETHUB_API_KEY, or pass --api-key.');
+};
+const createContext = async (flags) => {
+    const auth = await resolveAuth(flags);
+    return {
+        auth,
+        flags,
+        client: createAssetHubClient({
+            apiKey: auth.apiKey,
+            baseUrl: auth.baseUrl,
+        }),
+    };
+};
+const parseFileRef = (value) => {
+    const parsed = JSON.parse(value);
+    if (parsed == null || typeof parsed !== 'object' || !('type' in parsed)) {
+        throw new Error('--file-ref-json must be a BlobLocation JSON object');
+    }
+    return parsed;
+};
+const readBlob = async (filePath) => {
+    const buffer = await readFile(filePath);
+    return new Blob([new Uint8Array(buffer)]);
+};
+const resolveSource = async ({ flags, client, fileMediaType, }) => {
+    const sourceResourceId = getFlag(flags, 'source-resource-id');
+    if (sourceResourceId != null) {
+        return { resourceId: sourceResourceId };
+    }
+    const sourceUrl = getFlag(flags, 'source-url');
+    if (sourceUrl != null) {
+        return { url: sourceUrl };
+    }
+    const fileRefJson = getFlag(flags, 'file-ref-json');
+    if (fileRefJson != null) {
+        return { fileRef: parseFileRef(fileRefJson) };
+    }
+    const filePath = getFlag(flags, 'file');
+    if (filePath != null) {
+        const fileRef = await client.v2.uploadFile({
+            file: await readBlob(filePath),
+            fileName: basename(filePath),
+            mediaType: fileMediaType,
+        });
+        return { fileRef: fileRef.fileRef };
+    }
+    return undefined;
+};
+const requireSource = async (options) => {
+    const source = await resolveSource(options);
+    if (source == null) {
+        throw new Error('Missing source. Pass --file, --source-url, --source-resource-id, or --file-ref-json.');
+    }
+    return source;
+};
+const sourceToV1ImageInput = (source) => {
+    if (source == null) {
+        return {};
+    }
+    if ('url' in source) {
+        return { imageUrl: source.url };
+    }
+    if ('fileRef' in source) {
+        return { imageBlobLocation: source.fileRef };
+    }
+    throw new Error('v1 image generation does not accept source-resource-id. Use --source-url, --file, or --api-version v2.');
+};
+const pollIfRequested = async ({ ctx, jobId, apiVersion = 'v2', }) => {
+    if (!hasFlag(ctx.flags, 'wait')) {
+        return undefined;
+    }
+    const intervalMs = parsePositiveIntegerFlag(ctx.flags, 'interval-ms', 5000);
+    const timeoutMs = parsePositiveIntegerFlag(ctx.flags, 'timeout-ms', 900000);
+    const pollJob = apiVersion === 'v1' ? ctx.client.v1.pollJob : ctx.client.v2.pollJob;
+    return pollJob(jobId, {
+        intervalMs,
+        timeoutMs,
+        onPoll: job => {
+            stderr.write(`[poll] job=${job.id} status=${job.status}\n`);
+        },
+    });
+};
+const requirePositional = (positionals, index, label) => {
+    const value = positionals[index];
+    if (value == null || value.trim().length === 0) {
+        throw new Error(`Missing required argument: ${label}`);
+    }
+    return value;
+};
+const commandModels = async (subcommand, positionals, ctx) => {
+    if (subcommand === 'list') {
+        const domain = getFlag(ctx.flags, 'domain');
+        const limit = getFlag(ctx.flags, 'limit') == null
+            ? undefined
+            : parsePositiveIntegerFlag(ctx.flags, 'limit', 1);
+        const models = (await ctx.client.v2.listModels())
+            .filter(model => domain == null || model.domain === domain)
+            .slice(0, limit);
+        print({
+            models: hasFlag(ctx.flags, 'ids-only')
+                ? models.map(model => model.id)
+                : models,
+        });
+        return;
+    }
+    if (subcommand === 'get') {
+        const modelId = requirePositional(positionals, 2, 'model-id');
+        print({ model: await ctx.client.v2.getModel(modelId) });
+        return;
+    }
+    throw new Error('Unknown models command. Use "models list" or "models get".');
+};
+const commandAuth = async (subcommand, flags) => {
+    const profile = getProfileName(flags);
+    const configPath = getConfigPath(flags);
+    if (subcommand === 'login') {
+        const apiKey = hasFlag(flags, 'api-key-stdin')
+            ? (await readStdin()).trim()
+            : (getFlag(flags, 'api-key') ?? env.ASSETHUB_API_KEY ?? '').trim();
+        if (apiKey.length === 0) {
+            throw new Error('API key is empty. Pass --api-key, use --api-key-stdin, or set ASSETHUB_API_KEY.');
+        }
+        const baseUrl = getFlag(flags, 'base-url') ?? env.ASSETHUB_API_BASE_URL ?? defaultBaseUrl;
+        if (!hasFlag(flags, 'skip-verify')) {
+            const client = createAssetHubClient({ apiKey, baseUrl });
+            await client.v2.listModels();
+        }
+        const config = await readAuthConfig(configPath);
+        const profiles = config.profiles ?? {};
+        profiles[profile] = {
+            apiKey,
+            baseUrl,
+            updatedAt: new Date().toISOString(),
+        };
+        await writeAuthConfig(configPath, {
+            ...config,
+            defaultProfile: profile,
+            profiles,
+        });
+        print({
+            success: true,
+            profile,
+            baseUrl,
+            configPath,
+            verified: !hasFlag(flags, 'skip-verify'),
+        });
+        return;
+    }
+    if (subcommand === 'status') {
+        const auth = await resolveAuth(flags);
+        const client = createAssetHubClient({
+            apiKey: auth.apiKey,
+            baseUrl: auth.baseUrl,
+        });
+        const models = await client.v2.listModels();
+        print({
+            authenticated: true,
+            profile: auth.profile,
+            source: auth.source,
+            baseUrl: auth.baseUrl,
+            modelCount: models.length,
+        });
+        return;
+    }
+    if (subcommand === 'logout') {
+        const config = await readAuthConfig(configPath);
+        const profiles = config.profiles ?? {};
+        const existed = profiles[profile] != null;
+        delete profiles[profile];
+        await writeAuthConfig(configPath, {
+            defaultProfile: config.defaultProfile === profile ? undefined : config.defaultProfile,
+            profiles,
+        });
+        print({ success: true, profile, removed: existed, configPath });
+        return;
+    }
+    throw new Error('Unknown auth command. Use "auth login", "auth status", or "auth logout".');
+};
+const commandFiles = async (subcommand, positionals, ctx) => {
+    const mediaType = parseMediaType(requireFlag(ctx.flags, 'media-type'));
+    if (subcommand === 'import') {
+        const url = requirePositional(positionals, 2, 'url');
+        print(await ctx.client.v2.importFile({ url, mediaType }));
+        return;
+    }
+    if (subcommand === 'upload') {
+        const filePath = requirePositional(positionals, 2, 'file');
+        print(await ctx.client.v2.uploadFile({
+            file: await readBlob(filePath),
+            fileName: basename(filePath),
+            mediaType,
+        }));
+        return;
+    }
+    throw new Error('Unknown files command. Use "files import" or "files upload".');
+};
+const commandImage = async (subcommand, ctx) => {
+    if (subcommand !== 'generate') {
+        throw new Error('Unknown image command. Use "image generate".');
+    }
+    const source = await resolveSource({
+        flags: ctx.flags,
+        client: ctx.client,
+        fileMediaType: 'image',
+    });
+    const apiVersion = getFlag(ctx.flags, 'api-version') ?? 'v1';
+    if (apiVersion !== 'v1' && apiVersion !== 'v2') {
+        throw new Error('--api-version must be "v1" or "v2"');
+    }
+    const commonInput = {
+        prompt: requireFlag(ctx.flags, 'prompt'),
+        modelId: getFlag(ctx.flags, 'model-id') ?? defaultImageModelId,
+        batchSize: parsePositiveIntegerFlag(ctx.flags, 'batch-size', 1),
+        negativePrompt: getFlag(ctx.flags, 'negative-prompt'),
+        seed: getFlag(ctx.flags, 'seed') == null
+            ? undefined
+            : parsePositiveIntegerFlag(ctx.flags, 'seed', 1),
+        steps: getFlag(ctx.flags, 'steps') == null
+            ? undefined
+            : parsePositiveIntegerFlag(ctx.flags, 'steps', 1),
+        cfgScale: getFlag(ctx.flags, 'cfg-scale') == null
+            ? undefined
+            : Number(getFlag(ctx.flags, 'cfg-scale')),
+    };
+    const queued = apiVersion === 'v1'
+        ? await ctx.client.v1.generateImage({
+            ...commonInput,
+            ...sourceToV1ImageInput(source),
+        })
+        : await ctx.client.v2.generateImage({
+            ...commonInput,
+            source,
+        });
+    const job = await pollIfRequested({ ctx, jobId: queued.jobId, apiVersion });
+    print({ queued, job, apiVersion });
+};
+const commandMesh = async (subcommand, ctx) => {
+    if (subcommand === 'generate') {
+        const queued = await ctx.client.v2.generateMesh({
+            source: await requireSource({
+                flags: ctx.flags,
+                client: ctx.client,
+                fileMediaType: 'image',
+            }),
+            modelId: getFlag(ctx.flags, 'model-id') ?? defaultMeshModelId,
+            name: getFlag(ctx.flags, 'name'),
+            faceLimit: getFlag(ctx.flags, 'face-limit') == null
+                ? undefined
+                : parsePositiveIntegerFlag(ctx.flags, 'face-limit', 1),
+            isLowPoly: parseBooleanFlag(ctx.flags, 'low-poly'),
+        });
+        const job = await pollIfRequested({ ctx, jobId: queued.jobId });
+        print({ queued, job });
+        return;
+    }
+    if (subcommand === 'retopo') {
+        const queued = await ctx.client.v2.retopo({
+            source: await requireSource({
+                flags: ctx.flags,
+                client: ctx.client,
+                fileMediaType: 'mesh',
+            }),
+            modelId: requireFlag(ctx.flags, 'model-id'),
+            name: getFlag(ctx.flags, 'name'),
+            faceLevel: getFlag(ctx.flags, 'face-level'),
+            polygonType: getFlag(ctx.flags, 'polygon-type'),
+        });
+        const job = await pollIfRequested({ ctx, jobId: queued.jobId });
+        print({ queued, job });
+        return;
+    }
+    throw new Error('Unknown mesh command. Use "mesh generate" or "mesh retopo".');
+};
+const commandJobs = async (subcommand, positionals, ctx) => {
+    const jobId = requirePositional(positionals, 2, 'job-id');
+    if (subcommand === 'get') {
+        print({ job: await ctx.client.v2.getJob(jobId) });
+        return;
+    }
+    if (subcommand === 'watch') {
+        const job = await ctx.client.v2.pollJob(jobId, {
+            intervalMs: parsePositiveIntegerFlag(ctx.flags, 'interval-ms', 5000),
+            timeoutMs: parsePositiveIntegerFlag(ctx.flags, 'timeout-ms', 900000),
+            onPoll: current => {
+                stderr.write(`[poll] job=${current.id} status=${current.status}\n`);
+            },
+        });
+        print({ job });
+        return;
+    }
+    throw new Error('Unknown jobs command. Use "jobs get" or "jobs watch".');
+};
+const commandProduction = async (subcommand, positionals, ctx) => {
+    if (subcommand === 'analyze') {
+        print(await ctx.client.v1.analyzeProduction({
+            imageUrl: requireFlag(ctx.flags, 'image-url'),
+            agentVersion: requireFlag(ctx.flags, 'agent-version'),
+            name: getFlag(ctx.flags, 'name'),
+        }));
+        return;
+    }
+    if (subcommand === 'status') {
+        const orderId = requirePositional(positionals, 2, 'order-id');
+        print(await ctx.client.v1.getProductionStatus(orderId));
+        return;
+    }
+    if (subcommand === 'execute') {
+        const confirmedTaskIds = getFlagValues(ctx.flags, 'task-id');
+        if (confirmedTaskIds.length === 0) {
+            throw new Error('Missing required flag: --task-id');
+        }
+        const partExtractionMode = getFlag(ctx.flags, 'part-extraction-mode');
+        if (partExtractionMode != null &&
+            partExtractionMode !== 'fast' &&
+            partExtractionMode !== 'quality') {
+            throw new Error('--part-extraction-mode must be "fast" or "quality"');
+        }
+        print(await ctx.client.v1.executeProduction({
+            orderId: requireFlag(ctx.flags, 'order-id'),
+            missionId: requireFlag(ctx.flags, 'mission-id'),
+            confirmedTaskIds,
+            agentVersion: requireFlag(ctx.flags, 'agent-version'),
+            partExtractionMode,
+        }));
+        return;
+    }
+    throw new Error('Unknown production command. Use "production analyze", "production status", or "production execute".');
+};
+const run = async () => {
+    const parsed = parseArgs(argv.slice(2));
+    if (hasFlag(parsed.flags, 'help') || parsed.positionals.length === 0) {
+        stdout.write(usage);
+        return;
+    }
+    const [command, subcommand] = parsed.positionals;
+    if (command === 'auth') {
+        await commandAuth(subcommand, parsed.flags);
+        return;
+    }
+    const ctx = await createContext(parsed.flags);
+    switch (command) {
+        case 'models':
+            await commandModels(subcommand, parsed.positionals, ctx);
+            return;
+        case 'files':
+            await commandFiles(subcommand, parsed.positionals, ctx);
+            return;
+        case 'image':
+            await commandImage(subcommand, ctx);
+            return;
+        case 'mesh':
+            await commandMesh(subcommand, ctx);
+            return;
+        case 'jobs':
+            await commandJobs(subcommand, parsed.positionals, ctx);
+            return;
+        case 'production':
+            await commandProduction(subcommand, parsed.positionals, ctx);
+            return;
+        default:
+            throw new Error(`Unknown command: ${command}`);
+    }
+};
+run().catch((error) => {
+    if (error instanceof AssetHubApiError) {
+        stderr.write(`AssetHub API error [${error.status}] ${error.code}: ${error.message}\n`);
+    }
+    else if (error instanceof Error) {
+        stderr.write(`${error.message}\n`);
+    }
+    else {
+        stderr.write(`${String(error)}\n`);
+    }
+    exit(1);
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@assethub/cli",
+  "version": "0.1.0",
+  "description": "Command line interface for AssetHub.",
+  "type": "module",
+  "bin": {
+    "assethub": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@assethub/api-client": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "typescript": "5.9.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && chmod +x dist/index.js",
+    "typecheck": "tsc -p tsconfig.typecheck.json --noEmit"
+  }
+}