@helix3/helix-cli 0.1.13-helix3.92 → 0.1.13-helix3.96

package/dist/index.js

@@ -694,6 +694,39 @@ item
             : `✖ ${err instanceof Error ? err.message : String(err)}`);
     }
 });
+// `delete` is a dead end once anyone owns an instance — and a publish always
+// self-grants the creator one — so the server refuses it with "Delist or
+// suspend it instead." (CH-1669). This is the "instead": a creator-owned,
+// non-destructive unlist. Existing owners keep their copies; the item stops
+// appearing on browse/marketplace and can no longer be newly acquired. It is
+// NOT a delete and NOT reversible from the CLI today — there is no `relist`.
+// Distinct from `item distribution disable` below: a distribution is ONE
+// acquisition route (you can have several); delist takes the whole item
+// definition off browse/marketplace regardless of how many routes it has.
+item
+    .command('delist')
+    .description('Unlist a published item you own — existing owners keep what they own, nobody new can acquire it. Not a delete (see `helix item publish` for why delete refuses an owned item), and not currently reversible.')
+    .argument('<item-id>', 'the universal item id (printed by `helix item publish`, or from the item URL/API)')
+    .option('--reason <text>', 'optional note for your own record; not shown to anyone else')
+    .option('--json', 'machine-readable output')
+    .action(async (itemId, opts) => {
+    const creds = requireAuth();
+    try {
+        const result = await (0, lib_1.delistItem)(itemId, creds, { reason: opts.reason });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`✔ Delisted "${result.title}" (${result.slug})`);
+        console.log(`  status: ${result.status}`);
+        console.log('  existing owners keep their copies; nobody new can acquire it.');
+    }
+    catch (err) {
+        fail(err instanceof lib_1.ApiError
+            ? err.render()
+            : `✖ ${err instanceof Error ? err.message : String(err)}`);
+    }
+});
 const itemDistribution = item
     .command('distribution')
     .description('Create and manage primary Claim/Buy routes for one published item definition');
@@ -2633,6 +2666,113 @@ gesture
         fail(`✖ ${err instanceof Error ? err.message : String(err)}`);
     }
 });
+const itemDef = program
+    .command('item-def')
+    .description('Interactive weapon definitions — scaffold a complete descriptor from a mesh + category, validate it offline, publish it to the Vault, and inspect a published one');
+itemDef
+    .command('scaffold')
+    .description('Emit a complete, publishable weapon descriptor: category archetype + engine spread/reload tables resolved in, default (or your own) sounds copied next to it')
+    .requiredOption('--mesh <file.glb>', 'the prop mesh (grip at origin, +y up, +z out the barrel, meters)')
+    .requiredOption('--category <category>', 'Rifle | Pistol | SMG | Shotgun | Sniper | LMG — inherits spread, reload foley, grip preset and shell class')
+    .option('--sounds <dir>', 'directory of your own .ogg shot sounds (mono opus-in-ogg; a file named *dry* becomes the dry-fire click)')
+    .option('--title <name>', 'item title, also the source of the item id (default: the mesh basename)')
+    .option('--out <dir>', 'output directory for the descriptor + copied files', '.')
+    .action(async (opts) => {
+    try {
+        const { scaffoldItemDef } = await Promise.resolve().then(() => __importStar(require('./itemDef/scaffold')));
+        const result = scaffoldItemDef({
+            mesh: opts.mesh,
+            category: opts.category,
+            ...(opts.sounds !== undefined && { sounds: opts.sounds }),
+            ...(opts.title !== undefined && { title: opts.title }),
+            out: opts.out,
+        });
+        console.log(`✔ ${result.descriptorPath}`);
+        console.log(`  ${result.copiedSounds.length} sound file(s) copied into sounds/`);
+        if (result.warnings.length > 0)
+            console.log(`warnings:\n  ${result.warnings.join('\n  ')}`);
+        console.log(`next steps:\n  ${result.nextSteps.join('\n  ')}`);
+    }
+    catch (err) {
+        fail(`✖ ${err instanceof Error ? err.message : String(err)}`);
+    }
+});
+itemDef
+    .command('validate')
+    .description('Validate a weapon descriptor offline: the manifest authority validator, the vendored engine gun-config rules, referenced-file existence, and the mesh precheck')
+    .argument('<file>', 'the .helix-interactive.json descriptor')
+    .action(async (file) => {
+    try {
+        const { validateItemDefFile } = await Promise.resolve().then(() => __importStar(require('./itemDef/validate')));
+        const result = validateItemDefFile(file);
+        if (result.warnings.length > 0)
+            console.log(`warnings:\n  ${result.warnings.join('\n  ')}`);
+        if (result.errors.length > 0) {
+            fail(`✖ ${result.errors.length} error(s):\n  - ${result.errors.join('\n  - ')}`);
+        }
+        console.log(`✔ valid — ${result.relativeRefs.length} referenced file(s) present`);
+    }
+    catch (err) {
+        fail(`✖ ${err instanceof Error ? err.message : String(err)}`);
+    }
+});
+itemDef
+    .command('publish')
+    .description('Publish a weapon definition: upload the mesh + every referenced sound, rewrite sound paths to vault: refs, publish the descriptor, link the product')
+    .argument('<file>', 'the .helix-interactive.json descriptor')
+    .option('--slug <slug>', 'product slug, unique platform-wide (default: weapon-<id>; reruns need a fresh one)')
+    .option('--keep-personal', 'keep the product off the marketplace and out of the publish fee; the link still grants you an instance')
+    .action(async (file, opts) => {
+    const creds = requireAuth();
+    const mismatch = (0, config_1.credsEnvMismatchWarning)(creds.apiUrl);
+    if (mismatch)
+        console.log(mismatch);
+    try {
+        const { publishItemDef } = await Promise.resolve().then(() => __importStar(require('./itemDef/publish')));
+        if (opts.keepPersonal !== true) {
+            console.log('note: a marketplace product link can charge a publish fee — pass --keep-personal for a fee-free personal publish.');
+        }
+        const report = await publishItemDef(lib_1.HelixApi.forCredentials(creds), {
+            file,
+            ...(opts.slug !== undefined && { slug: opts.slug }),
+            keepPersonal: opts.keepPersonal === true,
+        });
+        console.log(`✔ ${report.title} — definition ${report.definition.assetId}@${report.definition.version}`);
+        console.log(`  prop ${report.prop.assetId}@${report.prop.version} · ${report.audio.length} audio upload(s) · product slug ${report.product.slug}`);
+        if (report.warnings.length > 0)
+            console.log(`warnings:\n  ${report.warnings.join('\n  ')}`);
+    }
+    catch (err) {
+        fail(err instanceof lib_1.ApiError ? err.render() : `✖ ${err instanceof Error ? err.message : String(err)}`);
+    }
+});
+itemDef
+    .command('inspect')
+    .description('Resolve a published weapon definition and print the numbers an author tunes against')
+    .argument('<asset-ref>', 'definition assetId, optionally @version (e.g. abc123@2)')
+    .option('--json', 'machine-readable output (the raw descriptor + resolve metadata)')
+    .action(async (ref, opts) => {
+    const creds = (0, config_1.loadCredentials)();
+    const apiUrl = creds?.apiUrl ?? config_1.DEFAULT_API_URL;
+    try {
+        const { inspectItemDef, formatItemDefInspect } = await Promise.resolve().then(() => __importStar(require('./itemDef/inspect')));
+        const fetchText = async (url) => {
+            const res = await fetch(url);
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            return res.text();
+        };
+        const api = creds ? lib_1.HelixApi.forCredentials(creds) : new lib_1.HelixApi(apiUrl);
+        const result = await inspectItemDef(api, fetchText, ref);
+        if (opts.json)
+            console.log(JSON.stringify(result, null, 2));
+        else
+            console.log(formatItemDefInspect(result));
+    }
+    catch (err) {
+        fail(err instanceof lib_1.ApiError ? err.render() : `✖ ${err instanceof Error ? err.message : String(err)}`);
+    }
+});
 const world = program
     .command('world')
     .description("World tools — create the world's identity before publishing, and measure a built world's geometry as data instead of eyeballing screenshots");