@rankwrangler/cli 0.5.0 → 0.8.0

package/dist/cli-config.js

@@ -34,13 +34,31 @@ export const loadCliPathsOrDefault = async () => {
         return getDefaultCliPaths();
     }
 };
-export const clearConfig = async (paths) => {
-    await rm(paths.configPath, { force: true });
+export const resetConfig = async (paths) => {
+    await Promise.all([
+        rm(paths.configPath, { force: true }),
+        rm(paths.globalConfigPath, { force: true }),
+        paths.storageDir === paths.defaultStorageDir
+            ? Promise.resolve()
+            : rm(path.join(paths.defaultStorageDir, CONFIG_FILENAME), { force: true }),
+    ]);
+    return {
+        paths: getDefaultCliPaths(),
+        config: {},
+    };
 };
 export const saveConfig = async (paths, config) => {
     await mkdir(paths.storageDir, { recursive: true });
     await writeFile(paths.configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
 };
+export const unsetStorageDir = async (paths) => {
+    await rm(paths.globalConfigPath, { force: true });
+    const nextPaths = getDefaultCliPaths();
+    return {
+        paths: nextPaths,
+        config: await loadConfig(nextPaths.configPath),
+    };
+};
 export const switchStorageDir = async ({ currentConfig, currentPaths, requestedStorageDir, }) => {
     const storageDir = normalizeStorageDir(requestedStorageDir);
     const nextPaths = buildCliPaths(storageDir);

package/dist/cli-keyword-command.d.ts

@@ -0,0 +1,9 @@
+import type { createRankWranglerClient } from '@rankwrangler/http-client';
+import { type CliOptionValues } from './cli-options';
+type CliFail = (code: string, message: string, details?: unknown) => never;
+type CliClient = ReturnType<typeof createRankWranglerClient>;
+export declare const runKeywordCommand: (command: {
+    verb: string;
+    args: string[];
+}, client: CliClient, options: CliOptionValues, fail: CliFail) => Promise<unknown>;
+export {};

package/dist/cli-keyword-command.js

@@ -0,0 +1,69 @@
+import { parseIntegerOption } from './cli-options.js';
+const KEYWORD_MARKETPLACE_ID = 'ATVPDKIKX0DER';
+export const runKeywordCommand = async (command, client, options, fail) => {
+    if (options.refresh) {
+        fail('INVALID_INPUT', '--refresh is not supported for keyword reads');
+    }
+    if (command.verb === 'get') {
+        return await runKeywordGet(command.args, client, fail);
+    }
+    if (command.verb === 'search') {
+        return await runKeywordSearch(command.args, client, options, fail);
+    }
+    if (command.verb === 'history') {
+        return await runKeywordHistory(command.args, client, options, fail);
+    }
+    fail('UNKNOWN_COMMAND', 'Unknown Keyword command', {
+        command: `keyword ${command.verb}`,
+    });
+};
+const runKeywordGet = async (args, client, fail) => {
+    const keyword = requireKeyword(args, fail, 'keyword get');
+    return await client.keyword.get.query({
+        keyword,
+        marketplaceId: KEYWORD_MARKETPLACE_ID,
+    });
+};
+const runKeywordSearch = async (args, client, options, fail) => {
+    const text = requireKeyword(args, fail, 'keyword search');
+    return await client.keyword.search.query({
+        text,
+        marketplaceId: KEYWORD_MARKETPLACE_ID,
+        cursor: parseIntegerOption({
+            value: options.cursor,
+            optionName: 'cursor',
+            min: 0,
+            max: 1_000_000,
+            defaultValue: 0,
+        }, fail),
+        limit: parseIntegerOption({
+            value: options.limit,
+            optionName: 'limit',
+            min: 1,
+            max: 100,
+            defaultValue: 25,
+        }, fail),
+        merchOnly: true,
+    });
+};
+const runKeywordHistory = async (args, client, options, fail) => {
+    const keyword = requireKeyword(args, fail, 'keyword history');
+    return await client.keyword.history.query({
+        keyword,
+        marketplaceId: KEYWORD_MARKETPLACE_ID,
+        rangeDays: parseIntegerOption({
+            value: options.rangeDays ?? options.days,
+            optionName: 'rangeDays',
+            min: 7,
+            max: 365,
+            defaultValue: 90,
+        }, fail),
+    });
+};
+const requireKeyword = (args, fail, commandName) => {
+    const keyword = args.join(' ').trim();
+    if (!keyword) {
+        fail('INVALID_INPUT', `${commandName} requires text`);
+    }
+    return keyword;
+};

package/dist/cli-options.d.ts

@@ -1,22 +1,26 @@
 import type { CliConfig } from './cli-config';
-import { type HistoryMetricAlias } from './history-response';
+import { type HistoryBucket, type HistoryMetricAlias } from './history-options';
 type CliFail = (code: string, message: string, details?: unknown) => never;
-export type CliOptionValues = {
+export interface CliOptionValues {
     baseUrl?: string;
     marketplace?: string;
-    asin?: string[];
     metrics?: string;
     startAt?: string;
     endAt?: string;
     days?: string;
+    rangeDays?: string;
     limit?: string;
+    bucket?: string;
+    cursor?: string;
+    refresh?: boolean;
     help?: boolean;
     version?: boolean;
-};
+}
 export declare const requireMarketplaceId: (values: CliOptionValues, config: CliConfig) => string;
-export declare const requireAsins: (commandArgs: string[], values: CliOptionValues, fail: CliFail) => string[];
-export declare const requireSingleAsin: (commandArgs: string[], values: CliOptionValues, fail: CliFail) => string;
+export declare const requireSingleAsin: (commandArgs: string[], fail: CliFail, commandName?: string) => string;
+export declare const requireAsins: (commandArgs: string[], fail: CliFail, commandName?: string) => string[];
 export declare const resolveHistoryMetrics: (values: CliOptionValues, fail: CliFail) => HistoryMetricAlias[];
+export declare const resolveHistoryBucket: (values: CliOptionValues, fail: CliFail) => HistoryBucket;
 export declare const resolveHistoryWindow: (values: CliOptionValues, fail: CliFail) => {
     days: number;
     endAt?: string | undefined;

package/dist/cli-options.js

@@ -1,31 +1,34 @@
-import { HISTORY_METRIC_ALIASES } from './history-response.js';
+import { HISTORY_BUCKETS, HISTORY_METRIC_ALIASES, } from './history-options.js';
 const ASIN_REGEX = /^[A-Z0-9]{10}$/i;
 const TRAILING_SLASHES_REGEX = /\/+$/;
 const API_SUFFIX_REGEX = /\/api$/i;
 const DEFAULT_MARKETPLACE_ID = 'ATVPDKIKX0DER';
 export const requireMarketplaceId = (values, config) => {
-    return values.marketplace ?? config.marketplaceId ?? process.env.RR_MARKETPLACE_ID ?? DEFAULT_MARKETPLACE_ID;
+    return (values.marketplace ??
+        config.marketplaceId ??
+        process.env.RR_MARKETPLACE_ID ??
+        DEFAULT_MARKETPLACE_ID);
 };
-export const requireAsins = (commandArgs, values, fail) => {
-    const candidates = [...commandArgs, ...(values.asin ?? []), ...resolveEnvAsins()]
-        .map(value => value.trim())
-        .filter(Boolean);
-    if (candidates.length === 0) {
-        fail('INVALID_INPUT', 'at least one asin is required');
+export const requireSingleAsin = (commandArgs, fail, commandName = 'product history') => {
+    if (commandArgs.length !== 1) {
+        fail('INVALID_INPUT', `${commandName} requires exactly one ASIN`);
     }
-    return Array.from(new Set(candidates.map(value => normalizeAsin(value, fail))));
+    return normalizeAsin(commandArgs[0] ?? '', fail);
 };
-export const requireSingleAsin = (commandArgs, values, fail) => {
-    const asins = requireAsins(commandArgs, values, fail);
-    if (asins.length !== 1) {
-        fail('INVALID_INPUT', 'products history requires exactly one asin');
+export const requireAsins = (commandArgs, fail, commandName = 'product get') => {
+    if (commandArgs.length < 1 || commandArgs.length > 200) {
+        fail('INVALID_INPUT', `${commandName} requires between 1 and 200 ASINs`);
+    }
+    const asins = commandArgs.map(value => normalizeAsin(value, fail));
+    if (new Set(asins).size !== asins.length) {
+        fail('INVALID_INPUT', `${commandName} requires unique ASINs`);
     }
-    return asins[0];
+    return asins;
 };
 export const resolveHistoryMetrics = (values, fail) => {
-    const requested = (values.metrics ?? process.env.RR_HISTORY_METRICS ?? 'bsr,price')
+    const requested = (values.metrics ?? process.env.RR_HISTORY_METRICS ?? 'salesRank,price')
         .split(',')
-        .map(value => value.trim().toLowerCase())
+        .map(value => normalizeHistoryMetric(value.trim()))
         .filter(Boolean);
     if (requested.length === 0) {
         fail('INVALID_INPUT', 'metrics cannot be empty');
@@ -38,8 +41,19 @@ export const resolveHistoryMetrics = (values, fail) => {
     }
     return Array.from(new Set(requested));
 };
+export const resolveHistoryBucket = (values, fail) => {
+    const requested = (values.bucket ?? 'auto').trim().toLowerCase();
+    if (!HISTORY_BUCKETS.includes(requested)) {
+        fail('INVALID_INPUT', `unsupported history bucket: ${requested}`, {
+            supportedBuckets: HISTORY_BUCKETS,
+        });
+    }
+    return requested;
+};
 export const resolveHistoryWindow = (values, fail) => {
-    const startAt = values.startAt ? normalizeDateOption('startAt', values.startAt, fail) : undefined;
+    const startAt = values.startAt
+        ? normalizeDateOption('startAt', values.startAt, fail)
+        : undefined;
     const endAt = values.endAt ? normalizeDateOption('endAt', values.endAt, fail) : undefined;
     if (values.days && (startAt || endAt)) {
         fail('INVALID_INPUT', 'use --days or --startAt/--endAt, not both');
@@ -60,7 +74,10 @@ export const resolveBaseUrl = (values, config, defaultBaseUrl, fail) => {
     return normalizeBaseUrl(values.baseUrl ?? config.baseUrl ?? process.env.RR_API_URL ?? defaultBaseUrl, fail);
 };
 export const normalizeBaseUrl = (value, fail) => {
-    const normalized = value.trim().replace(TRAILING_SLASHES_REGEX, '').replace(API_SUFFIX_REGEX, '');
+    const normalized = value
+        .trim()
+        .replace(TRAILING_SLASHES_REGEX, '')
+        .replace(API_SUFFIX_REGEX, '');
     if (!normalized) {
         fail('INVALID_INPUT', 'base url cannot be empty');
     }
@@ -90,9 +107,12 @@ const normalizeAsin = (value, fail) => {
     }
     return normalized;
 };
-const resolveEnvAsins = () => {
-    return [
-        ...(process.env.RR_ASINS ? process.env.RR_ASINS.split(',') : []),
-        ...(process.env.RR_ASIN ? [process.env.RR_ASIN] : []),
-    ];
+const normalizeHistoryMetric = (value) => {
+    if (value.toLowerCase() === 'salesrank') {
+        return 'salesRank';
+    }
+    if (value.toLowerCase() === 'price') {
+        return 'price';
+    }
+    return value;
 };

package/dist/cli-output.js

@@ -1,4 +1,4 @@
-import { CliAuthError } from './cli-auth.js';
+import { CliAuthError } from './cli-auth-error.js';
 import { CliStorageError } from './cli-config.js';
 const OUTPUT_PRETTY = true;
 export const printSuccess = (data) => {

package/dist/cli-product-command.d.ts

@@ -0,0 +1,10 @@
+import type { createRankWranglerClient } from '@rankwrangler/http-client';
+import type { CliConfig } from './cli-config';
+import { type CliOptionValues } from './cli-options';
+type CliFail = (code: string, message: string, details?: unknown) => never;
+type CliClient = ReturnType<typeof createRankWranglerClient>;
+export declare const runProductCommand: (command: {
+    verb: string;
+    args: string[];
+}, client: CliClient, config: CliConfig, options: CliOptionValues, fail: CliFail) => Promise<unknown>;
+export {};

package/dist/cli-product-command.js

@@ -0,0 +1,62 @@
+import { parseIntegerOption, requireAsins, requireMarketplaceId, requireSingleAsin, resolveHistoryBucket, resolveHistoryMetrics, resolveHistoryWindow, } from './cli-options.js';
+export const runProductCommand = async (command, client, config, options, fail) => {
+    if (command.verb !== 'search' && options.refresh) {
+        fail('INVALID_INPUT', '--refresh is only supported for product search');
+    }
+    if (command.verb === 'get') {
+        return await runProductGet(command.args, client, config, options, fail);
+    }
+    if (command.verb === 'search') {
+        return await runProductSearch(command.args, client, options, fail);
+    }
+    if (command.verb === 'history') {
+        return await runProductHistory(command.args, client, config, options, fail);
+    }
+    fail('UNKNOWN_COMMAND', 'Unknown Product command', {
+        command: `product ${command.verb}`,
+    });
+};
+const runProductGet = async (args, client, config, options, fail) => {
+    const marketplaceId = requireMarketplaceId(options, config);
+    const asins = requireAsins(args, fail);
+    if (asins.length === 1) {
+        return await client.product.get.mutate({
+            marketplaceId,
+            asin: asins[0],
+        });
+    }
+    return await client.product.getMany.mutate({
+        products: asins.map(asin => ({ marketplaceId, asin })),
+    });
+};
+const runProductSearch = async (args, client, options, fail) => {
+    const term = args.join(' ').trim();
+    if (!term) {
+        fail('INVALID_INPUT', 'product search requires a keyword');
+    }
+    return await client.product.search.mutate({
+        term,
+        refresh: Boolean(options.refresh),
+    });
+};
+const runProductHistory = async (args, client, config, options, fail) => {
+    const asin = requireSingleAsin(args, fail, 'product history');
+    const historyOptions = resolveHistoryOptions(options, fail);
+    return await client.product.history.mutate({
+        marketplaceId: requireMarketplaceId(options, config),
+        asin,
+        ...historyOptions,
+    });
+};
+const resolveHistoryOptions = (options, fail) => ({
+    metrics: resolveHistoryMetrics(options, fail),
+    bucket: resolveHistoryBucket(options, fail),
+    limit: parseIntegerOption({
+        value: options.limit,
+        optionName: 'limit',
+        min: 1,
+        max: 10_000,
+        defaultValue: 5000,
+    }, fail),
+    ...resolveHistoryWindow(options, fail),
+});

package/dist/history-options.d.ts

@@ -0,0 +1,4 @@
+export declare const HISTORY_METRIC_ALIASES: readonly ["salesRank", "price"];
+export declare const HISTORY_BUCKETS: readonly ["auto", "day", "week", "month"];
+export type HistoryMetricAlias = (typeof HISTORY_METRIC_ALIASES)[number];
+export type HistoryBucket = (typeof HISTORY_BUCKETS)[number];

package/dist/history-options.js

@@ -0,0 +1,2 @@
+export const HISTORY_METRIC_ALIASES = ['salesRank', 'price'];
+export const HISTORY_BUCKETS = ['auto', 'day', 'week', 'month'];

package/dist/index.js

@@ -2,23 +2,28 @@
 import { parseArgs } from 'node:util';
 import { createRankWranglerClient, DEFAULT_API_BASE_URL } from '@rankwrangler/http-client';
 import { resolveApiKey, runAuthCommand } from './cli-auth.js';
-import { printBundledChangelog, printCliVersion } from './cli-metadata.js';
-import { runConfigCommand } from './cli-config-command.js';
 import { loadCliContext, loadCliPathsOrDefault } from './cli-config.js';
-import { parseIntegerOption, requireAsins, requireMarketplaceId, requireSingleAsin, resolveBaseUrl, resolveHistoryMetrics, resolveHistoryWindow, } from './cli-options.js';
+import { runConfigCommand } from './cli-config-command.js';
+import { runKeywordCommand } from './cli-keyword-command.js';
+import { printBundledChangelog, printCliVersion } from './cli-metadata.js';
+import { resolveBaseUrl } from './cli-options.js';
 import { fail, printSuccess, resolveError } from './cli-output.js';
-import { buildCliHistoryResponse } from './history-response.js';
+import { runProductCommand } from './cli-product-command.js';
 import { printUsage } from './usage.js';
 const SUPPORTED_COMMANDS = new Set([
-    'products:get',
-    'products:history',
-    'license:status',
-    'license:validate',
+    'product:get',
+    'product:search',
+    'product:history',
+    'keyword:get',
+    'keyword:search',
+    'keyword:history',
     'auth:status',
     'auth:set',
     'auth:clear',
     'config:show',
-    'config:clear',
+    'config:get',
+    'config:unset',
+    'config:reset',
     'config:set',
 ]);
 const { positionals, values } = parseArgs({
@@ -28,12 +33,16 @@ const { positionals, values } = parseArgs({
         version: { type: 'boolean' },
         baseUrl: { type: 'string' },
         marketplace: { type: 'string', short: 'm' },
-        asin: { type: 'string', multiple: true },
         metrics: { type: 'string' },
         startAt: { type: 'string' },
         endAt: { type: 'string' },
         days: { type: 'string' },
+        rangeDays: { type: 'string' },
         limit: { type: 'string' },
+        bucket: { type: 'string' },
+        cursor: { type: 'string' },
+        refresh: { type: 'boolean' },
+        stdin: { type: 'boolean' },
     },
     allowPositionals: true,
 });
@@ -48,11 +57,9 @@ const main = async () => {
         process.exit(values.help ? 0 : 1);
     }
     const metaCommand = resolveMetaCommand(positionals);
-    if (metaCommand) {
-        if (metaCommand.name === 'changelog') {
-            printBundledChangelog();
-            return;
-        }
+    if (metaCommand?.name === 'changelog') {
+        printBundledChangelog();
+        return;
     }
     const command = resolveCommandOrFail(positionals);
     if (!isSupportedCommand(command)) {
@@ -66,70 +73,32 @@ const main = async () => {
         return;
     }
     if (command.resource === 'auth') {
-        printSuccess(await runAuthCommand(command, fail));
+        printSuccess(await runAuthCommand(command, fail, {
+            stdin: Boolean(values.stdin),
+        }));
         return;
     }
     const apiKey = await resolveApiKey();
     if (!apiKey) {
-        fail('MISSING_CONFIG', 'license key is required. run `rw auth set <licenseKey>` or set RR_LICENSE_KEY');
+        fail('MISSING_CONFIG', 'Merchbase API key is required. run `rw auth set`, `rw auth set --stdin`, or set MERCHBASE_API_KEY');
     }
     const client = createRankWranglerClient({
         baseUrl: resolveBaseUrl(optionValues, config, DEFAULT_API_BASE_URL, fail),
         apiKey,
     });
-    printSuccess(await runApiCommand(command, client, config));
+    printSuccess(await runApiCommand(command, client, config, optionValues));
 };
-const runApiCommand = async (command, client, config) => {
-    if (command.resource === 'products' && command.verb === 'get') {
-        const optionValues = values;
-        const marketplaceId = requireMarketplaceId(optionValues, config);
-        const asins = requireAsins(command.args, optionValues, fail);
-        if (asins.length === 1) {
-            return client.getProductInfo.mutate({ marketplaceId, asin: asins[0] });
-        }
-        return client.getProductInfoBatch.mutate({ marketplaceId, asins });
-    }
-    if (command.resource === 'products' && command.verb === 'history') {
-        return runProductHistoryCommand(command, client, config);
+const runApiCommand = async (command, client, config, options) => {
+    if (command.resource === 'product') {
+        return await runProductCommand(command, client, config, options, fail);
     }
-    if (command.resource === 'license' && command.verb === 'status') {
-        return client.license.status.mutate();
-    }
-    if (command.resource === 'license' && command.verb === 'validate') {
-        return client.license.validate.mutate();
+    if (command.resource === 'keyword') {
+        return await runKeywordCommand(command, client, options, fail);
     }
     fail('UNKNOWN_COMMAND', 'Unknown command', {
         command: `${command.resource} ${command.verb}`,
     });
 };
-const runProductHistoryCommand = async (command, client, config) => {
-    const optionValues = values;
-    const asin = requireSingleAsin(command.args, optionValues, fail);
-    const marketplaceId = requireMarketplaceId(optionValues, config);
-    const metrics = resolveHistoryMetrics(optionValues, fail);
-    const historyWindow = resolveHistoryWindow(optionValues, fail);
-    const limit = parseIntegerOption({
-        value: optionValues.limit,
-        optionName: 'limit',
-        min: 1,
-        max: 10000,
-        defaultValue: 5000,
-    }, fail);
-    const response = await client.getProductHistory.mutate({
-        marketplaceId,
-        asin,
-        metrics,
-        format: 'agent',
-        limit,
-        ...historyWindow,
-    });
-    return buildCliHistoryResponse({
-        asin,
-        marketplaceId,
-        metrics,
-        response: response,
-    });
-};
 const resolveMetaCommand = (inputPositionals) => {
     if (inputPositionals.length === 1 && inputPositionals[0] === 'changelog') {
         return { name: 'changelog' };
@@ -138,7 +107,7 @@ const resolveMetaCommand = (inputPositionals) => {
 };
 const resolveCommand = (inputPositionals) => {
     const [first, second, ...rest] = inputPositionals;
-    if (!first || !second) {
+    if (!(first && second)) {
         return null;
     }
     return {
@@ -155,9 +124,7 @@ const resolveCommandOrFail = (inputPositionals) => {
     fail('UNKNOWN_COMMAND', 'Unknown command', { command: inputPositionals.join(' ') });
     throw new Error('unreachable');
 };
-const isSupportedCommand = (command) => {
-    return SUPPORTED_COMMANDS.has(`${command.resource}:${command.verb}`);
-};
+const isSupportedCommand = (command) => SUPPORTED_COMMANDS.has(`${command.resource}:${command.verb}`);
 await main().catch(error => {
     const resolved = resolveError(error);
     fail(resolved.code, resolved.message, resolved.details);

package/dist/usage.js

@@ -1,4 +1,4 @@
-import { LICENSE_KEY_ENV_VAR } from './cli-auth.js';
+import { API_KEY_ENV_VAR } from './cli-auth.js';
 const DEFAULT_MARKETPLACE_ID = 'ATVPDKIKX0DER';
 export const printUsage = (paths) => {
     const usage = [
@@ -15,54 +15,65 @@ export const printUsage = (paths) => {
         '',
         'COMMANDS',
         '  changelog',
-        '  products get <ASIN...>',
-        '  products history <ASIN>',
-        '  license status',
-        '  license validate',
+        '  product get <ASIN...>',
+        '  product search <keyword>',
+        '  product history <ASIN>',
+        '  keyword get <keyword>',
+        '  keyword search <text>',
+        '  keyword history <keyword>',
         '  auth status',
-        '  auth set <licenseKey>',
+        '  auth set [apiKey]',
+        '  auth set --stdin',
         '  auth clear',
         '  config show',
-        '  config clear',
+        '  config get <key>',
         '  config set base-url <origin>',
         '  config set marketplace <marketplaceId>',
         '  config set storage-dir <path>',
+        '  config unset <key>',
+        '  config reset',
         '',
         'OPTIONS',
         '  -h, --help               Show this help message',
         '  --version                Print the CLI version',
         '  --baseUrl <origin>       Override API origin',
         `  -m, --marketplace <id>   Override marketplace (default: ${DEFAULT_MARKETPLACE_ID})`,
-        '  --asin <ASIN>            Add ASIN (repeatable)',
-        '  --metrics <list>         History metrics: bsr,price (default: bsr,price)',
-        '  --days <N>               History lookback window (30-3650, default: 365)',
-        '  --startAt <ISO>          History range start (ISO date/time)',
-        '  --endAt <ISO>            History range end (ISO date/time)',
-        '  --limit <N>              Max points per metric (1-10000, default: 5000)',
+        '  --refresh                Product search refresh (separate Search contract)',
+        '  --metrics <list>         Product history metrics: salesRank,price (default: salesRank,price)',
+        '  --bucket <unit>          Product history buckets: auto,day,week,month (default: auto)',
+        '  --days <N>               Product history lookback (30-3650, default: 365)',
+        '  --rangeDays <N>          Keyword history lookback (7-365, default: 90)',
+        '  --startAt <ISO>          Product history range start (ISO date/time)',
+        '  --endAt <ISO>            Product history range end (ISO date/time)',
+        '  --limit <N>              Result limit',
+        '  --cursor <N>             Keyword search offset (default: 0)',
+        '  --stdin                  Read auth secret from standard input',
         '',
         'FILES',
         `  ${paths.configPath}           Active CLI config`,
         `  ${paths.globalConfigPath}           Global CLI settings`,
         '',
         'ENVIRONMENT',
-        `  ${LICENSE_KEY_ENV_VAR}           License key override for CI/automation`,
+        `  ${API_KEY_ENV_VAR}           Merchbase API key override for CI/automation`,
         '  RR_API_URL               API origin fallback',
         '  RR_MARKETPLACE_ID        Marketplace fallback',
         '  RR_STORAGE_DIR           Storage directory override',
-        '  RR_ASIN                  Single ASIN fallback',
-        '  RR_ASINS                 Comma-separated ASIN fallback',
-        '  RR_HISTORY_METRICS       Comma-separated history metrics fallback',
+        '  RR_HISTORY_METRICS       Comma-separated product history metrics fallback',
         '',
         'EXAMPLES',
-        '  rw auth set rrk_...',
-        `  ${LICENSE_KEY_ENV_VAR}=rrk_... rw products get B0DV53VS61`,
+        '  rw auth set ak_...',
+        '  printf %s "$MERCHBASE_API_KEY" | rw auth set --stdin',
+        `  ${API_KEY_ENV_VAR}=ak_... rw product get B0DV53VS61`,
+        '  rw product get B0DV53VS61 B012345678',
+        '  rw product search "retro gardening shirt"',
+        '  rw product history B0DV53VS61 --bucket week',
+        '  rw keyword get "retro gardening shirt"',
+        '  rw keyword search "retro gardening" --limit 10',
+        '  rw keyword history "retro gardening shirt" --rangeDays 90',
         '  RR_STORAGE_DIR=~/.config/rankwrangler rw config show',
         '  rw --version',
         '  rw changelog',
-        '  rw config set storage-dir ~/.config/rankwrangler',
-        '  rw products history B0DV53VS61 --metrics bsr,price',
-        '  rw products history B0DV53VS61 --startAt 2025-01-01 --endAt 2025-12-31',
-        '  rankwrangler license status',
+        '  rankwrangler auth status',
     ];
     console.log(usage.join('\n'));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rankwrangler/cli",
-    "version": "0.5.0",
+    "version": "0.8.0",
     "description": "Official RankWrangler command line interface",
     "type": "module",
     "bin": {
@@ -16,19 +16,21 @@
     "scripts": {
         "build": "tsc -p tsconfig.json && node scripts/fix-dist-imports.mjs && node scripts/sync-changelog.mjs",
         "prepack": "node scripts/sync-changelog.mjs",
-        "test:e2e": "bun test test/index.e2e.test.ts",
+        "test:e2e": "bun test test/*.e2e.test.ts",
         "prepublishOnly": "node ../../scripts/release/ensure-cli-http-client-published.mjs"
     },
     "publishConfig": {
-        "access": "public"
+        "access": "public",
+        "provenance": true
     },
     "dependencies": {
-        "@rankwrangler/http-client": "^0.5.0",
-        "keytar": "^7.9.0"
+        "@merchbaseco/access": "0.3.0",
+        "@rankwrangler/http-client": "^0.8.0",
+        "keytar": "7.9.0"
     },
     "devDependencies": {
-        "@types/node": "^24.3.0",
-        "typescript": "^5.9.2"
+        "@types/node": "24.10.12",
+        "typescript": "5.9.3"
     },
     "packageManager": "bun@1.1.27"
 }