@shopify/cli 4.8.4 → 4.9.0

package/dist/cli/services/commands/config/autoupgrade/types.js

@@ -0,0 +1,7 @@
+import { defineJsonOutputSchema } from '@shopify/cli-kit/node/json-output-schema';
+import { zod } from '@shopify/cli-kit/node/schema';
+export const autoUpgradeJsonOutputSchema = defineJsonOutputSchema({
+    name: 'AutoUpgradeResult',
+    schema: zod.object({ enabled: zod.boolean() }).strict(),
+});
+//# sourceMappingURL=types.js.map

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

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

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

@@ -13,7 +13,7 @@ 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) {
+export async function docFetchService(url, outputPath, language) {
     let parsedURL;
     try {
         parsedURL = new URL(url);
@@ -26,7 +26,16 @@ export async function docFetchService(url, outputPath) {
     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 } });
+    // shopify.dev filters Markdown code examples when Accept-Language is a
+    // recognized programming-language key. Unrecognized values are ignored and
+    // the unfiltered document is returned.
+    const response = await fetch(url, {
+        headers: {
+            Accept: MARKDOWN_CONTENT_TYPE,
+            [SURFACE_HEADER]: SURFACE,
+            ...(language ? { 'Accept-Language': language } : {}),
+        },
+    });
     if (!response.ok) {
         throw new AbortError(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
     }

package/dist/cli/services/commands/help/index.d.ts

@@ -0,0 +1,3 @@
+import { type HelpResult } from './types.js';
+import type { Interfaces } from '@oclif/core';
+export declare function helpService(config: Interfaces.Config, argv: string[], all?: boolean): Promise<HelpResult>;

package/dist/cli/services/commands/help/index.js

@@ -0,0 +1,51 @@
+import { helpJsonOutputSchema } from './types.js';
+import { Help } from '@oclif/core';
+import { BugError } from '@shopify/cli-kit/node/error';
+export async function helpService(config, argv, all = false) {
+    const help = new HelpMetadata(config, { all });
+    await help.showHelp(argv);
+    if (!help.result)
+        throw new BugError('Oclif did not resolve a help subject.');
+    return help.result;
+}
+// Reuse oclif's subject resolution (including space-separated commands, aliases,
+// topics, and unknown-command errors), but collect data instead of rendering text.
+class HelpMetadata extends Help {
+    result;
+    async showCommandHelp(command) {
+        const visible = (entry) => this.opts.all === true || !entry.hidden;
+        this.result = helpJsonOutputSchema.validate({
+            kind: 'command',
+            command: {
+                ...command,
+                args: Object.fromEntries(Object.entries(command.args).filter(([, arg]) => visible(arg))),
+                flags: Object.fromEntries(Object.entries(command.flags).filter(([, flag]) => visible(flag))),
+            },
+            ...this.listings(command.id),
+        });
+    }
+    async showRootHelp() {
+        this.result = helpJsonOutputSchema.validate({ kind: 'root', ...this.listings() });
+    }
+    async showTopicHelp(topic) {
+        this.result = helpJsonOutputSchema.validate({ kind: 'topic', topic, ...this.listings(topic.name) });
+    }
+    listings(parent) {
+        const included = (id) => {
+            if (parent === undefined)
+                return this.opts.all === true || !id.includes(':');
+            return id.startsWith(`${parent}:`) && id.split(':').length === parent.split(':').length + 1;
+        };
+        return {
+            commands: this.sortedCommands
+                .filter((command) => command.id && included(command.id))
+                .map((command) => ({
+                id: command.id,
+                summary: command.summary ?? command.description?.split('\n')[0],
+                hidden: command.hidden ?? false,
+            })),
+            topics: this.sortedTopics.filter((topic) => included(topic.name)),
+        };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/cli/services/commands/help/result.d.ts

@@ -0,0 +1,2 @@
+import { type HelpResult } from './types.js';
+export declare function presentHelpResult(result: HelpResult): void;

package/dist/cli/services/commands/help/result.js

@@ -0,0 +1,6 @@
+import { helpJsonOutputSchema } from './types.js';
+import { outputResult } from '@shopify/cli-kit/node/output';
+export function presentHelpResult(result) {
+    outputResult(helpJsonOutputSchema.encode(result));
+}
+//# sourceMappingURL=result.js.map

package/dist/cli/services/commands/help/types.d.ts

@@ -0,0 +1,431 @@
+import { type InferJsonOutputSchema } from '@shopify/cli-kit/node/json-output-schema';
+import { zod } from '@shopify/cli-kit/node/schema';
+export declare const helpJsonOutputSchema: import("@shopify/cli-kit/node/json-output-schema").JsonOutputSchema<zod.ZodDiscriminatedUnion<"kind", [zod.ZodObject<{
+    commands: zod.ZodArray<zod.ZodObject<{
+        id: zod.ZodString;
+        summary: zod.ZodOptional<zod.ZodString>;
+        hidden: zod.ZodDefault<zod.ZodBoolean>;
+    }, "strip", zod.ZodTypeAny, {
+        hidden: boolean;
+        id: string;
+        summary?: string | undefined;
+    }, {
+        id: string;
+        summary?: string | undefined;
+        hidden?: boolean | undefined;
+    }>, "many">;
+    topics: zod.ZodArray<zod.ZodObject<{
+        name: zod.ZodString;
+        description: zod.ZodOptional<zod.ZodString>;
+        hidden: zod.ZodDefault<zod.ZodBoolean>;
+    }, "strip", zod.ZodTypeAny, {
+        name: string;
+        hidden: boolean;
+        description?: string | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        hidden?: boolean | undefined;
+    }>, "many">;
+    kind: zod.ZodLiteral<"root">;
+}, "strip", zod.ZodTypeAny, {
+    commands: {
+        hidden: boolean;
+        id: string;
+        summary?: string | undefined;
+    }[];
+    kind: "root";
+    topics: {
+        name: string;
+        hidden: boolean;
+        description?: string | undefined;
+    }[];
+}, {
+    commands: {
+        id: string;
+        summary?: string | undefined;
+        hidden?: boolean | undefined;
+    }[];
+    kind: "root";
+    topics: {
+        name: string;
+        description?: string | undefined;
+        hidden?: boolean | undefined;
+    }[];
+}>, zod.ZodObject<{
+    commands: zod.ZodArray<zod.ZodObject<{
+        id: zod.ZodString;
+        summary: zod.ZodOptional<zod.ZodString>;
+        hidden: zod.ZodDefault<zod.ZodBoolean>;
+    }, "strip", zod.ZodTypeAny, {
+        hidden: boolean;
+        id: string;
+        summary?: string | undefined;
+    }, {
+        id: string;
+        summary?: string | undefined;
+        hidden?: boolean | undefined;
+    }>, "many">;
+    topics: zod.ZodArray<zod.ZodObject<{
+        name: zod.ZodString;
+        description: zod.ZodOptional<zod.ZodString>;
+        hidden: zod.ZodDefault<zod.ZodBoolean>;
+    }, "strip", zod.ZodTypeAny, {
+        name: string;
+        hidden: boolean;
+        description?: string | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        hidden?: boolean | undefined;
+    }>, "many">;
+    kind: zod.ZodLiteral<"topic">;
+    topic: zod.ZodObject<{
+        name: zod.ZodString;
+        description: zod.ZodOptional<zod.ZodString>;
+        hidden: zod.ZodDefault<zod.ZodBoolean>;
+    }, "strip", zod.ZodTypeAny, {
+        name: string;
+        hidden: boolean;
+        description?: string | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        hidden?: boolean | undefined;
+    }>;
+}, "strip", zod.ZodTypeAny, {
+    commands: {
+        hidden: boolean;
+        id: string;
+        summary?: string | undefined;
+    }[];
+    kind: "topic";
+    topics: {
+        name: string;
+        hidden: boolean;
+        description?: string | undefined;
+    }[];
+    topic: {
+        name: string;
+        hidden: boolean;
+        description?: string | undefined;
+    };
+}, {
+    commands: {
+        id: string;
+        summary?: string | undefined;
+        hidden?: boolean | undefined;
+    }[];
+    kind: "topic";
+    topics: {
+        name: string;
+        description?: string | undefined;
+        hidden?: boolean | undefined;
+    }[];
+    topic: {
+        name: string;
+        description?: string | undefined;
+        hidden?: boolean | undefined;
+    };
+}>, zod.ZodObject<{
+    commands: zod.ZodArray<zod.ZodObject<{
+        id: zod.ZodString;
+        summary: zod.ZodOptional<zod.ZodString>;
+        hidden: zod.ZodDefault<zod.ZodBoolean>;
+    }, "strip", zod.ZodTypeAny, {
+        hidden: boolean;
+        id: string;
+        summary?: string | undefined;
+    }, {
+        id: string;
+        summary?: string | undefined;
+        hidden?: boolean | undefined;
+    }>, "many">;
+    topics: zod.ZodArray<zod.ZodObject<{
+        name: zod.ZodString;
+        description: zod.ZodOptional<zod.ZodString>;
+        hidden: zod.ZodDefault<zod.ZodBoolean>;
+    }, "strip", zod.ZodTypeAny, {
+        name: string;
+        hidden: boolean;
+        description?: string | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        hidden?: boolean | undefined;
+    }>, "many">;
+    kind: zod.ZodLiteral<"command">;
+    command: zod.ZodObject<{
+        id: zod.ZodString;
+        summary: zod.ZodOptional<zod.ZodString>;
+        hidden: zod.ZodDefault<zod.ZodBoolean>;
+    } & {
+        description: zod.ZodOptional<zod.ZodString>;
+        aliases: zod.ZodArray<zod.ZodString, "many">;
+        usage: zod.ZodOptional<zod.ZodUnion<[zod.ZodString, zod.ZodArray<zod.ZodString, "many">]>>;
+        examples: zod.ZodOptional<zod.ZodArray<zod.ZodUnion<[zod.ZodString, zod.ZodObject<{
+            description: zod.ZodString;
+            command: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            description: string;
+            command: string;
+        }, {
+            description: string;
+            command: string;
+        }>]>, "many">>;
+        strict: zod.ZodDefault<zod.ZodBoolean>;
+        args: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            description: zod.ZodOptional<zod.ZodString>;
+            required: zod.ZodDefault<zod.ZodBoolean>;
+            hidden: zod.ZodDefault<zod.ZodBoolean>;
+            options: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+            default: zod.ZodOptional<zod.ZodUnknown>;
+        }, "strip", zod.ZodTypeAny, {
+            name: string;
+            required: boolean;
+            hidden: boolean;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+        }, {
+            name: string;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            hidden?: boolean | undefined;
+        }>>;
+        flags: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
+            name: zod.ZodString;
+            type: zod.ZodEnum<["boolean", "option"]>;
+            char: zod.ZodOptional<zod.ZodString>;
+            summary: zod.ZodOptional<zod.ZodString>;
+            description: zod.ZodOptional<zod.ZodString>;
+            env: zod.ZodOptional<zod.ZodString>;
+            required: zod.ZodDefault<zod.ZodBoolean>;
+            hidden: zod.ZodDefault<zod.ZodBoolean>;
+            options: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+            default: zod.ZodOptional<zod.ZodUnknown>;
+            multiple: zod.ZodOptional<zod.ZodBoolean>;
+            allowNo: zod.ZodOptional<zod.ZodBoolean>;
+            aliases: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+            dependsOn: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+            exclusive: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+            exactlyOne: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
+        }, "strip", zod.ZodTypeAny, {
+            type: "boolean" | "option";
+            name: string;
+            required: boolean;
+            hidden: boolean;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+            multiple?: boolean | undefined;
+            char?: string | undefined;
+            summary?: string | undefined;
+            env?: string | undefined;
+            dependsOn?: string[] | undefined;
+            exclusive?: string[] | undefined;
+            exactlyOne?: string[] | undefined;
+            aliases?: string[] | undefined;
+            allowNo?: boolean | undefined;
+        }, {
+            type: "boolean" | "option";
+            name: string;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            multiple?: boolean | undefined;
+            char?: string | undefined;
+            summary?: string | undefined;
+            env?: string | undefined;
+            hidden?: boolean | undefined;
+            dependsOn?: string[] | undefined;
+            exclusive?: string[] | undefined;
+            exactlyOne?: string[] | undefined;
+            aliases?: string[] | undefined;
+            allowNo?: boolean | undefined;
+        }>>;
+    }, "strip", zod.ZodTypeAny, {
+        flags: Record<string, {
+            type: "boolean" | "option";
+            name: string;
+            required: boolean;
+            hidden: boolean;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+            multiple?: boolean | undefined;
+            char?: string | undefined;
+            summary?: string | undefined;
+            env?: string | undefined;
+            dependsOn?: string[] | undefined;
+            exclusive?: string[] | undefined;
+            exactlyOne?: string[] | undefined;
+            aliases?: string[] | undefined;
+            allowNo?: boolean | undefined;
+        }>;
+        args: Record<string, {
+            name: string;
+            required: boolean;
+            hidden: boolean;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+        }>;
+        strict: boolean;
+        hidden: boolean;
+        aliases: string[];
+        id: string;
+        description?: string | undefined;
+        usage?: string | string[] | undefined;
+        examples?: (string | {
+            description: string;
+            command: string;
+        })[] | undefined;
+        summary?: string | undefined;
+    }, {
+        flags: Record<string, {
+            type: "boolean" | "option";
+            name: string;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            multiple?: boolean | undefined;
+            char?: string | undefined;
+            summary?: string | undefined;
+            env?: string | undefined;
+            hidden?: boolean | undefined;
+            dependsOn?: string[] | undefined;
+            exclusive?: string[] | undefined;
+            exactlyOne?: string[] | undefined;
+            aliases?: string[] | undefined;
+            allowNo?: boolean | undefined;
+        }>;
+        args: Record<string, {
+            name: string;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            hidden?: boolean | undefined;
+        }>;
+        aliases: string[];
+        id: string;
+        description?: string | undefined;
+        usage?: string | string[] | undefined;
+        examples?: (string | {
+            description: string;
+            command: string;
+        })[] | undefined;
+        strict?: boolean | undefined;
+        summary?: string | undefined;
+        hidden?: boolean | undefined;
+    }>;
+}, "strip", zod.ZodTypeAny, {
+    commands: {
+        hidden: boolean;
+        id: string;
+        summary?: string | undefined;
+    }[];
+    command: {
+        flags: Record<string, {
+            type: "boolean" | "option";
+            name: string;
+            required: boolean;
+            hidden: boolean;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+            multiple?: boolean | undefined;
+            char?: string | undefined;
+            summary?: string | undefined;
+            env?: string | undefined;
+            dependsOn?: string[] | undefined;
+            exclusive?: string[] | undefined;
+            exactlyOne?: string[] | undefined;
+            aliases?: string[] | undefined;
+            allowNo?: boolean | undefined;
+        }>;
+        args: Record<string, {
+            name: string;
+            required: boolean;
+            hidden: boolean;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+        }>;
+        strict: boolean;
+        hidden: boolean;
+        aliases: string[];
+        id: string;
+        description?: string | undefined;
+        usage?: string | string[] | undefined;
+        examples?: (string | {
+            description: string;
+            command: string;
+        })[] | undefined;
+        summary?: string | undefined;
+    };
+    kind: "command";
+    topics: {
+        name: string;
+        hidden: boolean;
+        description?: string | undefined;
+    }[];
+}, {
+    commands: {
+        id: string;
+        summary?: string | undefined;
+        hidden?: boolean | undefined;
+    }[];
+    command: {
+        flags: Record<string, {
+            type: "boolean" | "option";
+            name: string;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            multiple?: boolean | undefined;
+            char?: string | undefined;
+            summary?: string | undefined;
+            env?: string | undefined;
+            hidden?: boolean | undefined;
+            dependsOn?: string[] | undefined;
+            exclusive?: string[] | undefined;
+            exactlyOne?: string[] | undefined;
+            aliases?: string[] | undefined;
+            allowNo?: boolean | undefined;
+        }>;
+        args: Record<string, {
+            name: string;
+            default?: unknown;
+            options?: string[] | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            hidden?: boolean | undefined;
+        }>;
+        aliases: string[];
+        id: string;
+        description?: string | undefined;
+        usage?: string | string[] | undefined;
+        examples?: (string | {
+            description: string;
+            command: string;
+        })[] | undefined;
+        strict?: boolean | undefined;
+        summary?: string | undefined;
+        hidden?: boolean | undefined;
+    };
+    kind: "command";
+    topics: {
+        name: string;
+        description?: string | undefined;
+        hidden?: boolean | undefined;
+    }[];
+}>]>>;
+export type HelpResult = InferJsonOutputSchema<typeof helpJsonOutputSchema>;

package/dist/cli/services/commands/help/types.js

@@ -0,0 +1,71 @@
+import { defineJsonOutputSchema } from '@shopify/cli-kit/node/json-output-schema';
+import { zod } from '@shopify/cli-kit/node/schema';
+const HelpCommandSummarySchema = zod.object({
+    id: zod.string(),
+    summary: zod.string().optional(),
+    hidden: zod.boolean().default(false),
+});
+const HelpTopicSchema = zod.object({
+    name: zod.string(),
+    description: zod.string().optional(),
+    hidden: zod.boolean().default(false),
+});
+const HelpArgumentSchema = zod.object({
+    name: zod.string(),
+    description: zod.string().optional(),
+    required: zod.boolean().default(false),
+    hidden: zod.boolean().default(false),
+    options: zod.array(zod.string()).optional(),
+    default: zod.unknown().optional(),
+});
+const HelpFlagSchema = zod.object({
+    name: zod.string(),
+    type: zod.enum(['boolean', 'option']),
+    char: zod.string().optional(),
+    summary: zod.string().optional(),
+    description: zod.string().optional(),
+    env: zod.string().optional(),
+    required: zod.boolean().default(false),
+    hidden: zod.boolean().default(false),
+    options: zod.array(zod.string()).optional(),
+    default: zod.unknown().optional(),
+    multiple: zod.boolean().optional(),
+    allowNo: zod.boolean().optional(),
+    aliases: zod.array(zod.string()).optional(),
+    dependsOn: zod.array(zod.string()).optional(),
+    exclusive: zod.array(zod.string()).optional(),
+    exactlyOne: zod.array(zod.string()).optional(),
+});
+// Keep the public contract focused on command usage. Hidden aliases and oclif/plugin loader
+// metadata are intentionally omitted; JSON support is described by the exposed flags.
+const HelpCommandSchema = HelpCommandSummarySchema.extend({
+    description: zod.string().optional(),
+    aliases: zod.array(zod.string()),
+    usage: zod.union([zod.string(), zod.array(zod.string())]).optional(),
+    examples: zod
+        .array(zod.union([zod.string(), zod.object({ description: zod.string(), command: zod.string() })]))
+        .optional(),
+    strict: zod.boolean().default(true),
+    args: zod.record(HelpArgumentSchema),
+    flags: zod.record(HelpFlagSchema),
+});
+const listings = {
+    commands: zod.array(HelpCommandSummarySchema),
+    topics: zod.array(HelpTopicSchema),
+};
+export const helpJsonOutputSchema = defineJsonOutputSchema({
+    name: 'HelpResult',
+    schema: zod.discriminatedUnion('kind', [
+        zod.object({ kind: zod.literal('root'), ...listings }),
+        zod.object({ kind: zod.literal('topic'), topic: HelpTopicSchema, ...listings }),
+        zod.object({ kind: zod.literal('command'), command: HelpCommandSchema, ...listings }),
+    ]),
+    definitions: {
+        HelpCommandSummary: HelpCommandSummarySchema,
+        HelpTopic: HelpTopicSchema,
+        HelpArgument: HelpArgumentSchema,
+        HelpFlag: HelpFlagSchema,
+        HelpCommand: HelpCommandSchema,
+    },
+});
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,2 @@
+import type { SearchResult } from './types.js';
+export declare function searchService(query?: string): Promise<SearchResult>;

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

@@ -0,0 +1,8 @@
+export async function searchService(query) {
+    const searchParams = new URLSearchParams();
+    searchParams.append('search', query ?? '');
+    // The homepage redirects to /docs without preserving query parameters.
+    const url = `https://shopify.dev/docs?${searchParams.toString()}`;
+    return { url };
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,2 @@
+import { type SearchResult } from './types.js';
+export declare function presentSearchResult(result: SearchResult, format: 'json' | 'text'): Promise<void>;

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

@@ -0,0 +1,12 @@
+import { searchJsonOutputSchema } from './types.js';
+import { outputResult } from '@shopify/cli-kit/node/output';
+import { openURL } from '@shopify/cli-kit/node/system';
+export async function presentSearchResult(result, format) {
+    if (format === 'json') {
+        outputResult(searchJsonOutputSchema.encode(result));
+    }
+    else {
+        await openURL(result.url);
+    }
+}
+//# sourceMappingURL=result.js.map

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

@@ -0,0 +1,10 @@
+import { type InferJsonOutputSchema } from '@shopify/cli-kit/node/json-output-schema';
+import { zod } from '@shopify/cli-kit/node/schema';
+export declare const searchJsonOutputSchema: import("@shopify/cli-kit/node/json-output-schema").JsonOutputSchema<zod.ZodObject<{
+    url: zod.ZodString;
+}, "strip", zod.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>>;
+export type SearchResult = InferJsonOutputSchema<typeof searchJsonOutputSchema>;

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

@@ -0,0 +1,7 @@
+import { defineJsonOutputSchema } from '@shopify/cli-kit/node/json-output-schema';
+import { zod } from '@shopify/cli-kit/node/schema';
+export const searchJsonOutputSchema = defineJsonOutputSchema({
+    name: 'SearchResult',
+    schema: zod.object({ url: zod.string().url() }),
+});
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,2 @@
+import type { VersionResult } from './types.js';
+export declare function versionService(): Promise<VersionResult>;

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

@@ -0,0 +1,5 @@
+import { CLI_KIT_VERSION } from '@shopify/cli-kit/common/version';
+export async function versionService() {
+    return { version: CLI_KIT_VERSION };
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,2 @@
+import { type VersionResult } from './types.js';
+export declare function presentVersionResult(result: VersionResult, format: 'json' | 'text'): void;