@cognite/dune 0.3.1 → 0.3.3

package/bin/utils/crypto.js

@@ -4,9 +4,8 @@
  * Provides functions for generating secure random strings and PKCE code challenges.
  */
 
-import crypto from "node:crypto";
+import crypto from 'node:crypto';
 
-// biome-ignore lint/complexity/noStaticOnlyClass: Utility class pattern
 export class CryptoUtils {
   /**
    * Generate a cryptographically secure random string
@@ -16,10 +15,10 @@ export class CryptoUtils {
   static generateRandomString(length) {
     const bytes = crypto.randomBytes(length);
     return bytes
-      .toString("base64")
-      .replace(/\+/g, "-")
-      .replace(/\//g, "_")
-      .replace(/=/g, "")
+      .toString('base64')
+      .replace(/\+/g, '-')
+      .replace(/\//g, '_')
+      .replace(/=/g, '')
       .slice(0, length);
   }
 
@@ -29,7 +28,7 @@ export class CryptoUtils {
    * @returns {string} Base64url-encoded SHA256 hash of the verifier
    */
   static generateCodeChallenge(verifier) {
-    const hash = crypto.createHash("sha256").update(verifier).digest();
-    return hash.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    const hash = crypto.createHash('sha256').update(verifier).digest();
+    return hash.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
   }
 }

package/dist/auth/index.d.ts

@@ -1,31 +1,28 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as _cognite_sdk from '@cognite/sdk';
+import * as react from 'react';
+import { ReactNode } from 'react';
 import { CogniteClient } from '@cognite/sdk';
-import React from 'react';
 
-declare const DuneAuthProviderContext: React.Context<{
+interface DuneContextValue {
     sdk: CogniteClient;
     isLoading: boolean;
     error?: string;
-}>;
+}
+declare const DuneAuthProviderContext: react.Context<DuneContextValue>;
 interface DuneAuthProviderProps {
-    children: React.ReactNode;
+    children: ReactNode;
     useIFrameAuthentication?: boolean;
     useLocalConfiguration?: {
         org: string;
         project: string;
         baseUrl: string;
     };
-    loadingComponent?: React.ReactNode;
-    errorComponent?: (error: string) => React.ReactNode;
+    loadingComponent?: ReactNode;
+    errorComponent?: (error: string) => ReactNode;
 }
 declare const DuneAuthProvider: ({ children, loadingComponent, errorComponent, }: DuneAuthProviderProps) => react_jsx_runtime.JSX.Element;
 
-declare const useDune: () => {
-    sdk: _cognite_sdk.CogniteClient;
-    isLoading: boolean;
-    error?: string;
-};
+declare const useDune: () => DuneContextValue;
 
 interface CDFConfig {
     project: string;
@@ -38,4 +35,4 @@ declare const getToken: (clientId: string, clientSecret: string) => Promise<any>
 declare const createCDFSDK: (config: CDFConfig) => Promise<CogniteClient>;
 declare const EMPTY_SDK: CogniteClient;
 
-export { type CDFConfig, DuneAuthProvider, DuneAuthProviderContext, type DuneAuthProviderProps, EMPTY_SDK, createCDFSDK, getToken, useDune };
+export { type CDFConfig, DuneAuthProvider, DuneAuthProviderContext, type DuneAuthProviderProps, type DuneContextValue, EMPTY_SDK, createCDFSDK, getToken, useDune };

package/dist/auth/index.js

@@ -5,7 +5,7 @@ import {
   createCDFSDK,
   getToken,
   useDune
-} from "../chunk-VIBN7U5H.js";
+} from "../chunk-53VTKDSC.js";
 export {
   DuneAuthProvider,
   DuneAuthProviderContext,

package/dist/{chunk-VIBN7U5H.js → chunk-53VTKDSC.js}

@@ -1,7 +1,6 @@
 // src/auth/dune-auth-provider.tsx
 import { CogniteClient as CogniteClient2 } from "@cognite/sdk";
-import { createContext, useEffect } from "react";
-import { useState } from "react";
+import { createContext, useEffect, useState } from "react";
 
 // src/auth/utils.ts
 import { CogniteClient } from "@cognite/sdk";

package/dist/deploy/index.d.ts

@@ -7,6 +7,10 @@ type Deployment = {
     deployClientId: string;
     deploySecretName: string;
     published: boolean;
+    /** Identity provider type. Defaults to "cdf" if not specified */
+    idpType?: "cdf" | "entra_id";
+    /** Tenant ID for Entra ID authentication. Required when idpType is "entra_id" */
+    tenantId?: string;
 };
 type App = {
     externalId: string;
@@ -85,6 +89,10 @@ declare class ApplicationPackager {
 
 declare const getSdk: (deployment: Deployment, folder: string) => Promise<CogniteClient>;
 
-declare const getToken: (deployClientId: string, deploySecretName: string) => Promise<any>;
+/**
+ * Get access token for deployment using the appropriate identity provider.
+ * Supports both CDF OAuth and Entra ID (Azure AD) authentication.
+ */
+declare const getToken: (deployment: Deployment) => Promise<string>;
 
 export { type App, ApplicationPackager, CdfApplicationDeployer, type Deployment, deploy, getSdk, getToken };

package/dist/deploy/index.js

@@ -187,22 +187,39 @@ var loadSecretsFromEnv = () => {
     return {};
   }
 };
-var getToken = async (deployClientId, deploySecretName) => {
+var getSecretFromEnv = (secretEnvVarName) => {
   let deploySecret;
   if (process.env.DEPLOYMENT_SECRET) {
     deploySecret = process.env.DEPLOYMENT_SECRET;
   }
   if (!deploySecret) {
     const secrets = loadSecretsFromEnv();
-    deploySecret = secrets[deploySecretName];
+    deploySecret = secrets[secretEnvVarName];
   }
   if (!deploySecret) {
-    deploySecret = process.env[deploySecretName];
+    deploySecret = process.env[secretEnvVarName];
   }
   if (!deploySecret) {
-    throw new Error(`Deployment secret not found in environment: ${deploySecretName}`);
+    throw new Error(`Secret not found in environment: ${secretEnvVarName}`);
   }
-  const header = `Basic ${btoa(`${deployClientId}:${deploySecret}`)}`;
+  return deploySecret;
+};
+var extractClusterFromUrl = (url) => {
+  if (!url) return "";
+  try {
+    const urlObj = new URL(url);
+    const hostname = urlObj.hostname;
+    return hostname.replace(/\.cognitedata\.com$/, "");
+  } catch {
+    let cluster = url.replace(/^https?:\/\//, "");
+    cluster = cluster.split("/")[0];
+    cluster = cluster.split(":")[0];
+    cluster = cluster.replace(/\.cognitedata\.com$/, "");
+    return cluster;
+  }
+};
+var getTokenCdf = async (clientId, clientSecret) => {
+  const header = `Basic ${btoa(`${clientId}:${clientSecret}`)}`;
   const response = await fetch("https://auth.cognite.com/oauth2/token", {
     method: "POST",
     headers: {
@@ -212,15 +229,80 @@ var getToken = async (deployClientId, deploySecretName) => {
     body: new URLSearchParams({ grant_type: "client_credentials" })
   });
   if (!response.ok) {
-    throw new Error(`Failed to get token: ${response.status} ${response.statusText}`);
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to get token from CDF: ${response.status} ${response.statusText}
+${errorText}`
+    );
   }
   const data = await response.json();
+  if (!data.access_token) {
+    throw new Error("No access token returned from CDF authentication");
+  }
   return data.access_token;
 };
+var getTokenEntra = async (clientId, clientSecret, tenantId, baseUrl) => {
+  if (!baseUrl) {
+    throw new Error(
+      "Entra ID authentication requires 'baseUrl' to be set in deployment configuration"
+    );
+  }
+  const cluster = extractClusterFromUrl(baseUrl);
+  if (!cluster) {
+    throw new Error(
+      `Entra ID authentication requires 'baseUrl' to be a valid CDF URL (e.g., https://cluster.cognitedata.com), got: ${baseUrl}`
+    );
+  }
+  const tokenUrl = `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`;
+  const scope = `https://${cluster}.cognitedata.com/.default`;
+  const response = await fetch(tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      client_id: clientId,
+      client_secret: clientSecret,
+      scope,
+      grant_type: "client_credentials"
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to get token from Entra ID: ${response.status} ${response.statusText}
+${errorText}`
+    );
+  }
+  const data = await response.json();
+  if (!data.access_token) {
+    throw new Error("No access token returned from Entra ID authentication");
+  }
+  return data.access_token;
+};
+var getToken = async (deployment) => {
+  const {
+    deployClientId,
+    deploySecretName,
+    idpType = "cdf",
+    tenantId,
+    baseUrl
+  } = deployment;
+  const deploySecret = getSecretFromEnv(deploySecretName);
+  if (idpType === "entra_id") {
+    if (!tenantId) {
+      throw new Error(
+        "Entra ID authentication requires 'tenantId' in deployment configuration"
+      );
+    }
+    return getTokenEntra(deployClientId, deploySecret, tenantId, baseUrl);
+  }
+  return getTokenCdf(deployClientId, deploySecret);
+};
 
 // src/deploy/get-sdk.ts
 var getSdk = async (deployment, folder) => {
-  const token = await getToken(deployment.deployClientId, deployment.deploySecretName);
+  const token = await getToken(deployment);
   const sdk = new CogniteClient({
     appId: folder,
     project: deployment.project,

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { CDFConfig, DuneAuthProvider, DuneAuthProviderContext, DuneAuthProviderProps, EMPTY_SDK, createCDFSDK, getToken, useDune } from './auth/index.js';
+export { CDFConfig, DuneAuthProvider, DuneAuthProviderContext, DuneAuthProviderProps, DuneContextValue, EMPTY_SDK, createCDFSDK, getToken, useDune } from './auth/index.js';
 import 'react/jsx-runtime';
-import '@cognite/sdk';
 import 'react';
+import '@cognite/sdk';

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   createCDFSDK,
   getToken,
   useDune
-} from "./chunk-VIBN7U5H.js";
+} from "./chunk-53VTKDSC.js";
 export {
   DuneAuthProvider,
   DuneAuthProviderContext,

package/dist/vite/index.d.ts

@@ -5,6 +5,7 @@ interface ViteDevServer {
         } | string | null;
         on: (event: string, callback: () => void) => void;
     } | null;
+    printUrls: () => void;
 }
 declare const fusionOpenPlugin: () => {
     name: string;

package/dist/vite/index.js

@@ -14,7 +14,7 @@ var fusionOpenPlugin = () => {
   return {
     name: "fusion-open",
     configureServer(server) {
-      server.httpServer?.on("listening", () => {
+      server.printUrls = () => {
         const address = server.httpServer?.address();
         const port = address && typeof address === "object" ? address.port : 3001;
         const appJsonPath = path.join(process.cwd(), "app.json");
@@ -26,13 +26,16 @@ var fusionOpenPlugin = () => {
             const parsedBaseUrl = baseUrl?.split("//")[1];
             if (org && project && baseUrl) {
               const fusionUrl = `https://${org}.fusion.cognite.com/${project}/streamlit-apps/dune/development/${port}?cluster=${parsedBaseUrl}&workspace=industrial-tools`;
+              console.log(`  \u279C  Fusion: ${fusionUrl}`);
               openUrl(fusionUrl);
+              return;
             }
           } catch (error) {
             console.warn("Failed to read app.json for Fusion URL", error);
           }
         }
-      });
+        console.warn("  \u279C  No valid app.json found \u2014 cannot determine Fusion URL");
+      };
     }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/dune",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Build and deploy React apps to Cognite Data Fusion",
   "keywords": ["cognite", "dune", "cdf", "fusion", "react", "scaffold", "deploy"],
   "license": "Apache-2.0",

package/src/auth/dune-auth-provider.tsx

@@ -1,24 +1,25 @@
-import { CogniteClient } from "@cognite/sdk";
-import type React from "react";
-import { createContext, useEffect } from "react";
-import { useState } from "react";
-import { EMPTY_SDK, handleCredentialsResponse, requestCredentials } from "./utils";
+import { CogniteClient } from '@cognite/sdk';
+import { createContext, useEffect, useState, type ReactNode } from 'react';
 
-export const DuneAuthProviderContext = createContext<{
+import { EMPTY_SDK, handleCredentialsResponse, requestCredentials } from './utils';
+
+export interface DuneContextValue {
   sdk: CogniteClient;
   isLoading: boolean;
   error?: string;
-}>({
+}
+
+export const DuneAuthProviderContext = createContext<DuneContextValue>({
   sdk: EMPTY_SDK,
   isLoading: false,
 });
 
 export interface DuneAuthProviderProps {
-  children: React.ReactNode;
+  children: ReactNode;
   useIFrameAuthentication?: boolean;
   useLocalConfiguration?: { org: string; project: string; baseUrl: string };
-  loadingComponent?: React.ReactNode;
-  errorComponent?: (error: string) => React.ReactNode;
+  loadingComponent?: ReactNode;
+  errorComponent?: (error: string) => ReactNode;
 }
 
 export const DuneAuthProvider = ({
@@ -50,7 +51,7 @@ export const FusionIframeAuthenticationInnerProvider = ({
     requestCredentials();
 
     const handleMessage = async (event: MessageEvent) => {
-      console.log("🔍 Handling message from Fusion");
+      console.log('🔍 Handling message from Fusion');
 
       const credentials = handleCredentialsResponse(event);
 
@@ -60,7 +61,7 @@ export const FusionIframeAuthenticationInnerProvider = ({
 
       // Process credentials (initial or refresh)
       const sdk = new CogniteClient({
-        appId: "dune-app",
+        appId: 'dune-app',
         project: credentials.project,
         baseUrl: credentials.baseUrl,
         oidcTokenProvider: async () => {
@@ -74,12 +75,12 @@ export const FusionIframeAuthenticationInnerProvider = ({
       setIsLoading(false);
     };
 
-    console.log("🔍 Adding message listener");
-    window.addEventListener("message", handleMessage);
-    return () => window.removeEventListener("message", handleMessage);
+    console.log('🔍 Adding message listener');
+    window.addEventListener('message', handleMessage);
+    return () => window.removeEventListener('message', handleMessage);
   }, []);
 
-  console.log("🔍 CDFIframeAuthenticationInnerProvider", sdk, isLoading, error);
+  console.log('🔍 CDFIframeAuthenticationInnerProvider', sdk, isLoading, error);
 
   if (error && errorComponent) {
     return <>{errorComponent(error)}</>;

package/src/auth/index.ts

@@ -2,10 +2,10 @@
 export {
   DuneAuthProvider,
   DuneAuthProviderContext,
-} from "./dune-auth-provider";
-export { useDune } from "./use-dune";
-export { getToken, createCDFSDK, EMPTY_SDK } from "./utils";
+} from './dune-auth-provider';
+export { useDune } from './use-dune';
+export { getToken, createCDFSDK, EMPTY_SDK } from './utils';
 
 // Type exports
-export type { CDFConfig } from "./utils";
-export type { DuneAuthProviderProps } from "./dune-auth-provider";
+export type { CDFConfig } from './utils';
+export type { DuneAuthProviderProps, DuneContextValue } from './dune-auth-provider';

package/src/auth/use-dune.ts

@@ -1,11 +1,12 @@
-import { useContext } from "react";
-import { DuneAuthProviderContext } from "./dune-auth-provider";
+import { useContext } from 'react';
 
-export const useDune = () => {
+import { DuneAuthProviderContext, type DuneContextValue } from './dune-auth-provider';
+
+export const useDune = (): DuneContextValue => {
   const context = useContext(DuneAuthProviderContext);
 
   if (!context) {
-    throw new Error("useDune must be used within a DuneAuthProvider");
+    throw new Error('useDune must be used within a DuneAuthProvider');
   }
 
   return context;

package/src/auth/utils.ts

@@ -1,10 +1,10 @@
-import { CogniteClient } from "@cognite/sdk";
+import { CogniteClient } from '@cognite/sdk';
 
 export const MESSAGE_TYPES = {
-  APP_HOST_READY: "APP_HOST_READY",
-  APP_READY: "APP_READY",
-  CREDENTIALS: "CREDENTIALS",
-  REQUEST_CREDENTIALS: "REQUEST_CREDENTIALS",
+  APP_HOST_READY: 'APP_HOST_READY',
+  APP_READY: 'APP_READY',
+  CREDENTIALS: 'CREDENTIALS',
+  REQUEST_CREDENTIALS: 'REQUEST_CREDENTIALS',
 } as const;
 
 export interface CDFConfig {
@@ -18,14 +18,14 @@ export interface CDFConfig {
 export const getToken = async (clientId: string, clientSecret: string) => {
   const header = `Basic ${btoa(`${clientId}:${clientSecret}`)}`;
 
-  const response = await fetch("https://auth.cognite.com/oauth2/token", {
-    method: "POST",
+  const response = await fetch('https://auth.cognite.com/oauth2/token', {
+    method: 'POST',
     headers: {
       Authorization: header,
-      "Content-Type": "application/x-www-form-urlencoded",
+      'Content-Type': 'application/x-www-form-urlencoded',
     },
     body: new URLSearchParams({
-      grant_type: "client_credentials",
+      grant_type: 'client_credentials',
     }),
   });
 
@@ -34,11 +34,11 @@ export const getToken = async (clientId: string, clientSecret: string) => {
 };
 
 export const createCDFSDK = async (config: CDFConfig) => {
-  const { project, baseUrl, clientId, clientSecret, appId = "cdf-authentication-package" } = config;
+  const { project, baseUrl, clientId, clientSecret, appId = 'cdf-authentication-package' } = config;
 
   if (!project || !baseUrl || !clientId || !clientSecret) {
     throw new Error(
-      "Missing required configuration. Please provide: project, baseUrl, clientId, clientSecret"
+      'Missing required configuration. Please provide: project, baseUrl, clientId, clientSecret'
     );
   }
 
@@ -56,9 +56,9 @@ export const createCDFSDK = async (config: CDFConfig) => {
 };
 
 export const EMPTY_SDK = new CogniteClient({
-  appId: "cdf-authentication-package",
-  project: "",
-  oidcTokenProvider: async () => "",
+  appId: 'cdf-authentication-package',
+  project: '',
+  oidcTokenProvider: async () => '',
 });
 
 interface Credentials {
@@ -68,18 +68,18 @@ interface Credentials {
 }
 
 export const requestCredentials = () => {
-  console.log("🔑 Requesting credentials from parent...");
+  console.log('🔑 Requesting credentials from parent...');
   if (window.parent && window.parent !== window) {
-    window.parent.postMessage({ type: "REQUEST_CREDENTIALS" }, "*");
+    window.parent.postMessage({ type: 'REQUEST_CREDENTIALS' }, '*');
   }
 };
 
 export const handleCredentialsResponse = (event: MessageEvent) => {
   // Check if this is a credentials message (wrapped in type/credentials format)
-  if (event.data?.type === "PROVIDE_CREDENTIALS" && event.data?.credentials) {
+  if (event.data?.type === 'PROVIDE_CREDENTIALS' && event.data?.credentials) {
     const creds = event.data.credentials;
     if (creds.token && creds.baseUrl && creds.project) {
-      console.log("🎉 useCredentials received credentials:", {
+      console.log('🎉 useCredentials received credentials:', {
         hasToken: !!creds.token,
         tokenLength: creds.token?.length || 0,
         project: creds.project,

package/src/deploy/application-deployer.ts

@@ -4,8 +4,9 @@
  * Handles deployment of packaged applications to CDF.
  */
 
-import fs from "node:fs";
-import type { CogniteClient } from "@cognite/sdk";
+import fs from 'node:fs';
+
+import type { CogniteClient } from '@cognite/sdk';
 
 export class CdfApplicationDeployer {
   private client: CogniteClient;
@@ -17,7 +18,7 @@ export class CdfApplicationDeployer {
     this.client = client;
   }
 
-  private DATA_SET_EXTERNAL_ID = "published-custom-apps";
+  private DATA_SET_EXTERNAL_ID = 'published-custom-apps';
 
   /**
    * Validate that the required data set exists and is accessible
@@ -36,8 +37,8 @@ export class CdfApplicationDeployer {
         const created = await this.client.datasets.create([
           {
             externalId: this.DATA_SET_EXTERNAL_ID,
-            name: "Published Custom Apps",
-            description: "Published Custom Apps",
+            name: 'Published Custom Apps',
+            description: 'Published Custom Apps',
             writeProtected: false,
           },
         ]);
@@ -69,11 +70,11 @@ export class CdfApplicationDeployer {
     published = false
   ): Promise<void> {
     // Validate data set exists and get its ID
-    console.log("🔍 Validating data set access...");
+    console.log('🔍 Validating data set access...');
     const dataSetId = await this.validateDataSet();
     console.log(`✅ Data set '${this.DATA_SET_EXTERNAL_ID}' validated (ID: ${dataSetId})\n`);
 
-    console.log("📁 Creating file record...");
+    console.log('📁 Creating file record...');
 
     const fileContent = fs.readFileSync(zipFilename);
     const metadata = {
@@ -88,7 +89,7 @@ export class CdfApplicationDeployer {
       {
         name: `${appExternalId}-${versionTag}.zip`,
         externalId: `${appExternalId}-${versionTag}`,
-        directory: "/dune-apps",
+        directory: '/dune-apps',
         metadata: metadata,
         dataSetId: dataSetId,
       },
@@ -97,7 +98,7 @@ export class CdfApplicationDeployer {
       true // waitUntilAcknowledged
     );
 
-    console.log("✅ File record created");
+    console.log('✅ File record created');
   }
 
   /**
@@ -117,7 +118,7 @@ export class CdfApplicationDeployer {
     zipFilename: string,
     published = false
   ): Promise<void> {
-    console.log("\n🚀 Deploying application to CDF...\n");
+    console.log('\n🚀 Deploying application to CDF...\n');
 
     try {
       // Upload to Files API
@@ -130,7 +131,7 @@ export class CdfApplicationDeployer {
         published
       );
 
-      console.log("\n✅ Deployment successful!");
+      console.log('\n✅ Deployment successful!');
     } catch (error: unknown) {
       const message = error instanceof Error ? error.message : String(error);
       throw new Error(`Deployment failed: ${message}`);

package/src/deploy/application-packager.ts

@@ -4,9 +4,10 @@
  * Handles packaging of build directories into deployment-ready zip files.
  */
 
-import fs from "node:fs";
-import path from "node:path";
-import archiver from "archiver";
+import fs from 'node:fs';
+import path from 'node:path';
+
+import archiver from 'archiver';
 
 export class ApplicationPackager {
   private distPath: string;
@@ -14,7 +15,7 @@ export class ApplicationPackager {
   /**
    * @param {string} distDirectory - Build directory to package (can be relative or absolute)
    */
-  constructor(distDirectory = "dist") {
+  constructor(distDirectory = 'dist') {
     // If distDirectory is already an absolute path, use it as-is
     // Otherwise, join it with the current working directory
     this.distPath = path.isAbsolute(distDirectory)
@@ -38,29 +39,29 @@ export class ApplicationPackager {
    * @param {boolean} verbose - Enable verbose logging
    * @returns {Promise<string>} Path to created zip file
    */
-  async createZip(outputFilename = "app.zip", verbose = false): Promise<string> {
+  async createZip(outputFilename = 'app.zip', verbose = false): Promise<string> {
     this.validateBuildDirectory();
 
-    console.log("📦 Packaging application...");
+    console.log('📦 Packaging application...');
 
     return new Promise((resolve, reject) => {
       const output = fs.createWriteStream(outputFilename);
-      const archive = archiver("zip", {
+      const archive = archiver('zip', {
         zlib: { level: 9 }, // Maximum compression
       });
 
-      output.on("close", () => {
+      output.on('close', () => {
         const sizeMB = (archive.pointer() / 1024 / 1024).toFixed(2);
         console.log(`✅ App packaged: ${outputFilename} (${sizeMB} MB)`);
         resolve(outputFilename);
       });
 
-      archive.on("error", (err: Error) => {
+      archive.on('error', (err: Error) => {
         reject(new Error(`Failed to create zip: ${err.message}`));
       });
 
       if (verbose) {
-        archive.on("entry", (entry: archiver.EntryData) => {
+        archive.on('entry', (entry: archiver.EntryData) => {
           console.log(`  📄 ${entry.name}`);
         });
       }