@akash-chowdhury-24/deployhub 1.0.0

package/src/storage/providers/dropbox.js

@@ -0,0 +1,49 @@
+import { Dropbox } from 'dropbox';
+import fs from 'fs-extra';
+import path from 'path';
+
+export function createDropboxProvider(env = process.env) {
+  const token = env.DROPBOX_ACCESS_TOKEN;
+  if (!token) {
+    throw new Error('Dropbox credentials incomplete. Set DROPBOX_ACCESS_TOKEN.');
+  }
+
+  const dbx = new Dropbox({ accessToken: token });
+
+  async function upload(localPath, remoteKey) {
+    const key = `/${remoteKey || path.basename(localPath)}`;
+    const contents = await fs.readFile(localPath);
+    await dbx.filesUpload({ path: key, contents, mode: { '.tag': 'overwrite' } });
+  }
+
+  async function download(remoteKey, localPath) {
+    const key = remoteKey.startsWith('/') ? remoteKey : `/${remoteKey}`;
+    const response = await dbx.filesDownload({ path: key });
+    const fileBlob = response.result.fileBinary;
+    await fs.ensureDir(path.dirname(localPath));
+    await fs.writeFile(localPath, fileBlob);
+  }
+
+  async function verify(remoteKey) {
+    const key = remoteKey.startsWith('/') ? remoteKey : `/${remoteKey}`;
+    try {
+      await dbx.filesGetMetadata({ path: key });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async function deleteObject(remoteKey) {
+    const key = remoteKey.startsWith('/') ? remoteKey : `/${remoteKey}`;
+    await dbx.filesDeleteV2({ path: key });
+  }
+
+  async function testConnection() {
+    await dbx.usersGetCurrentAccount();
+  }
+
+  return { upload, download, verify, delete: deleteObject, testConnection };
+}
+
+export default { createDropboxProvider };

package/src/storage/providers/ftp.js

@@ -0,0 +1,69 @@
+import { Client } from 'basic-ftp';
+import fs from 'fs-extra';
+import path from 'path';
+
+export function createFtpProvider(env = process.env) {
+  const host = env.FTP_HOST;
+  const user = env.FTP_USER;
+  const password = env.FTP_PASSWORD;
+  const port = parseInt(env.FTP_PORT || '21', 10);
+  const basePath = env.FTP_PATH || '/uploads';
+
+  if (!host || !user) {
+    throw new Error('FTP credentials incomplete. Set FTP_HOST, FTP_USER, and FTP_PASSWORD.');
+  }
+
+  async function withClient(fn) {
+    const client = new Client();
+    try {
+      await client.access({ host, user, password, port, secure: false });
+      return await fn(client);
+    } finally {
+      client.close();
+    }
+  }
+
+  async function upload(localPath, remoteKey) {
+    const remotePath = `${basePath}/${remoteKey || path.basename(localPath)}`;
+    await withClient(async (client) => {
+      await client.uploadFrom(localPath, remotePath);
+    });
+  }
+
+  async function download(remoteKey, localPath) {
+    const remotePath = `${basePath}/${remoteKey}`;
+    await fs.ensureDir(path.dirname(localPath));
+    await withClient(async (client) => {
+      await client.downloadTo(localPath, remotePath);
+    });
+  }
+
+  async function verify(remoteKey) {
+    const remotePath = `${basePath}/${remoteKey}`;
+    try {
+      await withClient(async (client) => {
+        await client.size(remotePath);
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async function deleteObject(remoteKey) {
+    const remotePath = `${basePath}/${remoteKey}`;
+    await withClient(async (client) => {
+      await client.remove(remotePath);
+    });
+  }
+
+  async function testConnection() {
+    await withClient(async (client) => {
+      await client.pwd();
+    });
+  }
+
+  return { upload, download, verify, delete: deleteObject, testConnection };
+}
+
+export default { createFtpProvider };

package/src/storage/providers/gcp.js

@@ -0,0 +1,45 @@
+import { Storage } from '@google-cloud/storage';
+import fs from 'fs-extra';
+import path from 'path';
+
+export function createGcpProvider(env = process.env) {
+  const bucketName = env.GCP_BUCKET;
+  const keyFile = env.GCP_KEY_FILE;
+
+  if (!bucketName) {
+    throw new Error('GCP credentials incomplete. Set GCP_BUCKET and GCP_KEY_FILE.');
+  }
+
+  const storage = new Storage({
+    projectId: env.GCP_PROJECT_ID,
+    keyFilename: keyFile || undefined,
+  });
+  const bucket = storage.bucket(bucketName);
+
+  async function upload(localPath, remoteKey) {
+    const key = remoteKey || path.basename(localPath);
+    await bucket.upload(localPath, { destination: key });
+  }
+
+  async function download(remoteKey, localPath) {
+    await fs.ensureDir(path.dirname(localPath));
+    await bucket.file(remoteKey).download({ destination: localPath });
+  }
+
+  async function verify(remoteKey) {
+    const [exists] = await bucket.file(remoteKey).exists();
+    return exists;
+  }
+
+  async function deleteObject(remoteKey) {
+    await bucket.file(remoteKey).delete({ ignoreNotFound: true });
+  }
+
+  async function testConnection() {
+    await bucket.getMetadata();
+  }
+
+  return { upload, download, verify, delete: deleteObject, testConnection };
+}
+
+export default { createGcpProvider };

package/src/storage/providers/gdrive.js

@@ -0,0 +1,80 @@
+import { google } from 'googleapis';
+import fs from 'fs-extra';
+import path from 'path';
+import { createReadStream, createWriteStream } from 'fs';
+
+export function createGdriveProvider(env = process.env) {
+  const clientId = env.GDRIVE_CLIENT_ID;
+  const clientSecret = env.GDRIVE_CLIENT_SECRET;
+  const refreshToken = env.GDRIVE_REFRESH_TOKEN;
+  const folderId = env.GDRIVE_FOLDER_ID;
+
+  if (!clientId || !clientSecret || !refreshToken) {
+    throw new Error(
+      'Google Drive credentials incomplete. Set GDRIVE_CLIENT_ID, GDRIVE_CLIENT_SECRET, and GDRIVE_REFRESH_TOKEN.'
+    );
+  }
+
+  const oauth2Client = new google.auth.OAuth2(clientId, clientSecret);
+  oauth2Client.setCredentials({ refresh_token: refreshToken });
+  const drive = google.drive({ version: 'v3', auth: oauth2Client });
+
+  async function upload(localPath, remoteKey) {
+    const fileName = remoteKey || path.basename(localPath);
+    const metadata = { name: fileName };
+    if (folderId) metadata.parents = [folderId];
+
+    await drive.files.create({
+      requestBody: metadata,
+      media: { body: createReadStream(localPath) },
+      fields: 'id',
+    });
+  }
+
+  async function download(remoteKey, localPath) {
+    const res = await drive.files.list({
+      q: `name='${remoteKey}' and trashed=false`,
+      fields: 'files(id)',
+    });
+    const file = res.data.files?.[0];
+    if (!file?.id) throw new Error(`Google Drive file not found: ${remoteKey}`);
+
+    await fs.ensureDir(path.dirname(localPath));
+    const dest = createWriteStream(localPath);
+    const response = await drive.files.get(
+      { fileId: file.id, alt: 'media' },
+      { responseType: 'stream' }
+    );
+    await new Promise((resolve, reject) => {
+      response.data.pipe(dest);
+      dest.on('finish', resolve);
+      dest.on('error', reject);
+    });
+  }
+
+  async function verify(remoteKey) {
+    const res = await drive.files.list({
+      q: `name='${remoteKey}' and trashed=false`,
+      fields: 'files(id)',
+    });
+    return (res.data.files?.length || 0) > 0;
+  }
+
+  async function deleteObject(remoteKey) {
+    const res = await drive.files.list({
+      q: `name='${remoteKey}' and trashed=false`,
+      fields: 'files(id)',
+    });
+    for (const file of res.data.files || []) {
+      if (file.id) await drive.files.delete({ fileId: file.id });
+    }
+  }
+
+  async function testConnection() {
+    await drive.files.list({ pageSize: 1, fields: 'files(id)' });
+  }
+
+  return { upload, download, verify, delete: deleteObject, testConnection };
+}
+
+export default { createGdriveProvider };

package/src/storage/providers/local.js

@@ -0,0 +1,61 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * @param {Record<string, string>} [_env]
+ */
+export function createLocalProvider(_env = process.env) {
+  const baseDir = path.join(process.cwd(), '.deployhub-storage');
+
+  /**
+   * @param {string} localPath
+   * @param {string} [remoteKey]
+   */
+  async function upload(localPath, remoteKey) {
+    const key = remoteKey || path.basename(localPath);
+    const dest = path.join(baseDir, key);
+    await fs.ensureDir(path.dirname(dest));
+    await fs.copy(localPath, dest);
+  }
+
+  /**
+   * @param {string} remoteKey
+   * @param {string} localPath
+   */
+  async function download(remoteKey, localPath) {
+    const src = path.join(baseDir, remoteKey);
+    if (!(await fs.pathExists(src))) {
+      throw new Error(`Local storage file not found: ${remoteKey}`);
+    }
+    await fs.ensureDir(path.dirname(localPath));
+    await fs.copy(src, localPath);
+  }
+
+  /**
+   * @param {string} remoteKey
+   */
+  async function verify(remoteKey) {
+    return fs.pathExists(path.join(baseDir, remoteKey));
+  }
+
+  /**
+   * @param {string} remoteKey
+   */
+  async function deleteObject(remoteKey) {
+    const target = path.join(baseDir, remoteKey);
+    if (await fs.pathExists(target)) {
+      await fs.remove(target);
+    }
+  }
+
+  async function testConnection() {
+    await fs.ensureDir(baseDir);
+    const testFile = path.join(baseDir, '.connection-test');
+    await fs.writeFile(testFile, 'ok');
+    await fs.remove(testFile);
+  }
+
+  return { upload, download, verify, delete: deleteObject, testConnection };
+}
+
+export default { createLocalProvider };

package/src/utils/author.js

@@ -0,0 +1,141 @@
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+export const AUTHOR = {
+  name: 'Akash Chowdhury',
+  email: 'akashbumbac24@gmail.com',
+  linkedin: 'https://www.linkedin.com/in/akash-chowdhury-12141a222/',
+  linkedinShort: 'linkedin.com/in/akash-chowdhury-12141a222',
+};
+
+export const TOOL_NAME = 'DeployHub';
+
+/** GitHub repository slug (owner/repo) for releases and install scripts */
+export const GITHUB_REPO = 'Akash-Chowdhury-24/DeployHub';
+
+let cachedVersion = null;
+
+/**
+ * @returns {string}
+ */
+export function getDeployHubVersion() {
+  if (!cachedVersion) {
+    const pkgPath = path.join(
+      path.dirname(fileURLToPath(import.meta.url)),
+      '../../package.json'
+    );
+    cachedVersion = JSON.parse(readFileSync(pkgPath, 'utf-8')).version;
+  }
+  return cachedVersion;
+}
+
+/**
+ * @returns {string}
+ */
+export function formatVersionOutput() {
+  const version = getDeployHubVersion();
+  return `${version}\nBuilt by ${AUTHOR.name} — ${AUTHOR.email}\n${AUTHOR.linkedin}`;
+}
+
+/**
+ * @returns {object}
+ */
+export function getGeneratedByMetadata() {
+  return {
+    tool: TOOL_NAME,
+    version: getDeployHubVersion(),
+    author: AUTHOR.name,
+    email: AUTHOR.email,
+    linkedin: AUTHOR.linkedin,
+  };
+}
+
+/**
+ * @returns {string}
+ */
+export function getArtifactReadmeFooter() {
+  return `---
+Generated by DeployHub
+Built by ${AUTHOR.name} <${AUTHOR.email}>
+${AUTHOR.linkedin}
+
+This artifact was automatically created and stored by DeployHub.
+`;
+}
+
+/**
+ * @returns {string}
+ */
+export function getWorkflowHeaderComment() {
+  return `# ─────────────────────────────────────────────
+# This workflow was auto-generated by DeployHub
+# Built by ${AUTHOR.name} <${AUTHOR.email}>
+# ${AUTHOR.linkedin}
+# Do not edit this file manually.
+# ─────────────────────────────────────────────
+`;
+}
+
+export function printBanner() {
+  const dim = chalk.dim;
+  const padLine = (content) => {
+    const visible = content.replace(/\u001b\[[0-9;]*m/g, '');
+    const padding = Math.max(0, 49 - visible.length);
+    return dim('│') + content + ' '.repeat(padding) + dim('│');
+  };
+
+  console.log('');
+  console.log(dim('┌─────────────────────────────────────────────────┐'));
+  console.log(dim('│                                                 │'));
+  console.log(padLine('   🚀 ' + chalk.bold.white('DeployHub')));
+  console.log(padLine('   ' + chalk.cyan(`Built by ${AUTHOR.name}`)));
+  console.log(padLine('   ' + chalk.gray(AUTHOR.email)));
+  console.log(padLine('   ' + chalk.gray(AUTHOR.linkedinShort)));
+  console.log(dim('│                                                 │'));
+  console.log(dim('└─────────────────────────────────────────────────┘'));
+  console.log('');
+}
+
+export function printAuthorFooter() {
+  console.log(chalk.dim('─────────────────────────────────────────────'));
+  console.log(chalk.cyan(`  Built with ❤ by ${AUTHOR.name}`));
+  console.log('  Questions or feedback?');
+  console.log(chalk.gray(`  📧  ${AUTHOR.email}`));
+  console.log(chalk.gray(`  💼  ${AUTHOR.linkedinShort}`));
+  console.log(chalk.dim('─────────────────────────────────────────────'));
+  console.log('');
+}
+
+export function printDoctorFooter() {
+  console.log(
+    chalk.gray(`  DeployHub by ${AUTHOR.name} — ${AUTHOR.email}`)
+  );
+}
+
+/**
+ * @returns {boolean}
+ */
+export function shouldShowBanner() {
+  const args = process.argv.slice(2);
+  if (args.includes('--help') || args.includes('-h')) return false;
+  if (args.includes('--version') || args.includes('-V')) return false;
+  const subcommand = args.find((arg) => !arg.startsWith('-'));
+  return Boolean(subcommand);
+}
+
+export default {
+  AUTHOR,
+  TOOL_NAME,
+  GITHUB_REPO,
+  getDeployHubVersion,
+  formatVersionOutput,
+  getGeneratedByMetadata,
+  getArtifactReadmeFooter,
+  getWorkflowHeaderComment,
+  printBanner,
+  printAuthorFooter,
+  printDoctorFooter,
+  shouldShowBanner,
+};

package/src/utils/checksums.js

@@ -0,0 +1,53 @@
+import fs from 'fs-extra';
+import path from 'path';
+import crypto from 'crypto';
+
+/**
+ * @param {string} filePath
+ * @returns {Promise<string>}
+ */
+export async function sha256File(filePath) {
+  const hash = crypto.createHash('sha256');
+  const stream = fs.createReadStream(filePath);
+  return new Promise((resolve, reject) => {
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+
+/**
+ * @param {string} dir
+ * @returns {Promise<Record<string, string>>}
+ */
+export async function generateChecksums(dir) {
+  /** @type {Record<string, string>} */
+  const checksums = {};
+
+  async function walk(currentDir, base = '') {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      const relativePath = path.join(base, entry.name).replace(/\\/g, '/');
+      if (entry.isDirectory()) {
+        await walk(fullPath, relativePath);
+      } else {
+        checksums[relativePath] = await sha256File(fullPath);
+      }
+    }
+  }
+
+  await walk(dir);
+  return checksums;
+}
+
+/**
+ * @param {Record<string, string>} checksums
+ * @returns {string}
+ */
+export function formatChecksums(checksums) {
+  return Object.entries(checksums)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([file, hash]) => `${hash}  ${file}`)
+    .join('\n');
+}

package/src/utils/firebase-config-generator.js

@@ -0,0 +1,35 @@
+/**
+ * Generate firebase.json for Firebase Hosting if missing.
+ *
+ * @param {string} buildOutput
+ * @returns {object}
+ */
+export function generateFirebaseHostingConfig(buildOutput = 'dist') {
+  return {
+    hosting: {
+      public: buildOutput,
+      ignore: ['firebase.json', '**/.*', '**/node_modules/**'],
+      rewrites: [{ source: '**', destination: '/index.html' }],
+    },
+  };
+}
+
+/**
+ * @param {string} buildOutput
+ * @param {string} [cwd]
+ */
+export async function ensureFirebaseJson(buildOutput = 'dist', cwd = process.cwd()) {
+  const fs = (await import('fs-extra')).default;
+  const path = (await import('path')).default;
+  const firebasePath = path.join(cwd, 'firebase.json');
+
+  if (await fs.pathExists(firebasePath)) {
+    return firebasePath;
+  }
+
+  const config = generateFirebaseHostingConfig(buildOutput);
+  await fs.writeJson(firebasePath, config, { spaces: 2 });
+  return firebasePath;
+}
+
+export default { generateFirebaseHostingConfig, ensureFirebaseJson };