@helix3/helix-cli 0.1.20-helix3.383 → 0.1.20-helix3.385

package/README.md

@@ -47,6 +47,8 @@ The token is stored in `~/.helix/credentials.json` (mode `600`). It's sent as
 | `helix list` | List your worlds. |
 | `helix vehicle simulate <dir\|vehicle-package.json> [--item <id>] [--spec <file>] [--offline] [--json]` | Drive the package offline with the platform's **own** engine instrument (the runtime `^0.3` serves today, cached by sha; offline = last cached, labelled) and judge 0-100 km/h, 0-60 mph, quarter mile, top speed, 100-0 km/h / 60-0 mph braking, skidpad g, turbo lag and the rest pose against the package `targets` and `--spec`. Exit `0` pass, `1` a figure out of tolerance, `2` could not simulate. See [docs/vehicle-simulate.md](docs/vehicle-simulate.md). |
 | `helix vehicle validate <vehicle-package.json> [--glb <model.glb>] [--no-simulate] [--json]` | One-second local gate for a hand-authored Universal Vehicle, run before Package publication. Checks the package against the engine's own validator (vendored, pinned to an engine commit), the engine publish gate, the backend pin requirements, `groundToBodyOrigin` vs `wheelRadius + staticRideHeight`, and the `componentBuild` digest; with `--glb` also resolves the four wheel nodes, checks each wheel node's origin is at its hub (`WHEEL_PIVOT_NOT_AT_HUB`), the +X-left / +Z-forward frame, the vehicle publish budgets the articulation nodes and the add-on host manifest (`asset.extras.HELIX_vehicle`); drives packages that declare `targets` (`helix vehicle simulate`). Exit `0` no errors, `1` errors, `2` unreadable input. See [Vehicle validate](#vehicle-validate). |
+| `helix vehicle publish <dir> --content-rating <r> [--item <id> --package-version <v> --reason <t>] [--json]` | Package-first vehicle publication: validate, upload the model and samples, seal a public Vehicle Package (root pins the model; `publish.json` `hostGrantExtensions` sealed beside it), make the Item from that exact Version, read back pin, identity, audio and the host board (sockets, tunable paths). Resumable; `--item` stages a new Version and moves the car. Exit `0`/`1`/`2`. See [docs/vehicle-publish.md](docs/vehicle-publish.md). |
+| `helix vehicle addon publish <dir> --content-rating <r> [--json]` | Package-first vehicle add-on publication: the full `vehicle addon check`, seal a public addon Package (a tune-only part seals no model), make the Item, read back pin, backend fit and each host's add-on rail. Exit `0`/`1`/`2`. |
 | `helix vehicle preview [<dir-or-package.json>] [--glb <model.glb>] [--addon <dir>]… [--item <id>] [--tolerance-cm <cm>] [--out <dir>] [--proxy-item <id>] [--json]` | Render a vehicle that is **not published yet** headless in the real runtime (hosted test grounds, Try Now through a published proxy vehicle whose car is swapped for your package + GLB, served from disk; nothing uploaded or recorded) and measure it: body-origin height against the declared `groundToBodyOrigin` (the number that locks at first mint), wheels on their hubs, arch clearance, rolling radius vs `wheelRadius`, steering, doors, seats. Prints a numeric summary with PASS/FAIL per check and writes frames, a contact sheet, `bundle.json` and `preview.json`. Boards with the candidate's own seat ids. With `--addon <dir>` (repeatable) it previews unpublished vehicle **add-ons** instead: fits each to the candidate car or a published car and measures the drawn geometry in world space against its anchor (wheels within 1 cm of each hub, socket/host-framed parts at their mount, not at the car's origin; tune-only ops read back from the live tuning). Exit `0` pass, `1` fail, `2` could not measure. See [docs/vehicle-preview.md](docs/vehicle-preview.md). |
 | `helix continuum publish-glb <mesh.glb> --title <t> [--package-type asset\|character] [--offer marketplace\|world --price-lix <n> --content-rating <rating>]` | Seal a Package first; optional offer makes it ownable. See [Package-first GLB publication](#package-first-glb-publication). |
 | `helix continuum make-item --package-id <id> --package-version <v> --manifest-cid <cid> --content-rating <rating> [--offer marketplace\|world --price-lix <n>]` | Project one exact sealed Package Version into an Item, with an optional first offer. |

package/dist/index.js

@@ -862,6 +862,102 @@ vehicleAddOnCommand
         process.exitCode = 2;
     }
 });
+// ── vehicle publication (Package-first): seal the Package, make the Item, read it back ─────────────────────────────
+/** The deps `vehicle publish` / `vehicle addon publish` share: object upload, Package seal and make-item. */
+async function vehicleMintDeps() {
+    const base = await vehicleContinuumDeps();
+    const { makeItemFromPackage } = await Promise.resolve().then(() => __importStar(require('./publications')));
+    const makeItem = async (input) => {
+        const receipt = await makeItemFromPackage({
+            packagePin: input.packagePin, intentId: input.intentId, contentRating: input.contentRating,
+            title: input.title, description: input.description, tags: input.tags,
+        }, base.creds);
+        return receipt;
+    };
+    return { ...base, makeItem };
+}
+vehicleCommand
+    .command('publish')
+    .description('Publish a vehicle package directory: validate (package, GLB, host manifest, audio), upload the model and samples, seal a '
+    + 'public Vehicle Package whose root pins them, make the vehicle Item from that exact Version, and read it back (pin, package '
+    + 'identity, mesh pin, every audio URL, and the host board: hostKind vehicle, sockets, tunable paths). Resumable from '
+    + '<dir>/.helix-publish/ledger.json. With --item: seal a STAGED new Version of that car and move it (visual QA gates the move). '
+    + 'Directory: vehicle-package.json + model.glb (asset.extras.HELIX_vehicle with sockets) + WAVs; optional publish.json '
+    + '{ title, description, tags, version, contentRating, provenance, hostGrantExtensions }. '
+    + 'Exit 0 = published and verified, 1 = a check or read-back failed, 2 = could not run')
+    .argument('<dir>', 'the vehicle package directory')
+    .option('--glb <file>', 'the drawn model, when the directory holds more than one .glb')
+    .option('--title <title>', 'Item and Package title (default: publish.json title, else the package displayName)')
+    .option('--description <text>', 'Item description')
+    .option('--tags <a,b,c>', 'Item tags')
+    .option('--content-rating <rating>', 'creator-attested rating for a new Item: everyone, teen, mature or adult (or publish.json contentRating)')
+    .option('--package-version <semver>', 'the Package Version to seal (default 1.0.0; required with --item)')
+    .option('--item <id>', 'publish a NEW VERSION of this existing vehicle Item instead of minting one')
+    .option('--reason <text>', 'with --item: the version move reason (1-500 chars, audited)')
+    .option('--out <dir>', 'ledger, sealed root, descriptor and receipts (default <dir>/.helix-publish)')
+    .option('--no-simulate', 'skip the drive (by default a package with `targets` is driven by the platform\'s engine instrument, exactly as `vehicle validate`, and every figure outside its tolerance refuses the publish)')
+    .option('--offline', 'drive with the last cached engine runtime; never fetch')
+    .option('--dry-run', 'validate and check audio only; nothing is uploaded')
+    .option('--json', 'print the machine-readable result')
+    .action(async (dir, opts) => {
+    try {
+        const mint = await Promise.resolve().then(() => __importStar(require('./vehicle/mintVehicle')));
+        const deps = opts.dryRun ? null : await vehicleMintDeps();
+        const creds = deps?.creds ?? requireAuth();
+        const unreachable = async () => { throw new Error('dry run: no network writes'); };
+        const result = await mint.mintVehicle({
+            dir, glb: opts.glb, title: opts.title, description: opts.description, tags: opts.tags ? (0, lib_1.parseTags)(opts.tags) : undefined,
+            contentRating: opts.contentRating, version: opts.packageVersion, itemId: opts.item, reason: opts.reason, out: opts.out, dryRun: opts.dryRun,
+            simulate: opts.simulate, offline: opts.offline,
+        }, creds, deps ? {
+            api: deps.api, objects: deps.objects, publishPackage: deps.publishPackage, makeItem: deps.makeItem,
+            onProgress: (m) => { if (!opts.json)
+                console.log(`· ${m}`); },
+        } : {
+            api: { request: unreachable }, objects: { putObjectFromFile: unreachable }, publishPackage: unreachable, makeItem: unreachable,
+        });
+        printVehicleJsonOr(opts.json, result, () => console.log(mint.formatVehicleMint(result)));
+        if (!result.ok)
+            process.exitCode = 1;
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof lib_1.ApiError ? error.render() : `✖ ${error instanceof Error ? error.message : String(error)}`}\n`);
+        process.exitCode = 2;
+    }
+});
+vehicleAddOnCommand
+    .command('publish')
+    .description('Publish a vehicle add-on directory: the full `vehicle addon check` (drive effect measured), upload the model, seal a public addon '
+    + 'Package (root: the helix.vehicle-addon-definition/1 JSON; a tune-only part seals no model), make the add-on Item from that exact '
+    + 'Version, and read it back: pinned, the backend fit lists every host, every host\'s add-on rail lists it. No offer is opened. '
+    + 'Resumable from <dir>/.helix-publish/ledger.json. Exit 0 = published and verified, 1 = a check or read-back failed, 2 = could not run')
+    .argument('<dir>', 'the add-on directory (addon.json + model.glb; no model for a tune-only part)')
+    .option('--glb <file>', 'the add-on model, when the directory holds more than one .glb')
+    .option('--content-rating <rating>', 'creator-attested rating: everyone, teen, mature or adult (or addon.json contentRating)')
+    .option('--out <dir>', 'ledger, definition, descriptor and receipts (default <dir>/.helix-publish)')
+    .option('--no-measure', 'skip the drive-effect measurement')
+    .option('--dry-run', 'run the check only; nothing is uploaded')
+    .option('--json', 'print the machine-readable result')
+    .action(async (dir, opts) => {
+    try {
+        const addon = await Promise.resolve().then(() => __importStar(require('./vehicle/addon')));
+        const mint = await Promise.resolve().then(() => __importStar(require('./vehicle/mintAddOn')));
+        const deps = await vehicleMintDeps();
+        const result = await mint.mintVehicleAddOn({ dir, glb: opts.glb, contentRating: opts.contentRating, out: opts.out, dryRun: opts.dryRun }, deps.creds, {
+            api: deps.api, objects: deps.objects, publishPackage: deps.publishPackage, makeItem: deps.makeItem,
+            measureDrive: opts.measure === false ? undefined : await vehicleDriveMeasure(deps.creds.apiUrl),
+            onProgress: (m) => { if (!opts.json)
+                console.log(`· ${m}`); },
+        });
+        printVehicleJsonOr(opts.json, result, () => console.log(mint.formatAddOnMint(result, addon.formatAddOnReport(result.check))));
+        if (!result.ok)
+            process.exitCode = 1;
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof lib_1.ApiError ? error.render() : `✖ ${error instanceof Error ? error.message : String(error)}`}\n`);
+        process.exitCode = 2;
+    }
+});
 // Validate a token against the API, then persist it. Shared by the browser
 // flow and the --token (CI/headless) path.
 async function finishLogin(apiUrl, token) {