@zapier/zapier-sdk-cli 0.13.5 → 0.13.7

package/dist/src/plugins/add/index.js

@@ -1,110 +1,101 @@
 import { createFunction } from "@zapier/zapier-sdk";
 import { AddSchema } from "./schemas";
-import { AstTypeGenerator } from "./ast-generator";
-import { mkdir, access, writeFile } from "fs/promises";
-import { resolve, join } from "path";
-/**
- * Detect the best default directory for TypeScript types
- * Looks for src or lib directories, falls back to current directory
- */
-async function detectTypesOutputDirectory() {
-    // Check for common source directories in priority order
-    const candidates = ["src", "lib"];
-    for (const candidate of candidates) {
-        try {
-            await access(candidate);
-            return join(candidate, "zapier", "apps");
-        }
-        catch {
-            // Directory doesn't exist, continue to next candidate
-        }
-    }
-    // Fall back to current directory
-    return "./zapier/apps/";
-}
-export const addPlugin = ({ sdk, context }) => {
+import { detectTypesOutputDirectory } from "../../utils/directory-detection";
+import { resolve } from "path";
+export const addPlugin = ({ sdk }) => {
     const add = createFunction(async function add(options) {
         const { appKeys, authenticationIds, configPath, typesOutput = await detectTypesOutputDirectory(), } = options;
         const resolvedTypesOutput = resolve(typesOutput);
-        // Ensure types output directory exists
-        await mkdir(resolvedTypesOutput, { recursive: true });
-        // Get apps using listApps (which respects existing manifest for version locking)
-        console.log(`📦 Looking up ${appKeys.length} app(s)...`);
-        const appsIterator = sdk.listApps({ appKeys }).items();
-        const apps = [];
-        for await (const app of appsIterator) {
-            apps.push(app);
-        }
-        if (apps.length === 0) {
-            console.warn("⚠️ No apps found");
-            return;
-        }
-        // Fetch authentications if provided
-        let authentications = [];
-        if (authenticationIds && authenticationIds.length > 0) {
-            console.log(`🔐 Looking up ${authenticationIds.length} authentication(s)...`);
-            const authsIterator = sdk
-                .listAuthentications({ authenticationIds })
-                .items();
-            for await (const auth of authsIterator) {
-                authentications.push(auth);
-            }
-            console.log(`🔐 Found ${authentications.length} authentication(s)`);
-        }
-        // Process each app
-        for (const app of apps) {
-            const appSlugAndKey = app.slug ? `${app.slug} (${app.key})` : app.key;
-            console.log(`📦 Adding ${appSlugAndKey}...`);
-            try {
-                if (!app.version) {
-                    console.warn(`⚠️ Invalid implementation ID format for '${appSlugAndKey}': ${app.implementation_id}. Expected format: <implementationName>@<version>. Skipping...`);
-                    continue;
-                }
-                // Update manifest using manifest plugin's function
-                const [manifestKey] = await context.updateManifestEntry(app.key, {
-                    implementationName: app.key,
-                    version: app.version,
-                }, configPath);
-                console.log(`📝 Locked ${appSlugAndKey} to ${app.key}@${app.version} using key '${manifestKey}'`);
-                // Find matching authentication for this app if authentications were provided
-                let authenticationId;
-                if (authentications.length > 0) {
-                    // Match authentication by app_key
-                    const matchingAuth = authentications.find((auth) => {
-                        return auth.app_key === app.key;
-                    });
-                    if (matchingAuth) {
-                        authenticationId = matchingAuth.id;
-                        console.log(`🔐 Using authentication ${authenticationId} (${matchingAuth.title}) for ${appSlugAndKey}`);
+        console.log(`📦 Adding ${appKeys.length} app(s)...`);
+        // Track app names for better console output
+        const appSlugAndKeyMap = new Map();
+        // Define progress handler for manifest building
+        const handleManifestProgress = (event) => {
+            switch (event.type) {
+                case "apps_lookup_start":
+                    console.log(`📦 Looking up ${event.count} app(s)...`);
+                    break;
+                case "app_found":
+                    // Store the app display name for later use
+                    const displayName = event.app.slug
+                        ? `${event.app.slug} (${event.app.key})`
+                        : event.app.key;
+                    appSlugAndKeyMap.set(event.app.key, displayName);
+                    break;
+                case "apps_lookup_complete":
+                    if (event.count === 0) {
+                        console.warn("⚠️ No apps found");
                     }
-                    else {
-                        console.warn(`⚠️ No matching authentication found for ${appSlugAndKey}`);
-                    }
-                }
-                // Generate types using the manifest key for consistency
-                const typesPath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
-                try {
-                    // Use AST-based generator directly
-                    const generator = new AstTypeGenerator();
-                    const typeDefinitions = await generator.generateTypes({
-                        app,
-                        authenticationId,
-                        sdk,
-                    });
-                    // Write to file
-                    await writeFile(typesPath, typeDefinitions, "utf8");
-                    console.log(`🔧 Generated types for ${manifestKey} at ${typesPath}`);
-                }
-                catch (error) {
-                    console.warn(`⚠️ Failed to generate types for ${appSlugAndKey}: ${error}`);
-                    // Continue even if type generation fails
-                }
+                    break;
+                case "app_processing_start":
+                    const appName = event.slug
+                        ? `${event.slug} (${event.appKey})`
+                        : event.appKey;
+                    console.log(`📦 Adding ${appName}...`);
+                    break;
+                case "manifest_updated":
+                    const appDisplay = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+                    console.log(`📝 Locked ${appDisplay} to ${event.appKey}@${event.version} using key '${event.manifestKey}'`);
+                    break;
+                case "app_processing_error":
+                    const errorApp = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+                    console.warn(`⚠️ ${event.error} for ${errorApp}`);
+                    break;
             }
-            catch (error) {
-                console.warn(`⚠️ Failed to process ${appSlugAndKey}: ${error}`);
+        };
+        // Define progress handler for type generation
+        const handleTypesProgress = (event) => {
+            switch (event.type) {
+                case "authentications_lookup_start":
+                    console.log(`🔐 Looking up ${event.count} authentication(s)...`);
+                    break;
+                case "authentications_lookup_complete":
+                    console.log(`🔐 Found ${event.count} authentication(s)`);
+                    break;
+                case "authentication_matched":
+                    const appWithAuth = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+                    console.log(`🔐 Using authentication ${event.authenticationId} (${event.authenticationTitle}) for ${appWithAuth}`);
+                    break;
+                case "authentication_not_matched":
+                    const appWithoutAuth = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+                    console.warn(`⚠️ No matching authentication found for ${appWithoutAuth}`);
+                    break;
+                case "file_written":
+                    console.log(`🔧 Generated types for ${event.manifestKey} at ${event.filePath}`);
+                    break;
+                case "app_processing_error":
+                    const errorApp = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+                    console.warn(`⚠️ ${event.error} for ${errorApp}`);
+                    break;
             }
+        };
+        const manifestResult = await sdk.buildManifest({
+            appKeys,
+            skipWrite: false,
+            configPath,
+            onProgress: handleManifestProgress,
+        });
+        const typesResult = await sdk.generateAppTypes({
+            appKeys,
+            authenticationIds,
+            skipWrite: false,
+            typesOutputDirectory: resolvedTypesOutput,
+            onProgress: handleTypesProgress,
+        });
+        const results = manifestResult.manifest?.apps || {};
+        // Final summary
+        const successfulApps = Object.keys(results).filter((manifestKey) => typesResult.writtenFiles?.[manifestKey]);
+        if (successfulApps.length > 0) {
+            console.log(`✅ Added ${successfulApps.length} app(s) to manifest`);
+        }
+        // Report any errors
+        const allErrors = [...manifestResult.errors, ...typesResult.errors];
+        if (allErrors.length > 0) {
+            console.warn(`\n⚠️ ${allErrors.length} error(s) occurred:`);
+            allErrors.forEach(({ appKey, error }) => {
+                console.warn(`  - ${appKey}: ${error}`);
+            });
         }
-        console.log(`✅ Added ${apps.length} app(s) to manifest`);
     }, AddSchema);
     return {
         add,

package/dist/src/plugins/buildManifest/index.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin, GetSdkType, GetContextType, ListAppsPluginProvides, ManifestPluginProvides } from "@zapier/zapier-sdk";
+import { BuildManifestSchema, type BuildManifestOptions, type BuildManifestResult } from "./schemas";
+export interface BuildManifestPluginProvides {
+    buildManifest: (options: BuildManifestOptions) => Promise<BuildManifestResult>;
+    context: {
+        meta: {
+            buildManifest: {
+                inputSchema: typeof BuildManifestSchema;
+            };
+        };
+    };
+}
+export declare const buildManifestPlugin: Plugin<GetSdkType<ListAppsPluginProvides>, GetContextType<ManifestPluginProvides>, BuildManifestPluginProvides>;

package/dist/src/plugins/buildManifest/index.js

@@ -0,0 +1,81 @@
+import { createFunction } from "@zapier/zapier-sdk";
+import { BuildManifestSchema, } from "./schemas";
+import { createManifestEntry } from "../../utils/manifest-helpers";
+export const buildManifestPlugin = ({ sdk, context }) => {
+    const buildManifest = createFunction(async function buildManifest(options) {
+        const { appKeys, skipWrite = false, configPath, onProgress } = options;
+        const result = {
+            errors: [],
+        };
+        // Get apps using listApps (which respects existing manifest for version locking)
+        onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
+        const appsIterator = sdk.listApps({ appKeys }).items();
+        const apps = [];
+        for await (const app of appsIterator) {
+            apps.push(app);
+            onProgress?.({ type: "app_found", app });
+        }
+        onProgress?.({ type: "apps_lookup_complete", count: apps.length });
+        if (apps.length === 0) {
+            return result;
+        }
+        let updatedManifest;
+        // Process each app
+        for (const app of apps) {
+            onProgress?.({
+                type: "app_processing_start",
+                appKey: app.key,
+                slug: app.slug,
+            });
+            try {
+                const manifestEntry = createManifestEntry(app);
+                onProgress?.({
+                    type: "manifest_entry_built",
+                    appKey: app.key,
+                    manifestKey: manifestEntry.implementationName,
+                    version: manifestEntry.version || "",
+                });
+                const [updatedManifestKey, , manifest] = await context.updateManifestEntry({
+                    appKey: app.key,
+                    entry: manifestEntry,
+                    configPath,
+                    skipWrite,
+                    manifest: updatedManifest,
+                });
+                updatedManifest = manifest;
+                onProgress?.({
+                    type: "manifest_updated",
+                    appKey: app.key,
+                    manifestKey: updatedManifestKey,
+                    version: manifestEntry.version || "",
+                });
+                onProgress?.({ type: "app_processing_complete", appKey: app.key });
+            }
+            catch (error) {
+                const errorMessage = `Failed to process app: ${error}`;
+                result.errors.push({
+                    appKey: app.key,
+                    error: errorMessage,
+                });
+                onProgress?.({
+                    type: "app_processing_error",
+                    appKey: app.key,
+                    error: errorMessage,
+                });
+            }
+        }
+        result.manifest = updatedManifest;
+        return result;
+    }, BuildManifestSchema);
+    return {
+        buildManifest,
+        context: {
+            meta: {
+                buildManifest: {
+                    categories: ["utility"],
+                    inputSchema: BuildManifestSchema,
+                },
+            },
+        },
+    };
+};

package/dist/src/plugins/buildManifest/schemas.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import type { AppItem, Manifest } from "@zapier/zapier-sdk";
+export declare const BuildManifestSchema: z.ZodObject<{
+    appKeys: z.ZodArray<z.ZodString, "many">;
+    skipWrite: z.ZodOptional<z.ZodBoolean>;
+    configPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    appKeys: string[];
+    configPath?: string | undefined;
+    skipWrite?: boolean | undefined;
+}, {
+    appKeys: string[];
+    configPath?: string | undefined;
+    skipWrite?: boolean | undefined;
+}>;
+export type BuildManifestOptions = z.infer<typeof BuildManifestSchema> & {
+    onProgress?: (event: ManifestBuildProgressEvent) => void;
+};
+export type ManifestBuildProgressEvent = {
+    type: "apps_lookup_start";
+    count: number;
+} | {
+    type: "app_found";
+    app: AppItem;
+} | {
+    type: "apps_lookup_complete";
+    count: number;
+} | {
+    type: "app_processing_start";
+    appKey: string;
+    slug?: string;
+} | {
+    type: "manifest_entry_built";
+    appKey: string;
+    manifestKey: string;
+    version: string;
+} | {
+    type: "manifest_updated";
+    appKey: string;
+    manifestKey: string;
+    version: string;
+} | {
+    type: "app_processing_complete";
+    appKey: string;
+} | {
+    type: "app_processing_error";
+    appKey: string;
+    error: string;
+};
+export interface BuildManifestResult {
+    manifest?: Manifest;
+    errors: Array<{
+        appKey: string;
+        error: string;
+    }>;
+}

package/dist/src/plugins/buildManifest/schemas.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const BuildManifestSchema = z
+    .object({
+    appKeys: z
+        .array(z.string().min(1, "App key cannot be empty"))
+        .min(1, "At least one app key is required")
+        .describe("One or more app keys to build manifest entries for (e.g., 'slack', 'github', 'trello')"),
+    skipWrite: z
+        .boolean()
+        .optional()
+        .describe("If true, returns manifest entries without writing to disk. If false or omitted, writes to the manifest file."),
+    configPath: z
+        .string()
+        .optional()
+        .describe("Path to the manifest file. Only used when skipWrite is false or omitted."),
+})
+    .describe("Build manifest entries for apps - can optionally write to disk or just return JSON");

package/dist/src/plugins/generateAppTypes/index.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin, GetSdkType, ListActionsPluginProvides, ListAppsPluginProvides, ListInputFieldsPluginProvides, ListAuthenticationsPluginProvides, ManifestPluginProvides } from "@zapier/zapier-sdk";
+import { GenerateAppTypesSchema, type GenerateAppTypesOptions, type GenerateAppTypesResult } from "./schemas";
+export interface GenerateAppTypesPluginProvides {
+    generateAppTypes: (options: GenerateAppTypesOptions) => Promise<GenerateAppTypesResult>;
+    context: {
+        meta: {
+            generateAppTypes: {
+                inputSchema: typeof GenerateAppTypesSchema;
+            };
+        };
+    };
+}
+export declare const generateAppTypesPlugin: Plugin<GetSdkType<ListAppsPluginProvides & ListActionsPluginProvides & ListInputFieldsPluginProvides & ListAuthenticationsPluginProvides & ManifestPluginProvides>, {}, GenerateAppTypesPluginProvides>;

package/dist/src/plugins/generateAppTypes/index.js

@@ -0,0 +1,169 @@
+import { createFunction } from "@zapier/zapier-sdk";
+import { GenerateAppTypesSchema, } from "./schemas";
+import { AstTypeGenerator } from "../../generators/ast-generator";
+import { getManifestKey } from "../../utils/manifest-helpers";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+export const generateAppTypesPlugin = ({ sdk }) => {
+    const generateAppTypes = createFunction(async function generateAppTypes(options) {
+        const { appKeys, authenticationIds, skipWrite = false, typesOutputDirectory, onProgress, } = options;
+        // Validate that typesOutputDirectory is provided when skipWrite is false
+        if (!skipWrite && !typesOutputDirectory) {
+            throw new Error("typesOutputDirectory is required when skipWrite is false");
+        }
+        const result = {
+            typeDefinitions: {},
+            errors: [],
+        };
+        // Get apps using listApps (which respects existing manifest for version locking)
+        onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
+        const appsIterator = sdk.listApps({ appKeys }).items();
+        const apps = [];
+        for await (const app of appsIterator) {
+            apps.push(app);
+            onProgress?.({ type: "app_found", app });
+        }
+        onProgress?.({ type: "apps_lookup_complete", count: apps.length });
+        if (apps.length === 0) {
+            return result;
+        }
+        // Fetch authentications if provided
+        const authentications = [];
+        if (authenticationIds && authenticationIds.length > 0) {
+            onProgress?.({
+                type: "authentications_lookup_start",
+                count: authenticationIds.length,
+            });
+            const authsIterator = sdk
+                .listAuthentications({ authenticationIds })
+                .items();
+            for await (const auth of authsIterator) {
+                authentications.push(auth);
+            }
+            onProgress?.({
+                type: "authentications_lookup_complete",
+                count: authentications.length,
+            });
+        }
+        // Ensure output directory exists if we're writing files
+        if (!skipWrite && typesOutputDirectory) {
+            await mkdir(typesOutputDirectory, { recursive: true });
+        }
+        // Initialize writtenFiles if we're writing to disk
+        if (!skipWrite) {
+            result.writtenFiles = {};
+        }
+        // Process each app
+        for (const app of apps) {
+            onProgress?.({
+                type: "app_processing_start",
+                appKey: app.key,
+                slug: app.slug,
+            });
+            try {
+                if (!app.version) {
+                    const error = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
+                    result.errors.push({
+                        appKey: app.key,
+                        error,
+                    });
+                    onProgress?.({
+                        type: "app_processing_error",
+                        appKey: app.key,
+                        error,
+                    });
+                    continue;
+                }
+                // Find matching authentication for this app if authentications were provided
+                let authenticationId;
+                if (authentications.length > 0) {
+                    const matchingAuth = authentications.find((auth) => {
+                        return auth.app_key === app.key;
+                    });
+                    if (matchingAuth) {
+                        authenticationId = matchingAuth.id;
+                        onProgress?.({
+                            type: "authentication_matched",
+                            appKey: app.key,
+                            authenticationId: matchingAuth.id,
+                            authenticationTitle: matchingAuth.title || "",
+                        });
+                    }
+                    else {
+                        onProgress?.({
+                            type: "authentication_not_matched",
+                            appKey: app.key,
+                        });
+                    }
+                }
+                const manifestKey = getManifestKey(app);
+                // Generate type definitions
+                try {
+                    const generator = new AstTypeGenerator();
+                    const typeDefinitionString = await generator.generateTypes({
+                        app,
+                        authenticationId,
+                        sdk,
+                    });
+                    result.typeDefinitions[manifestKey] = typeDefinitionString;
+                    onProgress?.({
+                        type: "type_generated",
+                        manifestKey,
+                        sizeBytes: typeDefinitionString.length,
+                    });
+                    // Write to file if skipWrite is false
+                    if (!skipWrite && typesOutputDirectory && result.writtenFiles) {
+                        const filePath = join(typesOutputDirectory, `${manifestKey}.d.ts`);
+                        await writeFile(filePath, typeDefinitionString, "utf8");
+                        result.writtenFiles[manifestKey] = filePath;
+                        onProgress?.({
+                            type: "file_written",
+                            manifestKey,
+                            filePath,
+                        });
+                    }
+                    onProgress?.({
+                        type: "app_processing_complete",
+                        appKey: app.key,
+                    });
+                }
+                catch (error) {
+                    const errorMessage = `Failed to generate types: ${error}`;
+                    result.errors.push({
+                        appKey: app.key,
+                        error: errorMessage,
+                    });
+                    onProgress?.({
+                        type: "app_processing_error",
+                        appKey: app.key,
+                        error: errorMessage,
+                    });
+                }
+            }
+            catch (error) {
+                const errorMessage = `Failed to process app: ${error}`;
+                result.errors.push({
+                    appKey: app.key,
+                    error: errorMessage,
+                });
+                onProgress?.({
+                    type: "app_processing_error",
+                    appKey: app.key,
+                    error: errorMessage,
+                });
+            }
+        }
+        return result;
+    }, GenerateAppTypesSchema);
+    return {
+        generateAppTypes,
+        context: {
+            meta: {
+                generateAppTypes: {
+                    categories: ["utility"],
+                    inputSchema: GenerateAppTypesSchema,
+                },
+            },
+        },
+    };
+};

package/dist/src/plugins/generateAppTypes/schemas.d.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import type { AppItem } from "@zapier/zapier-sdk";
+export declare const GenerateAppTypesSchema: z.ZodObject<{
+    appKeys: z.ZodArray<z.ZodString, "many">;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    skipWrite: z.ZodOptional<z.ZodBoolean>;
+    typesOutputDirectory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    appKeys: string[];
+    authenticationIds?: string[] | undefined;
+    skipWrite?: boolean | undefined;
+    typesOutputDirectory?: string | undefined;
+}, {
+    appKeys: string[];
+    authenticationIds?: string[] | undefined;
+    skipWrite?: boolean | undefined;
+    typesOutputDirectory?: string | undefined;
+}>;
+export type GenerateAppTypesOptions = z.infer<typeof GenerateAppTypesSchema> & {
+    onProgress?: (event: AppTypesProgressEvent) => void;
+};
+export type AppTypesProgressEvent = {
+    type: "apps_lookup_start";
+    count: number;
+} | {
+    type: "app_found";
+    app: AppItem;
+} | {
+    type: "apps_lookup_complete";
+    count: number;
+} | {
+    type: "authentications_lookup_start";
+    count: number;
+} | {
+    type: "authentications_lookup_complete";
+    count: number;
+} | {
+    type: "app_processing_start";
+    appKey: string;
+    slug?: string;
+} | {
+    type: "authentication_matched";
+    appKey: string;
+    authenticationId: number;
+    authenticationTitle: string;
+} | {
+    type: "authentication_not_matched";
+    appKey: string;
+} | {
+    type: "type_generated";
+    manifestKey: string;
+    sizeBytes: number;
+} | {
+    type: "file_written";
+    manifestKey: string;
+    filePath: string;
+} | {
+    type: "app_processing_complete";
+    appKey: string;
+} | {
+    type: "app_processing_error";
+    appKey: string;
+    error: string;
+};
+export interface GenerateAppTypesResult {
+    typeDefinitions: Record<string, string>;
+    writtenFiles?: Record<string, string>;
+    errors: Array<{
+        appKey: string;
+        error: string;
+    }>;
+}

package/dist/src/plugins/generateAppTypes/schemas.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export const GenerateAppTypesSchema = z
+    .object({
+    appKeys: z
+        .array(z.string().min(1, "App key cannot be empty"))
+        .min(1, "At least one app key is required")
+        .describe("One or more app keys to generate types for (e.g., 'slack', 'github', 'trello')"),
+    authenticationIds: z
+        .array(z.string())
+        .optional()
+        .describe("Authentication IDs to use for type generation (e.g., ['123', '456'])"),
+    skipWrite: z
+        .boolean()
+        .optional()
+        .describe("If true, returns type definitions without writing to disk. If false or omitted, writes type files."),
+    typesOutputDirectory: z
+        .string()
+        .optional()
+        .describe("Directory for TypeScript type files. Required when skipWrite is false or omitted."),
+})
+    .describe("Generate TypeScript type definitions for apps - can optionally write to disk or just return type strings");

package/dist/src/plugins/index.d.ts

@@ -4,3 +4,5 @@ export { mcpPlugin } from "./mcp";
 export { bundleCodePlugin } from "./bundleCode";
 export { getLoginConfigPathPlugin } from "./getLoginConfigPath";
 export { addPlugin } from "./add";
+export { generateAppTypesPlugin } from "./generateAppTypes";
+export { buildManifestPlugin } from "./buildManifest";

package/dist/src/plugins/index.js

@@ -4,3 +4,5 @@ export { mcpPlugin } from "./mcp";
 export { bundleCodePlugin } from "./bundleCode";
 export { getLoginConfigPathPlugin } from "./getLoginConfigPath";
 export { addPlugin } from "./add";
+export { generateAppTypesPlugin } from "./generateAppTypes";
+export { buildManifestPlugin } from "./buildManifest";