@hagicode/hagiscript 0.1.15-dev.91.1.7ddec89 → 0.1.15-dev.95.1.042739d

package/README.md

@@ -4,317 +4,379 @@
 [![npm downloads](https://img.shields.io/npm/dm/%40hagicode%2Fhagiscript?logo=npm&color=2d8cf0)](https://www.npmjs.com/package/@hagicode/hagiscript)
 [![license](https://img.shields.io/badge/license-MIT-ffd43b)](./LICENSE)
 
-`@hagicode/hagiscript` is the runtime management CLI behind the `hagicode-runtime` contract. Use it to install, inspect, update, remove, and operate a managed HagiCode runtime without depending on system Node.js, system PM2, or host-global npm packages.
+`@hagicode/hagiscript` is the CLI used to install and operate a managed HagiCode runtime. It manages the runtime layout, bundled services, managed npm tools, and the released backend server from a manifest-driven workflow.
 
-## Install
+## Install The CLI
 
 ```bash
 npm install -g @hagicode/hagiscript
 ```
 
-Primary entrypoints:
+Check the installed version:
 
-- `hagiscript`
-- `hagicode-runtime` (`hagiscript runtime ...` wrapper)
+```bash
+hagiscript --version
+```
+
+## Quick Start
+
+For a first-time setup, run these commands in order:
+
+```bash
+npm install -g @hagicode/hagiscript
+hagiscript runtime install
+hagiscript server install
+hagiscript server start
+hagiscript server status
+```
+
+If you also want the npm tools declared in your runtime manifest:
 
-Node.js 20 or newer is required to run the package itself.
+```bash
+hagiscript npm-sync --runtime-root ~/.hagicode/runtime
+```
+
+If you are working with a custom manifest or runtime root, use the same flow with explicit paths:
 
-## Runtime Model
+```bash
+hagiscript runtime install \
+	--from-manifest ./runtime/manifest.yaml \
+	--runtime-root ~/.hagicode/runtime
 
-By default, Hagiscript loads `runtime/manifest.yaml` and manages the runtime under `~/.hagicode/runtime`.
+hagiscript server install \
+	--from-manifest ./runtime/manifest.yaml \
+	--runtime-root ~/.hagicode/runtime
 
-```text
-<runtime-root>/
-  program/
-    bin/
-    npm/
-    components/
-  runtime-data/
-    config/
-    logs/
-    data/
-    components/
-    state.json
+hagiscript server start \
+	--from-manifest ./runtime/manifest.yaml \
+	--runtime-root ~/.hagicode/runtime
 ```
 
-The split is intentional:
+## What Hagiscript Manages
+
+The packaged runtime manifest defines these default components:
 
-- `program/` holds managed executables, vendored payloads, wrappers, and the managed npm prefix.
-- `runtime-data/` holds mutable config, logs, state, PM2 data, and component-specific writable files.
+- `node`: managed Node.js runtime
+- `dotnet`: managed .NET runtime
+- `omniroute`: bundled PM2-managed service
+- `code-server`: bundled PM2-managed service
+- `server`: released backend service package
 
-The packaged manifest currently manages:
+The managed runtime layout separates immutable program files from mutable data:
 
-- `node` - managed Node.js runtime
-- `dotnet` - managed .NET and ASP.NET Core runtime
-- `server` - released backend package metadata and PM2 launch assets for `lib/PCode.Web.dll`
-- `omniroute` - vendored bundled runtime
-- `code-server` - vendored bundled runtime
+- `program/`: installed runtime payloads, wrappers, bundled executables
+- `runtime-data/`: mutable config, logs, PM2 state, managed npm packages
+- `server/`: installed released server versions
+- `server-data/`: server config, logs, PM2 runtime files, version state
 
-The runtime layout still reserves `program/npm/` as the managed npm prefix, but package inventory inside that prefix is not part of the runtime component manifest. Tool installation there is handled separately through `hagiscript npm-sync` or external provisioning.
+By default, the packaged manifest installs into `~/.hagicode/runtime`, but you can override that with `--runtime-root`.
 
-## Core Runtime Commands
+## Runtime Basics
 
-Install the full runtime:
+Create a standalone editable manifest from Hagiscript's packaged default:
 
 ```bash
-hagiscript runtime install
+hagiscript manifest init ./hagiscript.manifest.yaml
 ```
 
-Runtime installs reuse a shared download cache by default. Disable it with `--no-download-cache`, or relocate it with `--download-cache-dir <path>`.
+Generate a manifest and set the managed layout at the same time:
 
-Install selected components only:
+```bash
+hagiscript manifest init ./hagiscript.manifest.yaml \
+	--runtime-home program \
+	--runtime-data-root runtime-data \
+	--server-program-root server \
+	--server-data-root server-data
+```
+
+Update an existing manifest after initialization:
 
 ```bash
-hagiscript runtime install --components node,omniroute
+hagiscript manifest set ./hagiscript.manifest.yaml \
+	--npm-package-version pm2=7.0.2 \
+	--npm-package-version @openai/codex=0.126.0 \
+	--server-active-version 0.1.0-beta.60
 ```
 
-Preview planned changes without mutating files:
+Print the current manifest summary in a friendlier format:
 
 ```bash
-hagiscript runtime install --dry-run
-hagiscript runtime update --check-only
+hagiscript manifest get ./hagiscript.manifest.yaml
+```
+
+Install the default runtime:
+
+```bash
+hagiscript runtime install
+```
+
+Install from an explicit manifest into a specific root:
+
+```bash
+hagiscript runtime install \
+	--from-manifest ./runtime/manifest.yaml \
+	--runtime-root ~/.hagicode/runtime
 ```
 
-Inspect the canonical runtime state:
+Show the current runtime state:
 
 ```bash
 hagiscript runtime state
+```
+
+Show machine-readable state:
+
+```bash
 hagiscript runtime state --json
 ```
 
-Update or remove managed components:
+Preview what would be installed without changing files:
 
 ```bash
-hagiscript runtime update
-hagiscript runtime remove --components code-server --purge
+hagiscript runtime install --dry-run
 ```
 
-Override the runtime root or manifest when needed:
+Update installed components:
 
 ```bash
-hagiscript runtime install --runtime-root /srv/hagicode/runtime
-hagiscript runtime state --from-manifest /path/to/runtime-manifest.yaml --json
+hagiscript runtime update
 ```
 
-If you prefer the runtime-oriented wrapper:
+Only check whether updates are needed:
 
 ```bash
-hagicode-runtime install --runtime-root /srv/hagicode/runtime
+hagiscript runtime update --check-only
 ```
 
-## Runtime State and Maintenance
+Remove the runtime but keep retained data where supported:
+
+```bash
+hagiscript runtime remove
+```
 
-`hagiscript runtime state --json` is the canonical inspection surface for automation. It reports:
+Purge runtime data as well:
 
-- resolved runtime root
-- `program/` and `runtime-data/` locations
-- per-component install status
-- per-component runtime data homes
-- derived PM2 homes for managed services
-- program/data path separation
+```bash
+hagiscript runtime remove --purge
+```
 
-Use it before and after maintenance work to confirm the expected component set and writable paths.
+Operate on selected components only:
 
-Typical maintenance flow:
+```bash
+hagiscript runtime install --components node,dotnet
+hagiscript runtime update --components code-server,omniroute
+hagiscript runtime remove --components code-server --purge
+```
 
-1. Check current state: `hagiscript runtime state --json`
-2. Apply changes: `hagiscript runtime install`, `update`, or `remove`
-3. Re-check state to confirm the final layout
-4. Operate services through `hagiscript pm2 ...`
+## Runtime Install Workflow
 
-Lifecycle commands print the resolved manifest, managed root, changed component count, skipped entries, and log file path when a log is generated.
+The typical runtime flow is:
 
-## Managed PM2 Services
+```bash
+hagiscript runtime install
+hagiscript runtime state
+hagiscript runtime update
+```
 
-Hagiscript manages runtime-scoped PM2 services for:
+If you want a clean rebuild:
 
-- `server`
-- `omniroute`
-- `code-server`
+```bash
+hagiscript runtime remove --purge
+hagiscript runtime install
+```
 
-Supported actions:
+## Server Install And Management
 
-- `start`
-- `restart`
-- `stop`
-- `status`
-- `env`
+The managed server is installed separately from the core runtime. `hagiscript server install` ensures runtime dependencies are available, resolves a released server package, and makes that version active.
 
-Examples:
+Install the server from the default source:
 
 ```bash
-hagiscript pm2 server start
-hagiscript pm2 server restart
-hagiscript pm2 server status
-hagiscript pm2 server env
-hagiscript pm2 server env --json
-hagiscript pm2 omniroute status
-hagiscript pm2 omniroute start
-hagiscript pm2 code-server stop
+hagiscript server install
 ```
 
-The PM2 flow is runtime-scoped:
+Install the server against an explicit runtime manifest and root:
 
-- PM2 is resolved from the managed npm prefix, not the host environment.
-- Hagiscript resolves the runtime manifest before every PM2 action.
-- PM2 runs with the managed Node runtime and managed PATH ordering.
-- `PM2_HOME` is derived from the managed runtime layout, so service state stays inside the runtime data boundary.
+```bash
+hagiscript server install \
+	--from-manifest ./runtime/manifest.yaml \
+	--runtime-root ~/.hagicode/runtime
+```
 
-This means maintenance scripts should call `hagiscript pm2 ...` instead of a system `pm2` binary, and should ensure `pm2` has been installed into the managed npm prefix beforehand.
+Install from a local archive:
 
-### Released backend `server` contract
+```bash
+hagiscript server install --archive ./hagicode-server.zip
+```
 
-The packaged runtime manifest treats `server` as a `released-service` component. The managed runtime expects a published backend package staged under:
+Install from a specific index version:
 
-```text
-<runtime-root>/program/components/server/current/
-  lib/PCode.Web.dll
-  lib/PCode.Web.deps.json
-  lib/PCode.Web.runtimeconfig.json
-  start.sh (or the platform equivalent from the release package)
+```bash
+hagiscript server install --index-version 0.1.0-beta.60
 ```
 
-Hagiscript keeps mutable launch state for that service under:
+List installed server versions and the active version:
 
-```text
-<runtime-root>/runtime-data/components/services/server/
-  .pm2/
-  pm2-runtime/
+```bash
+hagiscript server list
 ```
 
-`hagiscript runtime install --components server` prepares the runtime-owned launch assets and reports whether the published payload is already staged. `hagiscript pm2 server start` then generates the final PM2 ecosystem/env files under `pm2-runtime/` and launches the released backend through the managed `dotnet` runtime. Use `hagiscript pm2 server env` to print the exact resolved working directory, PATH ordering, and environment variables that HagiScript will use for that startup flow.
+Switch the active version:
 
-## Managed Server Commands
+```bash
+hagiscript server use 0.1.0-beta.60
+```
 
-Hagiscript can now stage a released backend package and prepare all startup prerequisites from a single command surface:
+Remove an installed version:
 
 ```bash
-hagiscript server install
-hagiscript server install --package-dir /srv/hagicode/packages
-hagiscript server install --archive ./hagicode-1.2.3-linux-x64-nort.zip
-hagiscript server install --url https://example.com/hagicode-1.2.3-linux-x64-nort.zip
-hagiscript server install --github-repo HagiCode-org/releases --tag v1.2.3
+hagiscript server remove 0.1.0-beta.60
 ```
 
-By default, `server install`:
-
-- selects or downloads a server archive
-- extracts and stages it into `program/components/server/current/`
-- runs `hagiscript runtime install --components server`
-- ensures `pm2` exists in the managed npm prefix
+## Server Lifecycle
 
-Once installed, use the higher-level lifecycle wrappers:
+Start the managed server:
 
 ```bash
 hagiscript server start
-hagiscript server restart --instance demo
-hagiscript server stop --instance demo
-hagiscript server status --json
-hagiscript server env --instance demo
 ```
 
-`--instance <name>` maps to the PM2 name identifier and defaults to `hagicode`, so one host can run multiple managed runtime roots without colliding app names.
+Stop it:
+
+```bash
+hagiscript server stop
+```
+
+Restart it:
 
-## Runtime Environment Contract
+```bash
+hagiscript server restart
+```
 
-Runtime lifecycle scripts and managed services receive a stable environment contract:
+Check status:
 
-- `HAGICODE_RUNTIME_HOME` - runtime program home
-- `HAGICODE_RUNTIME_DATA_HOME` - writable runtime data home for the current component
-- `PM2_HOME` - PM2 state directory for the current managed service
-- `PATH` - rebuilt so managed Node, managed npm, and managed wrappers come first
+```bash
+hagiscript server status
+```
 
-This contract is what keeps installs, updates, wrappers, and PM2-managed services aligned to the same runtime root.
+Show the startup environment:
 
-## Manifest Customization
+```bash
+hagiscript server env
+```
 
-`runtime/manifest.yaml` controls the runtime shape. Common override points:
+Emit JSON for status or environment:
 
-- `paths.runtimeRoot`
-- `paths.runtimeHome`
-- `paths.runtimeDataRoot`
-- `paths.componentDataRoot`
-- `paths.defaultPm2Home`
-- component `runtimeDataDir`
-- service `pm2.appName`
-- service `pm2.cwd`
-- service `pm2.script`
-- service `pm2.args`
-- service `pm2.env`
-- service `pm2.pm2Home`
+```bash
+hagiscript server status --json
+hagiscript server env --json
+```
 
-For deployment-specific behavior, keep the packaged manifest as the baseline and pass `--from-manifest` with an override manifest rather than mutating the installed package in place.
+Override the PM2 instance name used for namespaced app names:
 
-## Related Runtime Tooling
+```bash
+hagiscript server start --instance myruntime
+```
 
-### Managed Node Runtime
+## Server Configuration
 
-Install a standalone managed Node.js runtime:
+Read the effective managed server config:
 
 ```bash
-hagiscript install-node --target /opt/hagiscript/node
-hagiscript install-node --target /opt/hagiscript/node22 --version 22
+hagiscript server config get
 ```
 
-Standalone Node installs also reuse the shared download cache by default. Pass `--no-download-cache` to force a fresh download, or `--download-cache-dir <path>` to share a custom cache location across installs.
+Update host and port:
 
-Validate an existing managed Node.js runtime:
+```bash
+hagiscript server config set --host 127.0.0.1 --port 39150
+```
+
+Read the config as JSON:
 
 ```bash
-hagiscript check-node --target /opt/hagiscript/node
+hagiscript server config get --json
 ```
 
-### Managed npm Package Sync
+## Managed NPM Tool Sync
 
-Sync npm global packages into the managed npm prefix instead of the host environment:
+The runtime manifest can also declare managed npm packages under `npmSync`. These packages are installed into the managed npm prefix under `runtime-data/npm`, not into `program/`.
+
+If the managed runtime has already been installed, `npm-sync` can read `runtime-data/state.json` under the selected runtime and automatically reuse the recorded `manifestPath` and managed npm prefix. In that case you do not need to pass `--from-manifest`.
+
+Sync npm packages by pointing at the runtime root:
 
 ```bash
-hagiscript npm-sync --manifest ./manifest.json
-hagiscript npm-sync --runtime /opt/hagiscript/node --manifest ./manifest.json
-hagiscript npm-sync --managed-runtime ~/.hagicode/runtime/program/components/node/runtime --prefix ~/.hagicode/runtime/program/npm --manifest ./manifest.json
+hagiscript npm-sync --runtime-root ~/.hagicode/runtime
 ```
 
-When `npm-sync` has to provision a managed Node runtime first, it uses the same shared download cache by default.
+Sync npm packages declared in a runtime manifest:
 
-This is the path for installing `pm2` and any other scenario-specific global tools. The package list is data, not a built-in runtime component.
+```bash
+hagiscript npm-sync --from-manifest ./runtime/manifest.yaml
+```
 
-## Development
+`npm-sync` does not define its own program/data/server root layout. It reads the runtime manifest associated with the selected runtime root and follows that manifest's `npmSync` definition.
 
-Run from `repos/hagiscript/`:
+If you want to change the npm tool versions captured in a manifest, update the manifest first:
 
 ```bash
-npm install
-npm test
-npm run build
-npm run pack:check
+hagiscript manifest set ./hagiscript.manifest.yaml \
+	--npm-package-version pm2=7.0.2 \
+	--npm-package-version @openai/codex=0.126.0
 ```
 
-Useful runtime-focused checks:
+Use an explicit managed Node runtime and prefix:
 
 ```bash
-npm run integration:runtime-management
-npm run integration:runtime-key-path
-npm run integration:installed-runtime
+hagiscript npm-sync \
+	--from-manifest ./runtime/manifest.yaml \
+	--managed-runtime ~/.hagicode/runtime/program/components/node/runtime \
+	--prefix ~/.hagicode/runtime/runtime-data/npm
 ```
 
-The dedicated runtime key-path flow validates the critical production sequence with real network downloads: runtime install for fixed components, npm-sync for scenario-specific tools in the managed npm prefix, and PM2 lifecycle commands resolved from that managed prefix. Run the base flow with:
+Force re-sync even if installed versions already satisfy the requested target:
 
 ```bash
-npm run integration:runtime-key-path
+hagiscript npm-sync --from-manifest ./runtime/manifest.yaml --force
 ```
 
-The release-oriented key-path mode additionally stages the latest public backend package from GitHub Releases and validates the same managed PM2 contract for `server`:
+## Common End-To-End Flow
+
+For a fresh machine or a new runtime root, this is the usual sequence:
 
 ```bash
-HAGISCRIPT_ENABLE_RELEASED_SERVER_TEST=1 npm run integration:runtime-key-path
+hagiscript runtime install
+hagiscript server install
+hagiscript server start
+hagiscript server status
 ```
 
-The broader runtime-management integration path remains available for the existing end-to-end runtime assertions, including the corresponding released-server mode:
+If you also want the manifest-declared npm tools:
 
 ```bash
-HAGISCRIPT_ENABLE_RELEASED_SERVER_TEST=1 npm run integration:runtime-management
+hagiscript npm-sync --runtime-root ~/.hagicode/runtime
 ```
 
+## Useful Flags
+
+- `manifest init [path]`: generate an editable manifest from the packaged default
+- `manifest get [path]`: print a readable summary of the current manifest
+- `manifest set <path>`: update manifest paths, npmSync package versions, or server defaults
+- `--from-manifest <path>`: use a specific runtime manifest YAML
+- `--runtime-root <path>`: change the managed runtime root
+- `--runtime-home <path>`: set the manifest's program root
+- `--runtime-data-root <path>`: set the manifest's runtime-data root
+- `--server-program-root <path>`: set the manifest's server program root
+- `--server-data-root <path>`: set the manifest's server data root
+- `--npm-package-version <package=version>`: update a manifest npmSync package entry
+- `--server-active-version <version>`: set the manifest's preferred managed server version
+- `--components <list>`: target specific runtime components
+- `--dry-run`: print the plan without mutating files
+- `--force`: force reinstall or update where supported
+- `--purge`: remove retained mutable data during runtime removal
+- `--json`: emit machine-readable output for `manifest get`, state, status, env, and config commands
+
 ## License
 
 MIT. See [LICENSE](./LICENSE).

package/dist/cli.js

@@ -3,6 +3,7 @@ import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 import { createRuntimeInfo, packageVersion } from "./index.js";
+import { registerManifestCommands } from "./commands/manifest-commands.js";
 import { registerNpmSyncCommand } from "./commands/npm-sync-commands.js";
 import { registerNodeRuntimeCommands } from "./commands/node-runtime-commands.js";
 import { registerPm2Commands } from "./commands/pm2-commands.js";
@@ -22,6 +23,7 @@ export function createCli() {
         process.stdout.write(`${JSON.stringify(info, null, 2)}\n`);
     });
     registerNodeRuntimeCommands(program);
+    registerManifestCommands(program);
     registerNpmSyncCommand(program);
     registerPm2Commands(program);
     registerRuntimeCommands(program);

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAClF,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEvE,MAAM,UAAU,SAAS;IACvB,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAE9B,OAAO;SACJ,IAAI,CAAC,YAAY,CAAC;SAClB,WAAW,CAAC,6CAA6C,CAAC;SAC1D,OAAO,CAAC,cAAc,EAAE,eAAe,EAAE,8BAA8B,CAAC,CAAC;IAE5E,OAAO;SACJ,OAAO,CAAC,MAAM,CAAC;SACf,WAAW,CAAC,mCAAmC,CAAC;SAChD,MAAM,CAAC,GAAG,EAAE;QACX,MAAM,IAAI,GAAG,iBAAiB,EAAE,CAAC;QACjC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;IAEL,2BAA2B,CAAC,OAAO,CAAC,CAAC;IACrC,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAChC,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAC7B,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACjC,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAEhC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE;QAClB,OAAO,CAAC,UAAU,EAAE,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI;IAC9C,MAAM,OAAO,GAAG,SAAS,EAAE,CAAC;IAC5B,MAAM,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAC3B,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAE1B,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,CAAC;QACH,OAAO,YAAY,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,KAAK,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC3E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,IAAI,eAAe,EAAE,EAAE,CAAC;IACtB,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;QAChC,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC;QACrC,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAClF,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEvE,MAAM,UAAU,SAAS;IACvB,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAE9B,OAAO;SACJ,IAAI,CAAC,YAAY,CAAC;SAClB,WAAW,CAAC,6CAA6C,CAAC;SAC1D,OAAO,CAAC,cAAc,EAAE,eAAe,EAAE,8BAA8B,CAAC,CAAC;IAE5E,OAAO;SACJ,OAAO,CAAC,MAAM,CAAC;SACf,WAAW,CAAC,mCAAmC,CAAC;SAChD,MAAM,CAAC,GAAG,EAAE;QACX,MAAM,IAAI,GAAG,iBAAiB,EAAE,CAAC;QACjC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;IAEL,2BAA2B,CAAC,OAAO,CAAC,CAAC;IACrC,wBAAwB,CAAC,OAAO,CAAC,CAAC;IAClC,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAChC,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAC7B,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACjC,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAEhC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE;QAClB,OAAO,CAAC,UAAU,EAAE,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI;IAC9C,MAAM,OAAO,GAAG,SAAS,EAAE,CAAC;IAC5B,MAAM,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAC3B,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAE1B,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,CAAC;QACH,OAAO,YAAY,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,KAAK,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC3E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,IAAI,eAAe,EAAE,EAAE,CAAC;IACtB,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;QAChC,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC;QACrC,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/commands/manifest-commands.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerManifestCommands(program: Command): void;