dev

package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.2.5",
+  "version": "1.2.6",
   "name": "rosetta-dbt-studio",
   "description": "Turn Raw Data into Business Insights—Faster with RosettaDB",
   "keywords": [

release/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rosetta-dbt-studio",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "A modern DBT desktop IDE",
   "license": "MIT",
   "author": {

src/main/ipcHandlers/connectors.ipcHandlers.ts

@@ -1,6 +1,10 @@
 import { ipcMain } from 'electron';
 import { ConnectorsService } from '../services';
-import type { ConnectionInput, QueryResponseType } from '../../types/backend';
+import type {
+  ConnectionInput,
+  QueryResponseType,
+  ExecuteStatementType,
+} from '../../types/backend';
 import { ConfigureConnectionBody, UpdateConnectionBody } from '../../types/ipc';
 import { CloudConnection, RecentItem } from '../../types/frontend';
 
@@ -10,6 +14,7 @@ const handlerChannels = [
   'connector:validate',
   'connector:getJdbcUrl',
   'connector:query',
+  'connector:cancel-query',
   'connector:list',
 ];
 
@@ -67,10 +72,7 @@ const registerConnectorsHandlers = () => {
 
   ipcMain.handle(
     'connector:query',
-    async (
-      _event,
-      body: { connection: ConnectionInput; query: string; projectName: string },
-    ): Promise<QueryResponseType> => {
+    async (_event, body: ExecuteStatementType): Promise<QueryResponseType> => {
       try {
         return ConnectorsService.executeSelectStatement(body);
       } catch (error: any) {
@@ -79,6 +81,13 @@ const registerConnectorsHandlers = () => {
     },
   );
 
+  ipcMain.handle(
+    'connector:cancel-query',
+    async (_event, queryId: string): Promise<void> => {
+      return ConnectorsService.cancelQuery(queryId);
+    },
+  );
+
   ipcMain.handle(
     'connector:setConnectionEnvVariable',
     async (_event, { key, value }: { key: string; value: string }) => {

src/main/ipcHandlers/duckLake.ipcHandlers.ts

@@ -104,6 +104,15 @@ const registerDuckLakeHandlers = () => {
     },
   );
 
+  ipcMain.handle(
+    'ducklake:instance:listSnapshots',
+    async (_event, instanceId: string, params: any) => {
+      // Ensure params has defaults if missing (though Service also defaults)
+      const listParams = params || { page: 1, pageSize: 100 };
+      return DuckLakeService.listInstanceSnapshots(instanceId, listParams);
+    },
+  );
+
   ipcMain.handle(
     'ducklake:snapshot:restore',
     async (

src/main/services/connectors.service.ts

@@ -347,13 +347,25 @@ export default class ConnectorsService {
     }
   }
 
+  private static runningQueries = new Map<string, () => void>();
+
+  static async cancelQuery(queryId: string): Promise<void> {
+    const cancelFn = this.runningQueries.get(queryId);
+    if (cancelFn) {
+      // Execute the cancellation function (closes connection/client)
+      cancelFn();
+      this.runningQueries.delete(queryId);
+    }
+  }
+
   /**
    * Run a select statement and expect the results and fields
    */
   static async executeSelectStatement({
     connection,
     query,
     projectName,
+    queryId,
   }: ExecuteStatementType): Promise<QueryResponseType> {
     const storeUser = await SecureStorageService.getCredential(
       `db-user-${projectName}`,
@@ -384,25 +396,71 @@ export default class ConnectorsService {
       (connection as any).keyfile = bigQueryKey;
     }
 
-    switch (connection.type) {
-      case 'postgres':
-        return executePostgresQuery(connection, query);
-      case 'snowflake':
-        return executeSnowflakeQuery(connection, query);
-      case 'bigquery':
-        return executeBigQueryQuery(connection, query);
-      case 'databricks':
-        return executeDatabricksQuery(connection, query);
-      case 'duckdb':
-        return executeDuckDBQuery(connection, query);
-      case 'redshift':
-        return executeRedshiftQuery(connection, query);
-      default:
-        // Use the literal type instead of accessing the property to avoid TypeScript error
-        throw new Error(
-          `Unsupported connection type: ${(connection as any).type}`,
-        );
+    const startTime = Date.now();
+    let response: QueryResponseType;
+
+    // Helper to register cancel callback if queryId is present
+    const registerCancel = queryId
+      ? (fn: () => void) => {
+          this.runningQueries.set(queryId, fn);
+        }
+      : undefined;
+
+    try {
+      switch (connection.type) {
+        case 'postgres':
+          response = await executePostgresQuery(
+            connection,
+            query,
+            registerCancel,
+          );
+          break;
+        case 'snowflake':
+          response = await executeSnowflakeQuery(
+            connection,
+            query,
+            registerCancel,
+          );
+          break;
+        case 'bigquery':
+          // BigQuery cancellation not yet implemented in utils
+          response = await executeBigQueryQuery(connection, query);
+          break;
+        case 'databricks':
+          response = await executeDatabricksQuery(
+            connection,
+            query,
+            registerCancel,
+          );
+          break;
+        case 'duckdb':
+          response = await executeDuckDBQuery(
+            connection,
+            query,
+            registerCancel,
+          );
+          break;
+        case 'redshift':
+          response = await executeRedshiftQuery(
+            connection,
+            query,
+            registerCancel,
+          );
+          break;
+        default:
+          throw new Error(
+            `Unsupported connection type: ${(connection as any).type}`,
+          );
+      }
+    } finally {
+      // Clean up running query registry
+      if (queryId) {
+        this.runningQueries.delete(queryId);
+      }
     }
+
+    response.duration = Date.now() - startTime;
+    return response;
   }
 
   static extractDbNameFromPath = (url: string) => {
@@ -637,10 +695,6 @@ export default class ConnectorsService {
     conn: ConnectionInput,
   ): Promise<string> {
     const profileConfig = {
-      config: {
-        send_anonymous_usage_stats: false,
-        partial_parse: true,
-      },
       [name]: {
         target: 'dev',
         outputs: {

src/main/services/duckLake.service.ts

@@ -17,12 +17,15 @@ import {
   DuckLakeInstanceHealth,
   DuckLakeTableInfo,
   DuckLakeSnapshotInfo,
+  DuckLakeSnapshotDetail,
   DuckLakeQueryRequest,
   DuckLakeQueryResult,
   DuckLakeMaintenanceTask,
   DuckLakeCatalogConfig,
   DuckLakeMaintenanceType,
   DuckLakeStorageConfig,
+  DuckLakeSnapshotParams,
+  DuckLakePaginatedResult,
 } from '../../types/duckLake';
 import { DuckLakeError } from '../../types/duckLakeErrors';
 
@@ -563,6 +566,24 @@ export default class DuckLakeService {
     }
   }
 
+  static async listInstanceSnapshots(
+    instanceId: string,
+    params: DuckLakeSnapshotParams = { page: 1, pageSize: 100 },
+  ): Promise<DuckLakePaginatedResult<DuckLakeSnapshotDetail>> {
+    try {
+      await this.ensureConnected(instanceId);
+      const adapter = await this.getAdapter(instanceId);
+      return await adapter.listInstanceSnapshots(params);
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error(
+        `[DuckLakeService] Failed to list instance snapshots for ${instanceId}:`,
+        error,
+      );
+      throw error;
+    }
+  }
+
   static async restoreSnapshot(
     instanceId: string,
     // eslint-disable-next-line @typescript-eslint/no-unused-vars

src/main/services/duckLake/adapters/base.adapter.ts

@@ -9,9 +9,12 @@ import {
   DuckLakeInstance,
   DuckLakeTableInfo,
   DuckLakeSnapshotInfo,
+  DuckLakeSnapshotDetail,
   DuckLakeQueryResult,
   DuckLakeQueryRequest,
   DuckLakeStorageConfig,
+  DuckLakeSnapshotParams,
+  DuckLakePaginatedResult,
 } from '../../../../types/duckLake';
 import { generateGCSBearerToken } from '../../../helpers/cloudAuth.helper';
 
@@ -96,6 +99,14 @@ export abstract class CatalogAdapter {
    */
   abstract listSnapshots(tableName: string): Promise<DuckLakeSnapshotInfo[]>;
 
+  /**
+   * Get all snapshots for the entire instance (not table-specific)
+   * Used for instance-wide history view with pagination
+   */
+  abstract listInstanceSnapshots(
+    params: DuckLakeSnapshotParams,
+  ): Promise<DuckLakePaginatedResult<DuckLakeSnapshotDetail>>;
+
   /**
    * Get comprehensive table details from DuckLake metadata catalog (Phase 8b)
    * Queries multiple metadata tables to provide complete table information