@zapier/zapier-sdk 0.8.3 → 0.10.0

package/dist/plugins/listInputFields/index.test.js

@@ -169,7 +169,7 @@ describe("listInputFields plugin", () => {
             expect(result.data).toHaveLength(3);
             // Check message field transformation
             expect(result.data[0]).toEqual(expect.objectContaining({
-                id: "message",
+                key: "message",
                 title: "Message",
                 description: "The message to send",
                 is_required: true,
@@ -177,22 +177,18 @@ describe("listInputFields plugin", () => {
                 placeholder: "Enter your message",
                 default_value: "",
             }));
-            // Check channel field with choices (SELECT format)
+            // Check channel field with SELECT format
             expect(result.data[1]).toEqual(expect.objectContaining({
-                id: "channel",
+                key: "channel",
                 title: "Channel",
                 description: "The channel to send to",
                 is_required: true,
                 value_type: "STRING",
                 format: "SELECT",
-                choices: [
-                    { value: "#general", label: "General", sample: "#general" },
-                    { value: "#random", label: "Random", sample: "#random" },
-                ],
             }));
             // Check array field
             expect(result.data[2]).toEqual(expect.objectContaining({
-                id: "tags",
+                key: "tags",
                 title: "Tags",
                 description: "List of tags",
                 value_type: "ARRAY",
@@ -321,7 +317,7 @@ describe("listInputFields plugin", () => {
                 items.push(item);
             }
             expect(items).toHaveLength(3);
-            expect(items[0].id).toBe("message");
+            expect(items[0].key).toBe("message");
         });
     });
 });

package/dist/plugins/listInputFields/schemas.d.ts

@@ -3,7 +3,9 @@ import type { InputFieldItem } from "../../types/domain";
 import type { PaginatedSdkFunction } from "../../types/functions";
 import type { ZapierConfigurationError, ZapierApiError, ZapierAuthenticationError, ZapierAppNotFoundError, ZapierValidationError, ZapierUnknownError } from "../../types/errors";
 export declare const ListInputFieldsSchema: z.ZodObject<{
-    appKey: z.ZodString;
+    appKey: z.ZodString & {
+        _def: z.ZodStringDef & import("../..").PositionalMetadata;
+    };
     actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
     actionKey: z.ZodString;
     authenticationId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
@@ -12,7 +14,7 @@ export declare const ListInputFieldsSchema: z.ZodObject<{
     maxItems: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     appKey: string;
-    actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    actionType: "filter" | "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write";
     actionKey: string;
     authenticationId?: number | null | undefined;
     inputs?: Record<string, unknown> | undefined;
@@ -20,7 +22,7 @@ export declare const ListInputFieldsSchema: z.ZodObject<{
     maxItems?: number | undefined;
 }, {
     appKey: string;
-    actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    actionType: "filter" | "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write";
     actionKey: string;
     authenticationId?: number | null | undefined;
     inputs?: Record<string, unknown> | undefined;

package/dist/plugins/listInputFields/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/listInputFields/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EACV,wBAAwB,EACxB,cAAc,EACd,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAG5B,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;EAoBgC,CAAC;AAGnE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAG3E,MAAM,MAAM,oBAAoB,GAC5B,wBAAwB,GACxB,cAAc,GACd,yBAAyB,GACzB,sBAAsB,GACtB,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,cAAc,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,WAAW,0BAA0B;IACzC,eAAe,EAAE,oBAAoB,CAAC,sBAAsB,EAAE,cAAc,CAAC,CAAC;CAC/E"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/listInputFields/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EACV,wBAAwB,EACxB,cAAc,EACd,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAG5B,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBgC,CAAC;AAGnE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAG3E,MAAM,MAAM,oBAAoB,GAC5B,wBAAwB,GACxB,cAAc,GACd,yBAAyB,GACzB,sBAAsB,GACtB,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,cAAc,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,WAAW,0BAA0B;IACzC,eAAe,EAAE,oBAAoB,CAAC,sBAAsB,EAAE,cAAc,CAAC,CAAC;CAC/E"}

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

@@ -1,22 +1,38 @@
-import type { GetImplementation, GetManifestEntry, GetVersionedImplementationId, Manifest, ManifestPluginOptionsSchema } from "./schemas";
-import type { GetSdkType, Plugin } from "../../types/plugin";
+import type { GetVersionedImplementationId, Manifest, ManifestEntry, ManifestPluginOptionsSchema, ResolveAppKeys } from "./schemas";
+import type { Plugin } from "../../types/plugin";
 import type { z } from "zod";
 import type { ApiClient } from "../../api";
-import type { ListAppsPluginProvides } from "../listApps";
 export type ManifestPluginOptions = z.infer<typeof ManifestPluginOptionsSchema>;
 export interface ManifestPluginProvides {
     context: {
         getVersionedImplementationId: GetVersionedImplementationId;
-        getManifestEntry: GetManifestEntry;
-        getImplementation: GetImplementation;
+        resolveAppKeys: ResolveAppKeys;
+        updateManifestEntry: (appKey: string, entry: ManifestEntry, configPath?: string) => Promise<[string, ManifestEntry]>;
     };
 }
 /**
- * Load manifest from a file path synchronously
- * Supports local files (Node.js only)
+ * Read manifest from a file path asynchronously
+ * Supports local files (Node.js) and browser environments (fallback to global filesystem)
  */
-export declare function loadManifestFromFile(filePath: string): Manifest | null;
-export declare const manifestPlugin: Plugin<GetSdkType<ListAppsPluginProvides>, {
+export declare function readManifestFromFile(filePath: string): Promise<Manifest | null>;
+/**
+ * Get the preferred key for storing an app in the manifest
+ * Extracted from plugin to make it easier to test
+ */
+export declare function getPreferredManifestEntryKey({ appKey, api, }: {
+    appKey: string;
+    api: ApiClient;
+}): Promise<string>;
+/**
+ * Find a manifest entry by any app key (implementation name, slug, etc.).
+ */
+export declare function findManifestEntry({ appKey, manifest, }: {
+    appKey: string;
+    manifest: Manifest;
+}): [string, ManifestEntry] | null;
+export { DEFAULT_CONFIG_PATH } from "./schemas";
+export declare const manifestPlugin: Plugin<{}, // no SDK dependencies
+{
     api: ApiClient;
 }, ManifestPluginProvides>;
 //# sourceMappingURL=index.d.ts.map

package/dist/plugins/manifest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/manifest/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,4BAA4B,EAC5B,QAAQ,EACR,2BAA2B,EAC5B,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAO1D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE;QACP,4BAA4B,EAAE,4BAA4B,CAAC;QAC3D,gBAAgB,EAAE,gBAAgB,CAAC;QACnC,iBAAiB,EAAE,iBAAiB,CAAC;KACtC,CAAC;CACH;AA2BD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAUtE;AAcD,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,UAAU,CAAC,sBAAsB,CAAC,EAClC;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAClB,sBAAsB,CA6FvB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/manifest/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,4BAA4B,EAC5B,QAAQ,EACR,aAAa,EACb,2BAA2B,EAC3B,cAAc,EACf,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAgB3C,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE;QACP,4BAA4B,EAAE,4BAA4B,CAAC;QAC3D,cAAc,EAAE,cAAc,CAAC;QAC/B,mBAAmB,EAAE,CACnB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,MAAM,KAChB,OAAO,CAAC,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;KACvC,CAAC;CACH;AA2BD;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAU1B;AAcD;;;GAGG;AACH,wBAAsB,4BAA4B,CAAC,EACjD,MAAM,EACN,GAAG,GACJ,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,SAAS,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAkClB;AAoCD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,MAAM,EACN,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;CACpB,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,IAAI,CAyBjC;AA8GD,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEhD,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EAAE,sBAAsB;AAC1B;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAClB,sBAAsB,CA8GvB,CAAC"}

package/dist/plugins/manifest/index.js

@@ -1,7 +1,9 @@
-import { readFileSync } from "fs";
-import { resolve } from "path";
-import { ManifestSchema } from "./schemas";
-import { normalizeImplementationToAppItem, splitVersionedKey, } from "../../utils/domain-utils";
+import { readFile, writeFile, resolve } from "../../utils/file-utils";
+import { ManifestSchema, DEFAULT_CONFIG_PATH } from "./schemas";
+import { normalizeImplementationMetaToAppItem, splitVersionedKey, isSnakeCasedSlug, dashifySnakeCasedSlug, toAppLocator, isResolvedAppLocator, } from "../../utils/domain-utils";
+import { extractCursor } from "../../utils/function-utils";
+import { paginate } from "../../utils/pagination-utils";
+import { toArrayFromAsync } from "../../utils/array-utils";
 /**
  * Parse manifest content from a string
  */
@@ -23,103 +25,273 @@ function parseManifestContent(content, source) {
     }
 }
 /**
- * Load manifest from a file path synchronously
- * Supports local files (Node.js only)
+ * Read manifest from a file path asynchronously
+ * Supports local files (Node.js) and browser environments (fallback to global filesystem)
  */
-export function loadManifestFromFile(filePath) {
+export async function readManifestFromFile(filePath) {
     try {
         // Resolve relative paths relative to current working directory
-        const resolvedPath = resolve(filePath);
-        const content = readFileSync(resolvedPath, "utf8");
+        const resolvedPath = await resolve(filePath);
+        const content = await readFile(resolvedPath);
         return parseManifestContent(content, resolvedPath);
     }
     catch {
-        console.warn(`⚠️ Failed to load manifest from ${filePath}`);
+        console.warn(`⚠️ Failed to read manifest from ${filePath}`);
         return null;
     }
 }
-const emitWarning = (appKey) => {
-    console.warn(`\n${"⚠️".padEnd(3)} ${"WARNING".padEnd(8)} No manifest version found for '${appKey}'`);
-    console.warn(`   ${"↳".padEnd(3)} Using a manifest ensures version locking and prevents unexpected behavior due to version changes.`);
-    console.warn(`   ${"↳".padEnd(3)} Generate/update the manifest with: \`zapier-sdk lock-version ${appKey}\`\n`);
-};
+/**
+ * Write manifest to a file path asynchronously
+ * Supports local files (Node.js) and browser environments (fallback to global filesystem)
+ */
+async function writeManifestToFile(manifest, filePath) {
+    const resolvedPath = await resolve(filePath);
+    await writeFile(resolvedPath, JSON.stringify(manifest, null, 2));
+}
+/**
+ * Get the preferred key for storing an app in the manifest
+ * Extracted from plugin to make it easier to test
+ */
+export async function getPreferredManifestEntryKey({ appKey, api, }) {
+    const locator = toAppLocator(appKey);
+    // If we have a slug, prefer it
+    if (locator.slug) {
+        return locator.slug;
+    }
+    // If we have implementation name, look up the latest to get the slug
+    if (locator.implementationName) {
+        try {
+            // API call to get app metadata by implementation name using selected_apis parameter
+            const implementationsEnvelope = await api.get(`/api/v4/implementations-meta/lookup/`, {
+                searchParams: {
+                    selected_apis: locator.implementationName,
+                },
+            });
+            if (implementationsEnvelope.results.length > 0 &&
+                implementationsEnvelope.results[0].slug) {
+                return implementationsEnvelope.results[0].slug;
+            }
+        }
+        catch {
+            // Fall back to implementation name if lookup fails
+        }
+        return locator.implementationName;
+    }
+    // Fall back to original key if we can't determine anything better
+    return locator.lookupAppKey;
+}
+async function listAppsForSlugsPage({ slugs, cursor, api, }) {
+    const searchParams = {};
+    if (slugs.length > 0) {
+        searchParams.slugs = slugs.join(",");
+    }
+    if (cursor) {
+        searchParams.offset = cursor;
+    }
+    const implementationsEnvelope = await api.get("/api/v4/implementations-meta/lookup/", {
+        searchParams,
+    });
+    return {
+        data: implementationsEnvelope.results.map(normalizeImplementationMetaToAppItem),
+        nextCursor: extractCursor(implementationsEnvelope),
+    };
+}
+/**
+ * Find a manifest entry by any app key (implementation name, slug, etc.).
+ */
+export function findManifestEntry({ appKey, manifest, }) {
+    const [appKeyWithoutVersion] = splitVersionedKey(appKey);
+    // Direct match by key
+    if (manifest.apps[appKeyWithoutVersion]) {
+        return [appKeyWithoutVersion, manifest.apps[appKeyWithoutVersion]];
+    }
+    // Handle snake-cased slugs (convert to dashed)
+    if (isSnakeCasedSlug(appKey)) {
+        const slug = dashifySnakeCasedSlug(appKey);
+        if (manifest.apps[slug]) {
+            return [slug, manifest.apps[slug]];
+        }
+    }
+    // Search by implementation name in manifest values
+    for (const [key, entry] of Object.entries(manifest.apps)) {
+        if (entry.implementationName === appKeyWithoutVersion) {
+            return [key, entry];
+        }
+    }
+    // No match found
+    return null;
+}
+/**
+ * Turn any app keys (slugs, implementation names, etc.) into app locators, which are objects that will be guaranteed to
+ * have implementation names. Note that this function will not actually guarantee that implementation names are valid!
+ * It will attempt to find the app key in the manifest, or if it's a slug, actually do an API call, or otherwise just
+ * assume it's an implementation name that will be used for an API call.
+ */
+async function resolveAppKeys({ appKeys, api, manifest, }) {
+    // Step 1: Convert all app keys to locators
+    const locators = appKeys.map(toAppLocator);
+    // Step 2: Map to resolved/unresolved via manifest
+    const locatorsWithManifest = locators.map((locator) => {
+        const manifestEntryResult = findManifestEntry({
+            appKey: locator.lookupAppKey,
+            manifest,
+        });
+        if (manifestEntryResult) {
+            const [, manifestEntry] = manifestEntryResult;
+            // Use manifest entry to resolve implementation name
+            const resolvedVersion = locator.version || manifestEntry.version;
+            const resolvedLocator = {
+                ...locator,
+                implementationName: manifestEntry.implementationName,
+                version: resolvedVersion,
+            };
+            return resolvedLocator;
+        }
+        // If these have an implementationName, they're already resolved.
+        return locator;
+    });
+    // Step 3: Separate resolved from unresolved
+    const unresolvedLocators = locatorsWithManifest.filter((locator) => !isResolvedAppLocator(locator));
+    // Step 4: Resolve slugs via API
+    const slugsToResolve = unresolvedLocators
+        .map((locator) => locator.slug)
+        .filter((slug) => !!slug)
+        .filter((slug, index, array) => array.indexOf(slug) === index); // dedupe
+    if (slugsToResolve.length === 0) {
+        return locatorsWithManifest.filter(isResolvedAppLocator);
+    }
+    const iterator = paginate(listAppsForSlugsPage, {
+        slugs: slugsToResolve,
+        api,
+    });
+    const pages = await toArrayFromAsync(iterator);
+    const apps = pages.flatMap((page) => page.data);
+    const slugToAppData = new Map();
+    for (const app of apps) {
+        if (app.slug) {
+            slugToAppData.set(app.slug, app);
+        }
+    }
+    const slugResolvedLocators = locatorsWithManifest.map((locator) => {
+        if (isResolvedAppLocator(locator)) {
+            return locator;
+        }
+        if (locator.slug) {
+            const appData = slugToAppData.get(locator.slug);
+            if (appData) {
+                // After resolving from API, check if we have a manifest entry for this implementation name
+                const manifestEntryByImplementationName = findManifestEntry({
+                    appKey: appData.key, // appData.key is the implementation name
+                    manifest,
+                });
+                let version = locator.version;
+                if (!version) {
+                    // Prefer manifest version if available, otherwise use API version
+                    version = manifestEntryByImplementationName
+                        ? manifestEntryByImplementationName[1].version || appData.version
+                        : appData.version;
+                }
+                return {
+                    ...locator,
+                    implementationName: appData.key,
+                    version,
+                };
+            }
+        }
+        return locator;
+    });
+    // Return all resolved locators.
+    return slugResolvedLocators.filter(isResolvedAppLocator);
+}
+export { DEFAULT_CONFIG_PATH } from "./schemas";
 export const manifestPlugin = (params) => {
-    const { sdk, context } = params;
+    const { context } = params;
     const { api, options } = context;
-    const { manifestPath = ".zapierrc", manifest } = options || {};
+    const { manifestPath = DEFAULT_CONFIG_PATH, manifest } = options || {};
     let resolvedManifest;
-    function resolveManifest() {
+    async function resolveManifest() {
         // If manifest is provided directly, use it
         if (manifest) {
             return manifest;
         }
         // If manifestPath is provided, load from file
         if (manifestPath) {
-            return loadManifestFromFile(manifestPath);
+            return await readManifestFromFile(manifestPath);
         }
         return null;
     }
-    const getResolvedManifest = () => {
+    const getResolvedManifest = async () => {
         if (typeof resolvedManifest === "undefined") {
-            resolvedManifest = resolveManifest() ?? null;
+            resolvedManifest = (await resolveManifest()) ?? null;
         }
         return resolvedManifest;
     };
-    const getManifestEntry = (appKey) => {
-        return getResolvedManifest()?.apps?.[appKey] || null;
+    const getVersionedImplementationId = async (appKey) => {
+        const resolvedApps = await resolveAppKeys({
+            appKeys: [appKey],
+            api,
+            manifest: (await getResolvedManifest()) ?? { apps: {} },
+        });
+        const resolvedApp = resolvedApps[0];
+        if (!resolvedApp)
+            return null;
+        return `${resolvedApp.implementationName}@${resolvedApp.version || "latest"}`;
     };
-    const getImplementation = async (appKey) => {
-        let selectedApi = null;
-        const manifestImplementation = getResolvedManifest()?.apps?.[appKey];
-        const [versionlessAppKey, version] = splitVersionedKey(appKey);
-        // Use versioned app key if provided
-        if (version) {
-            selectedApi = `${versionlessAppKey}@${version}`;
-            // Otherwise, use manifest entry if available
+    const updateManifestEntry = async (appKey, entry, configPath = DEFAULT_CONFIG_PATH) => {
+        const manifest = (await readManifestFromFile(configPath)) || { apps: {} };
+        // Try to find existing entry by direct key first
+        let existingEntry = findManifestEntry({
+            appKey,
+            manifest,
+        });
+        // If not found directly, try to resolve the app key and search by implementation name
+        if (!existingEntry) {
+            try {
+                const resolvedApps = await resolveAppKeys({
+                    appKeys: [appKey],
+                    api,
+                    manifest,
+                });
+                if (resolvedApps.length > 0) {
+                    const resolvedImplementationName = resolvedApps[0].implementationName;
+                    // Try to find entry using the resolved implementation name
+                    existingEntry = findManifestEntry({
+                        appKey: resolvedImplementationName,
+                        manifest,
+                    });
+                }
+            }
+            catch {
+                // If resolution fails, continue with original logic
+            }
         }
-        else if (manifestImplementation) {
-            selectedApi = `${manifestImplementation.implementationName}@${manifestImplementation.version || "latest"}`;
+        let manifestKey;
+        if (existingEntry) {
+            // Use existing key to maintain consistency with types files
+            manifestKey = existingEntry[0];
         }
-        if (selectedApi) {
-            const searchParams = {
-                selected_apis: selectedApi,
-            };
-            const implementationData = await api.get("/api/v4/implementations/", {
-                searchParams,
+        else {
+            // Get preferred key for new entries
+            manifestKey = await getPreferredManifestEntryKey({
+                appKey,
+                api,
             });
-            const implementationResults = implementationData.results[0];
-            if (!implementationResults)
-                return null;
-            return normalizeImplementationToAppItem(implementationResults);
-        }
-        emitWarning(appKey);
-        const appsIterator = sdk.listApps({ appKeys: [appKey] }).items();
-        const apps = [];
-        for await (const app of appsIterator) {
-            apps.push(app);
-            break; // Only need the first result
         }
-        if (apps.length === 0) {
-            return null;
-        }
-        const app = apps[0];
-        return app;
-    };
-    const getVersionedImplementationId = async (appKey) => {
-        const manifestEntry = getManifestEntry(appKey);
-        if (manifestEntry) {
-            return `${manifestEntry.implementationName}@${manifestEntry.version || "latest"}`;
-        }
-        const implementation = await getImplementation(appKey);
-        if (!implementation)
-            return null;
-        return implementation.current_implementation_id;
+        manifest.apps[manifestKey] = entry;
+        await writeManifestToFile(manifest, configPath);
+        // Clear the cached manifest so it gets reloaded with the new data
+        resolvedManifest = undefined;
+        return [manifestKey, entry];
     };
     return {
         context: {
             getVersionedImplementationId,
-            getManifestEntry,
-            getImplementation,
+            resolveAppKeys: async ({ appKeys }) => resolveAppKeys({
+                appKeys,
+                api,
+                manifest: (await getResolvedManifest()) ?? { apps: {} },
+            }),
+            updateManifestEntry,
         },
     };
 };