@zapier/zapier-sdk 0.15.2 → 0.15.4

package/dist/index.cjs

@@ -2721,6 +2721,17 @@ async function readFile(filePath) {
   throw new Error(`File not found: ${filePath}`);
 }
 var DEFAULT_CONFIG_PATH = ".zapierrc";
+var ActionEntrySchema = zod.z.object({
+  appKey: zod.z.string().describe("App key (slug or implementation name)"),
+  actionKey: zod.z.string().describe("Action key identifier"),
+  actionType: zod.z.string().describe("Action type (e.g., 'read', 'write', 'search')"),
+  authenticationId: zod.z.number().nullable().optional().describe("Authentication ID used"),
+  inputs: zod.z.record(zod.z.unknown()).optional().describe("Resolved input values"),
+  schema: zod.z.record(zod.z.unknown()).describe(
+    "Complete JSON Schema from getInputFieldsSchema (includes $schema, type, properties, required, etc.)"
+  ),
+  createdAt: zod.z.string().describe("ISO 8601 timestamp when created")
+});
 var ManifestSchema = zod.z.object({
   apps: zod.z.record(
     zod.z.string(),
@@ -2730,8 +2741,9 @@ var ManifestSchema = zod.z.object({
       ),
       version: zod.z.string().describe("Version string (e.g., '1.21.1')")
     })
-  )
-}).describe("Manifest mapping app keys to version information");
+  ),
+  actions: zod.z.record(zod.z.string(), ActionEntrySchema).optional().describe("Saved action configurations with their schemas")
+}).describe("Manifest for app version locking and action configurations");
 zod.z.object({
   manifestPath: zod.z.string().optional().describe("Path to manifest file"),
   manifest: zod.z.record(
@@ -3002,7 +3014,81 @@ var manifestPlugin = (params) => {
       await writeManifestToFile(updatedManifest, configPath);
       resolvedManifest = void 0;
     }
-    return [manifestKey, entry, updatedManifest];
+    return {
+      key: manifestKey,
+      entry,
+      manifest: updatedManifest
+    };
+  };
+  const addActionEntry = async (options2) => {
+    const {
+      name,
+      entry,
+      configPath = DEFAULT_CONFIG_PATH,
+      skipWrite = false,
+      manifest: inputManifest
+    } = options2;
+    const manifest2 = inputManifest || await readManifestFromFile(configPath) || { apps: {} };
+    const actions = manifest2.actions || {};
+    if (actions[name] && !skipWrite) {
+      throw new Error(
+        `Action "${name}" already exists. Please choose a different name or remove the existing action first.`
+      );
+    }
+    const updatedManifest = {
+      ...manifest2,
+      actions: {
+        ...actions,
+        [name]: entry
+      }
+    };
+    if (!skipWrite) {
+      await writeManifestToFile(updatedManifest, configPath);
+      resolvedManifest = void 0;
+    }
+    return {
+      name,
+      entry,
+      manifest: updatedManifest
+    };
+  };
+  const findActionEntry = ({
+    name,
+    manifest: manifest2
+  }) => {
+    return manifest2.actions?.[name] || null;
+  };
+  const listActionEntries = async ({
+    configPath = DEFAULT_CONFIG_PATH
+  } = {}) => {
+    const manifest2 = await readManifestFromFile(configPath) || { };
+    return Object.entries(manifest2.actions || {});
+  };
+  const deleteActionEntry = async ({
+    name,
+    configPath = DEFAULT_CONFIG_PATH,
+    skipWrite = false
+  }) => {
+    const manifest2 = await readManifestFromFile(configPath) || { apps: {} };
+    if (!manifest2.actions?.[name]) {
+      throw new Error(`Action "${name}" does not exist.`);
+    }
+    const { [name]: removed, ...remainingActions } = manifest2.actions;
+    const updatedManifest = {
+      ...manifest2,
+      actions: remainingActions
+    };
+    if (!skipWrite) {
+      await writeManifestToFile(updatedManifest, configPath);
+      resolvedManifest = void 0;
+    }
+    return updatedManifest;
+  };
+  const hasActionEntry = ({
+    name,
+    manifest: manifest2
+  }) => {
+    return !!manifest2.actions?.[name];
   };
   return {
     context: {
@@ -3012,7 +3098,14 @@ var manifestPlugin = (params) => {
         api,
         manifest: await getResolvedManifest() ?? { apps: {} }
       }),
-      updateManifestEntry
+      updateManifestEntry,
+      addActionEntry,
+      findActionEntry,
+      listActionEntries,
+      deleteActionEntry,
+      hasActionEntry,
+      findManifestEntry,
+      readManifestFromFile
     }
   };
 };
@@ -3106,6 +3199,34 @@ function getAuthorizationHeader(token) {
   }
   return `Bearer ${token}`;
 }
+function extractUserIdsFromJwt(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      return { customuser_id: null, account_id: null };
+    }
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf-8")
+    );
+    let actualPayload = payload;
+    if (payload.sub_type === "service" && payload.njwt) {
+      const nestedParts = payload.njwt.split(".");
+      if (nestedParts.length === 3) {
+        actualPayload = JSON.parse(
+          Buffer.from(nestedParts[1], "base64url").toString("utf-8")
+        );
+      }
+    }
+    const accountId = actualPayload["zap:acc"] != null ? parseInt(String(actualPayload["zap:acc"]), 10) : null;
+    const customUserId = actualPayload.sub_type === "customuser" && actualPayload.sub != null ? parseInt(String(actualPayload.sub), 10) : null;
+    return {
+      customuser_id: customUserId !== null && !isNaN(customUserId) ? customUserId : null,
+      account_id: accountId !== null && !isNaN(accountId) ? accountId : null
+    };
+  } catch {
+    return { customuser_id: null, account_id: null };
+  }
+}
 
 // src/api/debug.ts
 var utilModule = null;
@@ -4502,7 +4623,7 @@ function getCpuTime() {
 
 // package.json
 var package_default = {
-  version: "0.15.2"};
+  version: "0.15.4"};
 
 // src/plugins/eventEmission/builders.ts
 function createBaseEvent(context = {}) {
@@ -4573,17 +4694,26 @@ function buildErrorEventWithContext(data, context = {}) {
 }
 
 // src/plugins/eventEmission/index.ts
+var TELEMETRY_EMIT_TIMEOUT_MS = 300;
 var APPLICATION_LIFECYCLE_EVENT_SUBJECT = "platform.sdk.ApplicationLifecycleEvent";
 var ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
 var transportStates = /* @__PURE__ */ new WeakMap();
-async function silentEmit(transport, subject, event) {
+async function silentEmit(transport, subject, event, userContextPromise) {
   try {
     let state = transportStates.get(transport);
     if (!state) {
       state = { hasWorked: false, hasLoggedFailure: false };
       transportStates.set(transport, state);
     }
-    transport.emit(subject, event).then(() => {
+    let enrichedEvent = event;
+    if (userContextPromise) {
+      try {
+        const userContext = await userContextPromise;
+        enrichedEvent = Object.assign({}, event, userContext);
+      } catch {
+      }
+    }
+    transport.emit(subject, enrichedEvent).then(() => {
       state.hasWorked = true;
     }).catch((error) => {
       if (!state.hasWorked && !state.hasLoggedFailure) {
@@ -4631,6 +4761,19 @@ var eventEmissionPlugin = ({ context }) => {
       )
     )
   };
+  const getUserContext = (async () => {
+    try {
+      const { getToken } = await import('@zapier/zapier-sdk-cli-login');
+      const token = await getToken({
+        baseUrl: context.options.baseUrl
+      });
+      if (token) {
+        return extractUserIdsFromJwt(token);
+      }
+    } catch {
+    }
+    return { customuser_id: null, account_id: null };
+  })();
   const startupTime = Date.now();
   let shutdownStartTime = null;
   if (!config.enabled) {
@@ -4641,7 +4784,7 @@ var eventEmissionPlugin = ({ context }) => {
           config,
           emit: () => {
           },
-          createBaseEvent: () => ({
+          createBaseEvent: async () => ({
             event_id: generateEventId(),
             timestamp_ms: getCurrentTimestamp(),
             release_id: getReleaseId(),
@@ -4661,21 +4804,34 @@ var eventEmissionPlugin = ({ context }) => {
   } catch {
     transport = createTransport({ type: "noop" });
   }
-  const createBaseEventHelper = () => ({
-    event_id: generateEventId(),
-    timestamp_ms: getCurrentTimestamp(),
-    release_id: getReleaseId(),
-    customuser_id: null,
-    account_id: null,
-    identity_id: null,
-    visitor_id: null,
-    correlation_id: null
-  });
+  const createBaseEventHelper = async () => {
+    const baseEvent = {
+      event_id: generateEventId(),
+      timestamp_ms: getCurrentTimestamp(),
+      release_id: getReleaseId(),
+      customuser_id: null,
+      account_id: null,
+      identity_id: null,
+      visitor_id: null,
+      correlation_id: null
+    };
+    try {
+      const userContext = await getUserContext;
+      return { ...baseEvent, ...userContext };
+    } catch {
+      return baseEvent;
+    }
+  };
   if (config.enabled) {
     const startupEvent = buildApplicationLifecycleEvent({
       lifecycle_event_type: "startup"
     });
-    silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, startupEvent);
+    silentEmit(
+      transport,
+      APPLICATION_LIFECYCLE_EVENT_SUBJECT,
+      startupEvent,
+      getUserContext
+    );
     if (typeof process?.on === "function") {
       process.on("exit", (code) => {
         const uptime = Date.now() - startupTime;
@@ -4687,10 +4843,15 @@ var eventEmissionPlugin = ({ context }) => {
           is_graceful_shutdown: code === 0,
           shutdown_duration_ms: shutdownDuration
         });
-        silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, exitEvent);
+        silentEmit(
+          transport,
+          APPLICATION_LIFECYCLE_EVENT_SUBJECT,
+          exitEvent,
+          getUserContext
+        );
       });
       process.on("uncaughtException", async (error) => {
-        const errorEvent = buildErrorEventWithContext({
+        let errorEvent = buildErrorEventWithContext({
           error_message: error.message || "Unknown error",
           error_type: "UncaughtException",
           error_stack_trace: error.stack || null,
@@ -4699,10 +4860,17 @@ var eventEmissionPlugin = ({ context }) => {
           is_recoverable: false,
           execution_start_time: startupTime
         });
+        try {
+          const userContext = await getUserContext;
+          errorEvent = { ...errorEvent, ...userContext };
+        } catch {
+        }
         try {
           await Promise.race([
             transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-            new Promise((resolve2) => setTimeout(resolve2, 300))
+            new Promise(
+              (resolve2) => setTimeout(resolve2, TELEMETRY_EMIT_TIMEOUT_MS)
+            )
           ]);
         } catch {
         }
@@ -4712,7 +4880,7 @@ var eventEmissionPlugin = ({ context }) => {
         async (reason, promise) => {
           const errorMessage = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
           const errorStack = reason instanceof Error ? reason.stack : null;
-          const errorEvent = buildErrorEventWithContext({
+          let errorEvent = buildErrorEventWithContext({
             error_message: errorMessage,
             error_type: "UnhandledRejection",
             error_stack_trace: errorStack,
@@ -4724,10 +4892,17 @@ var eventEmissionPlugin = ({ context }) => {
               promise: String(promise)
             }
           });
+          try {
+            const userContext = await getUserContext;
+            errorEvent = { ...errorEvent, ...userContext };
+          } catch {
+          }
           try {
             await Promise.race([
               transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-              new Promise((resolve2) => setTimeout(resolve2, 300))
+              new Promise(
+                (resolve2) => setTimeout(resolve2, TELEMETRY_EMIT_TIMEOUT_MS)
+              )
             ]);
           } catch {
           }
@@ -4736,16 +4911,23 @@ var eventEmissionPlugin = ({ context }) => {
       const handleSignal = async (signal) => {
         shutdownStartTime = Date.now();
         const uptime = Date.now() - startupTime;
-        const signalEvent = buildApplicationLifecycleEvent({
+        let signalEvent = buildApplicationLifecycleEvent({
           lifecycle_event_type: "signal_termination",
           signal_name: signal,
           uptime_ms: uptime,
           is_graceful_shutdown: true
         });
+        try {
+          const userContext = await getUserContext;
+          signalEvent = { ...signalEvent, ...userContext };
+        } catch {
+        }
         try {
           await Promise.race([
             transport.emit(APPLICATION_LIFECYCLE_EVENT_SUBJECT, signalEvent),
-            new Promise((resolve2) => setTimeout(resolve2, 300))
+            new Promise(
+              (resolve2) => setTimeout(resolve2, TELEMETRY_EMIT_TIMEOUT_MS)
+            )
           ]);
         } catch {
         }
@@ -4761,7 +4943,7 @@ var eventEmissionPlugin = ({ context }) => {
         transport,
         config,
         emit: (subject, event) => {
-          silentEmit(transport, subject, event);
+          silentEmit(transport, subject, event, getUserContext);
         },
         createBaseEvent: createBaseEventHelper
       }