ngx-git 1.0.4 → 1.0.6

package/cli.js

@@ -1,5 +1,685 @@
 #!/usr/bin/env node
 
+// /**
+//  * NGX CLI v4.0
+//  * Pushes code directly to your GitHub repos via NGX server (OAuth proxy).
+//  * No git installation needed. No commit setup. No branch config.
+//  */
+
+// const fs = require("fs");
+// const path = require("path");
+// const http = require("http");
+// const os = require("os");
+// const zlib = require("zlib");
+// const { doOpen } = require("./ngx-open");
+// const axios = require("axios");
+
+// const _log = console.log;
+// console.log = () => {};
+// require("dotenv").config();
+// console.log = _log;
+
+// const VERSION = "1.0.5";
+// const CONFIG_PATH = path.join(os.homedir(), ".ngxconfig");
+// const CB_PORT = 9988; // local callback server port for OAuth
+
+// const encoded = atob("aHR0cHM6Ly9uZ3gubmdpbnhzb2Z0Lm9ubGluZS9hcGk=");
+// // console.log(encoded);
+// // ─── Default ignore patterns ──────────────────────────────────────────────────
+// const DEFAULT_IGNORE = new Set([
+//   ".env",
+//   "node_modules",
+//   ".git",
+//   ".DS_Store",
+//   "Thumbs.db",
+//   "dist",
+//   "build",
+//   ".cache",
+//   "coverage",
+//   ".nyc_output",
+//   "tmp",
+//   "temp",
+//   "__pycache__",
+//   ".pytest_cache",
+//   ".mypy_cache",
+//   "*.log",
+//   "*.sqlite",
+//   "*.db",
+//   "*.pem",
+//   "*.key",
+//   "*.p12",
+//   "*.pfx",
+//   "*.cer",
+//   "*.crt",
+//   "secrets",
+//   ".secrets",
+// ]);
+
+// // ─── Config ───────────────────────────────────────────────────────────────────
+// function cfg() {
+//   try {
+//     return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+//   } catch {
+//     return {};
+//   }
+// }
+// function saveCfg(d) {
+//   fs.writeFileSync(CONFIG_PATH, JSON.stringify(d, null, 2));
+// }
+
+// function getServer() {
+//   return cfg().server || process.env.NGX_SERVER || encoded;
+// }
+// function getToken() {
+//   return cfg().token || process.env.NGX_TOKEN || null;
+// }
+// function getUsername() {
+//   return cfg().username || null;
+// }
+// function authHdr() {
+//   const t = getToken();
+//   if (!t) fatal("Not logged in. Run:  ngx login");
+//   return { Authorization: `Bearer ${t}`, "Content-Type": "application/json" };
+// }
+
+// // ─── Output ───────────────────────────────────────────────────────────────────
+// const C = {
+//   cyan: (s) => `\x1b[96m${s}\x1b[0m`,
+//   green: (s) => `\x1b[92m${s}\x1b[0m`,
+//   grey: (s) => `\x1b[90m${s}\x1b[0m`,
+//   red: (s) => `\x1b[91m${s}\x1b[0m`,
+//   yel: (s) => `\x1b[93m${s}\x1b[0m`,
+//   bold: (s) => `\x1b[1m${s}\x1b[0m`,
+// };
+// function fatal(msg) {
+//   console.error(C.red("✗ ") + msg);
+//   process.exit(1);
+// }
+// function ok(msg) {
+//   console.log(C.green("✓ ") + msg);
+// }
+// function info(msg) {
+//   console.log(C.grey("  ") + msg);
+// }
+// function step(msg) {
+//   process.stdout.write(`\r${C.cyan("›")} ${msg}                    `);
+// }
+
+// // ─── Ignore logic ─────────────────────────────────────────────────────────────
+// function loadIgnorePatterns(folderPath) {
+//   const pats = new Set(DEFAULT_IGNORE);
+//   // Read .ngxignore
+//   const ngxFile = path.join(folderPath, ".ngxignore");
+//   if (fs.existsSync(ngxFile))
+//     fs.readFileSync(ngxFile, "utf-8")
+//       .split("\n")
+//       .map((l) => l.trim())
+//       .filter((l) => l && !l.startsWith("#"))
+//       .forEach((p) => pats.add(p));
+//   // Read .gitignore
+//   const gitFile = path.join(folderPath, ".gitignore");
+//   if (fs.existsSync(gitFile))
+//     fs.readFileSync(gitFile, "utf-8")
+//       .split("\n")
+//       .map((l) => l.trim())
+//       .filter((l) => l && !l.startsWith("#"))
+//       .forEach((p) => pats.add(p));
+//   return pats;
+// }
+
+// function matchesIgnore(name, patterns) {
+//   for (const p of patterns) {
+//     if (p === name) return true;
+//     if (p.startsWith("*.") && name.endsWith(p.slice(1))) return true;
+//     if (p.endsWith("*") && name.startsWith(p.slice(0, -1))) return true;
+//     if (p.startsWith("*") && name.endsWith(p.slice(1))) return true;
+//   }
+//   return false;
+// }
+
+// // ─── Collect files from folder ────────────────────────────────────────────────
+// // Returns array of { path: "relative/path", content_b64: "..." }
+// function collectFiles(folderPath) {
+//   const ignore = loadIgnorePatterns(folderPath);
+//   const files = [];
+
+//   function walk(dir, rel) {
+//     const entries = fs.readdirSync(dir, { withFileTypes: true });
+//     for (const entry of entries) {
+//       if (matchesIgnore(entry.name, ignore)) continue;
+//       const fullPath = path.join(dir, entry.name);
+//       const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+//       if (entry.isDirectory()) {
+//         walk(fullPath, relPath);
+//       } else if (entry.isFile()) {
+//         const buf = fs.readFileSync(fullPath);
+//         const compressed = zlib.gzipSync(buf);
+
+//         // Skip binary files > 50 MB (GitHub limit)
+//         if (buf.length > 50 * 1024 * 1024) {
+//           console.log(
+//             C.yel(
+//               `  ⚠ Skipping large file: ${relPath} (${(buf.length / 1024 / 1024).toFixed(1)} MB)`,
+//             ),
+//           );
+//           continue;
+//         }
+
+//         files.push({
+//           path: relPath,
+//           content_b64: compressed.toString("base64"),
+//           compressed: true,
+//         });
+//       }
+//     }
+//   }
+//   walk(folderPath, "");
+//   return files;
+// }
+
+// // ─── LOGIN — GitHub OAuth ─────────────────────────────────────────────────────
+// async function doLogin() {
+//   const existing = getToken();
+//   if (existing) {
+//     ok(`Already logged in as ${C.bold(getUsername())}`);
+//     info("Run 'ngx logout' to switch accounts.");
+//     return;
+//   }
+
+//   console.log(`\n${C.bold("NGX GitHub Login")}`);
+
+//   const loginUrl = `${getServer()}/auth/github`;
+//   console.log(C.grey(`Opening: ${loginUrl}\n`));
+
+//   // Try to open browser
+//   try {
+//     const { default: open } = await import("open").catch(() => ({
+//       default: null,
+//     }));
+//     if (open) await open(loginUrl);
+//     else console.log(C.yel(`Open this in your browser:\n  ${loginUrl}\n`));
+//   } catch {
+//     console.log(C.yel(`Open this in your browser:\n  ${loginUrl}\n`));
+//   }
+
+//   // Spin local HTTP server to receive token
+//   return new Promise((resolve, reject) => {
+//     const srv = http.createServer((req, res) => {
+//       const CORS = {
+//         "Access-Control-Allow-Origin": "*",
+//         "Access-Control-Allow-Headers": "Content-Type",
+//       };
+//       if (req.method === "OPTIONS") {
+//         res.writeHead(204, CORS);
+//         res.end();
+//         return;
+//       }
+//       if (req.method === "POST" && req.url === "/token") {
+//         let body = "";
+//         req.on("data", (d) => (body += d));
+//         req.on("end", () => {
+//           res.writeHead(200, { "Content-Type": "application/json", ...CORS });
+//           res.end(JSON.stringify({ ok: true }));
+//           try {
+//             const { token, username } = JSON.parse(body);
+//             const c = cfg();
+//             c.token = token;
+//             c.username = username;
+//             saveCfg(c);
+//             srv.close();
+//             console.log();
+//             ok(`Logged in as ${C.bold(username)}`);
+//             resolve();
+//           } catch (e) {
+//             reject(e);
+//           }
+//         });
+//       } else {
+//         res.writeHead(404, CORS);
+//         res.end();
+//       }
+//     });
+
+//     srv.on("error", (e) => {
+//       if (e.code === "EADDRINUSE")
+//         fatal(
+//           `Port ${CB_PORT} is busy. Kill whatever is using it and try again.`,
+//         );
+//       reject(e);
+//     });
+//     console.log(
+//       `\n${C.bold("If Not Auto Login You Get Token on Browser (exit) Copy Pest")}`,
+//     );
+//     console.log(`\n${C.bold("Like this ngx token eyJhbGc.....")}`);
+
+//     srv.listen(CB_PORT, () =>
+//       info(`Waiting for GitHub callback (port ${CB_PORT})...`),
+//     );
+//     setTimeout(() => {
+//       srv.close();
+//       fatal("Login timed out (5 min).");
+//     }, 300_000);
+//   });
+// }
+
+// // ─── PUSH — upload files to GitHub via server ────────────────────────────────
+// async function doPush(repoArg, opts = {}) {
+//   const username = getUsername();
+//   if (!username) fatal("Not logged in. Run: ngx login");
+//   const server = getServer();
+//   const folder = path.resolve(opts.path || ".");
+//   if (!fs.existsSync(folder)) fatal(`Folder not found: ${folder}`);
+
+//   const repoName = repoArg || path.basename(folder);
+//   const isPrivate = opts.visibility !== "public";
+//   const commitMsg = opts.message || `ngx push — ${new Date().toLocaleString()}`;
+//   const branch = opts.branch || "main";
+
+//   step(`Scanning ${C.bold(folder)}...`);
+//   const files = collectFiles(folder);
+//   if (!files.length) fatal("No files found to push (everything was ignored).");
+//   process.stdout.write(`\n`);
+
+//   // Show summary
+//   const totalKB =
+//     files.reduce((s, f) => s + Buffer.from(f.content_b64, "base64").length, 0) /
+//     1024;
+//   info(
+//     `${files.length} files  •  ${totalKB.toFixed(1)} KB  →  ${C.bold(username + "/" + repoName)}`,
+//   );
+
+//   step("Pushing to GitHub...");
+//   try {
+//     const res = await axios.post(
+//       `${server}/push`,
+//       {
+//         repoName,
+//         files,
+//         message: commitMsg,
+//         branch,
+//         createIfMissing: true,
+//         private: isPrivate,
+//       },
+//       { headers: authHdr(), maxBodyLength: Infinity, timeout: 120_000 },
+//     );
+
+//     process.stdout.write("\n");
+//     ok(`Pushed ${C.bold(res.data.files)} files to ${C.bold(res.data.repo)}`);
+//     info(`Branch : ${res.data.branch}`);
+//     info(`Commit : ${res.data.commit}`);
+//     info(`GitHub : ${C.cyan(res.data.url)}`);
+//   } catch (e) {
+//     process.stdout.write("\n");
+//     fatal(e.response?.data?.error || e.message);
+//   }
+// }
+
+// // ─── CLONE — clone repo from GitHub ──────────────────────────────────────────
+// // Uses GitHub API to fetch file tree + blob contents, writes to disk.
+// // No `git` binary needed.
+// async function doClone(target, destArg, opts = {}) {
+//   if (!target || !target.includes("/"))
+//     fatal("Usage: ngx clone owner/repo [dest]");
+//   const [owner, repoName] = target.split("/");
+//   const dest = path.resolve(destArg || repoName);
+//   const server = getServer();
+
+//   step(`Fetching file tree for ${C.bold(target)}...`);
+//   let treeData;
+//   try {
+//     const res = await axios.get(`${server}/tree/${owner}/${repoName}`, {
+//       headers: authHdr(),
+//     });
+//     treeData = res.data;
+//   } catch (e) {
+//     process.stdout.write("\n");
+//     if (e.response?.status === 404)
+//       fatal("Repo not found or you don't have access");
+//     fatal(e.response?.data?.error || e.message);
+//   }
+
+//   const files = treeData.files || [];
+//   const branch = treeData.branch;
+//   process.stdout.write("\n");
+//   info(`${files.length} files on branch ${branch}`);
+
+//   // GitHub raw content URL for each file
+//   const ghToken = null; // optional: could expose via /me route
+//   const ghHeaders = { Accept: "application/vnd.github.raw+json", ...authHdr() };
+//   // We'll download via the server proxy or directly from GitHub raw
+//   const repoInfo = await axios.get(`${server}/repos/${owner}/${repoName}`, {
+//     headers: authHdr(),
+//   });
+//   const cloneBase = `https://raw.githubusercontent.com/${owner}/${repoName}/${branch}`;
+
+//   // For private repos we need the GitHub token — fetch it via server
+//   let rawHeaders = {};
+//   try {
+//     // The server can expose a /me/ghtoken route for the logged-in user's own repos
+//     const tk = await axios.get(`${server}/me/ghtoken`, { headers: authHdr() });
+//     if (tk.data?.ghToken)
+//       rawHeaders["Authorization"] = `Bearer ${tk.data.ghToken}`;
+//   } catch {}
+
+//   if (fs.existsSync(dest)) {
+//     info(`Destination ./${path.basename(dest)}/ already exists — overwriting`);
+//   } else {
+//     fs.mkdirSync(dest, { recursive: true });
+//   }
+
+//   let done = 0;
+//   for (const file of files) {
+//     step(`Downloading ${done + 1}/${files.length}  ${C.grey(file.path)}`);
+//     try {
+//       const raw = await axios.get(`${cloneBase}/${file.path}`, {
+//         headers: rawHeaders,
+//         responseType: "arraybuffer",
+//       });
+//       const outPath = path.join(dest, file.path);
+//       fs.mkdirSync(path.dirname(outPath), { recursive: true });
+//       fs.writeFileSync(outPath, raw.data);
+//       done++;
+//     } catch (e) {
+//       process.stdout.write("\n");
+//       info(
+//         C.yel(
+//           `Could not download: ${file.path} — ${e.response?.status || e.message}`,
+//         ),
+//       );
+//     }
+//   }
+//   process.stdout.write("\n");
+//   ok(
+//     `Cloned ${C.bold(target)} (${done}/${files.length} files) → ./${path.basename(dest)}/`,
+//   );
+// }
+
+// // ─── REPOS ────────────────────────────────────────────────────────────────────
+// async function listRepos() {
+//   if (!getToken()) fatal("Not logged in");
+//   step("Fetching repos from GitHub...");
+//   try {
+//     const res = await axios.get(`${getServer()}/repos`, { headers: authHdr() });
+//     process.stdout.write("\n");
+//     const repos = res.data.repos || [];
+//     if (!repos.length) {
+//       info("No repos found.");
+//       return;
+//     }
+//     console.log(`\n${C.bold(getUsername() + "'s GitHub repos:")}\n`);
+//     repos.forEach((r) => {
+//       const icon = r.private ? "🔒" : "🌐";
+//       const lang = r.language ? C.grey(r.language.padEnd(14)) : " ".repeat(14);
+//       const upd = r.pushed_at ? timeSince(r.pushed_at) : "—";
+//       console.log(
+//         `  ${icon} ${C.cyan(r.name.padEnd(32))} ${lang} ${C.grey(upd)}`,
+//       );
+//     });
+//     console.log();
+//   } catch (e) {
+//     process.stdout.write("\n");
+//     fatal(e.response?.data?.error || e.message);
+//   }
+// }
+
+// // ─── CREATE REPO ──────────────────────────────────────────────────────────────
+// async function createRepo(name, opts = {}) {
+//   if (!name) fatal('Usage: ngx create <reponame> [--public] [--desc "..."]');
+//   step(`Creating ${C.bold(name)} on GitHub...`);
+//   try {
+//     const res = await axios.post(
+//       `${getServer()}/repos`,
+//       {
+//         name,
+//         private: opts.visibility !== "public",
+//         description: opts.desc || "",
+//       },
+//       { headers: authHdr() },
+//     );
+//     process.stdout.write("\n");
+//     ok(`Created ${C.bold(res.data.full_name)}`);
+//     info(`GitHub : ${C.cyan(`https://github.com/${res.data.full_name}`)}`);
+//     info(`Private: ${res.data.private}`);
+//   } catch (e) {
+//     process.stdout.write("\n");
+//     fatal(e.response?.data?.error || e.message);
+//   }
+// }
+
+// // ─── DELETE ───────────────────────────────────────────────────────────────────
+// async function deleteRepo(name) {
+//   if (!name) fatal("Usage: ngx delete <reponame>");
+//   step(`Deleting ${C.bold(name)}...`);
+//   try {
+//     const res = await axios.delete(`${getServer()}/repos/${name}`, {
+//       headers: authHdr(),
+//     });
+//     process.stdout.write("\n");
+//     ok(res.data.message);
+//   } catch (e) {
+//     process.stdout.write("\n");
+//     fatal(e.response?.data?.error || e.message);
+//   }
+// }
+
+// // ─── VISIBILITY ───────────────────────────────────────────────────────────────
+// async function setVisibility(name, vis) {
+//   if (!name || !["public", "private"].includes(vis))
+//     fatal("Usage: ngx visibility <repo> public|private");
+//   try {
+//     const res = await axios.patch(
+//       `${getServer()}/repos/${name}/visibility`,
+//       { visibility: vis },
+//       { headers: authHdr() },
+//     );
+//     ok(res.data.message);
+//   } catch (e) {
+//     fatal(e.response?.data?.error || e.message);
+//   }
+// }
+
+// // ─── LOGS ─────────────────────────────────────────────────────────────────────
+// async function showLogs() {
+//   if (!getToken()) fatal("Not logged in");
+//   try {
+//     const res = await axios.get(`${getServer()}/logs`, { headers: authHdr() });
+//     const logs = res.data.logs || [];
+//     if (!logs.length) {
+//       info("No activity yet.");
+//       return;
+//     }
+//     console.log();
+//     logs.forEach((l) => {
+//       const ts = new Date(l.ts).toLocaleString();
+//       const det =
+//         l.details && Object.keys(l.details).length
+//           ? C.grey(" " + JSON.stringify(l.details))
+//           : "";
+//       console.log(
+//         `  ${C.grey(ts)}  ${C.cyan(l.action.padEnd(18))}  ${l.repo || ""}${det}`,
+//       );
+//     });
+//     console.log();
+//   } catch (e) {
+//     fatal(e.response?.data?.error || e.message);
+//   }
+// }
+
+// // ─── UTILS ────────────────────────────────────────────────────────────────────
+// function timeSince(d) {
+//   const s = Math.floor((Date.now() - new Date(d)) / 1000);
+//   if (s < 60) return "just now";
+//   if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+//   if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+//   return `${Math.floor(s / 86400)}d ago`;
+// }
+
+// function parseArgs(rawArgs) {
+//   const flags = {};
+//   const rest = [];
+//   for (let i = 0; i < rawArgs.length; i++) {
+//     if (rawArgs[i].startsWith("--")) {
+//       const key = rawArgs[i].slice(2);
+//       const val =
+//         rawArgs[i + 1] && !rawArgs[i + 1].startsWith("--")
+//           ? rawArgs[++i]
+//           : true;
+//       flags[key] = val;
+//     } else {
+//       rest.push(rawArgs[i]);
+//     }
+//   }
+//   return { flags, rest };
+// }
+
+// // ─── MAIN ─────────────────────────────────────────────────────────────────────
+// const [, , cmd, ...rawArgs] = process.argv;
+// const { flags, rest } = parseArgs(rawArgs || []);
+
+// (async () => {
+//   switch (cmd) {
+//     case "-v":
+//     case "--version":
+//       console.log(`ngx ${VERSION}`);
+//       break;
+
+//     case "token":
+//       if (!rest[0]) fatal("Usage: ngx token <JWT>");
+
+//       try {
+//         const decoded = JSON.parse(
+//           Buffer.from(rest[0].split(".")[1], "base64").toString(),
+//         );
+
+//         const c = cfg();
+//         c.token = rest[0];
+//         c.username = decoded.username; // 🔥 fix
+//         saveCfg(c);
+
+//         ok(`Token saved for ${decoded.username}`);
+//       } catch {
+//         fatal("Invalid JWT token");
+//       }
+//       break;
+
+//     case "open":
+//       if (!rest[0]) fatal("Usage: ngx open <reponame>");
+//       await doOpen(rest[0], getUsername()); // 👈 pass here
+
+//       break;
+
+//     case "login":
+//       await doLogin();
+//       break;
+
+//     case "logout":
+//       const c2 = cfg();
+//       delete c2.token;
+//       delete c2.username;
+//       saveCfg(c2);
+//       ok("Logged out");
+//       break;
+
+//     case "whoami":
+//       const u = getUsername();
+//       if (u) console.log(`Logged in as: ${C.bold(u)}  "nginxSoft"`);
+//       else console.log("Not logged in");
+//       break;
+
+//     // ngx push [reponame] [--path <dir>] [--public] [--message "msg"] [--branch main]
+//     case "push":
+//       await doPush(rest[0], {
+//         path: flags.path,
+//         visibility: flags.public ? "public" : flags.visibility || "private",
+//         message: flags.message || flags.m,
+//         branch: flags.branch || flags.b,
+//       });
+//       break;
+
+//     // ngx clone owner/repo [dest]
+//     case "clone":
+//       if (!rest[0]) fatal("Usage: ngx clone owner/repo [dest]");
+//       await doClone(rest[0], rest[1], {});
+//       break;
+
+//     // ngx repos
+//     case "repos":
+//       await listRepos();
+//       break;
+
+//     // ngx create <name> [--public] [--desc "..."]
+//     case "create":
+//       await createRepo(rest[0], {
+//         visibility: flags.public ? "public" : "private",
+//         desc: flags.desc || flags.description || "",
+//       });
+//       break;
+
+//     // ngx delete <name>
+//     case "delete":
+//       if (!rest[0]) fatal("Usage: ngx delete <reponame>");
+//       await deleteRepo(rest[0]);
+//       break;
+
+//     // ngx visibility <repo> public|private
+//     case "visibility":
+//       await setVisibility(rest[0], rest[1]);
+//       break;
+
+//     // ngx logs
+//     case "logs":
+//       await showLogs();
+//       break;
+
+//     // ngx config server <url>
+//     case "config":
+//       if (rest[0] === "server" && rest[1]) {
+//         const c3 = cfg();
+//         c3.server = rest[1];
+//         saveCfg(c3);
+//         ok(`Server set to ${rest[1]}`);
+//       } else console.log("Usage: ngx config server <url>");
+//       break;
+
+//     default:
+//       console.log(`
+// ${C.bold("NGX v" + VERSION)} — GitHub proxy CLI
+
+// ${C.cyan("Auth:")}
+//   ngx login                              GitHub OAuth (opens browser)
+//   ngx logout                             Clear saved session
+//   ngx whoami                             Show current user
+
+// ${C.cyan("Push / Clone:")}
+//   ngx push                               Push current folder to GitHub
+//   ngx push my-repo                       Push with specific repo name
+//   ngx push my-repo --public              Push as public repo
+//   ngx push my-repo --path ./src          Push a subfolder
+//   ngx push my-repo --message "feat: x"   Custom commit message
+//   ngx clone owner/repo                   Clone repo (downloads all files)
+//   ngx clone owner/repo ./local-dir       Clone into specific directory
+
+// ${C.cyan("Repos:")}
+//   ngx repos                              List your GitHub repos
+//   ngx create <name> [--public]           Create a new GitHub repo
+//   ngx delete <name>                      Delete a GitHub repo
+//   ngx visibility <repo> public|private   Change repo visibility
+
+// ${C.cyan("Logs:")}
+//   ngx logs                               Your NGX activity log
+
+// ${C.cyan("Config:")}
+//   ngx config server <url>                Point to a different NGX server
+//   ngx -v                                 Show version
+
+// ${C.grey("Auto-ignored on push:")}
+//   ${C.grey(".env  node_modules  .git  build  *.key  *.pem  secrets")}
+//   ${C.grey("Add extras in .ngxignore or .gitignore")}
+// `);
+//   }
+// })();
+// #!/usr/bin/env node
+
 /**
  * NGX CLI v4.0
  * Pushes code directly to your GitHub repos via NGX server (OAuth proxy).
@@ -11,7 +691,7 @@ const path = require("path");
 const http = require("http");
 const os = require("os");
 const zlib = require("zlib");
-
+const readline = require("readline");
 const axios = require("axios");
 
 const _log = console.log;
@@ -19,12 +699,15 @@ console.log = () => {};
 require("dotenv").config();
 console.log = _log;
 
-const VERSION = "1.0.3";
+const VERSION = "1.0.6";
 const CONFIG_PATH = path.join(os.homedir(), ".ngxconfig");
-const CB_PORT = 9988; // local callback server port for OAuth
+const CB_PORT = 9988;
+
+const encoded = Buffer.from(
+  "aHR0cHM6Ly9uZ3gubmdpbnhzb2Z0Lm9ubGluZS9hcGk=",
+  "base64",
+).toString("utf-8");
 
-const encoded = atob("aHR0cHM6Ly9uZ3gubmdpbnhzb2Z0Lm9ubGluZS9hcGk=");
-// console.log(encoded);
 // ─── Default ignore patterns ──────────────────────────────────────────────────
 const DEFAULT_IGNORE = new Set([
   ".env",
@@ -91,6 +774,7 @@ const C = {
   yel: (s) => `\x1b[93m${s}\x1b[0m`,
   bold: (s) => `\x1b[1m${s}\x1b[0m`,
 };
+
 function fatal(msg) {
   console.error(C.red("✗ ") + msg);
   process.exit(1);
@@ -108,7 +792,6 @@ function step(msg) {
 // ─── Ignore logic ─────────────────────────────────────────────────────────────
 function loadIgnorePatterns(folderPath) {
   const pats = new Set(DEFAULT_IGNORE);
-  // Read .ngxignore
   const ngxFile = path.join(folderPath, ".ngxignore");
   if (fs.existsSync(ngxFile))
     fs.readFileSync(ngxFile, "utf-8")
@@ -116,7 +799,6 @@ function loadIgnorePatterns(folderPath) {
       .map((l) => l.trim())
       .filter((l) => l && !l.startsWith("#"))
       .forEach((p) => pats.add(p));
-  // Read .gitignore
   const gitFile = path.join(folderPath, ".gitignore");
   if (fs.existsSync(gitFile))
     fs.readFileSync(gitFile, "utf-8")
@@ -138,7 +820,6 @@ function matchesIgnore(name, patterns) {
 }
 
 // ─── Collect files from folder ────────────────────────────────────────────────
-// Returns array of { path: "relative/path", content_b64: "..." }
 function collectFiles(folderPath) {
   const ignore = loadIgnorePatterns(folderPath);
   const files = [];
@@ -153,9 +834,6 @@ function collectFiles(folderPath) {
         walk(fullPath, relPath);
       } else if (entry.isFile()) {
         const buf = fs.readFileSync(fullPath);
-        const compressed = zlib.gzipSync(buf);
-
-        // Skip binary files > 50 MB (GitHub limit)
         if (buf.length > 50 * 1024 * 1024) {
           console.log(
             C.yel(
@@ -164,7 +842,7 @@ function collectFiles(folderPath) {
           );
           continue;
         }
-
+        const compressed = zlib.gzipSync(buf);
         files.push({
           path: relPath,
           content_b64: compressed.toString("base64"),
@@ -177,6 +855,33 @@ function collectFiles(folderPath) {
   return files;
 }
 
+// ─── Utils ────────────────────────────────────────────────────────────────────
+function timeSince(d) {
+  const s = Math.floor((Date.now() - new Date(d)) / 1000);
+  if (s < 60) return "just now";
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  return `${Math.floor(s / 86400)}d ago`;
+}
+
+function parseArgs(rawArgs) {
+  const flags = {};
+  const rest = [];
+  for (let i = 0; i < rawArgs.length; i++) {
+    if (rawArgs[i].startsWith("--")) {
+      const key = rawArgs[i].slice(2);
+      const val =
+        rawArgs[i + 1] && !rawArgs[i + 1].startsWith("--")
+          ? rawArgs[++i]
+          : true;
+      flags[key] = val;
+    } else {
+      rest.push(rawArgs[i]);
+    }
+  }
+  return { flags, rest };
+}
+
 // ─── LOGIN — GitHub OAuth ─────────────────────────────────────────────────────
 async function doLogin() {
   const existing = getToken();
@@ -187,11 +892,9 @@ async function doLogin() {
   }
 
   console.log(`\n${C.bold("NGX GitHub Login")}`);
-
   const loginUrl = `${getServer()}/auth/github`;
   console.log(C.grey(`Opening: ${loginUrl}\n`));
 
-  // Try to open browser
   try {
     const { default: open } = await import("open").catch(() => ({
       default: null,
@@ -202,7 +905,6 @@ async function doLogin() {
     console.log(C.yel(`Open this in your browser:\n  ${loginUrl}\n`));
   }
 
-  // Spin local HTTP server to receive token
   return new Promise((resolve, reject) => {
     const srv = http.createServer((req, res) => {
       const CORS = {
@@ -248,6 +950,11 @@ async function doLogin() {
       reject(e);
     });
 
+    console.log(
+      `\n${C.bold("If Not Auto Login You Get Token on Browser (exit) Copy Paste")}`,
+    );
+    console.log(`\n${C.bold("Like this: ngx token eyJhbGc.....")}`);
+
     srv.listen(CB_PORT, () =>
       info(`Waiting for GitHub callback (port ${CB_PORT})...`),
     );
@@ -258,7 +965,7 @@ async function doLogin() {
   });
 }
 
-// ─── PUSH — upload files to GitHub via server ────────────────────────────────
+// ─── PUSH ────────────────────────────────────────────────────────────────────
 async function doPush(repoArg, opts = {}) {
   const username = getUsername();
   if (!username) fatal("Not logged in. Run: ngx login");
@@ -274,9 +981,8 @@ async function doPush(repoArg, opts = {}) {
   step(`Scanning ${C.bold(folder)}...`);
   const files = collectFiles(folder);
   if (!files.length) fatal("No files found to push (everything was ignored).");
-  process.stdout.write(`\n`);
+  process.stdout.write("\n");
 
-  // Show summary
   const totalKB =
     files.reduce((s, f) => s + Buffer.from(f.content_b64, "base64").length, 0) /
     1024;
@@ -298,7 +1004,6 @@ async function doPush(repoArg, opts = {}) {
       },
       { headers: authHdr(), maxBodyLength: Infinity, timeout: 120_000 },
     );
-
     process.stdout.write("\n");
     ok(`Pushed ${C.bold(res.data.files)} files to ${C.bold(res.data.repo)}`);
     info(`Branch : ${res.data.branch}`);
@@ -310,9 +1015,7 @@ async function doPush(repoArg, opts = {}) {
   }
 }
 
-// ─── CLONE — clone repo from GitHub ──────────────────────────────────────────
-// Uses GitHub API to fetch file tree + blob contents, writes to disk.
-// No `git` binary needed.
+// ─── CLONE ────────────────────────────────────────────────────────────────────
 async function doClone(target, destArg, opts = {}) {
   if (!target || !target.includes("/"))
     fatal("Usage: ngx clone owner/repo [dest]");
@@ -339,24 +1042,15 @@ async function doClone(target, destArg, opts = {}) {
   process.stdout.write("\n");
   info(`${files.length} files on branch ${branch}`);
 
-  // GitHub raw content URL for each file
-  const ghToken = null; // optional: could expose via /me route
-  const ghHeaders = { Accept: "application/vnd.github.raw+json", ...authHdr() };
-  // We'll download via the server proxy or directly from GitHub raw
-  const repoInfo = await axios.get(`${server}/repos/${owner}/${repoName}`, {
-    headers: authHdr(),
-  });
-  const cloneBase = `https://raw.githubusercontent.com/${owner}/${repoName}/${branch}`;
-
-  // For private repos we need the GitHub token — fetch it via server
   let rawHeaders = {};
   try {
-    // The server can expose a /me/ghtoken route for the logged-in user's own repos
     const tk = await axios.get(`${server}/me/ghtoken`, { headers: authHdr() });
     if (tk.data?.ghToken)
       rawHeaders["Authorization"] = `Bearer ${tk.data.ghToken}`;
   } catch {}
 
+  const cloneBase = `https://raw.githubusercontent.com/${owner}/${repoName}/${branch}`;
+
   if (fs.existsSync(dest)) {
     info(`Destination ./${path.basename(dest)}/ already exists — overwriting`);
   } else {
@@ -418,7 +1112,7 @@ async function listRepos() {
   }
 }
 
-// ─── CREATE REPO ──────────────────────────────────────────────────────────────
+// ─── CREATE ───────────────────────────────────────────────────────────────────
 async function createRepo(name, opts = {}) {
   if (!name) fatal('Usage: ngx create <reponame> [--public] [--desc "..."]');
   step(`Creating ${C.bold(name)} on GitHub...`);
@@ -501,34 +1195,770 @@ async function showLogs() {
   }
 }
 
-// ─── UTILS ────────────────────────────────────────────────────────────────────
-function timeSince(d) {
-  const s = Math.floor((Date.now() - new Date(d)) / 1000);
-  if (s < 60) return "just now";
-  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
-  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
-  return `${Math.floor(s / 86400)}d ago`;
+// ══════════════════════════════════════════════════════════════════════════════
+// ─── NGX OPEN — Repo Shell Mode ───────────────────────────────────────────────
+// ══════════════════════════════════════════════════════════════════════════════
+
+// ─── Virtual FS state ─────────────────────────────────────────────────────────
+let _repoFiles = [];
+let _cwd = "/";
+let _repoName = "";
+let _dirty = new Map();
+let _deleted = new Set();
+let _owner = "";
+
+// ─── Path helpers ─────────────────────────────────────────────────────────────
+function normPath(p) {
+  const parts = p.split("/").filter(Boolean);
+  const stack = [];
+  for (const part of parts) {
+    if (part === "..") stack.pop();
+    else if (part !== ".") stack.push(part);
+  }
+  return "/" + stack.join("/");
 }
 
-function parseArgs(rawArgs) {
-  const flags = {};
-  const rest = [];
-  for (let i = 0; i < rawArgs.length; i++) {
-    if (rawArgs[i].startsWith("--")) {
-      const key = rawArgs[i].slice(2);
-      const val =
-        rawArgs[i + 1] && !rawArgs[i + 1].startsWith("--")
-          ? rawArgs[++i]
-          : true;
-      flags[key] = val;
+function resolvePath(input) {
+  if (!input) return _cwd;
+  if (input.startsWith("/")) return normPath(input);
+  return normPath(_cwd + "/" + input);
+}
+
+function relativePath(abs) {
+  return abs === "/" ? "" : abs.slice(1);
+}
+
+// ─── Fetch repo files ─────────────────────────────────────────────────────────
+async function fetchRepo(owner, repo) {
+  const server = getServer();
+  try {
+    const treeRes = await axios.get(`${server}/tree/${owner}/${repo}`, {
+      headers: authHdr(),
+    });
+    const files = treeRes.data.files || [];
+    const branch = treeRes.data.branch;
+
+    let rawHeaders = {};
+    try {
+      const tk = await axios.get(`${server}/me/ghtoken`, {
+        headers: authHdr(),
+      });
+      if (tk.data?.ghToken)
+        rawHeaders["Authorization"] = `Bearer ${tk.data.ghToken}`;
+    } catch {}
+
+    const cloneBase = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`;
+
+    step(`Loading ${files.length} files...`);
+    const loaded = [];
+    for (const f of files) {
+      try {
+        const raw = await axios.get(`${cloneBase}/${f.path}`, {
+          headers: rawHeaders,
+          responseType: "arraybuffer",
+          timeout: 10_000,
+        });
+        const buf = Buffer.from(raw.data);
+        const content = buf.toString("utf-8");
+        const isBinary = content.includes("\0");
+        loaded.push({
+          path: f.path,
+          content: isBinary ? null : content,
+          binary: isBinary,
+          size: buf.length,
+          modified: new Date().toISOString(),
+        });
+      } catch {
+        loaded.push({
+          path: f.path,
+          content: "",
+          binary: false,
+          size: 0,
+          modified: new Date().toISOString(),
+        });
+      }
+    }
+    process.stdout.write("\n");
+    return loaded;
+  } catch (e) {
+    process.stdout.write("\n");
+    if (e.response?.status === 404) fatal("Repo not found or no access.");
+    fatal(e.response?.data?.error || e.message);
+  }
+}
+
+// ─── Shell commands ───────────────────────────────────────────────────────────
+function cmd_ls(args) {
+  const target = args.filter((a) => !a.startsWith("-"))[0];
+  const dirAbs = target ? resolvePath(target) : _cwd;
+  const rel = relativePath(dirAbs);
+  const longFmt = args.some((a) => a.startsWith("-") && a.includes("l"));
+
+  const seen = new Set();
+  const entries = [];
+
+  const addEntry = (fp, forceFile = false) => {
+    if (rel === "") {
+      const top = fp.split("/")[0];
+      if (seen.has(top)) return;
+      seen.add(top);
+      const isDir = !forceFile && fp.includes("/");
+      entries.push({ name: top, isDir, size: 0, path: fp });
     } else {
-      rest.push(rawArgs[i]);
+      if (!fp.startsWith(rel + "/")) return;
+      const rest = fp.slice(rel.length + 1);
+      if (!rest) return;
+      const part = rest.split("/")[0];
+      if (seen.has(part)) return;
+      seen.add(part);
+      const isDir = !forceFile && rest.includes("/");
+      entries.push({ name: part, isDir, size: 0, path: fp });
     }
+  };
+
+  for (const f of _repoFiles) {
+    if (_deleted.has(f.path)) continue;
+    addEntry(f.path);
+  }
+  for (const [p] of _dirty) {
+    const fp = p.startsWith("/") ? p.slice(1) : p;
+    addEntry(fp, true);
+  }
+
+  if (!entries.length) {
+    console.log(C.grey("  (empty)"));
+    return;
+  }
+
+  entries.sort((a, b) => {
+    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  if (longFmt) {
+    for (const e of entries) {
+      const dirty = _dirty.has(rel ? rel + "/" + e.name : e.name)
+        ? C.yel("*")
+        : " ";
+      const type = e.isDir ? C.cyan("d") : "-";
+      const name = e.isDir ? C.cyan(e.name + "/") : e.name;
+      console.log(`  ${type}${dirty} ${String(e.size).padStart(8)}  ${name}`);
+    }
+  } else {
+    const row = entries.map((e) => (e.isDir ? C.cyan(e.name + "/") : e.name));
+    console.log("  " + row.join("   "));
   }
-  return { flags, rest };
 }
 
+function cmd_cd(args) {
+  if (!args[0] || args[0] === "~") {
+    _cwd = "/";
+    return;
+  }
+  const target = resolvePath(args[0]);
+  const rel = relativePath(target);
+  if (rel === "") {
+    _cwd = "/";
+    return;
+  }
+  const exists = _repoFiles.some(
+    (f) => f.path === rel || f.path.startsWith(rel + "/"),
+  );
+  if (exists) _cwd = target;
+  else console.log(C.red(`  cd: no such directory: ${args[0]}`));
+}
+
+function cmd_pwd() {
+  console.log("  " + (_cwd === "/" ? `/${_repoName}` : `/${_repoName}${_cwd}`));
+}
+
+function getFileContent(relPath) {
+  if (_dirty.has(relPath)) return _dirty.get(relPath);
+  return _repoFiles.find((f) => f.path === relPath)?.content || null;
+}
+
+function cmd_cat(args) {
+  if (!args[0]) {
+    console.log(C.red("  Usage: cat <file>"));
+    return;
+  }
+  const rel = relativePath(resolvePath(args[0]));
+  if (_dirty.has(rel)) {
+    console.log(_dirty.get(rel));
+    return;
+  }
+  const f = _repoFiles.find((x) => x.path === rel);
+  if (!f) {
+    console.log(C.red(`  cat: ${args[0]}: No such file`));
+    return;
+  }
+  if (f.binary) {
+    console.log(C.grey("  [binary file]"));
+    return;
+  }
+  console.log(f.content || "");
+}
+
+function cmd_head(args) {
+  const nIdx = args.indexOf("-n");
+  const n = nIdx !== -1 ? parseInt(args[nIdx + 1]) || 10 : 10;
+  const fileArg = args.filter((a) => !a.startsWith("-") && !/^\d+$/.test(a))[0];
+  if (!fileArg) {
+    console.log(C.red("  Usage: head [-n N] <file>"));
+    return;
+  }
+  const rel = relativePath(resolvePath(fileArg));
+  const content = getFileContent(rel);
+  if (content === null) {
+    console.log(C.red(`  head: ${fileArg}: No such file`));
+    return;
+  }
+  console.log(content.split("\n").slice(0, n).join("\n"));
+}
+
+function cmd_tail(args) {
+  const nIdx = args.indexOf("-n");
+  const n = nIdx !== -1 ? parseInt(args[nIdx + 1]) || 10 : 10;
+  const fileArg = args.filter((a) => !a.startsWith("-") && !/^\d+$/.test(a))[0];
+  if (!fileArg) {
+    console.log(C.red("  Usage: tail [-n N] <file>"));
+    return;
+  }
+  const rel = relativePath(resolvePath(fileArg));
+  const content = getFileContent(rel);
+  if (content === null) {
+    console.log(C.red(`  tail: ${fileArg}: No such file`));
+    return;
+  }
+  const lines = content.split("\n");
+  console.log(lines.slice(-n).join("\n"));
+}
+
+function cmd_stat(args) {
+  if (!args[0]) {
+    console.log(C.red("  Usage: stat <file>"));
+    return;
+  }
+  const rel = relativePath(resolvePath(args[0]));
+  const f = _repoFiles.find((x) => x.path === rel);
+  if (!f) {
+    console.log(C.red(`  stat: ${args[0]}: No such file`));
+    return;
+  }
+  console.log(`  File : ${f.path}`);
+  console.log(`  Size : ${f.size} bytes`);
+  console.log(`  Type : ${f.binary ? "binary" : "text"}`);
+  console.log(`  Mod  : ${f.modified}`);
+}
+
+function cmd_find(args) {
+  const nameFlag = args.indexOf("-name");
+  const pattern = nameFlag !== -1 ? args[nameFlag + 1] : args[0];
+  if (!pattern) {
+    console.log(C.red("  Usage: find -name <pattern>"));
+    return;
+  }
+  const re = new RegExp(pattern.replace(/\*/g, ".*"), "i");
+  const matches = _repoFiles
+    .filter((f) => !_deleted.has(f.path) && re.test(path.basename(f.path)))
+    .map((f) => C.grey("  ./") + f.path);
+  if (!matches.length) console.log(C.grey("  (no matches)"));
+  else console.log(matches.join("\n"));
+}
+
+function cmd_grep(args) {
+  if (args.length < 2) {
+    console.log(C.red("  Usage: grep <pattern> <file|*>"));
+    return;
+  }
+  const pattern = args[0];
+  const target = args[1];
+  let re;
+  try {
+    re = new RegExp(pattern, "gi");
+  } catch {
+    console.log(C.red("  Invalid regex pattern"));
+    return;
+  }
+
+  const files =
+    target === "*" || target === "."
+      ? _repoFiles.filter((f) => !f.binary && !_deleted.has(f.path))
+      : [
+          _repoFiles.find((f) => f.path === relativePath(resolvePath(target))),
+        ].filter(Boolean);
+
+  let found = false;
+  for (const f of files) {
+    if (!f || f.binary) continue;
+    const content = getFileContent(f.path) || "";
+    content.split("\n").forEach((line, i) => {
+      if (re.test(line)) {
+        re.lastIndex = 0;
+        console.log(
+          `  ${C.cyan(f.path)}:${C.grey(i + 1)}:${line.replace(re, (m) => C.yel(m))}`,
+        );
+        re.lastIndex = 0;
+        found = true;
+      }
+    });
+  }
+  if (!found) console.log(C.grey("  (no matches)"));
+}
+
+function cmd_mkdir(args) {
+  if (!args[0]) {
+    console.log(C.red("  Usage: mkdir <dirname>"));
+    return;
+  }
+  console.log(
+    C.grey(
+      `  mkdir: ${args[0]} (will exist after first file is created inside)`,
+    ),
+  );
+}
+
+function cmd_touch(args) {
+  if (!args[0]) {
+    console.log(C.red("  Usage: touch <file>"));
+    return;
+  }
+  const rel = relativePath(resolvePath(args[0]));
+  if (!_dirty.has(rel) && !_repoFiles.find((f) => f.path === rel)) {
+    _dirty.set(rel, "");
+    console.log(C.yel(`  created: ${rel}`));
+  } else {
+    console.log(C.grey(`  touched: ${rel}`));
+  }
+}
+
+function cmd_rm(args) {
+  if (!args[0]) {
+    console.log(C.red("  Usage: rm <file>"));
+    return;
+  }
+  const rel = relativePath(resolvePath(args[0]));
+  const f = _repoFiles.find((x) => x.path === rel);
+  if (!f && !_dirty.has(rel)) {
+    console.log(C.red(`  rm: ${args[0]}: No such file`));
+    return;
+  }
+  _deleted.add(rel);
+  _dirty.delete(rel);
+  console.log(C.grey(`  removed: ${rel}`));
+}
+
+function cmd_cp(args) {
+  if (args.length < 2) {
+    console.log(C.red("  Usage: cp <src> <dest>"));
+    return;
+  }
+  const srcRel = relativePath(resolvePath(args[0]));
+  const destRel = relativePath(resolvePath(args[1]));
+  const content = getFileContent(srcRel);
+  if (content === null) {
+    console.log(C.red(`  cp: ${args[0]}: No such file`));
+    return;
+  }
+  _dirty.set(destRel, content);
+  console.log(C.grey(`  ${srcRel} → ${destRel}`));
+}
+
+function cmd_mv(args) {
+  if (args.length < 2) {
+    console.log(C.red("  Usage: mv <src> <dest>"));
+    return;
+  }
+  const srcRel = relativePath(resolvePath(args[0]));
+  const destRel = relativePath(resolvePath(args[1]));
+  const content = getFileContent(srcRel);
+  if (content === null) {
+    console.log(C.red(`  mv: ${args[0]}: No such file`));
+    return;
+  }
+  _dirty.set(destRel, content);
+  _deleted.add(srcRel);
+  _dirty.delete(srcRel);
+  console.log(C.grey(`  ${srcRel} → ${destRel}`));
+}
+
+function cmd_tree(args) {
+  const tArg = args.filter((a) => !a.startsWith("-"))[0];
+  const target = tArg ? relativePath(resolvePath(tArg)) : relativePath(_cwd);
+  const prefix = target === "" ? "" : target + "/";
+  const relevant = _repoFiles.filter(
+    (f) =>
+      !_deleted.has(f.path) &&
+      (target === "" || f.path.startsWith(prefix) || f.path === target),
+  );
+  const paths = relevant
+    .map((f) => f.path.slice(prefix.length))
+    .filter(Boolean);
+
+  function printTree(items, indent) {
+    const dirs = new Set();
+    const files = [];
+    for (const p of items) {
+      const parts = p.split("/");
+      if (parts.length > 1) dirs.add(parts[0]);
+      else files.push(p);
+    }
+    for (const d of [...dirs].sort()) {
+      console.log(indent + C.cyan("├── " + d + "/"));
+      const sub = items
+        .filter((p) => p.startsWith(d + "/"))
+        .map((p) => p.slice(d.length + 1));
+      printTree(sub, indent + "│   ");
+    }
+    for (const f of files.sort()) {
+      console.log(indent + "├── " + f);
+    }
+  }
+
+  console.log(C.cyan("  " + (target || _repoName)));
+  printTree(paths, "  ");
+}
+
+function cmd_diff() {
+  if (!_dirty.size && !_deleted.size) {
+    console.log(C.grey("  No changes."));
+    return;
+  }
+  console.log(C.bold("\n  Pending changes:\n"));
+  for (const [p] of _dirty) {
+    const isNew = !_repoFiles.find((f) => f.path === p);
+    console.log(C.yel(`  M  ${p}`) + (isNew ? C.green(" (new)") : ""));
+  }
+  for (const p of _deleted) {
+    console.log(C.red(`  D  ${p}`));
+  }
+  console.log();
+}
+
+function cmd_help() {
+  console.log(`
+${C.bold("NGX Repo Terminal — available commands:")}
+
+${C.cyan("Navigation:")}
+  ls [-l]             List files and directories
+  cd <dir>            Change directory
+  pwd                 Show current path
+  tree [dir]          Show directory tree
+
+${C.cyan("File ops:")}
+  cat <file>          Print file contents
+  head [-n N] <file>  First N lines
+  tail [-n N] <file>  Last N lines
+  stat <file>         File info
+  nano <file>         Edit file (inline editor)
+  touch <file>        Create empty file
+  rm <file>           Mark file for deletion
+  cp <src> <dest>     Copy file
+  mv <src> <dest>     Move/rename file
+  mkdir <dir>         Create directory (virtual)
+
+${C.cyan("Search:")}
+  find -name <pat>    Find files matching pattern
+  grep <pat> <file>   Search text in file (use * for all)
+
+${C.cyan("Repo:")}
+  diff                Show pending changes
+  push [message]      Commit & push changes to GitHub
+  reload              Re-fetch repo files from GitHub
+  clear               Clear terminal screen
+
+${C.cyan("Session:")}
+  help                Show this help
+  exit / quit         Leave repo terminal
+`);
+}
+
+// ─── nano: inline editor ──────────────────────────────────────────────────────
+async function cmd_nano(args, rl) {
+  if (!args[0]) {
+    console.log(C.red("  Usage: nano <file>"));
+    return;
+  }
+  const rel = relativePath(resolvePath(args[0]));
+  const existing = getFileContent(rel) || "";
+
+  console.log(`\n${C.bold("NGX nano")} — ${C.cyan(rel)}`);
+  console.log(
+    C.grey(
+      "  Paste/type your content. Type " +
+        C.bold("::save") +
+        " on a new line to save, " +
+        C.bold("::quit") +
+        " to cancel.\n",
+    ),
+  );
+
+  if (existing) {
+    console.log(C.grey("  [current content — will be replaced]"));
+    const preview = existing.split("\n").slice(0, 5).join("\n  ");
+    const more = existing.split("\n").length > 5 ? "\n  ..." : "";
+    console.log(C.grey("  " + preview + more));
+    console.log();
+  }
+
+  const lines = [];
+  let lineNum = 1;
+
+  return new Promise((resolve) => {
+    rl.setPrompt(C.grey(`  ${lineNum}: `));
+    rl.prompt();
+
+    const onLine = (line) => {
+      if (line === "::save") {
+        _dirty.set(rel, lines.join("\n"));
+        console.log(
+          C.green(
+            `\n  ✓ Saved ${rel} (${lines.length} lines, use 'push' to commit)\n`,
+          ),
+        );
+        rl.removeListener("line", onLine);
+        resolve();
+      } else if (line === "::quit") {
+        console.log(C.grey("\n  Cancelled.\n"));
+        rl.removeListener("line", onLine);
+        resolve();
+      } else {
+        lines.push(line);
+        lineNum++;
+        rl.setPrompt(C.grey(`  ${lineNum}: `));
+        rl.prompt();
+      }
+    };
+    rl.on("line", onLine);
+  });
+}
+
+// ─── push from within the session ────────────────────────────────────────────
+async function cmd_sessionPush(args) {
+  if (!_dirty.size && !_deleted.size) {
+    console.log(C.grey("  Nothing to push. No changes made."));
+    return;
+  }
+
+  const commitMsg =
+    args.join(" ") || `ngx open — ${new Date().toLocaleString()}`;
+  const files = [];
+
+  for (const f of _repoFiles) {
+    if (_deleted.has(f.path)) continue;
+    if (!f.binary) {
+      const content = getFileContent(f.path) || "";
+      const buf = Buffer.from(content);
+      const compressed = zlib.gzipSync(buf);
+      files.push({
+        path: f.path,
+        content_b64: compressed.toString("base64"),
+        compressed: true,
+      });
+    }
+  }
+
+  for (const [p, content] of _dirty) {
+    if (!_repoFiles.find((f) => f.path === p)) {
+      const buf = Buffer.from(content);
+      const compressed = zlib.gzipSync(buf);
+      files.push({
+        path: p,
+        content_b64: compressed.toString("base64"),
+        compressed: true,
+      });
+    }
+  }
+
+  step("Pushing changes...");
+  try {
+    const res = await axios.post(
+      `${getServer()}/push`,
+      {
+        repoName: _repoName,
+        files,
+        message: commitMsg,
+        branch: "main",
+        createIfMissing: false,
+        private: true,
+      },
+      { headers: authHdr(), maxBodyLength: Infinity, timeout: 120_000 },
+    );
+    process.stdout.write("\n");
+    ok(`Pushed ${C.bold(res.data.files)} files — ${C.cyan(res.data.url)}`);
+    _dirty.clear();
+    _deleted.clear();
+  } catch (e) {
+    process.stdout.write("\n");
+    fatal(e.response?.data?.error || e.message);
+  }
+}
+
+// ─── OPEN — Main entry point ──────────────────────────────────────────────────
+async function doOpen(repoArg) {
+  if (!repoArg) fatal("Usage: ngx open <reponame>  or  ngx open owner/repo");
+
+  const username = getUsername();
+  if (!username) fatal("Not logged in. Run: ngx login");
+
+  let owner, repoName;
+  if (repoArg.includes("/")) {
+    [owner, repoName] = repoArg.split("/");
+  } else {
+    owner = username;
+    repoName = repoArg;
+  }
+
+  _owner = owner;
+  _repoName = repoName;
+  _cwd = "/";
+  _dirty = new Map();
+  _deleted = new Set();
+
+  console.log(
+    `\n${C.bold("NGX Repo Terminal")} — ${C.cyan(`${owner}/${repoName}`)}`,
+  );
+  console.log(C.grey("  Loading repo files from GitHub...\n"));
+
+  _repoFiles = await fetchRepo(owner, repoName);
+
+  console.log(C.green(`  ✓ ${_repoFiles.length} files loaded`));
+  console.log(
+    C.grey(
+      `  Type ${C.bold("help")} for available commands, ${C.bold("exit")} to leave.\n`,
+    ),
+  );
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+  });
+
+  function prompt() {
+    const rel = relativePath(_cwd);
+    const loc = rel ? `${repoName}/${rel}` : repoName;
+    const dirty = _dirty.size + _deleted.size > 0 ? C.yel("*") : "";
+    rl.setPrompt(
+      `${C.grey(owner + "/")}${C.bold(C.cyan(loc))}${dirty} ${C.grey("❯")} `,
+    );
+    rl.prompt();
+  }
+
+  prompt();
+
+  rl.on("line", async (input) => {
+    rl.pause();
+    const trimmed = input.trim();
+    if (!trimmed) {
+      prompt();
+      rl.resume();
+      return;
+    }
+
+    const [command, ...args] = trimmed.split(/\s+/);
+
+    switch (command) {
+      case "ls":
+        cmd_ls(args);
+        break;
+      case "cd":
+        cmd_cd(args);
+        break;
+      case "pwd":
+        cmd_pwd();
+        break;
+      case "cat":
+        cmd_cat(args);
+        break;
+      case "head":
+        cmd_head(args);
+        break;
+      case "tail":
+        cmd_tail(args);
+        break;
+      case "stat":
+        cmd_stat(args);
+        break;
+      case "find":
+        cmd_find(args);
+        break;
+      case "grep":
+        cmd_grep(args);
+        break;
+      case "mkdir":
+        cmd_mkdir(args);
+        break;
+      case "touch":
+        cmd_touch(args);
+        break;
+      case "rm":
+        cmd_rm(args);
+        break;
+      case "cp":
+        cmd_cp(args);
+        break;
+      case "mv":
+        cmd_mv(args);
+        break;
+      case "tree":
+        cmd_tree(args);
+        break;
+      case "diff":
+        cmd_diff();
+        break;
+      case "help":
+        cmd_help();
+        break;
+      case "clear":
+        process.stdout.write("\x1Bc");
+        break;
+      case "nano":
+        await cmd_nano(args, rl);
+        break;
+      case "push":
+        await cmd_sessionPush(args);
+        break;
+      case "reload":
+        console.log(C.grey("  Reloading..."));
+        _repoFiles = await fetchRepo(owner, repoName);
+        _dirty.clear();
+        _deleted.clear();
+        console.log(C.green(`  ✓ Reloaded ${_repoFiles.length} files`));
+        break;
+      case "exit":
+      case "quit":
+        if (_dirty.size + _deleted.size > 0 && !args.includes("--force")) {
+          console.log(
+            C.yel(
+              `\n  ⚠ You have ${_dirty.size + _deleted.size} unsaved change(s). Run 'push' first or 'exit --force'\n`,
+            ),
+          );
+          prompt();
+          rl.resume();
+          return;
+        }
+        console.log(C.grey(`\n  Leaving ${repoName} repo terminal.\n`));
+        rl.close();
+        process.exit(0);
+      default:
+        console.log(
+          C.red(`  command not found: ${command}`) +
+            C.grey("  (type 'help' for commands)"),
+        );
+    }
+
+    prompt();
+    rl.resume();
+  });
+
+  rl.on("close", () => process.exit(0));
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
 // ─── MAIN ─────────────────────────────────────────────────────────────────────
+// ══════════════════════════════════════════════════════════════════════════════
+
 const [, , cmd, ...rawArgs] = process.argv;
 const { flags, rest } = parseArgs(rawArgs || []);
 
@@ -539,25 +1969,47 @@ const { flags, rest } = parseArgs(rawArgs || []);
       console.log(`ngx ${VERSION}`);
       break;
 
+    case "token":
+      if (!rest[0]) fatal("Usage: ngx token <JWT>");
+      try {
+        const payload = Buffer.from(rest[0].split(".")[1], "base64").toString();
+        const decoded = JSON.parse(payload);
+        const c = cfg();
+        c.token = rest[0];
+        c.username = decoded.username || decoded.login || decoded.sub;
+        if (!c.username) fatal("Could not extract username from token");
+        saveCfg(c);
+        ok(`Token saved for ${C.bold(c.username)}`);
+      } catch {
+        fatal("Invalid JWT token");
+      }
+      break;
+
+    case "open":
+      if (!rest[0]) fatal("Usage: ngx open <reponame>");
+      await doOpen(rest[0]);
+      break;
+
     case "login":
       await doLogin();
       break;
 
-    case "logout":
-      const c2 = cfg();
-      delete c2.token;
-      delete c2.username;
-      saveCfg(c2);
+    case "logout": {
+      const c = cfg();
+      delete c.token;
+      delete c.username;
+      saveCfg(c);
       ok("Logged out");
       break;
+    }
 
-    case "whoami":
+    case "whoami": {
       const u = getUsername();
       if (u) console.log(`Logged in as: ${C.bold(u)}  "nginxSoft"`);
       else console.log("Not logged in");
       break;
+    }
 
-    // ngx push [reponame] [--path <dir>] [--public] [--message "msg"] [--branch main]
     case "push":
       await doPush(rest[0], {
         path: flags.path,
@@ -567,18 +2019,15 @@ const { flags, rest } = parseArgs(rawArgs || []);
       });
       break;
 
-    // ngx clone owner/repo [dest]
     case "clone":
       if (!rest[0]) fatal("Usage: ngx clone owner/repo [dest]");
       await doClone(rest[0], rest[1], {});
       break;
 
-    // ngx repos
     case "repos":
       await listRepos();
       break;
 
-    // ngx create <name> [--public] [--desc "..."]
     case "create":
       await createRepo(rest[0], {
         visibility: flags.public ? "public" : "private",
@@ -586,30 +2035,28 @@ const { flags, rest } = parseArgs(rawArgs || []);
       });
       break;
 
-    // ngx delete <name>
     case "delete":
       if (!rest[0]) fatal("Usage: ngx delete <reponame>");
       await deleteRepo(rest[0]);
       break;
 
-    // ngx visibility <repo> public|private
     case "visibility":
       await setVisibility(rest[0], rest[1]);
       break;
 
-    // ngx logs
     case "logs":
       await showLogs();
       break;
 
-    // ngx config server <url>
     case "config":
       if (rest[0] === "server" && rest[1]) {
-        const c3 = cfg();
-        c3.server = rest[1];
-        saveCfg(c3);
+        const c = cfg();
+        c.server = rest[1];
+        saveCfg(c);
         ok(`Server set to ${rest[1]}`);
-      } else console.log("Usage: ngx config server <url>");
+      } else {
+        console.log("Usage: ngx config server <url>");
+      }
       break;
 
     default:
@@ -620,6 +2067,7 @@ ${C.cyan("Auth:")}
   ngx login                              GitHub OAuth (opens browser)
   ngx logout                             Clear saved session
   ngx whoami                             Show current user
+  ngx token <JWT>                        Manually save a token
 
 ${C.cyan("Push / Clone:")}
   ngx push                               Push current folder to GitHub
@@ -635,6 +2083,7 @@ ${C.cyan("Repos:")}
   ngx create <name> [--public]           Create a new GitHub repo
   ngx delete <name>                      Delete a GitHub repo
   ngx visibility <repo> public|private   Change repo visibility
+  ngx open <repo>                        Open interactive repo terminal
 
 ${C.cyan("Logs:")}
   ngx logs                               Your NGX activity log