Added refresh method to connect and fixed bugs

Author: kevinwang5658

src/connect/http-routes/handlers/create-command.ts

@@ -1,16 +1,16 @@
 import { IPty, spawn } from '@homebridge/node-pty-prebuilt-multiarch';
 import chalk from 'chalk';
 import { Router } from 'express';
+import WebSocket from 'ws';
 
-import { ConnectOrchestrator } from '../../../orchestrators/connect.js';
 import { Session, SocketServer } from '../../socket-server.js';
-import WebSocket from 'ws';
 
 export enum ConnectCommand {
   TERMINAL = 'terminal',
   APPLY = 'apply',
   PLAN = 'plan',
-  IMPORT = 'import'
+  IMPORT = 'import',
+  REFRESH = 'refresh',
 }
 
 interface Params {

src/connect/http-routes/handlers/import-handler.ts

@@ -12,9 +12,8 @@ import { Session, SocketServer } from '../../socket-server.js';
 import { ConnectCommand, createCommandHandler } from './create-command.js';
 
 enum ImportType {
-  REFRESH = 'refresh',
-  NEW_RESOURCES = 'new_resources',
-  NEW_ALL = 'new_all',
+  IMPORT = 'import',
+  IMPORT_SPECIFIC = 'import_specific',
 }
 
 const validator = ajv.compile(ConfigFileSchema);
@@ -30,8 +29,8 @@ export function importHandler() {
       throw new Error('Unable to parse import type');
     }
 
-    if (type === ImportType.NEW_RESOURCES && (!resourceTypes || Array.isArray(resourceTypes))) {
-      throw new Error('For new resources import type, a list of resource types must be provided');
+    if (type === ImportType.IMPORT_SPECIFIC && (!resourceTypes || Array.isArray(resourceTypes))) {
+      throw new Error('For import specific, a list of resource types must be provided');
     }
 
     if (!validator(codifyConfig)) {
@@ -46,17 +45,12 @@ export function importHandler() {
 
     let args = '';
     switch (type as ImportType) {
-      case ImportType.REFRESH: { 
-        break;
-      }
-
-      case ImportType.NEW_RESOURCES: {
-        args = (resourceTypes as string[]).join(' ');
+      case ImportType.IMPORT: {
         break;
       }
 
-      case ImportType.NEW_ALL: {
-        args = '*'
+      case ImportType.IMPORT_SPECIFIC: {
+        args = (resourceTypes as string[]).join(' ');
         break;
       } 
     }
@@ -94,7 +88,7 @@ export function importHandler() {
   }
 
   return createCommandHandler({
-    name: ConnectCommand.APPLY,
+    name: ConnectCommand.IMPORT,
     spawnCommand,
     onExit
   });

src/connect/http-routes/handlers/plan-handler.ts

@@ -45,7 +45,7 @@ export function planHandler() {
   }
 
   return createCommandHandler({
-    name: ConnectCommand.APPLY,
+    name: ConnectCommand.PLAN,
     spawnCommand,
     onExit
   });

src/connect/http-routes/handlers/refresh-handler.ts

@@ -0,0 +1,95 @@
+import { spawn } from '@homebridge/node-pty-prebuilt-multiarch';
+import { ConfigFileSchema } from 'codify-schemas';
+import { diffChars } from 'diff';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { WebSocket } from 'ws';
+
+import { ConnectOrchestrator } from '../../../orchestrators/connect.js';
+import { ajv } from '../../../utils/ajv.js';
+import { Session, SocketServer } from '../../socket-server.js';
+import { ConnectCommand, createCommandHandler } from './create-command.js';
+
+enum RefreshType {
+  REFRESH = 'refresh',
+  REFRESH_SPECIFIC = 'refresh_specific'
+}
+
+const validator = ajv.compile(ConfigFileSchema);
+
+export function refreshHandler() {
+  const spawnCommand = async (body: Record<string, unknown>, ws: WebSocket, session: Session) => {
+    const { config: codifyConfig, type, resourceTypes } = body;
+    if (!codifyConfig) {
+      throw new Error('Unable to parse codify config');
+    }
+
+    if (!type || !Object.values(RefreshType).includes(type as RefreshType)) {
+      throw new Error('Unable to parse import type');
+    }
+
+    if (type === RefreshType.REFRESH_SPECIFIC && (!resourceTypes || Array.isArray(resourceTypes))) {
+      throw new Error('For refresh specific, a list of resource types must be provided');
+    }
+
+    if (!validator(codifyConfig)) {
+      throw new Error('Invalid codify config');
+    }
+    
+    const tmpDir = await fs.mkdtemp(os.tmpdir());
+    const filePath = path.join(tmpDir, 'codify.jsonc');
+    await fs.writeFile(filePath, JSON.stringify(codifyConfig, null, 2));
+    session.additionalData.filePath = filePath;
+    session.additionalData.existingFile = codifyConfig;
+
+    let args = '';
+    switch (type as RefreshType) {
+      case RefreshType.REFRESH: {
+        break;
+      }
+
+      case RefreshType.REFRESH_SPECIFIC: {
+        args = (resourceTypes as string[]).join(' ');
+        break;
+      }
+    }
+
+    return spawn('zsh', ['-c', `${ConnectOrchestrator.rootCommand} refresh ${args} -p ${filePath}`], {
+      name: 'xterm-color',
+      cols: 80,
+      rows: 30,
+      cwd: process.env.HOME,
+      env: process.env
+    });
+  }
+
+  const onExit = async (exitCode: number, ws: WebSocket, session: Session) => {
+    if (session.additionalData.filePath) {
+      const updatedFile = await fs.readFile(session.additionalData.filePath as string, 'utf8')
+
+      // Changes were found
+      if (diffChars(updatedFile, session.additionalData.existingFile as string).length > 0) {
+        console.log('Writing imported changes to Codify dashboard');
+
+        const ws = SocketServer.get().getMainConnection(session.clientId);
+        if (!ws) {
+          throw new Error(`Unable to find client for clientId ${session.clientId}`);
+        }
+
+        ws.send(JSON.stringify({ key: 'new_import', data: {
+          updated: updatedFile,
+        } }))
+      }
+
+
+      await fs.rm(session.additionalData.filePath as string, { recursive: true, force: true });
+    }
+  }
+
+  return createCommandHandler({
+    name: ConnectCommand.REFRESH,
+    spawnCommand,
+    onExit
+  });
+}

src/connect/http-routes/router.ts

@@ -4,6 +4,7 @@ import { applyHandler } from './handlers/apply-handler.js';
 import { importHandler } from './handlers/import-handler.js';
 import defaultHandler from './handlers/index.js';
 import { planHandler } from './handlers/plan-handler.js';
+import { refreshHandler } from './handlers/refresh-handler.js';
 import { terminalHandler } from './handlers/terminal-handler.js';
 
 const router = Router();
@@ -12,6 +13,7 @@ router.use('/', defaultHandler);
 router.use('/apply', applyHandler());
 router.use('/plan', planHandler())
 router.use('/import', importHandler());
+router.use('/refresh', refreshHandler());
 router.use('/terminal', terminalHandler());
 
 export default router;

src/events/context.ts

@@ -24,6 +24,7 @@ export enum ProcessName {
   PLAN = 'plan',
   DESTROY = 'destroy',
   IMPORT = 'import',
+  REFRESH = 'refresh',
   INIT = 'init',
 }
 

src/orchestrators/import.ts

@@ -37,11 +37,6 @@ export class ImportOrchestrator {
       { ...args, allowEmptyProject: true },
       reporter
     );
-    const { project } = initializationResult;
-
-    if ((!typeIds || typeIds.length === 0) && project.isEmpty()) {
-      throw new Error('At least one resource [type] must be specified. Ex: "codify import homebrew". Or the import command must be run in a directory with a valid codify file')
-    }
 
     await (!typeIds || typeIds.length === 0
       ? ImportOrchestrator.autoImportAll(reporter, initializationResult)

src/orchestrators/refresh.ts

@@ -27,7 +27,7 @@ export class RefreshOrchestrator {
     reporter: Reporter
   ) {
     const typeIds = args.typeIds?.filter(Boolean)
-    ctx.processStarted(ProcessName.IMPORT)
+    ctx.processStarted(ProcessName.REFRESH)
 
     const initializationResult = await PluginInitOrchestrator.run(
       { ...args, allowEmptyProject: true },
@@ -46,7 +46,7 @@ export class RefreshOrchestrator {
       project.resourceConfigs.filter((r) => !typeIds || typeIds.includes(r.type))
     );
 
-    ctx.processFinished(ProcessName.IMPORT);
+    ctx.processFinished(ProcessName.REFRESH);
 
     reporter.displayImportResult(importResult, false);