@ohos-ports/shopify 4.8.0-beta.0

package/dist/cli/help.d.ts

@@ -0,0 +1,38 @@
+import { CommandHelp, Help } from '@oclif/core';
+import type { Command } from '@oclif/core';
+type HelpSectionBody = Parameters<CommandHelp['section']>[1];
+/**
+ * Custom command-help renderer that relocates the `[env: ...]` metadata to the
+ * end of a flag's description instead of the front.
+ *
+ * Since oclif 4.8, flag help renders the backing environment variable inline
+ * *before* the description, e.g.:
+ *
+ *   -j, --json  [env: SHOPIFY_FLAG_JSON] Output the result as JSON.
+ *
+ * Because Shopify CLI's `SHOPIFY_FLAG_*` names are long, that pushes the actual
+ * description far to the right and hurts readability. We keep the information
+ * (it's useful for scripting and agents) but move it to the end:
+ *
+ *   -j, --json
+ *       Output the result as JSON.
+ *       [env: SHOPIFY_FLAG_JSON]
+ *
+ * We do this by cloning each flag, clearing its `env`, and appending the env
+ * label as a trailing summary line before delegating to oclif's own `flags()`
+ * renderer. Flag sections then use oclif's multiline list layout so long env
+ * labels get the full terminal width instead of being split inside the name.
+ */
+export declare class ShopifyCommandHelp extends CommandHelp {
+    section(header: string, body: HelpSectionBody): string;
+    protected flags(flags: Command.Flag.Any[]): [string, string | undefined][] | undefined;
+}
+/**
+ * Custom help class, wired up via `oclif.helpClass` in this package's
+ * `package.json`. It only swaps in {@link ShopifyCommandHelp}; everything else
+ * uses oclif's default help behaviour.
+ */
+export default class ShopifyHelp extends Help {
+    protected CommandHelpClass: typeof ShopifyCommandHelp;
+}
+export {};

package/dist/cli/help.js

@@ -0,0 +1,2 @@
+import{a as u}from"../chunk-CTNBSUVU.js";import"../chunk-TR4OWSEX.js";import"../chunk-2KD4LHRT.js";import"../chunk-I5A6BPCP.js";import"../chunk-CX5CC6P5.js";import"../chunk-ET2CGROE.js";import"../chunk-TOLPNBZK.js";import"../chunk-CRALWNNO.js";import{e as c,g as m}from"../chunk-VKWPEFWQ.js";m();var s=c(u(),1);function a(r){return Array.isArray(r)&&r.every(e=>Array.isArray(e))}var i=class extends s.CommandHelp{section(e,t){return e.endsWith("FLAGS")&&a(t)?super.section(e,this.renderList(t,{indentation:2,multiline:!0,stripAnsi:this.opts.stripAnsi})):super.section(e,t)}flags(e){let t=e.map(n=>{if(!n.env)return n;let d=n.summary??n.description??"",p=`[env: ${n.env}]`;return{...n,env:void 0,summary:d===""?p:`${d}
+${p}`}});return super.flags(t)}},o=class extends s.Help{CommandHelpClass=i};export{i as ShopifyCommandHelp,o as default};

package/dist/cli/services/commands/doc/fetch.d.ts

@@ -0,0 +1 @@
+export declare function docFetchService(url: string, outputPath?: string): Promise<void>;

package/dist/cli/services/commands/doc/fetch.js

@@ -0,0 +1,45 @@
+import { fetch } from '@shopify/cli-kit/node/http';
+import { outputInfo, outputResult } from '@shopify/cli-kit/node/output';
+import { AbortError } from '@shopify/cli-kit/node/error';
+import { mkdir, writeFile } from '@shopify/cli-kit/node/fs';
+import { dirname, resolvePath } from '@shopify/cli-kit/node/path';
+// Every page on shopify.dev has a Markdown representation, which is the clean,
+// parseable content agents want — so we always request it.
+const MARKDOWN_CONTENT_TYPE = 'text/markdown';
+// Identifies the CLI as the calling surface to shopify.dev, so traffic
+// originating from the CLI can be attributed as such.
+const SURFACE_HEADER = 'X-Shopify-Surface';
+const SURFACE = 'cli';
+// Hosts whose documents are allowed to be fetched. A URL matches when its
+// hostname is one of these or a subdomain of one of these.
+const ALLOWED_HOSTS = ['shopify.dev'];
+export async function docFetchService(url, outputPath) {
+    let parsedURL;
+    try {
+        parsedURL = new URL(url);
+    }
+    catch {
+        throw new AbortError(`Invalid URL: ${url}`);
+    }
+    const { hostname } = parsedURL;
+    const isAllowed = ALLOWED_HOSTS.some((host) => hostname === host || hostname.endsWith(`.${host}`));
+    if (!isAllowed) {
+        throw new AbortError(`Only documents from the following hosts can be fetched: ${ALLOWED_HOSTS.join(', ')}.`);
+    }
+    const response = await fetch(url, { headers: { Accept: MARKDOWN_CONTENT_TYPE, [SURFACE_HEADER]: SURFACE } });
+    if (!response.ok) {
+        throw new AbortError(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+    }
+    const body = await response.text();
+    // When an output path is provided, write the document to disk (creating any
+    // missing parent directories) instead of printing it to stdout.
+    if (outputPath) {
+        const absolutePath = resolvePath(outputPath);
+        await mkdir(dirname(absolutePath));
+        await writeFile(absolutePath, body);
+        outputInfo(`Saved ${url} to ${absolutePath}`);
+        return;
+    }
+    outputResult(body);
+}
+//# sourceMappingURL=fetch.js.map

package/dist/cli/services/commands/doc/search.d.ts

@@ -0,0 +1 @@
+export declare function docSearchService(query: string, apiName?: string, apiVersion?: string): Promise<void>;

package/dist/cli/services/commands/doc/search.js

@@ -0,0 +1,47 @@
+import { shopifyFetch } from '@shopify/cli-kit/node/http';
+import { outputResult } from '@shopify/cli-kit/node/output';
+import { AbortError } from '@shopify/cli-kit/node/error';
+// The dev-assistant search endpoint queries the shopify.dev vector store and
+// returns an array of matching documentation chunks as JSON.
+const SEARCH_URL = 'https://shopify.dev/assistant/search';
+// Identifies the CLI as the calling surface to shopify.dev, so traffic
+// originating from the CLI can be attributed as such.
+const SURFACE_HEADER = 'X-Shopify-Surface';
+const SURFACE = 'cli';
+export async function docSearchService(query, apiName, apiVersion) {
+    const params = new URLSearchParams({ query });
+    if (apiName)
+        params.append('api_name', apiName);
+    if (apiVersion)
+        params.append('api_version', apiVersion);
+    let response;
+    try {
+        response = await shopifyFetch(`${SEARCH_URL}?${params.toString()}`, {
+            headers: { Accept: 'application/json', [SURFACE_HEADER]: SURFACE },
+        });
+    }
+    catch {
+        // shopifyFetch retries transient failures; reaching here means the request
+        // could not complete (offline, DNS failure, TLS error, timeout, etc.).
+        throw new AbortError('Could not reach shopify.dev to run the search.', 'Check your network connection and try again.');
+    }
+    const body = await response.text();
+    if (!response.ok) {
+        // The endpoint returns a JSON `{error}` body for 400s (e.g. an invalid api_version
+        // lists the valid versions) — surface it directly instead of a bare status code.
+        let message = `${response.status} ${response.statusText}`;
+        try {
+            const parsed = JSON.parse(body);
+            if (parsed?.error)
+                message = parsed.error;
+        }
+        catch (parseError) {
+            // Body wasn't JSON; fall back to the status line. Rethrow anything unexpected.
+            if (!(parseError instanceof SyntaxError))
+                throw parseError;
+        }
+        throw new AbortError(`Search failed: ${message}`);
+    }
+    outputResult(body);
+}
+//# sourceMappingURL=search.js.map

package/dist/cli/services/commands/notifications.d.ts

@@ -0,0 +1,2 @@
+export declare function generate(): Promise<void>;
+export declare function list(): Promise<void>;

package/dist/cli/services/commands/notifications.js

@@ -0,0 +1,106 @@
+import { CLI_KIT_VERSION } from '@shopify/cli-kit/common/version';
+import { randomUUID } from '@shopify/cli-kit/node/crypto';
+import { writeFile } from '@shopify/cli-kit/node/fs';
+import { stringifyFilters, getNotifications, fetchNotifications, } from '@shopify/cli-kit/node/notifications-system';
+import { outputInfo } from '@shopify/cli-kit/node/output';
+import { renderSelectPrompt, renderTextPrompt, renderSuccess, renderTable } from '@shopify/cli-kit/node/ui';
+export async function generate() {
+    const today = new Date();
+    const formattedToday = `${today.getFullYear()}-${(today.getMonth() + 1).toString().padStart(2, '0')}-${today
+        .getDate()
+        .toString()
+        .padStart(2, '0')}`;
+    const id = randomUUID();
+    const type = await renderSelectPrompt({
+        message: 'Type of message?',
+        choices: [
+            { label: 'Info', value: 'info' },
+            { label: 'Warning', value: 'warning' },
+            { label: 'Error', value: 'error' },
+        ],
+    });
+    const title = await renderTextPrompt({
+        message: 'Title',
+    });
+    const message = await renderTextPrompt({
+        message: 'Message',
+    });
+    const frequency = await renderSelectPrompt({
+        message: 'Frequency',
+        choices: [
+            { label: 'Only once', value: 'once' },
+            { label: 'Once a week', value: 'once_a_week' },
+            { label: 'Once a day', value: 'once_a_day' },
+            { label: 'Always', value: 'always' },
+        ],
+    });
+    const minVersion = await renderTextPrompt({
+        message: 'Minimum CLI version (optional)',
+        initialAnswer: CLI_KIT_VERSION,
+        allowEmpty: true,
+    });
+    const maxVersion = await renderTextPrompt({
+        message: 'Maximum CLI version (optional)',
+        initialAnswer: CLI_KIT_VERSION,
+        allowEmpty: true,
+    });
+    const minDate = await renderTextPrompt({
+        message: 'Minimum date in YYYY-MM-DD format (optional)',
+        initialAnswer: formattedToday,
+        allowEmpty: true,
+    });
+    const maxDate = await renderTextPrompt({
+        message: 'Maximum date in YYYY-MM-DD format (optional)',
+        initialAnswer: formattedToday,
+        allowEmpty: true,
+    });
+    const surface = await renderTextPrompt({
+        message: 'Surface. E.g.: app, theme, hydrogen, theme_app_extension... (optional)',
+        allowEmpty: true,
+    });
+    const commands = await renderTextPrompt({
+        message: 'Comma separated list of commands. E.g.: app:generate:extension (optional)',
+        allowEmpty: true,
+    });
+    const ownerChannel = await renderTextPrompt({
+        message: 'Slack channel of the team who will own this notification',
+    });
+    const notifications = await getNotifications();
+    const notification = {
+        id,
+        type,
+        title,
+        frequency,
+        message,
+        minVersion: minVersion.length === 0 ? undefined : minVersion,
+        maxVersion: maxVersion.length === 0 ? undefined : maxVersion,
+        minDate: minDate.length === 0 ? undefined : minDate,
+        maxDate: maxDate.length === 0 ? undefined : maxDate,
+        surface: surface.length === 0 ? undefined : surface,
+        commands: commands.length === 0 ? undefined : commands.split(',').map((command) => command.trim()),
+        ownerChannel,
+    };
+    notifications.notifications.push(notification);
+    await writeFile('./notifications.json', JSON.stringify(notifications));
+    renderSuccess({ headline: 'notifications.json file updated successfully.' });
+}
+export async function list() {
+    const notifications = await fetchNotifications();
+    const columns = {
+        type: { header: 'Type', color: 'dim' },
+        title: { header: 'Title', color: 'dim' },
+        message: { header: 'Message', color: 'dim' },
+        filters: { header: 'Filters', color: 'dim' },
+    };
+    const rows = notifications.notifications.map((notification) => {
+        return {
+            type: notification.type,
+            title: notification.title ?? '',
+            message: notification.message,
+            filters: stringifyFilters(notification),
+        };
+    });
+    renderTable({ rows, columns });
+    outputInfo('\n');
+}
+//# sourceMappingURL=notifications.js.map

package/dist/cli/services/commands/search.d.ts

@@ -0,0 +1 @@
+export declare function searchService(query?: string): Promise<void>;

package/dist/cli/services/commands/search.js

@@ -0,0 +1,7 @@
+import { openURL } from '@shopify/cli-kit/node/system';
+export async function searchService(query) {
+    const searchParams = new URLSearchParams();
+    searchParams.append('search', query ?? '');
+    await openURL(`https://shopify.dev?${searchParams.toString()}`);
+}
+//# sourceMappingURL=search.js.map

package/dist/cli/services/commands/version.d.ts

@@ -0,0 +1 @@
+export declare function versionService(): Promise<void>;

package/dist/cli/services/commands/version.js

@@ -0,0 +1,6 @@
+import { CLI_KIT_VERSION } from '@shopify/cli-kit/common/version';
+import { outputResult } from '@shopify/cli-kit/node/output';
+export async function versionService() {
+    outputResult(CLI_KIT_VERSION);
+}
+//# sourceMappingURL=version.js.map

package/dist/cli/services/doctor-release/context.d.ts

@@ -0,0 +1,16 @@
+import type { DoctorContext } from '@shopify/cli-kit/node/doctor/types';
+export interface ThemeDoctorContext extends DoctorContext {
+    environment: string;
+    store?: string;
+    password?: string;
+    themeName?: string;
+    themePath?: string;
+    themeId?: string;
+}
+export interface ThemeDoctorOptions {
+    path?: string;
+    environment: string;
+    store?: string;
+    password?: string;
+}
+export declare function createDoctorContext(options: ThemeDoctorOptions): ThemeDoctorContext;

package/dist/cli/services/doctor-release/context.js

@@ -0,0 +1,11 @@
+import { cwd } from '@shopify/cli-kit/node/path';
+export function createDoctorContext(options) {
+    return {
+        workingDirectory: options.path ?? cwd(),
+        environment: options.environment,
+        store: options.store,
+        password: options.password,
+        data: {},
+    };
+}
+//# sourceMappingURL=context.js.map

package/dist/cli/services/doctor-release/theme/runner.d.ts

@@ -0,0 +1,7 @@
+import type { ThemeDoctorOptions } from '../context.js';
+import type { TestResult } from '@shopify/cli-kit/node/doctor/types';
+/**
+ * Run all theme doctor tests.
+ * Stops on first failure.
+ */
+export declare function runThemeDoctor(options: ThemeDoctorOptions): Promise<TestResult[]>;

package/dist/cli/services/doctor-release/theme/runner.js

@@ -0,0 +1,37 @@
+import ThemeInitTests from './tests/init.js';
+import ThemePushTests from './tests/push.js';
+import { createDoctorContext } from '../context.js';
+import { reportTestStart, reportTestResult, reportSuiteStart, reportSummary, initReporter, } from '@shopify/cli-kit/node/doctor/reporter';
+// Test suites run in order. If a test relies on another, ensure that test runs after it's dependency.
+const themeSuites = [ThemeInitTests, ThemePushTests];
+/**
+ * Run all theme doctor tests.
+ * Stops on first failure.
+ */
+export async function runThemeDoctor(options) {
+    const results = [];
+    const context = createDoctorContext(options);
+    // Initialize reporter with working directory
+    initReporter(context.workingDirectory);
+    // Run all test suites in order
+    for (const SuiteClass of themeSuites) {
+        const suite = new SuiteClass();
+        const description = SuiteClass.description ?? 'Test suite';
+        reportSuiteStart(SuiteClass.name, description);
+        // eslint-disable-next-line no-await-in-loop
+        const suiteResults = await suite.runSuite(context);
+        for (const result of suiteResults) {
+            reportTestStart(result.name);
+            reportTestResult(result);
+            results.push(result);
+            // Stop on first failure
+            if (result.status === 'failed') {
+                reportSummary(results);
+                return results;
+            }
+        }
+    }
+    reportSummary(results);
+    return results;
+}
+//# sourceMappingURL=runner.js.map

package/dist/cli/services/doctor-release/theme/tests/init.d.ts

@@ -0,0 +1,11 @@
+import { DoctorSuite } from '@shopify/cli-kit/node/doctor/framework';
+import type { ThemeDoctorContext } from '../../context.js';
+/**
+ * Tests for `shopify theme init` command
+ */
+export default class ThemeInitTests extends DoctorSuite<ThemeDoctorContext> {
+    static description: string;
+    private themeName;
+    private themePath;
+    tests(): void;
+}

package/dist/cli/services/doctor-release/theme/tests/init.js

@@ -0,0 +1,34 @@
+import { DoctorSuite } from '@shopify/cli-kit/node/doctor/framework';
+import { joinPath } from '@shopify/cli-kit/node/path';
+import { getRandomName } from '@shopify/cli-kit/common/string';
+/**
+ * Tests for `shopify theme init` command
+ */
+export default class ThemeInitTests extends DoctorSuite {
+    static description = 'Tests the theme init command creates a valid theme structure';
+    themeName = '';
+    themePath = '';
+    tests() {
+        this.test('init creates theme directory', async () => {
+            this.themeName = `doctor-theme-${getRandomName('creative')}`;
+            this.themePath = joinPath(this.context.workingDirectory, this.themeName);
+            const result = await this.runInteractive(`shopify theme init ${this.themeName} --path ${this.context.workingDirectory}`);
+            this.assertSuccess(result);
+            // Store for tests later in the suite
+            this.context.themeName = this.themeName;
+            this.context.themePath = this.themePath;
+        });
+        this.test('essential theme files exist', async () => {
+            const essentialFiles = ['layout/theme.liquid', 'config/settings_schema.json', 'templates/index.json'];
+            await Promise.all(essentialFiles.map((file) => this.assertFile(joinPath(this.themePath, file))));
+        });
+        this.test('theme directories exist', async () => {
+            const directories = ['sections', 'snippets', 'assets', 'locales'];
+            await Promise.all(directories.map((dir) => this.assertDirectory(joinPath(this.themePath, dir))));
+        });
+        this.test('layout/theme.liquid has valid content', async () => {
+            await this.assertFile(joinPath(this.themePath, 'layout/theme.liquid'), /<!doctype html>|<html|{{ content_for_header }}/i, 'layout/theme.liquid contains expected Liquid markup');
+        });
+    }
+}
+//# sourceMappingURL=init.js.map

package/dist/cli/services/doctor-release/theme/tests/push.d.ts

@@ -0,0 +1,10 @@
+import { DoctorSuite } from '@shopify/cli-kit/node/doctor/framework';
+import type { ThemeDoctorContext } from '../../context.js';
+/**
+ * Tests for `shopify theme push` command
+ */
+export default class ThemePushTests extends DoctorSuite<ThemeDoctorContext> {
+    static description: string;
+    static requiresStore: boolean;
+    tests(): void;
+}

package/dist/cli/services/doctor-release/theme/tests/push.js

@@ -0,0 +1,44 @@
+import { DoctorSuite } from '@shopify/cli-kit/node/doctor/framework';
+/**
+ * Tests for `shopify theme push` command
+ */
+export default class ThemePushTests extends DoctorSuite {
+    static description = 'Tests pushing a theme to the store creates an unpublished theme';
+    static requiresStore = true;
+    tests() {
+        this.test('push creates unpublished theme', async () => {
+            // Check prerequisite: theme must be initialized
+            if (!this.context.themePath) {
+                this.assert(false, 'Theme init did not complete successfully; themePath is missing in context');
+                return;
+            }
+            // Build command
+            const themeName = this.context.themeName ?? 'doctor-theme';
+            let cmd = `shopify theme push --unpublished --json --path ${this.context.themePath} -t ${themeName}`;
+            if (this.context.environment) {
+                cmd += ` -e ${this.context.environment}`;
+            }
+            if (this.context.store) {
+                cmd += ` -s ${this.context.store}`;
+            }
+            if (this.context.password) {
+                cmd += ` --password ${this.context.password}`;
+            }
+            const result = await this.run(cmd);
+            this.assertSuccess(result);
+            // Parse and validate JSON output
+            const json = this.assertJson(result, (data) => typeof data.theme?.id === 'number');
+            if (json?.theme) {
+                this.assert(typeof json.theme.id === 'number', 'Theme was created with a valid ID');
+                this.assertEqual(json.theme.role, 'unpublished', 'Theme role is unpublished');
+                this.assert(json.theme.editor_url.includes('/admin/themes/'), 'Editor URL is provided');
+                this.assert(json.theme.preview_url.includes('preview_theme_id='), 'Preview URL is provided');
+                // Update context for subsequent tests
+                this.context.themeId = String(json.theme.id);
+                this.context.data.editorUrl = json.theme.editor_url;
+                this.context.data.previewUrl = json.theme.preview_url;
+            }
+        });
+    }
+}
+//# sourceMappingURL=push.js.map

package/dist/cli/services/kitchen-sink/async.d.ts

@@ -0,0 +1 @@
+export declare function asyncTasks(): Promise<void>;

package/dist/cli/services/kitchen-sink/async.js

@@ -0,0 +1,65 @@
+import { renderConcurrent, renderSingleTask, renderTasks } from '@shopify/cli-kit/node/ui';
+import { outputContent, outputToken, TokenizedString } from '@shopify/cli-kit/node/output';
+export async function asyncTasks() {
+    // renderConcurrent
+    let backendPromiseResolve;
+    const backendPromise = new Promise(function (resolve, _reject) {
+        backendPromiseResolve = resolve;
+    });
+    const backendProcess = {
+        prefix: 'backend',
+        action: async (stdout, _stderr, _signal) => {
+            stdout.write('first backend message');
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            stdout.write('second backend message');
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            stdout.write('third backend message');
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            backendPromiseResolve();
+        },
+    };
+    const frontendProcess = {
+        prefix: 'frontend',
+        action: async (stdout, _stderr, _signal) => {
+            await backendPromise;
+            stdout.write('first frontend message');
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            stdout.write('second frontend message');
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            stdout.write('third frontend message');
+        },
+    };
+    await renderConcurrent({
+        processes: [backendProcess, frontendProcess],
+    });
+    // renderTasks
+    const tasks = [
+        {
+            title: 'Installing dependencies',
+            task: async () => {
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+            },
+        },
+        {
+            title: 'Downloading assets',
+            task: async () => {
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+            },
+        },
+    ];
+    await renderTasks(tasks);
+    // renderSingleTask
+    await renderSingleTask({
+        title: new TokenizedString('Importing data'),
+        task: async (updateStatus) => {
+            for (let i = 1; i <= 10; i++) {
+                // eslint-disable-next-line no-await-in-loop
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                const status = outputContent `Importing data ${outputToken.italic(outputContent `(${outputToken.green(i.toString())} complete)`)}`;
+                updateStatus(status);
+            }
+            return 'completed';
+        },
+    });
+}
+//# sourceMappingURL=async.js.map

package/dist/cli/services/kitchen-sink/prompts.d.ts

@@ -0,0 +1 @@
+export declare function prompts(): Promise<void>;