@cognite/dune 0.3.7 → 0.4.0

package/_templates/app/new/root/app.json.ejs.t

@@ -6,6 +6,9 @@ to: '<%= useCurrentDir ? "" : ((directoryName || name) + "/") %>app.json'
   "description": "<%= description %>",
   "externalId": "<%= name %>",
   "versionTag": "0.0.1",
+<% if (infra === 'appsApi') { -%>
+  "infra": "appsApi",
+<% } -%>
   "deployments": [
     {
       "org": "<%= org %>",

package/_templates/app/new/src/App.tsx.ejs.t

@@ -61,7 +61,21 @@ const CHECKLIST_STEPS = [
 ] as const;
 
 function App() {
-  const { sdk, isLoading } = useDune();
+  const { sdk, isLoading, error } = useDune();
+
+  if (error) {
+    return (
+      <main className="min-h-screen bg-muted/50 text-foreground">
+        <section className="mx-auto flex min-h-screen w-full max-w-lg flex-col justify-center p-4 sm:p-8">
+          <div className="mx-auto w-full max-w-sm">
+            <Alert variant="destructive" aria-label="Authentication error" aria-live="assertive">
+              <AlertDescription>{error}</AlertDescription>
+            </Alert>
+          </div>
+        </section>
+      </main>
+    );
+  }
 
   if (isLoading) {
     return (

package/_templates/app/new/src/main.tsx.ejs.t

@@ -1,7 +1,11 @@
 ---
 to: '<%= useCurrentDir ? "" : ((directoryName || name) + "/") %>src/main.tsx'
 ---
+<% if (infra === 'appsApi') { -%>
+import { AppSdkAuthProvider } from '@cognite/dune';
+<% } else { -%>
 import { DuneAuthProvider } from '@cognite/dune';
+<% } -%>
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import React from 'react';
 import ReactDOM from 'react-dom/client';
@@ -22,9 +26,15 @@ const queryClient = new QueryClient({
 ReactDOM.createRoot(document.getElementById('root')!).render(
   <React.StrictMode>
     <QueryClientProvider client={queryClient}>
+<% if (infra === 'appsApi') { -%>
+      <AppSdkAuthProvider>
+        <App />
+      </AppSdkAuthProvider>
+<% } else { -%>
       <DuneAuthProvider>
         <App />
       </DuneAuthProvider>
+<% } -%>
     </QueryClientProvider>
   </React.StrictMode>
 );

package/bin/cli.js

@@ -31,7 +31,7 @@ const defaultTemplates = resolve(dirname(fileURLToPath(import.meta.url)), '..',
  * @param {Function} onAppName - Callback to track the app name
  * @returns {() => object} Function that returns a prompter object with prompt method
  */
-export function createAppPrompter(isCurrentDir, dirName, enquirer, onAppName) {
+export function createAppPrompter(isCurrentDir, dirName, enquirer, onAppName, infra) {
   // IMPORTANT: All code paths below must set useCurrentDir (true or false) because
   // templates rely on it being defined. It's never undefined.
   return () => ({
@@ -52,8 +52,7 @@ export function createAppPrompter(isCurrentDir, dirName, enquirer, onAppName) {
         if (result.name && onAppName) {
           onAppName(result.name);
         }
-        // Add useCurrentDir variable for templates
-        return { ...result, useCurrentDir: true, directoryName: undefined };
+        return { ...result, useCurrentDir: true, directoryName: undefined, infra };
       }
       // If directory argument is provided, pre-fill the name prompt with directory name
       if (dirName) {
@@ -71,15 +70,13 @@ export function createAppPrompter(isCurrentDir, dirName, enquirer, onAppName) {
         if (result.name && onAppName) {
           onAppName(result.name);
         }
-        // Pass directoryName for folder structure, name for template content
-        return { ...result, directoryName: dirName, useCurrentDir: false };
+        return { ...result, directoryName: dirName, useCurrentDir: false, infra };
       }
       const result = await enquirer.default.prompt(prompts);
       if (result.name && onAppName) {
         onAppName(result.name);
       }
-      // No directory provided, so directoryName is undefined (templates will use name)
-      return { ...result, useCurrentDir: false, directoryName: undefined };
+      return { ...result, useCurrentDir: false, directoryName: undefined, infra };
     },
   });
 }
@@ -93,12 +90,15 @@ async function main() {
     // TODO(DUNE-362): simplify directory resolution logic
     // Parse directory argument
     // Support: npx @cognite/dune create . or npx @cognite/dune .
+    const useNewInfra = args.includes('--newinfra');
+    const filteredArgs = args.filter((a) => a !== '--newinfra');
+    const infra = useNewInfra ? 'appsApi' : undefined;
+
     let dirArg;
     if (command === '.') {
-      // If first arg is ".", treat it as directory argument with no command
       dirArg = '.';
     } else if (command === 'create' || command === 'new') {
-      dirArg = args[1];
+      dirArg = filteredArgs[1];
     }
     // When !command: no args, dirArg stays undefined (create app interactively)
     const isCurrentDir = dirArg === '.' || dirArg === './';
@@ -125,7 +125,7 @@ async function main() {
         logger: new Logger(console.log.bind(console)),
         createPrompter: createAppPrompter(isCurrentDir, dirName, enquirer, (name) => {
           appName = name;
-        }),
+        }, infra),
         exec: async (action, body) => {
           const { execa } = await import('execa');
           const opts = body && body.length > 0 ? { input: body } : {};
@@ -210,14 +210,18 @@ Commands:
   skills             Manage AI agent skills (pull, push, list)
   help               Show this help message
 
+Options:
+  --newinfra             Use the new App Hosting infrastructure (create only)
+
 Examples:
-  npx @cognite/dune                    # Create a new app (interactive)
-  npx @cognite/dune create             # Create a new app (interactive)
-  npx @cognite/dune create [directory] # Create app in [directory] subfolder
-  npx @cognite/dune create .           # Create app in current directory (. is special)
-  npx @cognite/dune deploy             # Deploy with env credentials
-  npx @cognite/dune deploy:interactive # Deploy with browser login
-  npx @cognite/dune skills pull        # Pull AI skills into your project
+  npx @cognite/dune                              # Create a new app (interactive)
+  npx @cognite/dune create                       # Create a new app (interactive)
+  npx @cognite/dune create --newinfra            # Create app using new App Hosting infra
+  npx @cognite/dune create [directory]           # Create app in [directory] subfolder
+  npx @cognite/dune create .                     # Create app in current directory (. is special)
+  npx @cognite/dune deploy                       # Deploy with env credentials
+  npx @cognite/dune deploy:interactive           # Deploy with browser login
+  npx @cognite/dune skills pull                  # Pull AI skills into your project
 
 For programmatic usage:
   import { DuneAuthProvider, useDune } from "@cognite/dune/auth"

package/bin/deploy-command.js

@@ -2,19 +2,7 @@ import { execSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
-/**
- * Generate Fusion app URL
- */
-function generateFusionUrl(deployment, appExternalId, versionTag) {
-  const { org, project, baseUrl } = deployment;
-  const cluster = baseUrl?.split('//')[1];
-
-  if (!org || !project || !cluster) {
-    return null;
-  }
-
-  return `https://${org}.fusion.cognite.com/${project}/streamlit-apps/dune/${appExternalId}-${versionTag}?cluster=${cluster}&workspace=industrial-tools`;
-}
+import { generateFusionUrl } from './utils/fusion-url.js';
 
 /**
  * Load app.json from a directory
@@ -214,6 +202,7 @@ export async function handleDeploy(args) {
         name: appConfig.name,
         description: appConfig.description,
         versionTag: appConfig.versionTag,
+        infra: appConfig.infra,
       },
       cwd
     );
@@ -229,7 +218,7 @@ export async function handleDeploy(args) {
     }
 
     // Generate and display the app URL
-    const appUrl = generateFusionUrl(deployment, appConfig.externalId, appConfig.versionTag);
+    const appUrl = generateFusionUrl(deployment, appConfig.externalId, appConfig.versionTag, appConfig.infra);
     if (appUrl) {
       console.log(`\n🔗 Open your app:\n   ${appUrl}`);
     }

package/bin/deploy-interactive-command.js

@@ -10,20 +10,7 @@ import os from 'node:os';
 import path, { resolve } from 'node:path';
 
 import { AuthenticationFlow } from './auth/authentication-flow.js';
-
-/**
- * Generate Fusion app URL
- */
-function generateFusionUrl(deployment, appExternalId, versionTag) {
-  const { org, project, baseUrl } = deployment;
-  const cluster = baseUrl?.split('//')[1];
-
-  if (!org || !project || !cluster) {
-    return null;
-  }
-
-  return `https://${org}.fusion.cognite.com/${project}/streamlit-apps/dune/${appExternalId}-${versionTag}?cluster=${cluster}&workspace=industrial-tools`;
-}
+import { generateFusionUrl } from './utils/fusion-url.js';
 
 // Default OAuth configuration for CDF
 const DEFAULT_CONFIG = {
@@ -324,40 +311,52 @@ export async function handleDeployInteractive(args) {
     console.log('\n✅ Authentication successful!');
     console.log(`\n📤 Deploying to ${deployment.project}...`);
 
-    // Import CogniteClient and deployer classes
-    const { CogniteClient } = await import('@cognite/sdk');
-    const { CdfApplicationDeployer, ApplicationPackager } = await import('../dist/deploy/index.js');
-
-    // Create SDK with the obtained token
-    const sdk = new CogniteClient({
-      appId: appConfig.externalId,
-      project: deployment.project,
-      baseUrl: deployment.baseUrl,
-      getToken: async () => tokens.access_token,
-    });
-    await sdk.authenticate();
+    const { ApplicationPackager } = await import('../dist/deploy/index.js');
 
     // Package the application
     const distPath = `${cwd}/dist`;
     const packager = new ApplicationPackager(distPath);
     const zipFilename = await packager.createZip('app.zip', true);
 
-    // Deploy to CDF
-    const deployer = new CdfApplicationDeployer(sdk);
-    await deployer.deploy(
-      appConfig.externalId,
-      appConfig.name,
-      appConfig.description,
-      appConfig.versionTag,
-      zipFilename,
-      deployment.published
-    );
-
-    // Clean up zip file
     try {
-      unlinkSync(zipFilename);
-    } catch {
-      // Ignore cleanup errors
+      const { CogniteClient } = await import('@cognite/sdk');
+      const sdk = new CogniteClient({
+        appId: appConfig.externalId,
+        project: deployment.project,
+        baseUrl: deployment.baseUrl,
+        getToken: async () => tokens.access_token,
+      });
+      await sdk.authenticate();
+
+      if (appConfig.infra === 'appsApi') {
+        const { AppHostingDeployer } = await import('../dist/deploy/index.js');
+        const deployer = new AppHostingDeployer(sdk);
+        await deployer.deploy(
+          appConfig.externalId,
+          appConfig.name,
+          appConfig.description,
+          appConfig.versionTag,
+          zipFilename,
+          deployment.published || published,
+        );
+      } else {
+        const { CdfApplicationDeployer } = await import('../dist/deploy/index.js');
+        const deployer = new CdfApplicationDeployer(sdk);
+        await deployer.deploy(
+          appConfig.externalId,
+          appConfig.name,
+          appConfig.description,
+          appConfig.versionTag,
+          zipFilename,
+          deployment.published || published,
+        );
+      }
+    } finally {
+      try {
+        unlinkSync(zipFilename);
+      } catch {
+        // Ignore cleanup errors
+      }
     }
 
     console.log(`\n✅ Successfully deployed ${appConfig.name} to ${deployment.project}`);
@@ -369,7 +368,7 @@ export async function handleDeployInteractive(args) {
     }
 
     // Generate and display the app URL
-    const appUrl = generateFusionUrl(deployment, appConfig.externalId, appConfig.versionTag);
+    const appUrl = generateFusionUrl(deployment, appConfig.externalId, appConfig.versionTag, appConfig.infra);
     if (appUrl) {
       console.log(`\n🔗 Open your app:\n   ${appUrl}`);
     }

package/bin/utils/fusion-url.js

@@ -0,0 +1,28 @@
+/**
+ * Generate a Fusion app URL from deployment config and app metadata.
+ *
+ * @param {object} deployment - Deployment config (org, project, baseUrl)
+ * @param {string} appExternalId - App external ID
+ * @param {string} versionTag - Version tag (used for legacy infra URL only)
+ * @param {string} [infra] - Infrastructure type; "appsApi" uses the new dune-app-host path
+ * @returns {string|null} URL, or null if required fields are missing
+ */
+export function generateFusionUrl(deployment, appExternalId, versionTag, infra) {
+  const { org, project, baseUrl } = deployment;
+  let cluster = null;
+  try {
+    cluster = baseUrl ? new URL(baseUrl).host : null;
+  } catch {
+    // baseUrl is not a valid URL; cluster stays null and we return null below
+  }
+
+  if (!org || !project || !cluster) {
+    return null;
+  }
+
+  if (infra === 'appsApi') {
+    return `https://${org}.fusion.cognite.com/${project}/dune-app-host/app/${encodeURIComponent(appExternalId)}?cluster=${cluster}`;
+  }
+
+  return `https://${org}.fusion.cognite.com/${project}/streamlit-apps/dune/${encodeURIComponent(appExternalId)}-${versionTag}?cluster=${cluster}&workspace=industrial-tools`;
+}

package/bin/utils/fusion-url.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import { generateFusionUrl } from './fusion-url.js';
+
+const BASE_DEPLOYMENT = {
+  org: 'acme',
+  project: 'my-project',
+  baseUrl: 'https://cognite.test',
+};
+
+describe(generateFusionUrl.name, () => {
+  it('returns null when org is missing', () => {
+    const result = generateFusionUrl({ ...BASE_DEPLOYMENT, org: '' }, 'app-id', '1.0.0');
+    expect(result).toBeNull();
+  });
+
+  it('returns null when project is missing', () => {
+    const result = generateFusionUrl({ ...BASE_DEPLOYMENT, project: '' }, 'app-id', '1.0.0');
+    expect(result).toBeNull();
+  });
+
+  it('returns null when baseUrl yields no cluster', () => {
+    // 'no-protocol' is not a valid URL, so new URL() throws and cluster stays null
+    const result = generateFusionUrl({ ...BASE_DEPLOYMENT, baseUrl: 'no-protocol' }, 'app-id', '1.0.0');
+    expect(result).toBeNull();
+  });
+
+  it('returns legacy URL when infra is undefined', () => {
+    const result = generateFusionUrl(BASE_DEPLOYMENT, 'my-app', '1.2.3');
+    expect(result).toBe(
+      'https://acme.fusion.cognite.com/my-project/streamlit-apps/dune/my-app-1.2.3?cluster=cognite.test&workspace=industrial-tools'
+    );
+  });
+
+  it('returns App Hosting URL when infra is appsApi', () => {
+    const result = generateFusionUrl(BASE_DEPLOYMENT, 'my-app', '1.2.3', 'appsApi');
+    expect(result).toBe(
+      'https://acme.fusion.cognite.com/my-project/dune-app-host/app/my-app?cluster=cognite.test'
+    );
+  });
+
+  it('extracts cluster from baseUrl hostname', () => {
+    const result = generateFusionUrl(
+      { ...BASE_DEPLOYMENT, baseUrl: 'https://az-ams-sp-002.cognitedata.com' },
+      'my-app',
+      '1.0.0'
+    );
+    expect(result).toContain('cluster=az-ams-sp-002.cognitedata.com');
+  });
+});

package/dist/auth/index.d.ts

@@ -3,6 +3,19 @@ import * as react from 'react';
 import { ReactNode } from 'react';
 import { CogniteClient } from '@cognite/sdk';
 
+interface AppSdkAuthProviderProps {
+    children: ReactNode;
+    loadingComponent?: ReactNode;
+    errorComponent?: (error: string) => ReactNode;
+}
+/**
+ * Auth provider for apps running in the new Fusion app host (dune-app-host).
+ * Uses @cognite/app-sdk's Comlink handshake to connect to the host and obtain
+ * tokens on-demand. Exposes the same DuneContextValue ({ sdk, isLoading,
+ * error }) as DuneAuthProvider so useDune() works unchanged.
+ */
+declare const AppSdkAuthProvider: ({ children, loadingComponent, errorComponent, }: AppSdkAuthProviderProps) => react_jsx_runtime.JSX.Element;
+
 interface DuneContextValue {
     sdk: CogniteClient;
     isLoading: boolean;
@@ -35,4 +48,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, type DuneContextValue, EMPTY_SDK, createCDFSDK, getToken, useDune };
+export { AppSdkAuthProvider, type CDFConfig, DuneAuthProvider, DuneAuthProviderContext, type DuneAuthProviderProps, type DuneContextValue, EMPTY_SDK, createCDFSDK, getToken, useDune };

package/dist/auth/index.js

@@ -1,12 +1,14 @@
 import {
+  AppSdkAuthProvider,
   DuneAuthProvider,
   DuneAuthProviderContext,
   EMPTY_SDK,
   createCDFSDK,
   getToken,
   useDune
-} from "../chunk-53VTKDSC.js";
+} from "../chunk-XWZCFZUH.js";
 export {
+  AppSdkAuthProvider,
   DuneAuthProvider,
   DuneAuthProviderContext,
   EMPTY_SDK,

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

@@ -1,3 +1,8 @@
+// src/auth/app-sdk-auth-provider.tsx
+import { connectToHostApp } from "@cognite/app-sdk";
+import { CogniteClient as CogniteClient3 } from "@cognite/sdk";
+import { useEffect as useEffect2, useState as useState2 } from "react";
+
 // src/auth/dune-auth-provider.tsx
 import { CogniteClient as CogniteClient2 } from "@cognite/sdk";
 import { createContext, useEffect, useState } from "react";
@@ -131,6 +136,50 @@ var FusionIframeAuthenticationInnerProvider = ({
   return /* @__PURE__ */ jsx(DuneAuthProviderContext.Provider, { value: { sdk, isLoading, error }, children });
 };
 
+// src/auth/app-sdk-auth-provider.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var AppSdkAuthProvider = ({
+  children,
+  loadingComponent = /* @__PURE__ */ jsx2("div", { children: "Loading CDF authentication..." }),
+  errorComponent = (error) => /* @__PURE__ */ jsxs2("div", { children: [
+    "Authentication error: ",
+    error
+  ] })
+}) => {
+  const [sdk, setSdk] = useState2(EMPTY_SDK);
+  const [isLoading, setIsLoading] = useState2(true);
+  const [error, setError] = useState2();
+  useEffect2(() => {
+    connectToHostApp().then(async ({ api }) => {
+      const [project, baseUrl] = await Promise.all([
+        api.getProject(),
+        api.getBaseUrl()
+      ]);
+      const client = new CogniteClient3({
+        appId: "dune-app",
+        project,
+        baseUrl,
+        oidcTokenProvider: async () => api.getAccessToken()
+      });
+      await client.authenticate();
+      setSdk(client);
+      setError(void 0);
+    }).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+    }).finally(() => {
+      setIsLoading(false);
+    });
+  }, []);
+  if (error && errorComponent) {
+    return /* @__PURE__ */ jsx2(Fragment2, { children: errorComponent(error) });
+  }
+  if (isLoading && loadingComponent) {
+    return /* @__PURE__ */ jsx2(Fragment2, { children: loadingComponent });
+  }
+  return /* @__PURE__ */ jsx2(DuneAuthProviderContext.Provider, { value: { sdk, isLoading, error }, children });
+};
+
 // src/auth/use-dune.ts
 import { useContext } from "react";
 var useDune = () => {
@@ -147,5 +196,6 @@ export {
   EMPTY_SDK,
   DuneAuthProviderContext,
   DuneAuthProvider,
+  AppSdkAuthProvider,
   useDune
 };

package/dist/cli/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+// cli/cli.ts
+import { Command } from "commander";
+
+// cli/commands/skills.ts
+import { execFileSync } from "child_process";
+import { createRequire } from "module";
+import { InvalidArgumentError } from "commander";
+var SKILL_SOURCE = "cognitedata/dune-skills";
+var SUPPORTED_AGENTS = ["claude-code", "cursor"];
+var AGENT_FLAGS = SUPPORTED_AGENTS.flatMap((agent) => ["-a", agent]);
+var SKILLS_BIN = createRequire(import.meta.url).resolve("skills/bin/cli.mjs");
+function execSkillsCli(args, options = {}) {
+  execFileSync(process.execPath, [SKILLS_BIN, ...args], {
+    stdio: "inherit",
+    cwd: process.cwd(),
+    ...options
+  });
+}
+function validateSource(value) {
+  if (!/^[\w.-]+\/[\w.-]+$/.test(value)) {
+    throw new InvalidArgumentError(
+      "Expected owner/repo format (e.g., cognitedata/dune-skills)"
+    );
+  }
+  return value;
+}
+function buildPullArgs(options) {
+  const args = ["add", options.source, ...AGENT_FLAGS];
+  if (options.skill) {
+    args.push("--skill", options.skill);
+  } else if (!options.interactive) {
+    args.push("--skill", "*", "-y");
+  }
+  if (options.global) {
+    args.push("--global");
+  }
+  return args;
+}
+function handlePull(options) {
+  console.log(`\u{1F504} Pulling skills from ${options.source}...`);
+  execSkillsCli(buildPullArgs(options));
+  console.log("\n\u2705 Skills pulled successfully");
+}
+function registerSkillsCommand(parent) {
+  const skills = parent.command("skills").description("Manage AI agent skills for your Dune app");
+  skills.command("pull").description("Pull all skills into your project").option(
+    "--source <owner/repo>",
+    "Skills repository",
+    validateSource,
+    SKILL_SOURCE
+  ).option("--skill <name>", "Pull a specific skill by name").option("-i, --interactive", "Interactively select which skills to install", false).option("--global", "Install skills globally", false).action(handlePull);
+  skills.command("list").description("List installed skills").action(() => {
+    execSkillsCli(["list"]);
+  });
+}
+
+// cli/cli.ts
+var program = new Command();
+program.name("dune").description("Build and deploy React apps to Cognite Data Fusion").version("0.4.0");
+registerSkillsCommand(program);
+program.parse();

package/dist/deploy/index.d.ts

@@ -17,10 +17,50 @@ type App = {
     name: string;
     description: string;
     versionTag: string;
+    /** When set to "appsApi", deploy uses the App Hosting API instead of Files API */
+    infra?: "appsApi";
 };
 
 declare const deploy: (deployment: Deployment, app: App, folder: string) => Promise<void>;
 
+/**
+ * App Hosting API Deployment
+ *
+ * Handles deployment of packaged applications via the new App Hosting API
+ * instead of CDF Files API + dataset.
+ */
+
+declare class AppHostingDeployer {
+    private client;
+    constructor(client: CogniteClient);
+    private get appsBasePath();
+    /**
+     * Ensure the app exists in the App Hosting service. Creates it if missing.
+     */
+    ensureApp(externalId: string, name: string, description: string): Promise<void>;
+    /**
+     * Upload a new version of the app as a zip file.
+     *
+     * `entryPath` must be a relative path (no leading slash). The App
+     * Hosting backend rejects absolute paths as a security measure against
+     * archive traversal, see `ZipCentralDirectory.normalizeEntryPath` in
+     * infrastructure/services/app-hosting.
+     */
+    uploadVersion(appExternalId: string, version: string, zipPath: string, entryPath?: string): Promise<void>;
+    /**
+     * Publish the version and set it as the ACTIVE alias.
+     */
+    publishAndActivate(appExternalId: string, version: string): Promise<void>;
+    /**
+     * Full deployment: ensure app exists, upload version, and optionally publish and activate.
+     *
+     * When `published` is false the version is uploaded in DRAFT state with no alias —
+     * it is stored but not served to end users. Pass `published: true` to transition the
+     * version to PUBLISHED and set it as the ACTIVE alias so it starts receiving traffic.
+     */
+    deploy(appExternalId: string, name: string, description: string, versionTag: string, zipPath: string, published?: boolean): Promise<void>;
+}
+
 /**
  * CDF Application Deployment
  *
@@ -95,4 +135,4 @@ declare const getSdk: (deployment: Deployment, folder: string) => Promise<Cognit
  */
 declare const getToken: (deployment: Deployment) => Promise<string>;
 
-export { type App, ApplicationPackager, CdfApplicationDeployer, type Deployment, deploy, getSdk, getToken };
+export { type App, AppHostingDeployer, ApplicationPackager, CdfApplicationDeployer, type Deployment, deploy, getSdk, getToken };