Add graph node install command to install local dev node

incrypto32 · incrypto32 · commit 1f62d10b9bb3 · 2025-09-18T20:36:04.000+05:30
diff --git a/packages/cli/package.json b/packages/cli/package.json
@@ -46,6 +46,7 @@
     "assemblyscript": "0.19.23",
     "chokidar": "4.0.3",
     "debug": "4.4.1",
+    "decompress": "^4.2.1",
     "docker-compose": "1.2.0",
     "fs-extra": "11.3.0",
     "glob": "11.0.2",
@@ -57,6 +58,7 @@
     "kubo-rpc-client": "^5.0.2",
     "open": "10.1.2",
     "prettier": "3.5.3",
+    "progress": "^2.0.3",
     "semver": "7.7.2",
     "tmp-promise": "3.0.3",
     "undici": "7.9.0",
@@ -65,8 +67,10 @@
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
+    "@types/decompress": "^4.2.7",
     "@types/fs-extra": "^11.0.4",
     "@types/js-yaml": "^4.0.9",
+    "@types/progress": "^2.0.7",
     "@types/semver": "^7.5.8",
     "@types/which": "^3.0.4",
     "copyfiles": "^2.4.1",
diff --git a/packages/cli/src/command-helpers/local-node.ts b/packages/cli/src/command-helpers/local-node.ts
@@ -0,0 +1,145 @@
+import * as fs from 'node:fs';
+import { createReadStream, createWriteStream } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createGunzip } from 'node:zlib';
+import decompress from 'decompress';
+import fetch from '../fetch.js';
+
+function getPlatformBinaryName(): string {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  if (platform === 'linux' && arch === 'x64') return 'gnd-linux-x86_64.gz';
+  if (platform === 'linux' && arch === 'arm64') return 'gnd-linux-aarch64.gz';
+  if (platform === 'darwin' && arch === 'x64') return 'gnd-macos-x86_64.gz';
+  if (platform === 'darwin' && arch === 'arm64') return 'gnd-windows-x86_64.exe.zip'; //'gnd-macos-aarch64.gz';
+  if (platform === 'win32' && arch === 'x64') return 'gnd-windows-x86_64.exe.zip';
+
+  throw new Error(`Unsupported platform: ${platform} ${arch}`);
+}
+
+export async function getGlobalBinDir(): Promise<string> {
+  const platform = os.platform();
+  let binDir: string;
+
+  if (platform === 'win32') {
+    // Prefer %USERPROFILE%\gnd\bin
+    binDir = path.join(process.env.USERPROFILE || os.homedir(), 'gnd', 'bin');
+  } else {
+    binDir = path.join(os.homedir(), '.local', 'bin');
+  }
+
+  await fs.promises.mkdir(binDir, { recursive: true });
+  return binDir;
+}
+
+async function getLatestGithubRelease(owner: string, repo: string) {
+  const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/releases/latest`);
+  const data = await res.json();
+  return data.tag_name;
+}
+
+export async function getLatestGraphNodeRelease(): Promise<string> {
+  return getLatestGithubRelease('incrypto32', 'graph-node');
+}
+
+export async function downloadGraphNodeRelease(
+  release: string,
+  outputDir: string,
+  onProgress?: (downloaded: number, total: number | null) => void,
+): Promise<string> {
+  const fileName = getPlatformBinaryName();
+  return downloadGithubRelease(
+    'incrypto32',
+    'graph-node',
+    release,
+    outputDir,
+    fileName,
+    onProgress,
+  );
+}
+
+async function downloadGithubRelease(
+  owner: string,
+  repo: string,
+  release: string,
+  outputDir: string,
+  fileName: string,
+  onProgress?: (downloaded: number, total: number | null) => void,
+): Promise<string> {
+  const url = `https://github.com/${owner}/${repo}/releases/download/${release}/${fileName}`;
+  return downloadFile(url, path.join(outputDir, fileName), onProgress);
+}
+
+export async function downloadFile(
+  url: string,
+  outputPath: string,
+  onProgress?: (downloaded: number, total: number | null) => void,
+): Promise<string> {
+  return download(url, outputPath, onProgress);
+}
+
+export async function download(
+  url: string,
+  outputPath: string,
+  onProgress?: (downloaded: number, total: number | null) => void,
+): Promise<string> {
+  const res = await fetch(url);
+  if (!res.ok || !res.body) {
+    throw new Error(`Failed to download: ${res.statusText}`);
+  }
+
+  const totalLength = Number(res.headers.get('content-length')) || null;
+  let downloaded = 0;
+
+  const fileStream = fs.createWriteStream(outputPath);
+  const nodeStream = Readable.from(res.body);
+
+  nodeStream.on('data', chunk => {
+    downloaded += chunk.length;
+    onProgress?.(downloaded, totalLength);
+  });
+
+  nodeStream.pipe(fileStream);
+
+  await new Promise<void>((resolve, reject) => {
+    nodeStream.on('error', reject);
+    fileStream.on('finish', resolve);
+    fileStream.on('error', reject);
+  });
+
+  return outputPath;
+}
+
+export async function extractGz(gzPath: string, outputPath?: string): Promise<string> {
+  const outPath = outputPath || path.join(path.dirname(gzPath), path.basename(gzPath, '.gz'));
+
+  await pipeline(createReadStream(gzPath), createGunzip(), createWriteStream(outPath));
+
+  return outPath;
+}
+
+export async function extractZipAndGetExe(zipPath: string, outputDir: string): Promise<string> {
+  const files = await decompress(zipPath, outputDir);
+  const exe = files.filter(file => file.path.endsWith('.exe'));
+
+  if (exe.length !== 1) {
+    throw new Error(`Expected 1 executable file in zip, got ${exe.length}`);
+  }
+
+  return path.join(outputDir, exe[0].path);
+}
+
+export async function moveFileToBinDir(srcPath: string, binDir?: string): Promise<string> {
+  const targetDir = binDir || (await getGlobalBinDir());
+  const destPath = path.join(targetDir, path.basename(srcPath));
+  await fs.promises.rename(srcPath, destPath);
+  return destPath;
+}
+export async function moveFile(srcPath: string, destPath: string): Promise<string> {
+  await fs.promises.rename(srcPath, destPath);
+  return destPath;
+}
diff --git a/packages/cli/src/commands/node.ts b/packages/cli/src/commands/node.ts
@@ -0,0 +1,90 @@
+import * as fs from 'node:fs';
+import { chmod } from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { print } from 'gluegun';
+import ProgressBar from 'progress';
+import { Command, Flags } from '@oclif/core';
+import {
+  downloadGraphNodeRelease,
+  extractGz,
+  extractZipAndGetExe,
+  getLatestGraphNodeRelease,
+  moveFileToBinDir,
+} from '../command-helpers/local-node.js';
+
+export default class NodeCommand extends Command {
+  static description = 'Manage Graph node related operations';
+
+  static flags = {
+    help: Flags.help({
+      char: 'h',
+    }),
+  };
+
+  static args = {};
+
+  static examples = ['$ graph node install'];
+
+  static strict = false;
+
+  async run() {
+    const { argv } = await this.parse(NodeCommand);
+
+    if (argv.length > 0) {
+      const subcommand = argv[0];
+
+      if (subcommand === 'install') {
+        await installGraphNode();
+      }
+
+      // If no valid subcommand is provided, show help
+      await this.config.runCommand('help', ['node']);
+    }
+  }
+}
+
+async function installGraphNode() {
+  const latestRelease = await getLatestGraphNodeRelease();
+  const tmpBase = os.tmpdir();
+  const tmpDir = await fs.promises.mkdtemp(path.join(tmpBase, 'graph-node-'));
+  let progressBar: ProgressBar | undefined;
+  const downloadPath = await downloadGraphNodeRelease(
+    latestRelease,
+    tmpDir,
+    (downloaded, total) => {
+      if (!total) return;
+
+      progressBar ||= new ProgressBar(`Downloading ${latestRelease} [:bar] :percent`, {
+        width: 30,
+        total,
+        complete: '=',
+        incomplete: ' ',
+      });
+
+      progressBar.tick(downloaded - (progressBar.curr || 0));
+    },
+  );
+
+  let extractedPath: string;
+
+  if (downloadPath.endsWith('.gz')) {
+    extractedPath = await extractGz(downloadPath);
+    print.info(`Extracted ${extractedPath}`);
+  } else if (downloadPath.endsWith('.zip')) {
+    extractedPath = await extractZipAndGetExe(downloadPath, tmpDir);
+    print.info(`Extracted ${extractedPath}`);
+  } else {
+    throw new Error(`Unsupported file type: ${downloadPath}`);
+  }
+
+  const movedPath = await moveFileToBinDir(extractedPath);
+  print.info(`Moved ${extractedPath} to ${movedPath}`);
+
+  if (os.platform() !== 'win32') {
+    await chmod(movedPath, 0o755);
+  }
+
+  // Delete the temporary directory
+  await fs.promises.rm(tmpDir, { recursive: true, force: true });
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
