feat: Added support for Codify remote files

Author: kevinwang5658

package-lock.json

@@ -17,7 +17,7 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
     "chalk": "^5.3.0",
-    "codify-schemas": "^1.0.76",
+    "codify-schemas": "^1.0.77",
     "cors": "^2.8.5",
     "debug": "^4.3.4",
     "detect-indent": "^7.0.1",

package.json

@@ -0,0 +1,91 @@
+import * as fsSync from 'node:fs';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { finished } from 'node:stream/promises';
+
+import { PluginSearchQuery, PluginSearchResult } from './types.js';
+
+const API_BASE_URL = 'https://api.codifycli.com'
+
+export const ApiClient = {
+  async searchPlugins(query: PluginSearchQuery[]): Promise<PluginSearchResult> {
+    const body = JSON.stringify({ query });
+    const res = await fetch(
+      `${API_BASE_URL}/v1/plugins/versions/search`,
+      { method: 'POST', body, headers: { 'Content-Type': 'application/json' } }
+    );
+
+    if (!res.ok) {
+      const message = await res.text();
+      throw new Error(message);
+    }
+
+    const json = await res.json();
+    return json.results as unknown as PluginSearchResult;
+  },
+
+  async downloadPlugin(filePath: string, url: string): Promise<void> {
+    const { body } = await fetch(url)
+
+    const dirname = path.dirname(filePath);
+    if (!await fs.stat(dirname).then((s) => s.isDirectory()).catch(() => false)) {
+      await fs.mkdir(dirname, { recursive: true });
+    }
+
+    const ws = fsSync.createWriteStream(filePath)
+    // Different type definitions here for readable stream (NodeJS vs DOM). Small hack to fix that
+    await finished(Readable.fromWeb(body as never).pipe(ws));
+  },
+
+  async getRemoteFileHash(filePath: string, credentials: string): Promise<string> {
+    const { documentId, fileId } = this.extractCodifyFileInfo(filePath);
+
+    const response = await fetch((`https://api.codifycli.com/v1/documents/${documentId}/file/${fileId}/hash`), {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${credentials}`,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to get remote file hash for ${filePath}`);
+    }
+
+    const data = await response.json();
+    return data.hash;
+  },
+
+  async updateRemoteFile(filePath: string, content: Blob, credentials: string): Promise<string> {
+    const { documentId, fileId } = this.extractCodifyFileInfo(filePath);
+
+    const formData = new FormData();
+    formData.append('file', content);
+
+    const response = await fetch((`https://api.codifycli.com/v1/documents/${documentId}/file/${fileId}`), {
+      method: 'PUT',
+      headers: {
+        'Authorization': `Bearer ${credentials}`,
+      },
+      body: formData,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to save remote file ${filePath}`);
+    }
+  },
+
+  extractCodifyFileInfo(url: string) {
+    const regex = /codify:\/\/(.*):(.*)/
+
+    const [, group1, group2] = regex.exec(url) ?? [];
+    if (!group1 || !group2) {
+      throw new Error(`Invalid codify url ${url} for file`);
+    }
+
+    return {
+      documentId: group1,
+      fileId: group2,
+    }
+  },
+};

src/api/backend/index.ts

@@ -6,6 +6,7 @@ import createDebug from 'debug';
 
 import { LoginHelper } from '../connect/login-helper.js';
 import { Event, ctx } from '../events/context.js';
+import { LoginOrchestrator } from '../orchestrators/login.js';
 import { Reporter, ReporterFactory, ReporterType } from '../ui/reporters/reporter.js';
 import { SudoUtils } from '../utils/sudo.js';
 import { prettyPrintError } from './errors.js';
@@ -65,7 +66,42 @@ export abstract class BaseCommand extends Command {
       ctx.pressKeyToContinueCompleted(pluginName)
     })
 
+    ctx.on(Event.CODIFY_LOGIN_CREDENTIALS_REQUEST, async (pluginName: string) => {
+      if (pluginName !== 'default') {
+        throw new Error(`Only the default plugin can request Codify credentials. Instead received ${pluginName}`);
+      }
+
+      if (LoginHelper.get()?.isLoggedIn) {
+        const credentials = LoginHelper.get()?.credentials?.accessToken;
+        if (!credentials) {
+          throw new Error('Unable to retrieve Codify credentials for user...');
+        }
+
+        ctx.codifyLoginCompleted(pluginName, credentials);
+      } else {
+        ctx.log('User is not currently logged. Attempt to Login to Codify...');
+        await LoginOrchestrator.run();
+
+        if (LoginHelper.get()?.isLoggedIn) {
+          const credentials = LoginHelper.get()?.credentials?.accessToken;
+          if (!credentials) {
+            throw new Error('Unable to retrieve Codify credentials for user...');
+          }
+
+          ctx.codifyLoginCompleted(pluginName, credentials);
+        } else {
+          throw new Error('Unable to login...')
+        }
+      }
+    })
+
     await LoginHelper.load();
+
+    // Catch any un-caught exceptions
+    process.on('uncaughtException', (error) => {
+      console.log('Caught exception')
+      this.catch(error);
+    })
   }
 
   protected async catch(err: Error): Promise<void> {

src/api/types.ts src/api/backend/types.tssrc/api/types.ts renamed to src/api/backend/types.ts

@@ -17,6 +17,8 @@ export enum Event {
   SUDO_REQUEST_GRANTED = 'sudo_request_granted',
   PRESS_KEY_TO_CONTINUE_REQUEST = 'press_key_to_continue_request',
   PRESS_KEY_TO_CONTINUE_COMPLETED = 'press_key_to_continue_completed',
+  CODIFY_LOGIN_CREDENTIALS_REQUEST = 'codify_login_credentials_request',
+  CODIFY_LOGIN_CREDENTIALS_COMPLETED = 'codify_login_credentials_completed',
 }
 
 export enum ProcessName {
@@ -116,6 +118,14 @@ export const ctx = new class {
     this.emitter.emit(Event.PRESS_KEY_TO_CONTINUE_COMPLETED, pluginName);
   }
 
+  codifyLoginRequested(pluginName: string) {
+    this.emitter.emit(Event.CODIFY_LOGIN_CREDENTIALS_REQUEST, pluginName);
+  }
+
+  codifyLoginCompleted(pluginName: string, credentials: string) {
+    this.emitter.emit(Event.CODIFY_LOGIN_CREDENTIALS_COMPLETED, pluginName, credentials);
+  }
+
   async subprocess<T>(name: string, run: () => Promise<T>): Promise<T> {
     this.emitter.emit(Event.SUB_PROCESS_START, name);
     const result = await run();

src/api/index.ts

@@ -1,6 +1,10 @@
+import chalk from 'chalk';
+import fs from 'node:fs/promises';
 import path from 'node:path';
 
+import { ApiClient } from '../api/backend/index.js';
 import { InitializationResult, PluginInitOrchestrator } from '../common/initialize-plugins.js';
+import { LoginHelper } from '../connect/login-helper.js';
 import { Project } from '../entities/project.js';
 import { ResourceConfig } from '../entities/resource-config.js';
 import { ResourceInfo } from '../entities/resource-info.js';
@@ -15,6 +19,7 @@ import { PromptType, Reporter } from '../ui/reporters/reporter.js';
 import { FileUtils } from '../utils/file.js';
 import { groupBy, sleep } from '../utils/index.js';
 import { wildCardMatch } from '../utils/wild-card-match.js';
+import { LoginOrchestrator } from './login.js';
 
 export type ImportResult = { result: ResourceConfig[], errors: string[] }
 
@@ -161,8 +166,10 @@ export class ImportOrchestrator {
     pluginManager: PluginManager,
     args: ImportArgs,
   ): Promise<void> {
-    const multipleCodifyFiles = project.codifyFiles.length > 1;
+    // Special handling for remote-file resources. Offer to save them remotely if any changes are detected on import.
+    await ImportOrchestrator.handleCodifyRemoteFiles(reporter, importResult);
 
+    const multipleCodifyFiles = project.codifyFiles.length > 1;
     const saveType = await ImportOrchestrator.getSaveType(reporter, project, args);
 
     // Update an existing file
@@ -259,6 +266,61 @@ export class ImportOrchestrator {
     await sleep(100);
   }
 
+  // Special handling for codify cloud files. Import and refresh can automatically save file updates.
+  static async handleCodifyRemoteFiles(reporter: Reporter, importResult: ImportResult) {
+    try {
+      if (!importResult.result.some((r) => r.type === 'remote-file')) {
+        return;
+      }
+
+      if (!LoginHelper.get()?.isLoggedIn) {
+        await LoginOrchestrator.run();
+      }
+
+      const credentials = LoginHelper.get()!.credentials!.accessToken;
+
+      const filesToUpdate = [];
+      const remoteFiles = importResult.result.filter((r) => r.type === 'remote-file');
+      for (const file of remoteFiles) {
+        if (!file.parameters.remote || !file.parameters.hash) {
+          continue;
+        }
+
+        const hash = await ApiClient.getRemoteFileHash(file.parameters.remote as string, credentials);
+        if (hash !== file.parameters.hash) {
+          filesToUpdate.push(file);
+        }
+      }
+
+      if (filesToUpdate.length === 0) {
+        return;
+      }
+
+      const fileNames = filesToUpdate.map((f) => `'${f.parameters.path}'`).join(', ')
+      const shouldUpdate = await reporter.promptConfirmation(
+        `The following files have been updated: [${fileNames}].\nDo you want to upload the changes to Codify cloud? ${chalk.bold('(Warning this will override any existing data!)')}`,
+      );
+
+      if (!shouldUpdate) {
+        return;
+      }
+
+      for (const file of filesToUpdate) {
+        if (!file.parameters.path) {
+          console.warn(`Unable to find file path for file ${file.parameters.remote}`)
+          continue;
+        }
+
+        const content = await fs.readFile(file.parameters.path as string);
+        await ApiClient.updateRemoteFile(file.parameters.remote as string, new Blob([content]), credentials);
+      }
+
+      ctx.log('Successfully uploaded changes to Codify cloud');
+    } catch {
+      console.warn('Unable to process remote-files');
+    }
+  }
+
   private static matchTypeIds(typeIds: string[], validTypeIds: string[]): string[] {
     const result: string[] = [];
     const unsupportedTypeIds: string[] = [];

src/common/base-command.ts

@@ -37,6 +37,10 @@ export class RefreshOrchestrator {
 
     reporter.displayImportResult(importResult, false);
 
+
+    // Special handling for remote-file resources. Offer to save them remotely if any changes are detected on import.
+    await ImportOrchestrator.handleCodifyRemoteFiles(reporter, importResult);
+
     const resourceInfoList = await pluginManager.getMultipleResourceInfo(
       project.resourceConfigs.map((r) => r.type),
     );