components/databricks/actions/run-job-now/run-job-now.mjs (1)

49-57: Guard against mutually exclusive params (jarParams vs notebookParams).

The API rejects requests specifying both. Add a quick check to fail fast with a clear error.

   async run({ $ }) {
-    const response = await this.databricks.runJobNow({
+    const hasJar = Array.isArray(this.jarParams) && this.jarParams.length > 0;
+    const hasNotebook = this.notebookParams && Object.keys(this.notebookParams).length > 0;
+    if (hasJar && hasNotebook) {
+      throw new Error("jarParams and notebookParams are mutually exclusive. Provide only one.");
+    }
+
+    const response = await this.databricks.runJobNow({
       data: {
         job_id: this.jobId,
         jar_params: this.jarParams,
         notebook_params: this.notebookParams,
         python_params: this.pythonParams,
         spark_submit_params: this.sparkSubmitParams,
         idempotency_token: this.idempotencyToken,
       },
       $,
     });

components/databricks/actions/list-runs/list-runs.mjs (2)

33-38: Respect maxResults during pagination to avoid over-fetching.

Adjust limit to the remaining budget and stop early when the cap is reached.

   async run({ $ }) {
-    const params = {
+    const params = {
       job_id: this.jobId,
       active_only: this.activeOnly,
-      limit: 100,
+      limit: 100,
       offset: 0,
     };
+    const max = this.maxResults ?? 100;

---

42-47: Cap each page by remaining results.

Prevents extra API calls and trimming later.

-    do {
-      const { runs } = await this.databricks.listRuns({
+    do {
+      // Stop if we've already reached the cap
+      if (allRuns.length >= max) break;
+      // Limit this page to the remaining budget
+      params.limit = Math.min(params.limit, Math.max(1, max - allRuns.length));
+      const { runs } = await this.databricks.listRuns({
         params,
         $,
       });

components/databricks/package.json (1)

3-3: Version bump — LGTM. Please ensure release notes.

Given the sizable feature set, add/update CHANGELOG and fill in the PR description before merge.

components/databricks/common/constants.mjs (1)

1-11: Prevent accidental mutation of shared constants.

Freeze the array to avoid runtime edits.

-export const CLUSTER_SIZES = [
+export const CLUSTER_SIZES = Object.freeze([
   "2X-Small",
   "X-Small",
   "Small",
   "Medium",
   "Large",
   "X-Large",
   "2X-Large",
   "3X-Large",
   "4X-Large",
-];
+]);

components/databricks/common/utils.mjs (3)

16-24: Limit recursion to plain objects to avoid mangling Dates/Maps/Sets/etc.

Current typeof obj === "object" will traverse non-POJOs and strip their contents. Guard for plain objects.

Apply:

-  if (typeof obj === "object") {
+  if (typeof obj === "object" && Object.getPrototypeOf(obj) === Object.prototype) {
     return Object.fromEntries(Object.entries(obj).map(([
       key,
       value,
     ]) => [
       key,
       parseObject(value),
     ]));
   }

---

1-27: Protect against cyclic structures to prevent infinite recursion.

Add a WeakSet to track seen objects.

One way:

-const parseObject = (obj) => {
+const parseObject = (obj, _seen = new WeakSet()) => {
@@
-  if (Array.isArray(obj)) {
-    return obj.map((item) => parseObject(item));
+  if (Array.isArray(obj)) {
+    return obj.map((item) => parseObject(item, _seen));
   }
@@
-  if (typeof obj === "object" && Object.getPrototypeOf(obj) === Object.prototype) {
+  if (typeof obj === "object" && Object.getPrototypeOf(obj) === Object.prototype) {
+    if (_seen.has(obj)) return obj;
+    _seen.add(obj);
     return Object.fromEntries(Object.entries(obj).map(([
       key,
       value,
-    ]) => [
-      key,
-      parseObject(value),
+    ]) => [
+      key,
+      parseObject(value, _seen),
     ]));
   }

---

29-31: Export named helper for ergonomics and tree-shaking.

Apply:

-export default {
-  parseObject,
-};
+export { parseObject };
+export default { parseObject };

components/databricks/actions/list-vector-search-indexes/list-vector-search-indexes.mjs (1)

16-17: Prefer nullish coalescing for count and keep concise pluralization.

Apply:

-    const count = response?.vector_indexes?.length || 0;
-    $.export("$summary", `Found ${count} vector search index${count === 1 ? "" : "es"}`);
+    const count = response?.vector_indexes?.length ?? 0;
+    $.export("$summary", `Found ${count} vector search index${count === 1 ? "" : "es"}`);

components/databricks/actions/delete-vector-search-index/delete-vector-search-index.mjs (1)

6-6: Clarify that deletion is irreversible in the description.

Apply:

-  description: "Deletes a vector search index in Databricks. [See the documentation](https://docs.databricks.com/api/workspace/vectorsearchindexes/deleteindex)",
+  description: "Irreversibly deletes a vector search index in Databricks. [See the documentation](https://docs.databricks.com/api/workspace/vectorsearchindexes/deleteindex)",

components/databricks/actions/start-sql-warehouse/start-sql-warehouse.mjs (1)

19-27: Optionally support waiting until the warehouse is ready.

Starting is async; add a waitForReady flag to poll status via getSQLWarehouse until RUNNING (with timeout).

Apply:

   props: {
     databricks,
     warehouseId: {
       description: "The ID of the SQL Warehouse to start",
       propDefinition: [
         databricks,
         "warehouseId",
       ],
     },
+    waitForReady: {
+      type: "boolean",
+      label: "Wait Until Ready",
+      description: "Polls the warehouse state until it's running (or times out).",
+      optional: true,
+      default: false,
+    },
+    pollIntervalMs: {
+      type: "integer",
+      label: "Poll Interval (ms)",
+      optional: true,
+      default: 5000,
+    },
+    timeoutMs: {
+      type: "integer",
+      label: "Timeout (ms)",
+      optional: true,
+      default: 300000,
+    },
   },
   async run({ $ }) {
     const response = await this.databricks.startSQLWarehouse({
       warehouseId: this.warehouseId,
       $,
     });
 
     $.export("$summary", `Successfully started SQL Warehouse with ID ${this.warehouseId}`);
-    return response;
+    if (!this.waitForReady) return response;
+
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    const start = Date.now();
+    while (Date.now() - start < this.timeoutMs) {
+      const { state } = await this.databricks.getSQLWarehouse({ warehouseId: this.warehouseId, $ });
+      if (state === "RUNNING") return { ...response, state };
+      await sleep(this.pollIntervalMs);
+    }
+    throw new Error(`Timed out waiting for SQL Warehouse ${this.warehouseId} to be RUNNING`);
   },

components/databricks/actions/delete-sql-warehouse/delete-sql-warehouse.mjs (2)

9-18: Add an optional “idempotent delete” switch

Allow users to treat 404 as success to make deletes safe to re-run.

Apply this diff to introduce an ignoreMissing prop:

   props: {
     databricks,
     warehouseId: {
       description: "The ID of the SQL Warehouse to delete",
       propDefinition: [
         databricks,
         "warehouseId",
       ],
     },
+    ignoreMissing: {
+      type: "boolean",
+      label: "Ignore Missing",
+      description: "Treat 404 (not found) as success.",
+      optional: true,
+    },
   },

---

19-29: Make deletion idempotent and improve error messaging

Catch 404s when ignoreMissing is enabled; keep other errors bubbling.

Apply this diff:

-  async run({ $ }) {
-    await this.databricks.deleteSQLWarehouse({
-      warehouseId: this.warehouseId,
-      $,
-    });
-
-    $.export("$summary", `Successfully deleted SQL Warehouse with ID ${this.warehouseId}`);
-    return {
-      success: true,
-    };
-  },
+  async run({ $ }) {
+    try {
+      await this.databricks.deleteSQLWarehouse({
+        warehouseId: this.warehouseId,
+        $,
+      });
+      $.export("$summary", `Successfully deleted SQL Warehouse with ID ${this.warehouseId}`);
+      return { success: true };
+    } catch (err) {
+      const status = err?.response?.status ?? err?.status;
+      if (this.ignoreMissing && status === 404) {
+        $.export("$summary", `Warehouse ${this.warehouseId} not found. Treated as success (ignored).`);
+        return { success: true, ignored: true };
+      }
+      throw err;
+    }
+  },

components/databricks/actions/set-sql-warehouse-config/set-sql-warehouse-config.mjs (1)

131-152: Validate configuration pair items before sending

Guard against malformed entries to fail fast with actionable errors.

Apply this minimal validation:

-    const configParam = utils.parseObject(this.configParam);
+    const configParam = utils.parseObject(this.configParam);
     if (Array.isArray(configParam) && configParam.length) {
+      configParam.forEach((p, i) => {
+        if (!p || typeof p !== "object" || typeof p.key !== "string") {
+          throw new ConfigurationError(`configParam[${i}] must be an object like { "key": string, "value": any }`);
+        }
+      });
       payload.config_param = {
         configuration_pairs: configParam,
       };
     }
-    const globalParam = utils.parseObject(this.globalParam);
+    const globalParam = utils.parseObject(this.globalParam);
     if (Array.isArray(globalParam) && globalParam.length) {
+      globalParam.forEach((p, i) => {
+        if (!p || typeof p !== "object" || typeof p.key !== "string") {
+          throw new ConfigurationError(`globalParam[${i}] must be an object like { "key": string, "value": any }`);
+        }
+      });
       payload.global_param = {
         configuration_pairs: globalParam,
       };
     }
-    const sqlConfigurationParameters = utils.parseObject(this.sqlConfigurationParameters);
+    const sqlConfigurationParameters = utils.parseObject(this.sqlConfigurationParameters);
     if (Array.isArray(sqlConfigurationParameters) && sqlConfigurationParameters.length) {
+      sqlConfigurationParameters.forEach((p, i) => {
+        if (!p || typeof p !== "object" || typeof p.key !== "string") {
+          throw new ConfigurationError(`sqlConfigurationParameters[${i}] must be an object like { "key": string, "value": any }`);
+        }
+      });
       payload.sql_configuration_parameters = {
         configuration_pairs: sqlConfigurationParameters,
       };
     }
-    const dataAccessConfig = utils.parseObject(this.dataAccessConfig);
+    const dataAccessConfig = utils.parseObject(this.dataAccessConfig);
     if (Array.isArray(dataAccessConfig) && dataAccessConfig.length) {
       payload.data_access_config = dataAccessConfig;
     }

components/databricks/actions/get-sql-warehouse-permissions/get-sql-warehouse-permissions.mjs (1)

19-27: Add user-friendly summaries for 404/403 (optional).

Export clearer summaries on not found / forbidden without hiding the error.

-  async run({ $ }) {
-    const response = await this.databricks.getSQLWarehousePermissions({
-      warehouseId: this.warehouseId,
-      $,
-    });
-
-    $.export("$summary", `Retrieved permissions for SQL Warehouse ID ${this.warehouseId}`);
-    return response;
-  },
+  async run({ $ }) {
+    try {
+      const response = await this.databricks.getSQLWarehousePermissions({
+        warehouseId: this.warehouseId,
+        $,
+      });
+      $.export("$summary", `Retrieved permissions for SQL Warehouse ID ${this.warehouseId}`);
+      return response;
+    } catch (err) {
+      if (err?.response?.status === 404) {
+        $.export("$summary", `SQL Warehouse ${this.warehouseId} not found.`);
+      } else if (err?.response?.status === 403) {
+        $.export("$summary", `Access denied to SQL Warehouse ${this.warehouseId}.`);
+      }
+      throw err;
+    }
+  },

components/databricks/actions/get-sql-warehouse/get-sql-warehouse.mjs (1)

25-26: Use resource name in summary when available (nit).

Improves UX in runs list.

-    $.export("$summary", `Retrieved details for SQL Warehouse ID ${this.warehouseId}`);
+    $.export("$summary", `Retrieved SQL Warehouse ${response?.name ?? this.warehouseId}`);

components/databricks/actions/stop-sql-warehouse/stop-sql-warehouse.mjs (2)

9-18: Optional: add wait-for-stop toggle.

Stopping is often async; offer a wait flag for convenience.

   props: {
     databricks,
     warehouseId: {
       description: "The ID of the SQL Warehouse to stop",
       propDefinition: [
         databricks,
         "warehouseId",
       ],
     },
+    waitForStop: {
+      type: "boolean",
+      label: "Wait Until Stopped",
+      description: "Polls the warehouse status until STOPPED (or timeout).",
+      optional: true,
+      default: false,
+    },
+    pollIntervalMs: {
+      type: "integer",
+      label: "Poll Interval (ms)",
+      optional: true,
+      default: 5000,
+    },
   },

---

19-27: Optional: implement simple polling when wait is enabled.

Poll status until STOPPED with a bounded loop.

   async run({ $ }) {
     const response = await this.databricks.stopSQLWarehouse({
       warehouseId: this.warehouseId,
       $,
     });
 
-    $.export("$summary", `Successfully stopped SQL Warehouse with ID ${this.warehouseId}`);
-    return response;
+    if (!this.waitForStop) {
+      $.export("$summary", `Stop requested for SQL Warehouse ${this.warehouseId}`);
+      return response;
+    }
+    // Poll for terminal state
+    const maxTries = 60; // ~5 min with 5s default interval
+    for (let i = 0; i < maxTries; i++) {
+      const { state } = await this.databricks.getSQLWarehouse({ warehouseId: this.warehouseId, $ });
+      if (state === "STOPPED") {
+        $.export("$summary", `SQL Warehouse ${this.warehouseId} is STOPPED.`);
+        return response;
+      }
+      await new Promise((r) => setTimeout(r, this.pollIntervalMs ?? 5000));
+    }
+    $.export("$summary", `Timed out waiting for SQL Warehouse ${this.warehouseId} to stop.`);
+    return response;
   },

components/databricks/actions/scan-vector-search-index/scan-vector-search-index.mjs (2)

39-41: Validate numResults > 0 (defensive).

Prevent accidental zero/negative values.

-    if (this.numResults !== undefined) {
-      body.num_results = this.numResults;
-    }
+    if (this.numResults !== undefined) {
+      if (!Number.isInteger(this.numResults) || this.numResults <= 0) {
+        throw new Error("numResults must be a positive integer.");
+      }
+      body.num_results = this.numResults;
+    }

---

35-47: Minor: rename body -> payload for consistency.

Matches other actions’ naming.

-    const body = {};
+    const payload = {};
-    if (typeof this.lastPrimaryKey === "string" && this.lastPrimaryKey.trim().length > 0) {
-      body.last_primary_key = this.lastPrimaryKey.trim();
+    if (typeof this.lastPrimaryKey === "string" && this.lastPrimaryKey.trim().length > 0) {
+      payload.last_primary_key = this.lastPrimaryKey.trim();
     }
-    if (this.numResults !== undefined) {
-      if (!Number.isInteger(this.numResults) || this.numResults <= 0) {
-        throw new Error("numResults must be a positive integer.");
-      }
-      body.num_results = this.numResults;
+    if (this.numResults !== undefined) {
+      if (!Number.isInteger(this.numResults) || this.numResults <= 0) {
+        throw new Error("numResults must be a positive integer.");
+      }
+      payload.num_results = this.numResults;
     }
@@
-      data: body,
+      data: payload,

components/databricks/actions/sync-vector-search-index/sync-vector-search-index.mjs (1)

18-30: LGTM with a minor enhancement suggestion

Looks good. Consider an optional boolean prop like waitForCompletion to poll until the sync job reaches a terminal state and surface failures earlier, defaulting to fire-and-forget to preserve current behavior.

components/databricks/actions/upsert-vector-search-index-data/upsert-vector-search-index-data.mjs (1)

42-53: Potential large-payload risk: consider chunking large upserts

inputs_json can get big; APIs often have size limits. Consider batching (e.g., chunks of N rows or bytes) and invoking the endpoint per chunk, aggregating results.

components/databricks/actions/query-vector-search-index/query-vector-search-index.mjs (2)

64-70: Stricter validation for queryVector content (optional)

After JSON.parse, ensure it’s a non-empty array of numbers to catch silent shape issues early.

   if (this.queryVector) {
     try {
       payload.query_vector = JSON.parse(this.queryVector);
+      if (!Array.isArray(payload.query_vector) || !payload.query_vector.length || payload.query_vector.some((v) => typeof v !== "number")) {
+        throw new Error("`queryVector` must be a non-empty JSON array of numbers.");
+      }
     } catch (err) {
       throw new Error(`Invalid queryVector JSON: ${err.message}`);
     }
   }

---

86-88: Result count path may vary across API versions

If responses use results instead of result.data_array, consider a fallback.

-  const count = response?.result?.data_array?.length || 0;
+  const count = response?.result?.data_array?.length
+    ?? response?.results?.length
+    ?? 0;

components/databricks/actions/set-sql-warehouse-permissions/set-sql-warehouse-permissions.mjs (1)

33-41: Optional: deduplicate ACL entries to avoid redundant updates

You can collapse duplicates by principal + permission_level before sending.

components/databricks/actions/create-sql-warehouse/create-sql-warehouse.mjs (4)

117-133: Validation is solid; consider aligning defaults and cross-field constraints

• You already enforce maxNumClusters ≥ minNumClusters. Consider also failing fast when maxNumClusters is omitted but minNumClusters > 1 and the backend requires both for autoscaling.
• Optionally cap num_clusters at backend-specific limits if they differ by edition.

---

149-158: Enforce PRO + serverless pairing (optional but user-friendly)

When enableServerlessCompute === true, validate warehouseType === "PRO" to avoid backend errors.

   if (this.enableServerlessCompute !== undefined)
     payload.enable_serverless_compute = this.enableServerlessCompute;
+  if (this.enableServerlessCompute && this.warehouseType && this.warehouseType !== "PRO") {
+    throw new ConfigurationError("Serverless compute requires warehouseType = PRO.");
+  }

---

135-147: Tags parsing: guard undefined to avoid surprises

If this.tags is undefined and utils.parseObject expects a string, default to {}.

-  const parsedTags = utils.parseObject(this.tags);
+  const parsedTags = utils.parseObject(this.tags || {});

---

156-158: Channel is already an object; parsing is optional

If the prop type enforces an object, utils.parseObject is unnecessary. Harmless but can be dropped.

components/databricks/actions/edit-sql-warehouse/edit-sql-warehouse.mjs (2)

140-146: Serverless + CLASSIC guard is good; consider auto-upgrading type (optional)

Optional: if enableServerlessCompute = true and warehouseType not provided, consider defaulting warehouse_type to PRO to reduce user error, or add a message prompting users to set it.

---

148-160: Harden tags parsing and enforce tag count limit (< 45)

parseObject on undefined relies on helper behavior; also enforce documented tag-count constraint and type-safety.

Apply this diff:

-    const parsedTags = utils.parseObject(this.tags);
-    const tagArray = Object.entries(parsedTags).map(([
-      key,
-      value,
-    ]) => ({
-      key,
-      value,
-    }));
-    if (tagArray.length) {
-      payload.tags = {
-        custom_tags: tagArray,
-      };
-    }
+    const parsedTags = this.tags ? utils.parseObject(this.tags) : {};
+    if (parsedTags && (typeof parsedTags !== "object" || Array.isArray(parsedTags))) {
+      throw new ConfigurationError("tags must be an object of key-value pairs.");
+    }
+    const tagEntries = Object.entries(parsedTags);
+    if (tagEntries.length > 45) {
+      throw new ConfigurationError("tags must contain fewer than 45 entries.");
+    }
+    const tagArray = tagEntries.map(([key, value]) => ({ key, value }));
+    if (tagArray.length) {
+      payload.tags = { custom_tags: tagArray };
+    }

components/databricks/databricks.app.mjs (1)

47-61: Nit: clarify prop description

This looks copy-pasted from runs; it’s about Warehouses.

Apply this diff:

-      description: "The ID of the SQL Warehouse to get runs from",
+      description: "The ID of the SQL Warehouse",

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

components/databricks/actions/repair-run/repair-run.mjs (1)

63-65: Harden summary against response shape differences

If the API returns a different field, the summary may print “undefined”. Use a safe fallback.

-    $.export("$summary", `Successfully initiated repair of run with ID \`${response.repair_id}\`.`);
+    $.export("$summary", `Successfully initiated repair of run with ID \`${response?.repair_id ?? runId}\`.`);

components/databricks/databricks.app.mjs (1)

285-306: URL‑encode endpointName in paths

Encode dynamic segments to avoid broken URLs and path confusion.

       return this._makeRequest({
-        path: `/vector-search/endpoints/${endpointName}`,
+        path: `/vector-search/endpoints/${encodeURIComponent(endpointName)}`,
         ...opts,
       });

       return this._makeRequest({
-        path: `/vector-search/endpoints/${endpointName}`,
+        path: `/vector-search/endpoints/${encodeURIComponent(endpointName)}`,
         method: "DELETE",
         ...opts,
       });

components/databricks/actions/upsert-vector-search-index-data/upsert-vector-search-index-data.mjs (1)

35-40: Friendlier validation on JSON parse

Wrap parse to surface a clear ConfigurationError on invalid JSON.

-    const parsedRows = utils.parseObject(this.rows);
-
-    if (!Array.isArray(parsedRows) || !parsedRows.length) {
+    let parsedRows;
+    try {
+      parsedRows = utils.parseObject(this.rows);
+    } catch (e) {
+      throw new ConfigurationError("rows must be a valid JSON array string.");
+    }
+    if (!Array.isArray(parsedRows) || parsedRows.length === 0) {
       throw new ConfigurationError("rows must be a non-empty JSON array.");
     }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro