Feature/authentication

.github/workflows/publish.yml

@@ -5,6 +5,7 @@ on:
     branches:
       - main
       - release/dev
+      - feature/authentication
 
 env:
   # This will be set by the first job and used by all others

assets/index.ts

@@ -1,4 +1,5 @@
 import logo from './logo.svg';
 import { icons } from './icons';
+import rosettaIcon from './icon.png';
 
-export { logo, icons };
+export { logo, icons, rosettaIcon };

package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.3.0",
+  "version": "1.3.1-auth-internal",
   "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.3.0",
+  "version": "1.3.1-auth-internal",
   "description": "A modern DBT desktop IDE",
   "license": "MIT",
   "author": {

src/main/ipcHandlers/git.ipcHandlers.ts

@@ -1,7 +1,12 @@
 import { ipcMain } from 'electron';
 import { GitService } from '../services';
 import { AuthError } from '../errors';
-import { FileStatus, GitCredentials } from '../../types/backend';
+import {
+  FileStatus,
+  GitChangesRes,
+  GitCredentials,
+  RepoInfoRes,
+} from '../../types/backend';
 
 const gitService = new GitService();
 
@@ -206,6 +211,26 @@ const registerGitHandlers = () => {
     },
   );
 
+  ipcMain.handle(
+    'git:getLocalChanges',
+    async (
+      _event,
+      { repoPath }: { repoPath: string },
+    ): Promise<GitChangesRes | null> => {
+      return gitService.getLocalChangesStatus(repoPath);
+    },
+  );
+
+  ipcMain.handle(
+    'git:repoInfo',
+    async (
+      _event,
+      { repoPath }: { repoPath: string },
+    ): Promise<RepoInfoRes | null> => {
+      return gitService.getRepoInfo(repoPath);
+    },
+  );
+
   ipcMain.handle(
     'git:unstage',
     async (

src/main/ipcHandlers/index.ts

@@ -9,6 +9,7 @@ import registerSecureStorageHandlers from './secureStorage.ipcHandlers';
 import registerUpdateHandlers from './updates.ipcHandlers';
 import registerCloudExplorerHandlers from './cloudExplorer.ipcHandlers';
 import registerAIHandlers from './ai.ipcHandlers';
+import registerRosettaCloudIpcHandlers from './rosettaCloud.ipcHandlers';
 import registerDuckLakeHandlers from './duckLake.ipcHandlers';
 import registerLineageHandlers from './lineage.ipcHandlers';
 
@@ -24,6 +25,7 @@ export {
   registerUpdateHandlers,
   registerCloudExplorerHandlers,
   registerAIHandlers,
+  registerRosettaCloudIpcHandlers,
   registerDuckLakeHandlers,
   registerLineageHandlers,
 };

src/main/ipcHandlers/projects.ipcHandlers.ts

@@ -207,23 +207,6 @@ const registerProjectHandlers = () => {
       return ProjectsService.downloadSeed(body);
     },
   );
-
-  ipcMain.handle(
-    'project:pushToCloud',
-    async (
-      _event,
-      body: {
-        title: string;
-        gitUrl: string;
-        gitBranch: string;
-        apiKey: string;
-        githubUsername?: string;
-        githubPassword?: string;
-      },
-    ) => {
-      return ProjectsService.pushProjectToCloud(body);
-    },
-  );
 };
 
 export default registerProjectHandlers;

src/main/ipcHandlers/rosettaCloud.ipcHandlers.ts

@@ -0,0 +1,63 @@
+import { ipcMain } from 'electron';
+import { RosettaCloudService } from '../services';
+import { CloudDeploymentPayload } from '../../types/backend';
+
+const registerRosettaCloudIpcHandlers = () => {
+  ipcMain.handle(
+    'rosettaCloud:push',
+    async (_event, body: CloudDeploymentPayload) => {
+      return RosettaCloudService.pushProjectToCloud(body);
+    },
+  );
+
+  ipcMain.handle('rosettaCloud:getProfile', async () => {
+    return RosettaCloudService.getProfile();
+  });
+
+  ipcMain.handle('rosettaCloud:refreshProfile', async () => {
+    return RosettaCloudService.refreshProfile();
+  });
+
+  ipcMain.handle('rosettaCloud:getCachedProfile', async () => {
+    return RosettaCloudService.getCachedProfile();
+  });
+
+  ipcMain.handle('rosettaCloud:login', async () => {
+    return RosettaCloudService.openLogin();
+  });
+
+  ipcMain.handle('rosettaCloud:getApiKey', async () => {
+    return RosettaCloudService.getApiKey();
+  });
+
+  ipcMain.handle('rosettaCloud:logout', async () => {
+    await RosettaCloudService.clearApiKey();
+  });
+
+  ipcMain.handle('rosettaCloud:storeApiKey', async (_event, apiKey: string) => {
+    await RosettaCloudService.storeApiKey(apiKey);
+  });
+
+  ipcMain.handle(
+    'rosettaCloud:validateApiKey',
+    async (_event, apiKey: string) => {
+      return RosettaCloudService.validateApiKey(apiKey);
+    },
+  );
+
+  ipcMain.handle(
+    'rosettaCloud:getSecrets',
+    async (_event, projectId: string) => {
+      return RosettaCloudService.getSecrets(projectId);
+    },
+  );
+
+  ipcMain.handle(
+    'rosettaCloud:deleteSecret',
+    async (_event, projectId: string, secretId: string) => {
+      return RosettaCloudService.deleteSecret(projectId, secretId);
+    },
+  );
+};
+
+export default registerRosettaCloudIpcHandlers;

src/main/ipcSetup.ts

@@ -11,6 +11,7 @@ import {
   registerUpdateHandlers,
   registerCloudExplorerHandlers,
   registerAIHandlers,
+  registerRosettaCloudIpcHandlers,
   registerDuckLakeHandlers,
   registerLineageHandlers,
 } from './ipcHandlers';
@@ -27,6 +28,7 @@ const registerHandlers = (mainWindow: BrowserWindow) => {
   registerUpdateHandlers();
   registerCloudExplorerHandlers();
   registerAIHandlers();
+  registerRosettaCloudIpcHandlers();
   registerDuckLakeHandlers();
   registerLineageHandlers();
 };

src/main/main.ts

@@ -10,6 +10,7 @@ import {
   SettingsService,
   AnalyticsService,
   UpdateService,
+  RosettaCloudService,
   DuckLakeConnectionManager,
 } from './services';
 import { copyAssetsToUserData } from './utils/fileHelper';
@@ -31,13 +32,85 @@ protocol.registerSchemesAsPrivileged([
       bypassCSP: true,
     },
   },
+  {
+    scheme: 'rosetta',
+    privileges: {
+      standard: true,
+      secure: true,
+    },
+  },
 ]);
 
 setupApplicationIcon();
 
+let windowManager: WindowManager | null = null;
+async function handleDeepLink(url: string) {
+  try {
+    const parsedUrl = new URL(url);
+    if (
+      parsedUrl.protocol === 'rosetta:' &&
+      (parsedUrl.pathname === '//auth' || parsedUrl.host === 'auth')
+    ) {
+      const apiKey = parsedUrl.searchParams.get('token'); // Still called 'token' in URL for compatibility
+      if (apiKey) {
+        try {
+          await RosettaCloudService.storeApiKey(apiKey);
+
+          windowManager
+            ?.getMainWindow()
+            ?.webContents.send('rosettaCloud:apiKeyUpdated');
+
+          windowManager
+            ?.getMainWindow()
+            ?.webContents.send('rosettaCloud:authSuccess', {
+              apiKey,
+            });
+
+          return;
+        } catch (storageError) {
+          console.error(
+            'Failed to store API key from deep link:',
+            storageError,
+          );
+          windowManager
+            ?.getMainWindow()
+            ?.webContents.send('rosettaCloud:authError', {
+              error: 'Failed to store API key. Please try again.',
+            });
+          return;
+        }
+      }
+
+      windowManager
+        ?.getMainWindow()
+        ?.webContents.send('rosettaCloud:authError', {
+          error: 'Missing API key in deep link response.',
+        });
+    }
+  } catch (error) {
+    console.error('Deep link processing error:', error);
+    windowManager?.getMainWindow()?.webContents.send('rosettaCloud:authError', {
+      error:
+        error instanceof Error
+          ? `Failed to process deep link: ${error.message}`
+          : 'Failed to process deep link.',
+    });
+  }
+}
+
 // Ensure single instance of the app
 const gotTheLock = app.requestSingleInstanceLock();
-let windowManager: WindowManager | null = null;
+
+// Register custom protocol for deep linking
+if (process.defaultApp) {
+  if (process.argv.length >= 2) {
+    app.setAsDefaultProtocolClient('rosetta', process.execPath, [
+      process.argv[1],
+    ]);
+  }
+} else {
+  app.setAsDefaultProtocolClient('rosetta');
+}
 
 if (!gotTheLock) {
   console.log('Another instance is already running. Quitting...');
@@ -150,9 +223,15 @@ if (!gotTheLock) {
     })
     .catch(console.log);
 
-  app.on('second-instance', () => {
+  app.on('second-instance', (event, commandLine) => {
     if (!windowManager) return;
 
+    // Handle deep link from second instance
+    const url = commandLine.find((arg) => arg.startsWith('rosetta://'));
+    if (url) {
+      handleDeepLink(url);
+    }
+
     const activeWindow = windowManager.getMainWindow();
 
     if (activeWindow) {
@@ -163,6 +242,21 @@ if (!gotTheLock) {
       windowManager.startApplication();
     }
   });
+
+  // Handle deep links on macOS
+  app.on('open-url', (event, url) => {
+    event.preventDefault();
+    handleDeepLink(url);
+  });
+
+  // Handle deep links on Windows/Linux
+  app.on('ready', () => {
+    // Check if app was opened with a deep link
+    const url = process.argv.find((arg) => arg.startsWith('rosetta://'));
+    if (url) {
+      handleDeepLink(url);
+    }
+  });
 }
 
 ipcMain.handle('windows:closeSetup', () => {