feat: Added connect integration with codify-dashboard

Author: kevinwang5658

package-lock.json

@@ -35,7 +35,9 @@
     "parse-json": "^8.1.0",
     "react": "^18.3.1",
     "semver": "^7.5.4",
-    "supports-color": "^9.4.0"
+    "socket.io": "^4.8.1",
+    "supports-color": "^9.4.0",
+    "ws": "^8.18.3"
   },
   "description": "Codify allows users to configure settings, install new packages, and automate their systems using code instead of the GUI. Get set up on a new laptop in one click, maintain a Codify file within your project so anyone can get started and never lose your cool apps or favourite settings again.",
   "devDependencies": {
@@ -52,6 +54,8 @@
     "@types/react": "^18.3.1",
     "@types/semver": "^7.5.4",
     "@types/strip-ansi": "^5.2.1",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^8.16.0",
     "codify-plugin-lib": "^1.0.151",
     "esbuild": "^0.24.0",
@@ -69,7 +73,8 @@
     "strip-ansi": "^7.1.0",
     "tsx": "^4.7.3",
     "typescript": "5.3.3",
-    "vitest": "^2.1.6"
+    "vitest": "^2.1.6",
+    "uuid": "^10.0.0"
   },
   "overrides": {
     "ink-form": {

package.json

@@ -0,0 +1,24 @@
+import { BaseCommand } from '../common/base-command.js';
+import { LoginOrchestrator } from '../orchestrators/login.js';
+import { ConnectOrchestrator } from '../orchestrators/connect.js';
+
+export default class Connect extends BaseCommand {
+  static description =
+    `Validate a codify.jsonc/codify.json/codify.yaml file.
+    
+For more information, visit: https://docs.codifycli.com/commands/validate
+`
+
+  static flags = {}
+
+  static examples = [
+    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> --path=../../import.codify.jsonc',
+  ]
+
+  public async run(): Promise<void> {
+    const { flags } = await this.parse(Connect)
+
+    await ConnectOrchestrator.run();
+  }
+}

src/commands/connect.ts

@@ -0,0 +1,51 @@
+import { spawn } from '@homebridge/node-pty-prebuilt-multiarch';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { v4 as uuid } from 'uuid';
+import { WebSocket } from 'ws';
+
+import { WsServerManager } from './server.js';
+
+export function connectApplyInitHandler(msg: any, initWs: WebSocket, manager: WsServerManager) {
+  const sessionId = uuid();
+
+  manager.startAdhocWsServer(sessionId, async (ws) => {
+    console.log('connected apply ws');
+
+    const { config } = msg;
+    console.log('apply ws open', config);
+
+    const tmpDir = await fs.mkdtemp(os.tmpdir());
+    const filePath = path.join(tmpDir, 'codify.json');
+
+    await fs.writeFile(filePath, JSON.stringify(config));
+
+    const pty = spawn('zsh', ['-c',  'codify apply'], {
+      name: 'xterm-color',
+      cols: 80,
+      rows: 30,
+      cwd: process.env.HOME,
+      env: process.env
+    });
+
+    pty.onData((data) => {
+      ws.send(Buffer.from(data, 'utf8'));
+    });
+
+    ws.on('message', (message) => {
+      pty.write(message.toString('utf8'));
+    })
+
+    pty.onExit(({ exitCode, signal }) => {
+      console.log('pty exit', exitCode, signal);
+      // ws.close(exitCode);
+      ws.terminate();
+    })
+  });
+
+  initWs.send(JSON.stringify({
+    cmd: 'apply_init_response',
+    sessionId,
+  }))
+}

src/connect/apply.ts

@@ -0,0 +1,33 @@
+import { WebSocket } from 'ws';
+
+import { connectApplyInitHandler } from './apply.js';
+import { WsServerManager } from './server.js';
+
+export async function defaultWsHandler(ws: WebSocket, manager: WsServerManager) {
+  ws.on('message', (message) => {
+    let msg;
+    try {
+      msg = JSON.parse(message.toString('utf8'));
+      console.log(msg);
+    } catch (error) {
+      console.error(error);
+      return;
+    }
+
+    const { cmd } = msg;
+    if (!cmd) {
+      console.error('No cmd found');
+      return;
+    }
+
+    switch (cmd) {
+      case 'apply_init': {
+        connectApplyInitHandler(msg, ws, manager);
+        break;
+      }
+    }
+
+  })
+}
+
+

src/connect/route-handler.ts

@@ -0,0 +1,112 @@
+import { IncomingMessage, Server, createServer } from 'node:http';
+import { v4 as uuid } from 'uuid';
+import { WebSocket, WebSocketServer } from 'ws';
+
+const DEFAULT_PORT = 51_040;
+
+export class WsServerManager {
+
+  server: Server;
+  port?: number;
+
+  private wsServerMap = new Map<string, WebSocketServer>();
+  private handlerMap = new Map<string, (ws: WebSocket, manager: WsServerManager, request: IncomingMessage) => void>();
+
+  private connectionSecret;
+
+  constructor(connectionSecret?: string) {
+    this.server = createServer();
+    this.connectionSecret = connectionSecret;
+    this.wsServerMap.set('default', this.createWssServer());
+
+    this.initServer();
+  }
+
+  listen(cb?: () => void, port?: number, ) {
+    this.port = port ?? DEFAULT_PORT
+    this.server.listen(this.port, 'localhost', cb);
+  }
+  
+  setDefaultHandler(handler: (ws: WebSocket, manager: WsServerManager) => void): WsServerManager {
+    const wss = this.createWssServer();
+    this.wsServerMap.set('default', wss);
+    this.handlerMap.set('default', handler);
+
+    return this;
+  }
+
+  addAdditionalHandlers(path: string, handler: (ws: WebSocket) => void): WsServerManager {
+    this.handlerMap.set(path, () => {
+      const wss = this.addWebsocketServer();
+
+    });
+
+    return this;
+  }
+
+  startAdhocWsServer(sessionId: string, handler: (ws: WebSocket, manager: WsServerManager) => void) {
+    this.wsServerMap.set(sessionId, this.createWssServer());
+    this.handlerMap.set(sessionId, handler);
+  }
+
+  private addWebsocketServer(): string {
+    const key = uuid();
+
+    const wss = new WebSocketServer({
+      noServer: true
+    })
+    this.wsServerMap.set(key, wss);
+
+    wss.on('close', () => {
+      this.wsServerMap.delete(key);
+    })
+
+    return key;
+  }
+
+  private initServer() {
+    this.server.on('upgrade', (request, socket, head) => {
+      console.log('upgrade')
+
+      const { pathname } = new URL(request.url!, 'ws://localhost:51040')
+      console.log('Pathname:', pathname)
+
+      const code = request.headers['sec-websocket-protocol']
+      if (this.connectionSecret && code !== this.connectionSecret) {
+        console.log('Auth failed');
+        socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n')
+        socket.destroy()
+        return;
+      }
+
+      if (pathname === '/' && this.handlerMap.has('default')) {
+        const wss = this.wsServerMap.get('default');
+        wss?.handleUpgrade(request, socket, head, (ws, request) => this.handlerMap.get('default')!(ws, this, request));
+        return;
+      }
+
+      const pathSections = pathname.split('/').filter(Boolean);
+      console.log(pathSections);
+      console.log('available sessions', this.handlerMap)
+
+      if (pathSections[0] === 'session'
+        && pathSections[1]
+        && this.handlerMap.has(pathSections[1])
+      ) {
+        const sessionId = pathSections[1];
+        console.log('session found, upgrading', sessionId);
+
+        const wss = this.wsServerMap.get(sessionId)!;
+
+        wss.handleUpgrade(request, socket, head, (ws, request) => this.handlerMap.get(sessionId)!(ws, this, request));
+        return;
+      }
+    })
+  }
+
+  private createWssServer(): WebSocketServer {
+    return new WebSocketServer({
+      noServer: true,
+    })
+  }
+}

src/connect/server.ts

@@ -0,0 +1,91 @@
+import { spawn } from '@homebridge/node-pty-prebuilt-multiarch';
+import { randomBytes } from 'node:crypto';
+import open from 'open';
+import { WebSocket } from 'ws';
+
+import { defaultWsHandler } from '../connect/route-handler.js';
+import { WsServerManager } from '../connect/server.js';
+
+export class ConnectOrchestrator {
+  static async run() {
+    const connectionSecret = ConnectOrchestrator.tokenGenerate()
+    console.log(connectionSecret)
+
+    const server = new WsServerManager(connectionSecret)
+      .setDefaultHandler(defaultWsHandler)
+      .addAdditionalHandlers('/apply-logs', () => {})
+      .addAdditionalHandlers('/import-logs', () => {})
+      .addAdditionalHandlers('/terminal', () => {})
+
+    server.listen(() => {
+      open(`http://localhost:3000/connection/success?code=${connectionSecret}`)
+    });
+  }
+
+  private static onConnection(ws: WebSocket) {
+    console.log('[WS] Connection opened');
+
+    ws.on('apply', (message) => {
+      let data;
+      try {
+        data = JSON.parse(message.toString('utf8'));
+        console.log(data);
+      } catch (error) {
+        console.error(error);
+      }
+
+    });
+
+    ws.on('close', () => {
+
+    });
+  }
+
+  /*
+  private static async onApply(ws: WebSocket, data: any) {
+    const { config } = data;
+    const tmpDir = await fs.mkdtemp(os.tmpdir());
+    const filePath = path.join(tmpDir, 'codify.json');
+
+    await fs.writeFile(filePath, JSON.stringify(config));
+
+    const server = createServer()
+    const wss = new WebSocketServer({
+
+    })
+
+    server.on('upgrade', (request, socket, head) => {
+      wss.handleUpgrade(request, socket, head, (ws2) => {
+        const pty = spawn('zsh', ['-c', '"codify apply"'], {
+          name: 'xterm-color',
+          cols: 80,
+          rows: 30,
+          cwd: process.env.HOME,
+          env: process.env
+        });
+
+        pty.onData((data) => {
+          ws2.send(Buffer.from(data, 'utf8'));
+        });
+
+        ws2.on('message', (message) => {
+          pty.write(message.toString('utf8'));
+        })
+
+        pty.onExit((code) => {
+          ws2.close(code, code);
+        })
+      })
+    });
+
+    server.listen(2123, () => {
+      ws.emit('apply_Response', {
+        wsPass: 'pass',
+      })
+    })
+  } */
+
+  private static tokenGenerate(length = 20): string {
+    return Buffer.from(randomBytes(length)).toString('hex')
+  }
+}

src/orchestrators/connect.ts

@@ -10,10 +10,6 @@ export class LoginOrchestrator {
       LoginOrchestrator.handleRequests(req, res);
     });
 
-    process.stdout.on('data', (data) => {
-      console.log(data);
-    })
-
     server.listen(51_039, 'localhost', () => {
       console.log('Opening CLI auth page...')
       open('http://localhost:3000/auth/cli');