lazypush-cli 0.1.0

package/README.md

@@ -0,0 +1,194 @@
+# lazyload-cli
+
+<div align="center">
+
+[![npm version](https://img.shields.io/npm/v/lazyload-cli?color=3fb950&label=lazyload-cli&logo=npm&style=flat-square)](https://www.npmjs.com/package/lazyload-cli)
+[![npm downloads](https://img.shields.io/npm/dm/lazyload-cli?color=58a6ff&style=flat-square)](https://www.npmjs.com/package/lazyload-cli)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen?style=flat-square&logo=node.js)](https://nodejs.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green?style=flat-square)](../LICENSE)
+
+*Schedule Git commits for a future push — no local daemons, no open terminals, no guilt.*
+
+</div>
+
+---
+
+## The Problem
+
+You finished the feature at 2pm. The standup is at 10am tomorrow. Pushing now means everyone knows you had the afternoon free, and guess who gets the next ticket assigned in 4 minutes?
+
+lazyload lets you schedule the push for later. Your git history stays clean. Your commit timestamp is exactly what you want it to be. You get your afternoon back.
+
+---
+
+## Install
+
+```bash
+npm install -g lazyload-cli
+```
+
+---
+
+## Quickstart
+
+```bash
+# Step 1: one-time login
+lazyload login
+
+# Step 2: schedule a push from inside your git repo
+lazyload schedule
+```
+
+You'll see an interactive prompt:
+
+```
+? Date (dd/mm/yyyy format, or press Enter for today)  20/05/2026
+? Time (e.g., 5:30pm, 17:30, 9:15am)                 9:00pm
+? Timezone (or press Enter for local)                 IST
+ℹ Local timezone: Asia/Calcutta
+
+? Commit message (optional)                           fix: handle null user
+
+ℹ ═══ PUSH DETAILS ═══
+ℹ Repository: https://github.com/you/your-repo
+ℹ Branch:     main
+ℹ Commit Message: fix: handle null user
+ℹ ═══════════════════
+
+? Confirm scheduling?  Yes
+
+ℹ Parsing scheduled time...
+ℹ Scheduled for: 5/20/2026, 9:00:00 PM UTC
+ℹ Creating git bundle...
+ℹ Compressing bundle...
+ℹ Encoding to base64...
+ℹ Uploading to backend...
+✓ Job scheduled! ID: 6a0dd278c2dcaedb805baf3c
+ℹ Push will occur at: 5/20/2026, 9:00:00 PM
+```
+
+Shut your laptop. The push will happen in the cloud at exactly that time.
+
+---
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `lazyload login` | Authenticate via GitHub OAuth. Opens browser, stores JWT locally. |
+| `lazyload schedule` | Interactive prompt to schedule a push. Auto-detects repo and branch. |
+| `lazyload jobs` | List all currently scheduled (pending) jobs. |
+| `lazyload list` | List all jobs — scheduled and finished — latest first. |
+| `lazyload cancel <id>` | Cancel a scheduled job by its ID. |
+| `lazyload logout` | Clear local session. |
+| `lazyload help` | Show all commands and options. |
+
+---
+
+## Time Format
+
+The time prompt accepts natural human input:
+
+| Input | Meaning |
+|-------|---------|
+| `5pm` | Today at 5:00 PM |
+| `17:30` | Today at 5:30 PM (24h) |
+| `tomorrow 9am` | Next day at 9:00 AM |
+| `in 2 hours` | 2 hours from now |
+| `friday 8pm` | Coming Friday at 8:00 PM |
+
+Timezone examples: `IST`, `EST`, `UTC`, `America/New_York`, `Asia/Kolkata`
+
+If no timezone is provided, your system's local timezone is used.
+
+---
+
+## How It Works
+
+```
+Inside your repo:
+┌──────────────────────────────────────────────────────────────┐
+│  lazyload schedule                                           │
+│                                                              │
+│  1. git bundle create repo.bundle HEAD                       │
+│  2. gzip repo.bundle                                         │
+│  3. base64 encode                                            │
+│  4. POST /jobs  { bundle, scheduledAt, repoUrl, branch }     │
+└──────────────────────────────────────────────────────────────┘
+                          │
+                          ▼
+              LazyPush Backend (cloud)
+              Stores job → polls every 60s
+              At T: restores bundle, rewrites timestamps, pushes
+```
+
+No background process runs on your machine after `schedule` completes. The CLI's job ends the moment the upload finishes.
+
+---
+
+## Session Storage
+
+After `lazyload login`, credentials are stored at:
+
+```
+~/.lazyload/session.json
+```
+
+```json
+{
+  "token": "<jwt>",
+  "userId": "...",
+  "username": "vaibhavgupta5"
+}
+```
+
+Protected by OS file permissions. Run `lazyload logout` to clear it.
+
+---
+
+## Source Structure
+
+```
+src/
+├── cli.ts              # Entry point — command registration via Commander.js
+├── config.ts           # Session read/write (~/.lazyload/session.json)
+├── logger.ts           # Colored terminal output (✓ green, ✗ red, ℹ blue)
+├── api/
+│   └── client.ts       # Authenticated HTTP client to backend
+├── commands/
+│   ├── login.ts        # OAuth flow + token storage
+│   ├── schedule.ts     # Interactive prompt + bundle upload
+│   ├── jobs.ts         # Fetch and display active jobs
+│   ├── list.ts         # Fetch and display all jobs
+│   ├── cancel.ts       # Cancel job by ID
+│   └── logout.ts       # Clear session
+└── utils/
+    ├── git.ts          # git bundle, gzip, base64
+    └── scheduler.ts    # Human-readable time parsing
+```
+
+---
+
+## Development
+
+```bash
+npm install
+npm run dev        # ts-node-dev with auto-reload
+
+# link locally to test as a global command
+npm link
+lazyload login
+```
+
+## Build & Publish
+
+```bash
+npm run build      # tsc → dist/
+npm publish --access public
+```
+
+---
+
+## License
+
+MIT © [Vaibhav Gupta](https://github.com/vaibhavgupta5)

package/dist/api/client.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+exports.getApiClient = getApiClient;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../config");
+const DEFAULT_API = process.env.LAZYPUSH_API || 'https://lazypush.onrender.com';
+class ApiClient {
+    constructor(apiUrl = DEFAULT_API) {
+        this.client = axios_1.default.create({
+            baseURL: apiUrl,
+            timeout: 30000
+        });
+    }
+    async login(code) {
+        const res = await this.client.post('/auth/callback', { code });
+        return res.data;
+    }
+    async getLoginUrl() {
+        const res = await this.client.get('/auth/github');
+        return res.request.path || '/auth/github';
+    }
+    async scheduleJob(data) {
+        const token = (0, config_1.getAuthToken)();
+        if (!token)
+            throw new Error('Not logged in');
+        const res = await this.client.post('/schedule', data, { headers: { Authorization: `Bearer ${token}` } });
+        return res.data;
+    }
+    async listJobs() {
+        const token = (0, config_1.getAuthToken)();
+        if (!token)
+            throw new Error('Not logged in');
+        const res = await this.client.get('/schedule', {
+            headers: { Authorization: `Bearer ${token}` }
+        });
+        return res.data;
+    }
+    async listAllJobs() {
+        const token = (0, config_1.getAuthToken)();
+        if (!token)
+            throw new Error('Not logged in');
+        const res = await this.client.get('/schedule/list', {
+            headers: { Authorization: `Bearer ${token}` }
+        });
+        return res.data;
+    }
+    async cancelJob(id) {
+        const token = (0, config_1.getAuthToken)();
+        if (!token)
+            throw new Error('Not logged in');
+        await this.client.delete(`/schedule/${id}`, {
+            headers: { Authorization: `Bearer ${token}` }
+        });
+    }
+}
+exports.ApiClient = ApiClient;
+function getApiClient() {
+    return new ApiClient();
+}

package/dist/cli.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const login_1 = require("./commands/login");
+const schedule_1 = require("./commands/schedule");
+const jobs_1 = require("./commands/jobs");
+const logout_1 = require("./commands/logout");
+commander_1.program
+    .name('lazypush')
+    .description('Schedule Git commits for future push')
+    .version('0.1.0');
+commander_1.program
+    .command('login')
+    .description('Authenticate with GitHub')
+    .action(login_1.handleLogin);
+commander_1.program
+    .command('schedule')
+    .option('-a, --at <time>', 'Time to push (required). Examples: "5pm", "tomorrow 9am", "in 2 hours", "friday 8pm"')
+    .option('-t, --tz <timezone>', 'Timezone (default: local). Examples: IST, EST, UTC, America/New_York')
+    .option('-m, --message <msg>', 'Commit message (optional)')
+    .description('Schedule a push')
+    .action(async (opts) => {
+    if (!opts.at) {
+        await (0, schedule_1.handleScheduleInteractive)();
+    }
+    else {
+        await (0, schedule_1.handleSchedule)(opts.at, opts.tz, opts.message);
+    }
+});
+commander_1.program
+    .command('jobs')
+    .description('List scheduled jobs')
+    .action(async () => (0, jobs_1.handleJobs)());
+commander_1.program
+    .command('list')
+    .description('List all scheduled and finished jobs (latest first)')
+    .action(async () => (0, jobs_1.handleList)());
+commander_1.program
+    .command('cancel <id>')
+    .description('Cancel a scheduled job')
+    .action(async (id) => {
+    await (0, jobs_1.handleCancel)(id);
+});
+commander_1.program
+    .command('logout')
+    .description('Logout and clear session')
+    .action(logout_1.handleLogout);
+commander_1.program
+    .command('help')
+    .description('Show command help')
+    .action(() => {
+    console.log('LazyPush CLI');
+    console.log('');
+    console.log('Commands:');
+    console.log('  login                 Authenticate with GitHub');
+    console.log('  schedule              Schedule a push (interactive or flags)');
+    console.log('  jobs                  List your scheduled jobs');
+    console.log('  list                  List all scheduled and finished jobs');
+    console.log('  cancel <id>           Cancel a scheduled job');
+    console.log('  logout                Logout and clear session');
+    console.log('  help                  Show this help');
+    console.log('');
+    console.log('Examples:');
+    console.log('  lazypush schedule');
+    console.log('  lazypush schedule --at "tomorrow 9am"');
+    console.log('  lazypush jobs');
+    console.log('  lazypush list');
+});
+commander_1.program.parse(process.argv);
+if (process.argv.length < 3) {
+    commander_1.program.help();
+}

package/dist/commands/jobs.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleJobs = handleJobs;
+exports.handleCancel = handleCancel;
+exports.handleList = handleList;
+const client_1 = require("../api/client");
+const logger_1 = require("../logger");
+const chalk_1 = __importDefault(require("chalk"));
+const auth_1 = require("../utils/auth");
+async function handleJobs() {
+    if (!(await (0, auth_1.requireAuth)())) {
+        process.exit(1);
+    }
+    try {
+        const api = (0, client_1.getApiClient)();
+        const jobs = await api.listJobs();
+        if (jobs.length === 0) {
+            (0, logger_1.info)('No scheduled jobs');
+            return;
+        }
+        (0, logger_1.log)('');
+        (0, logger_1.log)(chalk_1.default.bold('Scheduled Jobs:'));
+        (0, logger_1.log)('');
+        jobs.forEach((job, i) => {
+            const status = chalk_1.default.gray(job.status);
+            const time = new Date(job.scheduledAt).toLocaleString();
+            const branch = chalk_1.default.cyan(job.branch);
+            (0, logger_1.log)(`${i + 1}. ${chalk_1.default.yellow(job._id)} [${status}]`);
+            (0, logger_1.log)(`   Branch: ${branch} @ ${time}`);
+        });
+        (0, logger_1.log)('');
+    }
+    catch (e) {
+        (0, logger_1.error)(`Failed to fetch jobs: ${e.message}`);
+        process.exit(1);
+    }
+}
+async function handleCancel(id) {
+    if (!(await (0, auth_1.requireAuth)())) {
+        process.exit(1);
+    }
+    try {
+        const api = (0, client_1.getApiClient)();
+        await api.cancelJob(id);
+        (0, logger_1.success)(`Job ${id} cancelled`);
+    }
+    catch (e) {
+        (0, logger_1.error)(`Failed to cancel job: ${e.message}`);
+        process.exit(1);
+    }
+}
+async function handleList() {
+    if (!(await (0, auth_1.requireAuth)())) {
+        process.exit(1);
+    }
+    try {
+        const api = (0, client_1.getApiClient)();
+        const jobs = await api.listAllJobs();
+        if (jobs.length === 0) {
+            (0, logger_1.info)('No jobs found');
+            return;
+        }
+        (0, logger_1.log)('');
+        (0, logger_1.log)(chalk_1.default.bold('All Scheduled/Finished Jobs:'));
+        (0, logger_1.log)('');
+        jobs.forEach((job, i) => {
+            const status = chalk_1.default.gray(job.status);
+            const time = new Date(job.scheduledAt).toLocaleString();
+            const branch = chalk_1.default.cyan(job.branch);
+            const user = chalk_1.default.green(job.username || 'unknown');
+            (0, logger_1.log)(`${i + 1}. ${chalk_1.default.yellow(job._id)} [${status}]`);
+            (0, logger_1.log)(`   User: ${user}`);
+            (0, logger_1.log)(`   Branch: ${branch} @ ${time}`);
+        });
+        (0, logger_1.log)('');
+    }
+    catch (e) {
+        (0, logger_1.error)(`Failed to fetch jobs: ${e.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/login.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleLogin = handleLogin;
+const open_1 = __importDefault(require("open"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const http_1 = require("http");
+const config_1 = require("../config");
+const logger_1 = require("../logger");
+async function handleLogin() {
+    try {
+        const existing = (0, config_1.getSession)();
+        if (existing) {
+            (0, logger_1.success)(`Already logged in as: ${existing.username}`);
+            const { confirm } = await inquirer_1.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: "Login again?",
+                    default: false,
+                },
+            ]);
+            if (!confirm)
+                return;
+        }
+        const token = await waitForOAuthCallback();
+        if (!token) {
+            (0, logger_1.error)("Authentication cancelled");
+            process.exit(1);
+        }
+        (0, logger_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(),
+            };
+            (0, config_1.saveSession)(session);
+            (0, logger_1.success)(`Logged in successfully as ${jwtPayload.username}!`);
+            const expiryDate = new Date(jwtPayload.exp * 1000);
+            (0, logger_1.info)(`Token will expire on: ${expiryDate.toLocaleString()}`);
+        }
+        catch (e) {
+            (0, logger_1.error)(`Token validation failed: ${e.message}`);
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        (0, logger_1.error)(`Login failed: ${e.message}`);
+        process.exit(1);
+    }
+}
+async function waitForOAuthCallback() {
+    return new Promise((resolve) => {
+        let server = null;
+        const port = 3001;
+        const timeout = setTimeout(() => {
+            if (server)
+                server.close();
+            (0, logger_1.error)("Login timeout - no response from GitHub");
+            resolve(null);
+        }, 10 * 60 * 1000); // 10 minute timeout
+        server = (0, http_1.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, () => {
+            (0, logger_1.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)}`;
+            (0, open_1.default)(loginUrl);
+            (0, logger_1.info)("Browser opened. If it did not open, visit:");
+            (0, logger_1.info)(loginUrl);
+            (0, logger_1.info)("");
+        });
+    });
+}
+function parseJwt(token) {
+    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/dist/commands/logout.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleLogout = handleLogout;
+const config_1 = require("../config");
+const logger_1 = require("../logger");
+function handleLogout() {
+    try {
+        (0, config_1.clearSession)();
+        (0, logger_1.success)('Logged out');
+    }
+    catch (e) {
+        (0, logger_1.error)(`Logout failed: ${e.message}`);
+        process.exit(1);
+    }
+}