aemdm 0.1.0

package/LICENSE

@@ -0,0 +1,176 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, then any Derivative Works that You distribute must
+include a readable copy of the attribution notices contained
+within such NOTICE file, excluding those notices that do not
+pertain to any part of the Derivative Works, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,230 @@
+# `aemdm`
+
+`aemdm` is a small TypeScript CLI for Adobe Dynamic Media with OpenAPI.
+
+It is designed as a practical operator tool for both humans and LLM-driven workflows:
+
+- Build Dynamic Media delivery URLs from a known asset ID.
+- Fetch asset metadata JSON.
+- Download transformed or original binaries.
+- Search activated assets with simple exact-match metadata filters.
+- Emit an LLM-oriented usage guide with `--skill`.
+- Persist a default bucket in a local profile config so repeated commands stay short.
+
+## Features
+
+- Build asset delivery URLs by asset ID.
+- Apply delivery modifiers such as `format`, `size`, `width`, `height`, `quality`, and `max-quality`.
+- Fetch asset metadata.
+- Download transformed or original binaries.
+- Search activated assets with a simple metadata filter DSL.
+- Pass through raw search JSON when you need the full API request body.
+- Emit asset IDs in pipe-friendly forms for follow-up CLI calls.
+
+## Install
+
+```bash
+npm install
+```
+
+Install the CLI globally from npm:
+
+```bash
+npm install -g aemdm
+```
+
+## Usage
+
+```bash
+npm run build
+node dist/cli.js asset get urn:aaid:aem:1234 --bucket delivery-p123-e456.adobeaemcloud.com
+```
+
+### URL by asset ID
+
+```bash
+node dist/cli.js asset get urn:aaid:aem:1234 \
+  --bucket delivery-p123-e456.adobeaemcloud.com \
+  --format webp \
+  --size 1200x800 \
+  --quality 75
+```
+
+### Metadata
+
+```bash
+node dist/cli.js asset get urn:aaid:aem:1234 --metadata
+```
+
+If an IMS token is available, `--metadata` returns the full metadata document from the metadata endpoint. Without authentication, it returns a smaller public JSON object based on the asset response headers:
+
+```bash
+node dist/cli.js asset get urn:aaid:aem:1234 --metadata --ims-token "$AEMDM_IMS_TOKEN"
+```
+
+### Original binary
+
+```bash
+node dist/cli.js asset get urn:aaid:aem:1234 \
+  --original \
+  --binary \
+  --output ./asset.bin
+```
+
+Public assets can also be downloaded without passing a token:
+
+```bash
+node dist/cli.js asset get urn:aaid:aem:1234 --binary --output ./asset.bin
+```
+
+### Search
+
+```bash
+node dist/cli.js search \
+  --where x:y=z \
+  --where repositoryMetadata.dc:format=image/jpeg,image/png
+```
+
+### Search Output Modes
+
+The default `search` output is a compact table for humans. For automation and piping, use one of these:
+
+```bash
+node dist/cli.js search --text "hero" --first-id
+node dist/cli.js search --text "hero" --ids-only
+node dist/cli.js search --text "hero" --json
+```
+
+These are useful when another command needs an asset ID:
+
+```bash
+aemdm search --where x:y=z --first-id
+aemdm search --where x:y=z --ids-only | xargs -I {} aemdm asset get {}
+```
+
+If you want raw response automation with `jq`:
+
+```bash
+aemdm search --text "hero" --json | jq -r '.hits.results[0].assetId'
+```
+
+### LLM Skill Output
+
+Use `--skill` to print a concise guide that explains what the tool does, which commands to use, and how an LLM should choose between them.
+
+```bash
+node dist/cli.js --skill
+```
+
+Example output areas:
+
+- tool purpose
+- core commands
+- asset and search examples
+- metadata filter DSL behavior
+- raw query examples
+- LLM usage guidance for when to use `asset get`, `search`, `--first-url`, `--first-metadata`, and `--first-binary`
+
+### Save a Default Bucket
+
+You can save the bucket once and omit `--bucket` from later commands:
+
+```bash
+node dist/cli.js --bucket delivery-p123-e456.adobeaemcloud.com
+```
+
+After that, regular commands can use the saved profile bucket:
+
+```bash
+node dist/cli.js asset get urn:aaid:aem:1234
+node dist/cli.js search --where x:y=z
+```
+
+### First result helpers
+
+```bash
+node dist/cli.js search --text "hero banner" --first-url --format webp --width 800
+node dist/cli.js search --text "hero banner" --first-metadata
+node dist/cli.js search --text "hero banner" --first-binary --output ./hero.bin
+```
+
+## Configuration
+
+Resolution precedence is:
+
+1. explicit flags
+2. environment variables
+3. saved profile config
+
+Profile config path:
+
+- `$AEMDM_CONFIG_PATH`, if set
+- otherwise `$XDG_CONFIG_HOME/aemdm/config.json`
+- otherwise `$HOME/.config/aemdm/config.json`
+
+- `AEMDM_BUCKET`
+- `AEMDM_IMS_TOKEN`
+- `AEMDM_API_KEY` (defaults to `asset_search_service`)
+
+## `--skill` Examples
+
+These are especially useful when another tool or agent needs to understand how to call `aemdm`.
+
+```bash
+node dist/cli.js --skill
+```
+
+```bash
+aemdm --skill
+```
+
+Typical LLM-oriented patterns:
+
+```bash
+aemdm --bucket delivery-p123-e456.adobeaemcloud.com
+aemdm search --where x:y=z --first-id
+aemdm search --text "hero" --ids-only
+aemdm search --text "hero" --json
+aemdm asset get urn:aaid:aem:1234 --format webp --size 1600x900 --quality 80
+aemdm search --where x:y=z --first-url --format jpg --width 1200
+aemdm search --raw-query @./query.json
+```
+
+## Publishing
+
+Before publishing a new release, verify the package contents and publish from the repo root:
+
+```bash
+npm test
+npm run pack:check
+npm publish
+```
+
+`prepack` builds `dist/`, and `prepublishOnly` runs the test suite during `npm publish`.
+
+### Automated npm publish from GitHub
+
+The repository includes a GitHub Actions workflow that publishes to npm when you push a version tag like `v0.1.0` or publish a GitHub release for that tag.
+
+Required setup:
+
+```bash
+NPM_TOKEN
+```
+
+Add `NPM_TOKEN` as a GitHub repository secret with permission to publish the `aemdm` package on npm.
+
+Release flow:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+The workflow verifies that the tag matches the `version` field in `package.json`, runs `lint`, `build`, and `test`, and then publishes the package.
+
+## References
+
+- [Dynamic Media with OpenAPI spec](https://developer.adobe.com/experience-cloud/experience-manager-apis/api/stable/assets/delivery/)
+- [Delivery APIs](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/assets/dynamicmedia/dynamic-media-open-apis/deliver-assets-apis)
+- [Search Assets API](https://experienceleague.adobe.com/en/docs/experience-manager-cloud-service/content/assets/dynamicmedia/dynamic-media-open-apis/search-assets-api)

package/dist/cli.js

@@ -0,0 +1,477 @@
+#!/usr/bin/env node
+import { pathToFileURL } from "node:url";
+import { Command, CommanderError, Option } from "commander";
+import { z } from "zod";
+import { CliError, request, requestJson, resolveBucket, resolveOptionalImsToken, resolveSearchAuth, } from "./lib/client.js";
+import { readProfileConfig, writeProfileConfig, } from "./lib/config.js";
+import { buildAssetUrl, buildMetadataUrl, deliveryFormatSchema, resolveDimensions, } from "./lib/delivery.js";
+import { buildSearchRequest, getAssetIdFromHit, loadRawQuery, } from "./lib/search.js";
+import { formatSearchResults, writeBinaryOutput, writeJson, writeLine, } from "./lib/output.js";
+const numberOption = (flagName) => (value) => {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed)) {
+        throw new CliError(`${flagName} must be an integer.`);
+    }
+    return parsed;
+};
+const collectValues = (value, previous = []) => [...previous, value];
+const assetGetSchema = z
+    .object({
+    bucket: z.string().optional(),
+    format: deliveryFormatSchema.optional(),
+    size: z.string().optional(),
+    width: z.number().int().min(1).optional(),
+    height: z.number().int().min(1).optional(),
+    quality: z.number().int().min(1).max(100).optional(),
+    maxQuality: z.number().int().min(1).max(100).optional(),
+    seoName: z.string().trim().min(1).default("asset"),
+    original: z.boolean().default(false),
+    binary: z.boolean().default(false),
+    output: z.string().optional(),
+    metadata: z.boolean().default(false),
+    imsToken: z.string().optional(),
+})
+    .superRefine((value, ctx) => {
+    if (value.metadata && value.output) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "--output cannot be used with --metadata.",
+            path: ["output"],
+        });
+    }
+    if (value.metadata && value.binary) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "--metadata and --binary cannot be used together.",
+            path: ["binary"],
+        });
+    }
+    if (value.metadata && value.original) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "--metadata and --original cannot be used together.",
+            path: ["original"],
+        });
+    }
+    if (value.metadata && (value.format || value.size || value.width || value.height || value.quality || value.maxQuality)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "--metadata cannot be combined with delivery modifier flags.",
+            path: ["metadata"],
+        });
+    }
+    if (value.binary && !value.output) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "--output is required when using --binary. Use --output - for stdout.",
+            path: ["output"],
+        });
+    }
+    if (value.original && (value.format || value.size || value.width || value.height || value.quality || value.maxQuality)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "--original cannot be combined with delivery modifier flags.",
+            path: ["original"],
+        });
+    }
+});
+const searchSchema = z
+    .object({
+    bucket: z.string().optional(),
+    imsToken: z.string().optional(),
+    apiKey: z.string().optional(),
+    text: z.string().optional(),
+    where: z.array(z.string()).default([]),
+    limit: z.number().int().min(0).max(1000).optional(),
+    cursor: z.string().optional(),
+    field: z.array(z.string()).default([]),
+    sort: z.array(z.string()).default([]),
+    rawQuery: z.string().optional(),
+    json: z.boolean().default(false),
+    idsOnly: z.boolean().default(false),
+    firstId: z.boolean().default(false),
+    firstUrl: z.boolean().default(false),
+    firstMetadata: z.boolean().default(false),
+    firstBinary: z.boolean().default(false),
+    output: z.string().optional(),
+    format: deliveryFormatSchema.optional(),
+    size: z.string().optional(),
+    width: z.number().int().min(1).optional(),
+    height: z.number().int().min(1).optional(),
+    quality: z.number().int().min(1).max(100).optional(),
+    maxQuality: z.number().int().min(1).max(100).optional(),
+    seoName: z.string().trim().min(1).default("asset"),
+    original: z.boolean().default(false),
+})
+    .superRefine((value, ctx) => {
+    const firstModeCount = [value.firstId, value.firstUrl, value.firstMetadata, value.firstBinary]
+        .filter(Boolean).length;
+    if (firstModeCount > 1) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Use only one of --first-id, --first-url, --first-metadata, or --first-binary.",
+            path: ["firstId"],
+        });
+    }
+    const outputModeCount = [value.json, value.idsOnly, firstModeCount > 0].filter(Boolean).length;
+    if (outputModeCount > 1) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Use only one of --json, --ids-only, or a --first-* option.",
+            path: ["json"],
+        });
+    }
+    if (value.firstBinary && !value.output) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "--output is required when using --first-binary. Use --output - for stdout.",
+            path: ["output"],
+        });
+    }
+    if (!value.firstBinary && value.output) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "--output is only valid with --first-binary.",
+            path: ["output"],
+        });
+    }
+    if (value.rawQuery && (value.text || value.where.length > 0 || value.field.length > 0 || value.sort.length > 0 || value.limit !== undefined || value.cursor)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "--raw-query cannot be combined with --text, --where, --field, --sort, --limit, or --cursor.",
+            path: ["rawQuery"],
+        });
+    }
+    if (value.original && (value.format || value.size || value.width || value.height || value.quality || value.maxQuality)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "--original cannot be combined with delivery modifier flags.",
+            path: ["original"],
+        });
+    }
+});
+function parseWithSchema(schema, options) {
+    const result = schema.safeParse(options);
+    if (!result.success) {
+        throw new CliError(result.error.issues.map((issue) => issue.message).join("\n"));
+    }
+    return result.data;
+}
+async function handleAssetGet(assetId, options, runtime) {
+    const parsed = parseWithSchema(assetGetSchema, options);
+    const profile = await readProfileConfig(runtime.env);
+    const baseUrl = resolveBucket(parsed.bucket, runtime.env, profile.bucket);
+    const imsToken = resolveOptionalImsToken(parsed.imsToken, runtime.env);
+    const dimensions = resolveDimensions(parsed.size, parsed.width, parsed.height);
+    if (parsed.metadata) {
+        const metadata = imsToken
+            ? await requestJson(buildMetadataUrl(baseUrl, assetId), {
+                imsToken,
+                fetchImpl: runtime.fetchImpl,
+            })
+            : await fetchBasicAssetMetadata(assetId, baseUrl, runtime);
+        writeJson(runtime.stdout, metadata);
+        return;
+    }
+    const url = buildAssetUrl(baseUrl, {
+        assetId,
+        seoName: parsed.seoName,
+        format: parsed.format,
+        width: dimensions.width,
+        height: dimensions.height,
+        quality: parsed.quality,
+        maxQuality: parsed.maxQuality,
+        original: parsed.original,
+    });
+    if (!parsed.binary) {
+        writeLine(runtime.stdout, url);
+        return;
+    }
+    const response = await request(url, {
+        imsToken,
+        fetchImpl: runtime.fetchImpl,
+    });
+    await writeBinaryOutput(response, parsed.output, runtime.stdout);
+}
+async function buildSearchBody(parsed) {
+    if (parsed.rawQuery) {
+        return loadRawQuery(parsed.rawQuery);
+    }
+    return buildSearchRequest({
+        text: parsed.text,
+        where: parsed.where,
+        fields: parsed.field,
+        sort: parsed.sort,
+        limit: parsed.limit,
+        cursor: parsed.cursor,
+    });
+}
+async function handleSearch(options, runtime) {
+    const parsed = parseWithSchema(searchSchema, options);
+    const profile = await readProfileConfig(runtime.env);
+    const baseUrl = resolveBucket(parsed.bucket, runtime.env, profile.bucket);
+    const { imsToken, apiKey } = resolveSearchAuth(parsed.imsToken, parsed.apiKey, runtime.env);
+    const searchBody = await buildSearchBody(parsed);
+    const searchUrl = `${baseUrl}/search`;
+    const response = await requestJson(searchUrl, {
+        method: "POST",
+        imsToken,
+        apiKey,
+        jsonBody: searchBody,
+        fetchImpl: runtime.fetchImpl,
+    });
+    if (parsed.json) {
+        writeJson(runtime.stdout, response);
+        return;
+    }
+    if (parsed.idsOnly) {
+        const hits = response.hits?.results ?? [];
+        for (const hit of hits) {
+            writeLine(runtime.stdout, getAssetIdFromHit(hit));
+        }
+        return;
+    }
+    const firstHit = response.hits?.results?.[0];
+    if (parsed.firstId || parsed.firstUrl || parsed.firstMetadata || parsed.firstBinary) {
+        if (!firstHit) {
+            throw new CliError("No search results found for the requested first-result action.");
+        }
+        const assetId = getAssetIdFromHit(firstHit);
+        if (parsed.firstId) {
+            writeLine(runtime.stdout, assetId);
+            return;
+        }
+        if (parsed.firstMetadata) {
+            const metadata = await requestJson(buildMetadataUrl(baseUrl, assetId), {
+                imsToken,
+                fetchImpl: runtime.fetchImpl,
+            });
+            writeJson(runtime.stdout, metadata);
+            return;
+        }
+        const dimensions = resolveDimensions(parsed.size, parsed.width, parsed.height);
+        const assetUrl = buildAssetUrl(baseUrl, {
+            assetId,
+            seoName: parsed.seoName,
+            format: parsed.format,
+            width: dimensions.width,
+            height: dimensions.height,
+            quality: parsed.quality,
+            maxQuality: parsed.maxQuality,
+            original: parsed.original,
+        });
+        if (parsed.firstUrl) {
+            writeLine(runtime.stdout, assetUrl);
+            return;
+        }
+        const binaryResponse = await request(assetUrl, {
+            imsToken,
+            fetchImpl: runtime.fetchImpl,
+        });
+        await writeBinaryOutput(binaryResponse, parsed.output, runtime.stdout);
+        return;
+    }
+    writeLine(runtime.stdout, formatSearchResults(response));
+}
+async function fetchBasicAssetMetadata(assetId, baseUrl, runtime) {
+    const url = buildAssetUrl(baseUrl, { assetId });
+    let response = await runtime.fetchImpl(url, { method: "HEAD" });
+    // Some delivery endpoints may not support HEAD, so fall back to GET and
+    // discard the body after reading the headers.
+    if (response.status === 405 || response.status === 501) {
+        response = await runtime.fetchImpl(url);
+        await response.body?.cancel();
+    }
+    if (!response.ok) {
+        throw new CliError(`Unable to fetch public metadata for ${url}: HTTP ${response.status} ${response.statusText}`);
+    }
+    const contentLengthHeader = response.headers.get("content-length");
+    const contentLength = contentLengthHeader === null ? undefined : Number(contentLengthHeader);
+    return {
+        mode: "basic",
+        assetId,
+        publicUrl: response.url || url,
+        contentType: response.headers.get("content-type") ?? undefined,
+        contentDisposition: response.headers.get("content-disposition") ?? undefined,
+        etag: response.headers.get("etag") ?? undefined,
+        cacheControl: response.headers.get("cache-control") ?? undefined,
+        contentLength: Number.isFinite(contentLength) ? contentLength : undefined,
+        auth: "public",
+    };
+}
+function configureCommonDeliveryOptions(command) {
+    return command
+        .addOption(new Option("--format <format>", "Output format").choices(deliveryFormatSchema.options))
+        .option("--size <WxH>", "Convenience image size, for example 300x200, 300x, or x200")
+        .option("--width <px>", "Output width in pixels", numberOption("--width"))
+        .option("--height <px>", "Output height in pixels", numberOption("--height"))
+        .option("--quality <1-100>", "Output quality", numberOption("--quality"))
+        .option("--max-quality <1-100>", "Max dynamic quality", numberOption("--max-quality"))
+        .option("--seo-name <name>", "SEO name for transformed/original routes", "asset")
+        .option("--original", "Use the original binary route");
+}
+function buildProgram(runtime) {
+    const program = new Command();
+    program
+        .name("aemdm")
+        .description("CLI for Adobe Dynamic Media with OpenAPI")
+        .version("0.1.0")
+        .showHelpAfterError()
+        .configureOutput({
+        writeOut: (text) => runtime.stdout.write(text),
+        writeErr: (text) => runtime.stderr.write(text),
+    })
+        .exitOverride();
+    configureCommonDeliveryOptions(program.command("asset").description("Asset operations"))
+        .command("get <assetId>")
+        .description("Build a delivery URL, fetch metadata, or download a binary for an asset")
+        .option("--bucket <bucket-or-url>", "Bucket host or full bucket URL")
+        .option("--binary", "Fetch the binary instead of printing the URL")
+        .option("--output <file>", "Output file path for --binary. Use - for stdout")
+        .option("--metadata", "Fetch metadata JSON instead of building a URL")
+        .option("--ims-token <token>", "IMS bearer token for metadata or binary requests")
+        .action((assetId, options) => handleAssetGet(assetId, options, runtime));
+    configureCommonDeliveryOptions(program.command("search").description("Search assets and optionally resolve the first result"))
+        .option("--bucket <bucket-or-url>", "Bucket host or full bucket URL")
+        .option("--ims-token <token>", "IMS bearer token")
+        .option("--api-key <key>", "Adobe API key")
+        .option("--text <query>", "Full-text search query")
+        .option("--where <field=value>", "Metadata filter clause", collectValues, [])
+        .option("--limit <n>", "Maximum items to fetch", numberOption("--limit"))
+        .option("--cursor <cursor>", "Opaque cursor for pagination")
+        .option("--field <path>", "Projected field to include in results", collectValues, [])
+        .option("--sort <field[:ASC|DESC]>", "Sort rule", collectValues, [])
+        .option("--raw-query <json-or-@file>", "Raw JSON search request or @file path")
+        .option("--json", "Print the raw search response as JSON")
+        .option("--ids-only", "Print one asset ID per line")
+        .option("--first-id", "Print the first matching asset ID")
+        .option("--first-url", "Print a delivery URL for the first result")
+        .option("--first-metadata", "Fetch metadata for the first result")
+        .option("--first-binary", "Download the first result binary")
+        .option("--output <file>", "Output file path for --first-binary. Use - for stdout")
+        .action((options) => handleSearch(options, runtime));
+    return program;
+}
+function renderSkillText() {
+    return `aemdm skill
+
+Purpose:
+Use aemdm to work with Adobe Dynamic Media with OpenAPI assets from the command line. It can build delivery URLs, fetch metadata, download binaries, and search activated assets.
+
+Core commands:
+- aemdm asset get <assetId>
+- aemdm search
+
+Important defaults:
+- Bucket comes from --bucket or AEMDM_BUCKET.
+- A standalone call like aemdm --bucket delivery-p123-e456.adobeaemcloud.com saves the default bucket to the local aemdm profile config.
+- Search auth comes from --ims-token/AEMDM_IMS_TOKEN and --api-key/AEMDM_API_KEY.
+- asset get prints a URL by default.
+- asset get --metadata prints full JSON metadata when authenticated, or basic public JSON metadata when no token is supplied.
+- asset get --binary downloads the asset and requires --output.
+- search --first-id prints one asset ID for piping.
+- search --ids-only prints one asset ID per line.
+- search --json prints the raw search response.
+
+Asset URL examples:
+- aemdm asset get urn:aaid:aem:1234 --bucket delivery-p123-e456.adobeaemcloud.com
+- aemdm asset get urn:aaid:aem:1234 --format webp --size 1200x800 --quality 75
+- aemdm asset get urn:aaid:aem:1234 --original --binary --output ./asset.bin
+- aemdm asset get urn:aaid:aem:1234 --metadata
+- aemdm asset get urn:aaid:aem:1234 --metadata --ims-token <token>
+
+Search examples:
+- aemdm search --text "hero banner"
+- aemdm search --where x:y=z
+- aemdm search --where repositoryMetadata.dc:format=image/jpeg,image/png
+- aemdm search --first-id --where x:y=z
+- aemdm search --ids-only --text "homepage"
+- aemdm search --json --text "homepage"
+- aemdm search --text "homepage" --first-url --format webp --width 800
+- aemdm search --text "homepage" --first-metadata
+- aemdm search --text "homepage" --first-binary --output ./first.bin
+
+Filter DSL:
+- --where x:y=z maps to assetMetadata.x:y = ["z"]
+- --where repositoryMetadata.dc:format=image/jpeg,image/png maps to an exact-match term filter with multiple values
+
+Raw query escape hatch:
+- aemdm search --raw-query '{"query":[{"match":{"text":"homepage","mode":"FULLTEXT"}}]}'
+- aemdm search --raw-query @./query.json
+
+LLM usage guidance:
+- Use asset get when you already know the asset ID.
+- Use search when you need to discover an asset by metadata or text.
+- Prefer --first-id or --ids-only when another CLI call needs asset IDs.
+- Prefer --first-url when the user wants a delivery URL from a search result.
+- Prefer --first-metadata when the user wants the resolved asset metadata after search.
+- Prefer --first-binary with --output when the user wants the downloaded file.
+`;
+}
+function getStandaloneBucketValue(argv) {
+    if (argv.length === 1 && argv[0].startsWith("--bucket=")) {
+        return argv[0].slice("--bucket=".length);
+    }
+    if (argv.length === 2 && argv[0] === "--bucket") {
+        return argv[1];
+    }
+    return undefined;
+}
+function toCliError(error) {
+    if (error instanceof CliError) {
+        return error;
+    }
+    if (error instanceof CommanderError) {
+        if (Number(error.exitCode) === 0 ||
+            error.code === "commander.help" ||
+            error.code === "commander.helpDisplayed" ||
+            error.code === "commander.version" ||
+            error.code === "commander.versionDisplayed") {
+            return new CliError("", 0);
+        }
+        return new CliError(error.message, Number(error.exitCode) || 1);
+    }
+    if (error instanceof Error) {
+        return new CliError(error.message);
+    }
+    return new CliError(String(error));
+}
+export async function runCli(argv, runtimeOverrides = {}) {
+    const runtime = {
+        env: process.env,
+        stdout: process.stdout,
+        stderr: process.stderr,
+        fetchImpl: fetch,
+        ...runtimeOverrides,
+    };
+    try {
+        const standaloneBucket = getStandaloneBucketValue(argv);
+        if (standaloneBucket !== undefined) {
+            const bucket = resolveBucket(standaloneBucket, runtime.env);
+            const configPath = await writeProfileConfig(runtime.env, { bucket });
+            writeLine(runtime.stdout, `Saved bucket to profile config: ${bucket}`);
+            writeLine(runtime.stdout, `Config file: ${configPath}`);
+            return 0;
+        }
+        if (argv.includes("--skill")) {
+            writeLine(runtime.stdout, renderSkillText().trimEnd());
+            return 0;
+        }
+        const program = buildProgram(runtime);
+        await program.parseAsync(argv, { from: "user" });
+        return 0;
+    }
+    catch (error) {
+        const cliError = toCliError(error);
+        if (cliError.message) {
+            writeLine(runtime.stderr, cliError.message);
+        }
+        return cliError.exitCode;
+    }
+}
+const executedDirectly = process.argv[1] !== undefined &&
+    import.meta.url === pathToFileURL(process.argv[1]).href;
+if (executedDirectly) {
+    const exitCode = await runCli(process.argv.slice(2));
+    process.exitCode = exitCode;
+}

package/dist/lib/client.js

@@ -0,0 +1,91 @@
+import { z } from "zod";
+export class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = "CliError";
+        this.exitCode = exitCode;
+    }
+}
+export class HttpError extends CliError {
+    status;
+    statusText;
+    url;
+    responseBody;
+    constructor(response, url, responseBody) {
+        const detail = responseBody ? `\n${responseBody}` : "";
+        super(`HTTP ${response.status} ${response.statusText} for ${url}${detail}`, 1);
+        this.name = "HttpError";
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.url = url;
+        this.responseBody = responseBody;
+    }
+}
+const bucketSchema = z
+    .string()
+    .trim()
+    .min(1, "Bucket value cannot be empty.");
+export function normalizeBucket(input) {
+    const raw = bucketSchema.parse(input);
+    const url = raw.startsWith("http://") || raw.startsWith("https://")
+        ? new URL(raw)
+        : new URL(`https://${raw}`);
+    return new URL("/adobe/assets", url.origin).toString().replace(/\/$/, "");
+}
+export function resolveBucket(explicitValue, env, profileBucket) {
+    const bucket = explicitValue ?? env.AEMDM_BUCKET ?? profileBucket;
+    if (!bucket) {
+        throw new CliError("Missing bucket. Use --bucket, set AEMDM_BUCKET, or save a profile bucket with `aemdm --bucket <bucket>`.");
+    }
+    return normalizeBucket(bucket);
+}
+export function resolveOptionalImsToken(explicitValue, env) {
+    return explicitValue ?? env.AEMDM_IMS_TOKEN;
+}
+export function resolveSearchAuth(imsToken, apiKey, env) {
+    const resolvedImsToken = imsToken ?? env.AEMDM_IMS_TOKEN;
+    const resolvedApiKey = apiKey ?? env.AEMDM_API_KEY ?? "asset_search_service";
+    if (!resolvedImsToken) {
+        throw new CliError("Missing IMS token. Use --ims-token or set AEMDM_IMS_TOKEN.");
+    }
+    return {
+        imsToken: resolvedImsToken,
+        apiKey: resolvedApiKey,
+    };
+}
+function buildHeaders(options) {
+    const headers = new Headers(options.headers);
+    if (options.imsToken) {
+        headers.set("Authorization", `Bearer ${options.imsToken}`);
+    }
+    if (options.apiKey) {
+        headers.set("X-Api-Key", options.apiKey);
+    }
+    if (options.jsonBody !== undefined) {
+        headers.set("Content-Type", "application/json");
+        headers.set("X-Adobe-Accept-Experimental", "1");
+    }
+    return headers;
+}
+export function joinAssetUrl(baseUrl, path) {
+    const normalizedBase = `${baseUrl.replace(/\/+$/, "")}/`;
+    return new URL(path.replace(/^\/+/, ""), normalizedBase).toString();
+}
+export async function request(url, options = {}) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const response = await fetchImpl(url, {
+        method: options.method ?? (options.jsonBody === undefined ? "GET" : "POST"),
+        headers: buildHeaders(options),
+        body: options.jsonBody === undefined ? undefined : JSON.stringify(options.jsonBody),
+    });
+    if (!response.ok) {
+        const responseBody = await response.text();
+        throw new HttpError(response, url, responseBody);
+    }
+    return response;
+}
+export async function requestJson(url, options = {}) {
+    const response = await request(url, options);
+    return response.json();
+}

package/dist/lib/config.js

@@ -0,0 +1,50 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+const profileSchema = z.object({
+    bucket: z.string().optional(),
+});
+export function resolveConfigPath(env) {
+    if (env.AEMDM_CONFIG_PATH) {
+        return env.AEMDM_CONFIG_PATH;
+    }
+    const home = env.HOME;
+    const xdgConfigHome = env.XDG_CONFIG_HOME;
+    if (xdgConfigHome) {
+        return path.join(xdgConfigHome, "aemdm", "config.json");
+    }
+    if (home) {
+        return path.join(home, ".config", "aemdm", "config.json");
+    }
+    return path.join(process.cwd(), ".aemdm.config.json");
+}
+export async function readProfileConfig(env) {
+    const configPath = resolveConfigPath(env);
+    try {
+        const raw = await readFile(configPath, "utf8");
+        return profileSchema.parse(JSON.parse(raw));
+    }
+    catch (error) {
+        const typedError = error;
+        if (typedError?.code === "ENOENT") {
+            return {};
+        }
+        if (error instanceof z.ZodError) {
+            throw new Error(`Invalid aemdm profile config at ${configPath}: ${error.message}`, {
+                cause: error,
+            });
+        }
+        if (error instanceof SyntaxError) {
+            throw new Error(`Unable to parse aemdm profile config at ${configPath}: ${error.message}`, {
+                cause: error,
+            });
+        }
+        throw error;
+    }
+}
+export async function writeProfileConfig(env, profile) {
+    const configPath = resolveConfigPath(env);
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify(profile, null, 2)}\n`, "utf8");
+    return configPath;
+}

package/dist/lib/delivery.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { CliError } from "./client.js";
+export const DEFAULT_SEO_NAME = "asset";
+export const TRANSFORM_FALLBACK_FORMAT = "avif";
+export const deliveryFormatSchema = z.enum(["gif", "png", "jpg", "jpeg", "webp", "avif"]);
+const qualitySchema = z.number().int().min(1).max(100);
+const dimensionSchema = z.number().int().min(1);
+export function parseSize(value) {
+    const match = /^(?<width>\d+)?x(?<height>\d+)?$/i.exec(value.trim());
+    if (!match?.groups) {
+        throw new CliError("Invalid --size value. Use WxH, Wxx, or xH.");
+    }
+    const width = match.groups.width ? Number(match.groups.width) : undefined;
+    const height = match.groups.height ? Number(match.groups.height) : undefined;
+    if (!width && !height) {
+        throw new CliError("Invalid --size value. Provide at least width or height.");
+    }
+    if (width !== undefined) {
+        dimensionSchema.parse(width);
+    }
+    if (height !== undefined) {
+        dimensionSchema.parse(height);
+    }
+    return { width, height };
+}
+export function resolveDimensions(size, width, height) {
+    const sizeDimensions = size ? parseSize(size) : {};
+    const resolvedWidth = width ?? sizeDimensions.width;
+    const resolvedHeight = height ?? sizeDimensions.height;
+    if (resolvedWidth !== undefined) {
+        dimensionSchema.parse(resolvedWidth);
+    }
+    if (resolvedHeight !== undefined) {
+        dimensionSchema.parse(resolvedHeight);
+    }
+    return {
+        width: resolvedWidth,
+        height: resolvedHeight,
+    };
+}
+export function buildMetadataUrl(baseUrl, assetId) {
+    return `${baseUrl.replace(/\/+$/, "")}/${encodeURIComponent(assetId)}/metadata`;
+}
+export function buildAssetUrl(baseUrl, options) {
+    const seoName = options.seoName ?? DEFAULT_SEO_NAME;
+    const normalizedBase = baseUrl.replace(/\/+$/, "");
+    const encodedAssetId = encodeURIComponent(options.assetId);
+    const encodedSeoName = encodeURIComponent(seoName);
+    if (options.quality !== undefined) {
+        qualitySchema.parse(options.quality);
+    }
+    if (options.maxQuality !== undefined) {
+        qualitySchema.parse(options.maxQuality);
+    }
+    if (options.width !== undefined) {
+        dimensionSchema.parse(options.width);
+    }
+    if (options.height !== undefined) {
+        dimensionSchema.parse(options.height);
+    }
+    if (options.original) {
+        return `${normalizedBase}/${encodedAssetId}/original/as/${encodedSeoName}`;
+    }
+    const shouldUseTransformRoute = options.format !== undefined ||
+        options.width !== undefined ||
+        options.height !== undefined ||
+        options.quality !== undefined ||
+        options.maxQuality !== undefined;
+    if (!shouldUseTransformRoute) {
+        return `${normalizedBase}/${encodedAssetId}`;
+    }
+    const format = options.format ?? TRANSFORM_FALLBACK_FORMAT;
+    const url = new URL(`${normalizedBase}/${encodedAssetId}/as/${encodedSeoName}.${format}`);
+    if (options.width !== undefined) {
+        url.searchParams.set("width", String(options.width));
+    }
+    if (options.height !== undefined) {
+        url.searchParams.set("height", String(options.height));
+    }
+    if (options.quality !== undefined) {
+        url.searchParams.set("quality", String(options.quality));
+    }
+    if (options.maxQuality !== undefined) {
+        url.searchParams.set("max-quality", String(options.maxQuality));
+    }
+    return url.toString();
+}

package/dist/lib/output.js

@@ -0,0 +1,53 @@
+import { mkdir } from "node:fs/promises";
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+function valueToString(value) {
+    if (Array.isArray(value)) {
+        return value.join(", ");
+    }
+    return value === undefined || value === null ? "" : String(value);
+}
+export function writeLine(stream, line) {
+    stream.write(`${line}\n`);
+}
+export function writeJson(stream, value) {
+    stream.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export function formatSearchResults(response) {
+    const results = response.hits?.results ?? [];
+    if (results.length === 0) {
+        return "No results.";
+    }
+    const rows = [
+        ["assetId", "name", "format", "title"],
+        ...results.map((result) => [
+            valueToString(result.assetId ?? result.id),
+            valueToString(result.repositoryMetadata?.["repo:name"]),
+            valueToString(result.repositoryMetadata?.["dc:format"]),
+            valueToString(result.assetMetadata?.["dc:title"]),
+        ]),
+    ];
+    const widths = rows[0].map((_, columnIndex) => Math.max(...rows.map((row) => row[columnIndex].length)));
+    return rows
+        .map((row) => row
+        .map((cell, columnIndex) => cell.padEnd(widths[columnIndex]))
+        .join("  "))
+        .join("\n");
+}
+export async function writeBinaryOutput(response, output, stdout) {
+    if (!response.body) {
+        throw new Error("Response body is empty.");
+    }
+    const readable = Readable.fromWeb(response.body);
+    if (output === "-") {
+        for await (const chunk of readable) {
+            stdout.write(chunk);
+        }
+        return;
+    }
+    await mkdir(path.dirname(output), { recursive: true });
+    const fileStream = createWriteStream(output);
+    await pipeline(readable, fileStream);
+}

package/dist/lib/search.js

@@ -0,0 +1,95 @@
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+import { CliError } from "./client.js";
+const whereSchema = z.string().trim().min(1);
+export function normalizeSearchField(field) {
+    return /^(assetMetadata|repositoryMetadata)\./.test(field)
+        ? field
+        : `assetMetadata.${field}`;
+}
+export function parseWhereClause(input) {
+    const raw = whereSchema.parse(input);
+    const separatorIndex = raw.indexOf("=");
+    if (separatorIndex < 1) {
+        throw new CliError(`Invalid --where clause "${input}". Use field=value.`);
+    }
+    const field = raw.slice(0, separatorIndex).trim();
+    const rawValue = raw.slice(separatorIndex + 1).trim();
+    if (!rawValue) {
+        throw new CliError(`Invalid --where clause "${input}". Value cannot be empty.`);
+    }
+    const values = rawValue
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    if (values.length === 0) {
+        throw new CliError(`Invalid --where clause "${input}". Value cannot be empty.`);
+    }
+    return {
+        field: normalizeSearchField(field),
+        values,
+    };
+}
+export function parseSort(input) {
+    const trimmed = input.trim();
+    const match = /^(.*?):(asc|desc)$/i.exec(trimmed);
+    if (!match) {
+        return { field: trimmed };
+    }
+    return {
+        field: match[1],
+        order: match[2].toUpperCase(),
+    };
+}
+export function buildSearchRequest(options) {
+    const termClauses = (options.where ?? []).map(parseWhereClause);
+    const query = [
+        {
+            match: {
+                mode: "FULLTEXT",
+                text: options.text ?? "",
+            },
+        },
+    ];
+    for (const clause of termClauses) {
+        query.push({
+            term: {
+                [clause.field]: clause.values,
+            },
+        });
+    }
+    const request = { query };
+    if (options.limit !== undefined) {
+        request.limit = options.limit;
+    }
+    if (options.cursor) {
+        request.cursor = options.cursor;
+    }
+    if (options.fields && options.fields.length > 0) {
+        request.projectedFields = {
+            includes: options.fields,
+        };
+    }
+    if (options.sort && options.sort.length > 0) {
+        request.sort = options.sort.map(parseSort);
+    }
+    return request;
+}
+export async function loadRawQuery(input) {
+    const rawJson = input.startsWith("@")
+        ? await readFile(input.slice(1), "utf8")
+        : input;
+    try {
+        return JSON.parse(rawJson);
+    }
+    catch (error) {
+        throw new CliError(`Unable to parse raw query JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function getAssetIdFromHit(hit) {
+    const assetId = hit.assetId ?? hit.id;
+    if (!assetId) {
+        throw new CliError("Search result did not include an asset identifier.");
+    }
+    return assetId;
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "aemdm",
+  "version": "0.1.0",
+  "description": "CLI for Adobe Dynamic Media with OpenAPI",
+  "license": "Apache-2.0",
+  "author": "Chris Pilsworth",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cpilsworth/aemdm.git"
+  },
+  "homepage": "https://github.com/cpilsworth/aemdm#readme",
+  "bugs": {
+    "url": "https://github.com/cpilsworth/aemdm/issues"
+  },
+  "keywords": [
+    "aem",
+    "adobe",
+    "dynamic-media",
+    "cli",
+    "openapi"
+  ],
+  "type": "module",
+  "bin": {
+    "aemdm": "dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "node --enable-source-maps src/cli.ts",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "pack:check": "npm pack --dry-run --cache .npm-cache",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "commander": "^14.0.1",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^24.9.1",
+    "eslint": "^10.2.0",
+    "globals": "^17.5.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.58.2",
+    "vitest": "^4.0.7"
+  }
+}