@cognite/dune 0.1.2 → 0.2.0

package/bin/deploy-interactive-command.js

@@ -0,0 +1,382 @@
+/**
+ * Interactive Deploy Command
+ *
+ * Handles deployment with browser-based OAuth login instead of environment variables.
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { 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`;
+}
+
+// Default OAuth configuration for CDF
+const DEFAULT_CONFIG = {
+  authority: "https://auth.cognite.com",
+  clientId: "c6f97d29-79a5-48ac-85de-1de8229226cb", // CDF CLI public client ID
+  redirectUri: "https://localhost:3000",
+  port: 3000,
+  loginTimeout: 5 * 60 * 1000, // 5 minutes
+  certDir: path.join(os.homedir(), ".cdf-login"),
+};
+
+/**
+ * Load app.json from a directory
+ */
+function loadAppConfig(appDir) {
+  const configPath = resolve(appDir, "app.json");
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch (error) {
+    console.error(`Error parsing app.json: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Detect the package manager being used
+ */
+function detectPackageManager(appDir) {
+  if (existsSync(resolve(appDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(resolve(appDir, "yarn.lock"))) return "yarn";
+  if (existsSync(resolve(appDir, "bun.lockb"))) return "bun";
+  return "npm";
+}
+
+/**
+ * Build the app
+ */
+function buildApp(appDir, verbose = true) {
+  const pm = detectPackageManager(appDir);
+  console.log(`📦 Building app with ${pm}...`);
+
+  execSync(`${pm} run build`, {
+    cwd: appDir,
+    stdio: verbose ? "inherit" : "pipe",
+  });
+
+  console.log("✅ Build successful");
+}
+
+/**
+ * Print help message
+ */
+function printHelp() {
+  console.log(`
+Deploy your Dune app to Cognite Data Fusion (Interactive Login)
+
+Usage:
+  npx @cognite/dune deploy:interactive [options]
+
+Options:
+  --base-url <url>            CDF base URL (e.g., https://api.cognitedata.com)
+  --project <project>         CDF project name
+  --org <organization>        Organization hint for login
+  --deployment, -d <target>   Deployment target from app.json (index or name)
+  --skip-build                Skip the build step
+  --published                 Deploy as published (default: draft)
+  --help, -h                  Show this help message
+
+Description:
+  This command opens a browser window for you to log in to CDF.
+  No environment variables or secrets are required - authentication
+  is handled through your browser session.
+
+  If no options are provided, you'll be prompted to select a deployment
+  target from app.json or enter custom values.
+
+Examples:
+  npx @cognite/dune deploy:interactive                  # Interactive prompts
+  npx @cognite/dune deploy:interactive -d 0             # Use first deployment
+  npx @cognite/dune deploy:interactive --base-url https://api.cognitedata.com --project my-project
+`);
+}
+
+/**
+ * Interactive deploy command handler
+ */
+export async function handleDeployInteractive(args) {
+  // Check for help first
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const cwd = process.cwd();
+
+  // Load app.json
+  const appConfig = loadAppConfig(cwd);
+  if (!appConfig) {
+    console.error("❌ No app.json found in current directory");
+    console.error("Make sure you're running this command from your app's root directory.");
+    process.exit(1);
+  }
+
+  // Parse arguments
+  let baseUrl = null;
+  let project = null;
+  let organization = null;
+  let deploymentIndex = null;
+  let skipBuild = false;
+  let published = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--base-url") {
+      baseUrl = args[++i];
+    } else if (arg === "--project") {
+      project = args[++i];
+    } else if (arg === "--org") {
+      organization = args[++i];
+    } else if (arg === "--deployment" || arg === "-d") {
+      const value = args[++i];
+      if (value === undefined) {
+        console.error("❌ --deployment requires a value (index or project name)");
+        process.exit(1);
+      }
+      const idx = Number.parseInt(value, 10);
+      if (!Number.isNaN(idx)) {
+        deploymentIndex = idx;
+      } else if (appConfig.deployments) {
+        const found = appConfig.deployments.findIndex(
+          (d) => d.project === value || `${d.org}/${d.project}` === value
+        );
+        if (found === -1) {
+          console.error(`❌ No deployment found for project: ${value}`);
+          console.log("Available deployments:");
+          appConfig.deployments.forEach((d, i) => {
+            console.log(`  ${i}: ${d.org}/${d.project}`);
+          });
+          process.exit(1);
+        }
+        deploymentIndex = found;
+      }
+    } else if (arg === "--skip-build") {
+      skipBuild = true;
+    } else if (arg === "--published") {
+      published = true;
+    }
+  }
+
+  // Determine deployment target
+  let deployment;
+  const enquirer = await import("enquirer");
+
+  if (baseUrl && project) {
+    // Use CLI-provided values
+    deployment = {
+      baseUrl,
+      project,
+      org: organization || "unknown",
+      published,
+    };
+  } else if (deploymentIndex !== null) {
+    // Use deployment from app.json by index
+    if (
+      !appConfig.deployments ||
+      deploymentIndex < 0 ||
+      deploymentIndex >= appConfig.deployments.length
+    ) {
+      console.error(`❌ Invalid deployment index: ${deploymentIndex}`);
+      if (appConfig.deployments) {
+        console.log(`Available deployments (0-${appConfig.deployments.length - 1}):`);
+        appConfig.deployments.forEach((d, i) => {
+          console.log(`  ${i}: ${d.org}/${d.project}`);
+        });
+      }
+      process.exit(1);
+    }
+    deployment = appConfig.deployments[deploymentIndex];
+  } else if (appConfig.deployments && appConfig.deployments.length > 0) {
+    // Prompt user to select from existing deployments or enter custom
+    const choices = [
+      ...appConfig.deployments.map((d) => `${d.org}/${d.project}`),
+      "Enter custom target...",
+    ];
+
+    const { selected } = await enquirer.default.prompt({
+      type: "select",
+      name: "selected",
+      message: "Select deployment target",
+      choices,
+    });
+
+    if (selected === "Enter custom target...") {
+      const answers = await enquirer.default.prompt([
+        {
+          type: "input",
+          name: "baseUrl",
+          message: "CDF Base URL",
+          initial: "https://api.cognitedata.com",
+        },
+        {
+          type: "input",
+          name: "project",
+          message: "CDF Project",
+        },
+        {
+          type: "input",
+          name: "org",
+          message: "Organization (for login hint)",
+          initial: "",
+        },
+      ]);
+      deployment = {
+        baseUrl: answers.baseUrl,
+        project: answers.project,
+        org: answers.org || null,
+        published,
+      };
+      if (answers.org) {
+        organization = answers.org;
+      }
+    } else {
+      // Find the deployment by matching the selected name
+      deployment = appConfig.deployments.find((d) => `${d.org}/${d.project}` === selected);
+    }
+  } else {
+    // No deployments in app.json - prompt for values
+    console.log("No deployments configured in app.json. Enter target details:\n");
+
+    const answers = await enquirer.default.prompt([
+      {
+        type: "input",
+        name: "baseUrl",
+        message: "CDF Base URL",
+        initial: "https://api.cognitedata.com",
+      },
+      {
+        type: "input",
+        name: "project",
+        message: "CDF Project",
+        validate: (v) => (v ? true : "Project is required"),
+      },
+      {
+        type: "input",
+        name: "org",
+        message: "Organization (for login hint)",
+        initial: "",
+      },
+    ]);
+
+    deployment = {
+      baseUrl: answers.baseUrl,
+      project: answers.project,
+      org: answers.org || null,
+      published,
+    };
+    if (answers.org) {
+      organization = answers.org;
+    }
+  }
+
+  console.log("\n🚀 Dune Deploy (Interactive)");
+  console.log("=============================");
+  console.log(`App: ${appConfig.name} (${appConfig.externalId})`);
+  console.log(`Version: ${appConfig.versionTag}`);
+  console.log(`Target: ${deployment.project} @ ${deployment.baseUrl}`);
+  console.log();
+
+  // Build the app first
+  if (!skipBuild) {
+    try {
+      buildApp(cwd);
+    } catch (error) {
+      console.error("❌ Build failed:", error.message);
+      process.exit(1);
+    }
+  }
+
+  // Start interactive login flow
+  try {
+    const authFlow = new AuthenticationFlow(DEFAULT_CONFIG);
+
+    // Use org from CLI, then deployment, then null
+    const orgHint = organization || deployment.org || null;
+
+    console.log("\n🔐 Starting browser authentication...");
+    console.log("A browser window will open for you to log in.\n");
+
+    const tokens = await authFlow.login(orgHint);
+
+    if (!tokens || !tokens.access_token) {
+      throw new Error("No access token received from authentication");
+    }
+
+    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();
+
+    // 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
+    }
+
+    console.log(`\n✅ Successfully deployed ${appConfig.name} to ${deployment.project}`);
+
+    if (deployment.published || published) {
+      console.log("🌐 App is published and available to all users");
+    } else {
+      console.log("🔒 App is deployed in draft mode");
+    }
+
+    // Generate and display the app URL
+    const appUrl = generateFusionUrl(deployment, appConfig.externalId, appConfig.versionTag);
+    if (appUrl) {
+      console.log(`\n🔗 Open your app:\n   ${appUrl}`);
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.error("\n❌ Deployment failed:", error.message);
+    process.exit(1);
+  }
+}

package/bin/utils/crypto.js

@@ -0,0 +1,35 @@
+/**
+ * Cryptographic Utilities for OAuth 2.0 PKCE
+ *
+ * Provides functions for generating secure random strings and PKCE code challenges.
+ */
+
+import crypto from "node:crypto";
+
+// biome-ignore lint/complexity/noStaticOnlyClass: Utility class pattern
+export class CryptoUtils {
+  /**
+   * Generate a cryptographically secure random string
+   * @param {number} length - Desired length of the string
+   * @returns {string} Random string using URL-safe base64 characters
+   */
+  static generateRandomString(length) {
+    const bytes = crypto.randomBytes(length);
+    return bytes
+      .toString("base64")
+      .replace(/\+/g, "-")
+      .replace(/\//g, "_")
+      .replace(/=/g, "")
+      .slice(0, length);
+  }
+
+  /**
+   * Generate PKCE code challenge from verifier
+   * @param {string} verifier - The code verifier string
+   * @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, "");
+  }
+}

package/dist/deploy/index.d.ts

@@ -29,6 +29,13 @@ declare class CdfApplicationDeployer {
      * @param {CogniteClient} client - Cognite SDK client
      */
     constructor(client: CogniteClient);
+    private DATA_SET_EXTERNAL_ID;
+    /**
+     * Validate that the required data set exists and is accessible
+     * @returns {Promise<number>} Data set ID (numerical)
+     * @throws {Error} If data set doesn't exist or user doesn't have access
+     */
+    validateDataSet(): Promise<number | undefined>;
     /**
      * Upload application package to CDF Files API
      * @param {string} appExternalId - Application external ID

package/dist/deploy/index.js

@@ -1,3 +1,6 @@
+// src/deploy/deploy.ts
+import fs3 from "fs";
+
 // src/deploy/application-deployer.ts
 import fs from "fs";
 var CdfApplicationDeployer = class {
@@ -5,8 +8,38 @@ var CdfApplicationDeployer = class {
    * @param {CogniteClient} client - Cognite SDK client
    */
   constructor(client) {
+    this.DATA_SET_EXTERNAL_ID = "published-custom-apps";
     this.client = client;
   }
+  /**
+   * Validate that the required data set exists and is accessible
+   * @returns {Promise<number>} Data set ID (numerical)
+   * @throws {Error} If data set doesn't exist or user doesn't have access
+   */
+  async validateDataSet() {
+    try {
+      const dataSets = await this.client.datasets.retrieve([
+        { externalId: this.DATA_SET_EXTERNAL_ID }
+      ]);
+      return dataSets[0].id;
+    } catch (error) {
+      try {
+        this.client.datasets.create([
+          {
+            externalId: this.DATA_SET_EXTERNAL_ID,
+            name: "Published Custom Apps",
+            description: "Published Custom Apps",
+            writeProtected: false
+          }
+        ]);
+        console.log(`\u2705 Data set '${this.DATA_SET_EXTERNAL_ID}' created`);
+      } catch (error2) {
+        throw new Error(
+          `Failed to create data set '${this.DATA_SET_EXTERNAL_ID}'. Please ask your IT admin to create it or grant access.`
+        );
+      }
+    }
+  }
   /**
    * Upload application package to CDF Files API
    * @param {string} appExternalId - Application external ID
@@ -17,6 +50,10 @@ var CdfApplicationDeployer = class {
    * @param {boolean} published - Whether the application should be published
    */
   async uploadToFilesApi(appExternalId, name, description, versionTag, zipFilename, published = false) {
+    console.log("\u{1F50D} Validating data set access...");
+    const dataSetId = await this.validateDataSet();
+    console.log(`\u2705 Data set '${this.DATA_SET_EXTERNAL_ID}' validated (ID: ${dataSetId})
+`);
     console.log("\u{1F4C1} Creating file record...");
     const fileContent = fs.readFileSync(zipFilename);
     const metadata = {
@@ -31,7 +68,8 @@ var CdfApplicationDeployer = class {
         name: `${appExternalId}-${versionTag}.zip`,
         externalId: `${appExternalId}-${versionTag}`,
         directory: "/dune-apps",
-        metadata
+        metadata,
+        dataSetId
       },
       fileContent,
       true,
@@ -209,6 +247,10 @@ var deploy = async (deployment, app, folder) => {
     zipFilename,
     deployment.published
   );
+  try {
+    fs3.unlinkSync(zipFilename);
+  } catch {
+  }
 };
 export {
   ApplicationPackager,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/dune",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Build and deploy React apps to Cognite Data Fusion",
   "keywords": [
     "cognite",
@@ -59,7 +59,8 @@
     "archiver": "^7.0.1",
     "enquirer": "^2.4.1",
     "execa": "^5.1.1",
-    "hygen": "^6.2.11"
+    "hygen": "^6.2.11",
+    "open": "^10.1.0"
   },
   "peerDependencies": {
     "@cognite/sdk": ">=9.0.0",

package/src/deploy/application-deployer.ts

@@ -17,6 +17,38 @@ export class CdfApplicationDeployer {
     this.client = client;
   }
 
+  private DATA_SET_EXTERNAL_ID = "published-custom-apps";
+
+  /**
+   * Validate that the required data set exists and is accessible
+   * @returns {Promise<number>} Data set ID (numerical)
+   * @throws {Error} If data set doesn't exist or user doesn't have access
+   */
+  async validateDataSet() {
+    try {
+      const dataSets = await this.client.datasets.retrieve([
+        { externalId: this.DATA_SET_EXTERNAL_ID },
+      ]);
+      return dataSets[0].id;
+    } catch (error) {
+      try {
+        this.client.datasets.create([
+          {
+            externalId: this.DATA_SET_EXTERNAL_ID,
+            name: "Published Custom Apps",
+            description: "Published Custom Apps",
+            writeProtected: false,
+          },
+        ]);
+        console.log(`✅ Data set '${this.DATA_SET_EXTERNAL_ID}' created`);
+      } catch (error) {
+        throw new Error(
+          `Failed to create data set '${this.DATA_SET_EXTERNAL_ID}'. Please ask your IT admin to create it or grant access.`
+        );
+      }
+    }
+  }
+
   /**
    * Upload application package to CDF Files API
    * @param {string} appExternalId - Application external ID
@@ -34,6 +66,11 @@ export class CdfApplicationDeployer {
     zipFilename: string,
     published = false
   ): Promise<void> {
+    // Validate data set exists and get its ID
+    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...");
 
     const fileContent = fs.readFileSync(zipFilename);
@@ -51,6 +88,7 @@ export class CdfApplicationDeployer {
         externalId: `${appExternalId}-${versionTag}`,
         directory: "/dune-apps",
         metadata: metadata,
+        dataSetId: dataSetId,
       },
       fileContent,
       true, // overwrite

package/src/deploy/deploy.ts

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import { CdfApplicationDeployer } from "./application-deployer";
 import { ApplicationPackager } from "./application-packager";
 import { getSdk } from "./get-sdk";
@@ -22,4 +23,11 @@ export const deploy = async (deployment: Deployment, app: App, folder: string) =
     zipFilename,
     deployment.published
   );
+
+  // Step 4: Clean up zip file
+  try {
+    fs.unlinkSync(zipFilename);
+  } catch {
+    // Ignore cleanup errors
+  }
 };

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

@@ -1,25 +0,0 @@
----
-to: <%= name %>/biome.json
----
-{
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-  "vcs": {
-    "enabled": true,
-    "clientKind": "git",
-    "useIgnoreFile": true
-  },
-  "organizeImports": {
-    "enabled": true
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true
-    }
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "tab"
-  }
-}
-

package/_templates/app/new/vite.config.ts.ejs.t

@@ -1,15 +0,0 @@
----
-to: <%= name %>/vite.config.ts
----
-import react from "@vitejs/plugin-react";
-import { defineConfig } from "vite";
-import mkcert from "vite-plugin-mkcert";
-
-export default defineConfig({
-  plugins: [react(), mkcert()],
-  server: {
-    https: true,
-    port: 3000,
-  },
-});
-