lazypush-cli 0.1.0

package/src/commands/jobs.ts

@@ -0,0 +1,87 @@
+import { getApiClient } from '../api/client';
+import { info, success, error, log } from '../logger';
+import chalk from 'chalk';
+import { requireAuth } from '../utils/auth';
+
+export async function handleJobs() {
+  if (!(await requireAuth())) {
+    process.exit(1);
+  }
+
+  try {
+    const api = getApiClient();
+    const jobs = await api.listJobs();
+
+    if (jobs.length === 0) {
+      info('No scheduled jobs');
+      return;
+    }
+
+    log('');
+    log(chalk.bold('Scheduled Jobs:'));
+    log('');
+
+    jobs.forEach((job: any, i: number) => {
+      const status = chalk.gray(job.status);
+      const time = new Date(job.scheduledAt).toLocaleString();
+      const branch = chalk.cyan(job.branch);
+      log(`${i + 1}. ${chalk.yellow(job._id)} [${status}]`);
+      log(`   Branch: ${branch} @ ${time}`);
+    });
+
+    log('');
+  } catch (e: any) {
+    error(`Failed to fetch jobs: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+export async function handleCancel(id: string) {
+  if (!(await requireAuth())) {
+    process.exit(1);
+  }
+
+  try {
+    const api = getApiClient();
+    await api.cancelJob(id);
+    success(`Job ${id} cancelled`);
+  } catch (e: any) {
+    error(`Failed to cancel job: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+export async function handleList() {
+  if (!(await requireAuth())) {
+    process.exit(1);
+  }
+
+  try {
+    const api = getApiClient();
+    const jobs = await api.listAllJobs();
+
+    if (jobs.length === 0) {
+      info('No jobs found');
+      return;
+    }
+
+    log('');
+    log(chalk.bold('All Scheduled/Finished Jobs:'));
+    log('');
+
+    jobs.forEach((job: any, i: number) => {
+      const status = chalk.gray(job.status);
+      const time = new Date(job.scheduledAt).toLocaleString();
+      const branch = chalk.cyan(job.branch);
+      const user = chalk.green(job.username || 'unknown');
+      log(`${i + 1}. ${chalk.yellow(job._id)} [${status}]`);
+      log(`   User: ${user}`);
+      log(`   Branch: ${branch} @ ${time}`);
+    });
+
+    log('');
+  } catch (e: any) {
+    error(`Failed to fetch jobs: ${e.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/login.ts

@@ -0,0 +1,131 @@
+import open from "open";
+import inquirer from "inquirer";
+import { createServer, Server } from "http";
+import { saveSession, getSession } from "../config";
+import { info, success, error } from "../logger";
+
+export async function handleLogin() {
+  try {
+    const existing = getSession();
+    if (existing) {
+      success(`Already logged in as: ${existing.username}`);
+      const { confirm } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: "Login again?",
+          default: false,
+        },
+      ]);
+      if (!confirm) return;
+    }
+
+    const token = await waitForOAuthCallback();
+    
+    if (!token) {
+      error("Authentication cancelled");
+      process.exit(1);
+    }
+
+    info("Verifying token...");
+    try {
+      const jwtPayload = parseJwt(token);
+      if (!jwtPayload.userId) {
+        throw new Error('Invalid token: missing userId');
+      }
+      
+      const session = {
+        token,
+        userId: jwtPayload.userId,
+        username: jwtPayload.username || "user",
+        createdAt: new Date().toISOString(),
+      };
+
+      saveSession(session);
+      success(`Logged in successfully as ${jwtPayload.username}!`);
+      const expiryDate = new Date(jwtPayload.exp * 1000);
+      info(`Token will expire on: ${expiryDate.toLocaleString()}`);
+    } catch (e: any) {
+      error(`Token validation failed: ${e.message}`);
+      process.exit(1);
+    }
+  } catch (e: any) {
+    error(`Login failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+async function waitForOAuthCallback(): Promise<string | null> {
+  return new Promise((resolve) => {
+    let server: Server | null = null;
+    const port = 3001;
+    const timeout = setTimeout(() => {
+      if (server) server.close();
+      error("Login timeout - no response from GitHub");
+      resolve(null);
+    }, 10 * 60 * 1000); // 10 minute timeout
+
+    server = createServer((req, res) => {
+      if (!req.url) {
+        res.writeHead(400);
+        res.end("Invalid request");
+        return;
+      }
+
+      
+      const urlObj = new URL(`http://localhost${req.url}`);
+      const token = urlObj.searchParams.get("token");
+      const errorParam = urlObj.searchParams.get("error");
+
+      if (errorParam) {
+        res.writeHead(400);
+        res.end(`Authentication failed: ${errorParam}`);
+        if (server) server.close();
+        clearTimeout(timeout);
+        resolve(null);
+        return;
+      }
+
+      if (token) {
+        res.writeHead(200);
+        res.end("Authentication successful! You can close this window.");
+        if (server) server.close();
+        clearTimeout(timeout);
+        resolve(token);
+        return;
+      }
+
+      res.writeHead(400);
+      res.end("Missing token");
+    });
+
+    server.listen(port, () => {
+      info("Opening browser for GitHub authentication...");
+      const apiUrl = process.env.LAZYPUSH_API || "https://lazypush.onrender.com";
+      const redirectUri = `http://localhost:${port}/auth/callback`;
+      const loginUrl = `${apiUrl}/auth/github?redirect_uri=${encodeURIComponent(redirectUri)}`;
+
+      open(loginUrl);
+      info("Browser opened. If it did not open, visit:");
+      info(loginUrl);
+      info("");
+    });
+  });
+}
+
+function parseJwt(token: string) {
+  try {
+    const base64Url = token.split(".")[1];
+    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+    const jsonPayload = decodeURIComponent(
+      atob(base64)
+        .split("")
+        .map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2))
+        .join(""),
+    );
+    return JSON.parse(jsonPayload);
+  } catch {
+    return {};
+  }
+  process.exit(1);
+}

package/src/commands/logout.ts

@@ -0,0 +1,12 @@
+import { clearSession } from '../config';
+import { success, error } from '../logger';
+
+export function handleLogout() {
+  try {
+    clearSession();
+    success('Logged out');
+  } catch (e: any) {
+    error(`Logout failed: ${e.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/schedule.ts

@@ -0,0 +1,241 @@
+import inquirer from 'inquirer';
+import dayjs from 'dayjs';
+import { getApiClient } from '../api/client';
+import { info, success, error,  warn } from '../logger';
+import { requireAuth } from '../utils/auth';
+import { getRepoUrl, getBranch, createBundle, compressBundle, bundleToBase64, cleanupBundle, hasUncommittedChanges, getUncommittedFiles, getBranchTrackingInfo } from '../utils/git';
+import { parseScheduleTime } from '../utils/scheduler';
+
+export async function handleScheduleInteractive() {
+  if (!(await requireAuth())) {
+    process.exit(1);
+  }
+
+  try {
+    // Pre-flight checks
+    info('═══ PRE-FLIGHT CHECKS ═══');
+    info('Detecting repository...');
+    const repoUrl = getRepoUrl();
+    const branch = getBranch();
+    info(`Repository: ${repoUrl}`);
+    info(`Branch: ${branch}`);
+    info('');
+
+    // Check for uncommitted changes
+    if (hasUncommittedChanges()) {
+      const files = getUncommittedFiles();
+      warn(`Found ${files.length} uncommitted file(s):`);
+      files.forEach(f => info(`  - ${f}`));
+      info('');
+
+      try {
+        require('child_process').execSync('git add .', { stdio: 'inherit' });
+        success('Files staged for commit');
+        const staged = require('child_process')
+          .execSync('git diff --name-only --cached', { encoding: 'utf8' })
+          .trim();
+        if (staged) {
+          info('Staged files:');
+          staged.split('\n').forEach((f: string) => info(`  - ${f}`));
+        } else {
+          warn('No staged files found');
+        }
+        info('');
+      } catch (e) {
+        error('Failed to stage files');
+        process.exit(1);
+      }
+    } else {
+      success('Working directory clean');
+      info('');
+    }
+
+    // Check branch tracking
+    const tracking = getBranchTrackingInfo();
+    if (tracking) {
+      info(`Remote: ${tracking.remote}/${tracking.upstream}`);
+    } else {
+      warn(`No upstream tracking set for branch "${branch}"`);
+      info('Note: Will push to origin');
+      info('');
+    }
+    info('═══════════════════════');
+    info('');
+
+    // Step 1: Date, time, timezone
+    const timeAnswers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'date',
+        message: 'Date (dd/mm/yyyy format, or press Enter for today)',
+        default: () => dayjs().format('DD/MM/YYYY'),
+        validate: (input: string) => {
+          const parts = input.split('/');
+          if (parts.length !== 3) return 'Invalid format. Use dd/mm/yyyy';
+          const d = parseInt(parts[0], 10);
+          const m = parseInt(parts[1], 10);
+          const y = parseInt(parts[2], 10);
+          if (d < 1 || d > 31 || m < 1 || m > 12) return 'Invalid date';
+          return true;
+        }
+      },
+      {
+        type: 'input',
+        name: 'time',
+        message: 'Time (e.g., 5:30pm, 17:30, 9:15am)',
+        validate: (input: string) => {
+          const match = input.match(/^(\d{1,2})(?::(\d{2}))?\s?(am|pm)?$/i);
+          if (!match) return 'Invalid time format. Use: 5pm, 5:30pm, or 17:30';
+          return true;
+        }
+      },
+      {
+        type: 'input',
+        name: 'timezone',
+        message: 'Timezone (or press Enter for local)',
+        default: 'local'
+      }
+    ]);
+
+    // Show timezone info
+    const tz = timeAnswers.timezone === 'local' ? undefined : timeAnswers.timezone;
+    const tzDisplay = tz || dayjs.tz.guess() || 'UTC';
+    info(`Local timezone: ${tzDisplay}`);
+    info('');
+
+    // Step 2: Commit message
+    const messageAnswers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'message',
+        message: 'Commit message (optional)',
+        default: ''
+      }
+    ]);
+
+    // Step 3: Show repo/branch and ask for confirmation
+    info('');
+    info('═══ PUSH DETAILS ═══');
+    info(`Repository: ${repoUrl}`);
+    info(`Branch: ${branch}`);
+    info(`Commit Message: ${messageAnswers.message || '(none)'}`);
+    info('═══════════════════');
+    info('');
+
+    const confirmAnswers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Confirm scheduling?',
+        default: true
+      }
+    ]);
+
+    if (!confirmAnswers.confirm) {
+      info('Scheduling cancelled');
+      return;
+    }
+
+    info('Parsing scheduled time...');
+    const dateStr = timeAnswers.date;
+    const timeStr = timeAnswers.time;
+
+    const [day, month, year] = dateStr.split('/');
+    let scheduledAt: Date;
+
+    try {
+      let target = dayjs(`${year}-${month}-${day}`);
+      if (tz) target = target.tz(tz);
+      
+      const timeMatch = timeStr.match(/^(\d{1,2})(?::(\d{2}))?\s?(am|pm)?$/i);
+      if (timeMatch) {
+        let [, hour, minutes, ampm] = timeMatch;
+        let h = parseInt(hour, 10);
+        let m = minutes ? parseInt(minutes, 10) : 0;
+        if (ampm?.toLowerCase() === 'pm' && h !== 12) h += 12;
+        if (ampm?.toLowerCase() === 'am' && h === 12) h = 0;
+        target = target.hour(h).minute(m).second(0);
+      }
+
+      scheduledAt = (tz ? target.utc() : target).toDate();
+    } catch (e) {
+      throw new Error('Invalid date/time');
+    }
+
+    info(`Scheduled for: ${scheduledAt.toLocaleString()} UTC`);
+
+    info('Creating git bundle...');
+    const bundlePath = createBundle(branch);
+
+    info('Compressing bundle...');
+    const gzPath = compressBundle(bundlePath);
+
+    info('Encoding to base64...');
+    const bundleBase64 = bundleToBase64(gzPath);
+
+    info('Uploading to backend...');
+    const api = getApiClient();
+    const job = await api.scheduleJob({
+      repoUrl,
+      branch,
+      scheduledAt,
+      bundleBase64,
+      commitMessage: messageAnswers.message || undefined
+    });
+
+    cleanupBundle(bundlePath, gzPath);
+
+    success(`Job scheduled! ID: ${job.id}`);
+    info(`Push will occur at: ${scheduledAt.toLocaleString()}`);
+  } catch (e: any) {
+    error(`Failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+export async function handleSchedule(timeInput: string, timezone?: string, message?: string) {
+  if (!(await requireAuth())) {
+    process.exit(1);
+  }
+
+  try {
+    info('Detecting repository...');
+    const repoUrl = getRepoUrl();
+    const branch = getBranch();
+    info(`Repository: ${repoUrl}`);
+    info(`Branch: ${branch}`);
+
+    info('Parsing scheduled time...');
+    const tz = timezone || 'UTC';
+    info(`Using timezone: ${tz}`);
+    const scheduledAt = parseScheduleTime(timeInput, tz);
+    info(`Scheduled for: ${scheduledAt.toLocaleString()} UTC`);
+
+    info('Creating git bundle...');
+    const bundlePath = createBundle(branch);
+
+    info('Compressing bundle...');
+    const gzPath = compressBundle(bundlePath);
+
+    info('Encoding to base64...');
+    const bundleBase64 = bundleToBase64(gzPath);
+
+    info('Uploading to backend...');
+    const api = getApiClient();
+    const job = await api.scheduleJob({
+      repoUrl,
+      branch,
+      scheduledAt,
+      bundleBase64,
+      commitMessage: message
+    });
+
+    cleanupBundle(bundlePath, gzPath);
+
+    success(`Job scheduled! ID: ${job.id}`);
+    info(`Push will occur at: ${scheduledAt.toLocaleString()}`);
+  } catch (e: any) {
+    error(`Failed: ${e.message}`);
+    process.exit(1);
+  }
+}

package/src/config.ts

@@ -0,0 +1,45 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.lazypush');
+const SESSION_FILE = path.join(CONFIG_DIR, 'session.json');
+
+export interface Session {
+  token: string;
+  userId: string;
+  username: string;
+  createdAt: string;
+}
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function saveSession(session: Session) {
+  ensureConfigDir();
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2), 'utf8');
+}
+
+export function getSession(): Session | null {
+  if (!fs.existsSync(SESSION_FILE)) return null;
+  try {
+    const data = fs.readFileSync(SESSION_FILE, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+export function clearSession() {
+  if (fs.existsSync(SESSION_FILE)) {
+    fs.unlinkSync(SESSION_FILE);
+  }
+}
+
+export function getAuthToken(): string | null {
+  const session = getSession();
+  return session?.token || null;
+}

package/src/logger.ts

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+
+export function info(msg: string) {
+  console.log(chalk.blue('ℹ'), msg);
+}
+
+export function success(msg: string) {
+  console.log(chalk.green('✓'), msg);
+}
+
+export function error(msg: string) {
+  console.log(chalk.red('✗'), msg);
+}
+
+export function warn(msg: string) {
+  console.log(chalk.yellow('⚠'), msg);
+}
+
+export function log(msg: string) {
+  console.log(msg);
+}

package/src/utils/auth.ts

@@ -0,0 +1,15 @@
+import { handleLogin } from '../commands/login';
+import { getAuthToken } from '../config';
+import { warn, info } from '../logger';
+
+export async function requireAuth(): Promise<boolean> {
+  const token = getAuthToken();
+  if (token) {
+    return true;
+  }
+
+  warn('Not authenticated. Starting login...');
+  info('');
+  await handleLogin();
+  return getAuthToken() ? true : false;
+}

package/src/utils/git.ts

@@ -0,0 +1,93 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import zlib from 'zlib';
+import path from 'path';
+import os from 'os';
+
+export function getRepoUrl(): string {
+  try {
+    const url = execSync('git remote get-url origin', { encoding: 'utf8' }).trim();
+    if (!url) throw new Error('No origin found');
+    return url;
+  } catch {
+    throw new Error('Not in a git repository or no origin set');
+  }
+}
+
+export function getBranch(): string {
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();
+    if (!branch || branch === 'HEAD') throw new Error('Cannot determine branch');
+    return branch;
+  } catch {
+    throw new Error('Could not detect current branch');
+  }
+}
+
+export function hasUncommittedChanges(): boolean {
+  try {
+    const status = execSync('git status --porcelain', { encoding: 'utf8' }).trim();
+    return status.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+export function getUncommittedFiles(): string[] {
+  try {
+    const status = execSync('git status --porcelain', { encoding: 'utf8' }).trim();
+    if (!status) return [];
+    return status.split('\n').map(line => line.slice(3).trim()).filter(f => f);
+  } catch {
+    return [];
+  }
+}
+
+export function getBranchTrackingInfo(): { remote: string; upstream: string } | null {
+  try {
+    const remote = execSync('git config --get branch.$(git rev-parse --abbrev-ref HEAD).remote', { encoding: 'utf8' }).trim();
+    const upstream = execSync('git config --get branch.$(git rev-parse --abbrev-ref HEAD).merge', { encoding: 'utf8' }).trim();
+    if (!remote || !upstream) return null;
+    return { remote, upstream: upstream.replace('refs/heads/', '') };
+  } catch {
+    return null;
+  }
+}
+
+export function createBundle(branch: string = 'HEAD'): string {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lazypush-'));
+  const bundlePath = path.join(tmpDir, 'repo.bundle');
+  try {
+    // Create bundle with the branch name to preserve refs/heads/<branch>
+    execSync(`git bundle create "${bundlePath}" ${branch}`, { stdio: 'pipe' });
+    if (!fs.existsSync(bundlePath)) throw new Error('Bundle not created');
+    return bundlePath;
+  } catch (e) {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    throw new Error(`Failed to create bundle: ${e}`);
+  }
+}
+
+export function compressBundle(bundlePath: string): string {
+  const gzPath = bundlePath + '.gz';
+  try {
+    const bundle = fs.readFileSync(bundlePath);
+    const compressed = zlib.gzipSync(bundle);
+    fs.writeFileSync(gzPath, compressed);
+    return gzPath;
+  } catch (e) {
+    throw new Error(`Compression failed: ${e}`);
+  }
+}
+
+export function bundleToBase64(gzPath: string): string {
+  const data = fs.readFileSync(gzPath);
+  return data.toString('base64');
+}
+
+export function cleanupBundle(bundlePath: string, gzPath: string) {
+  try {
+    const tmpDir = path.dirname(bundlePath);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  } catch {}
+}