stackedge 1.0.0

package/README.md

@@ -0,0 +1,215 @@
+### Stackedge
+
+<div align="center">
+  <img src="/download.jfif" alt="Stackedge Logo" width="200"/>
+</div>
+
+## Decentralized App Hosting on Android using Termux + Tor
+
+Stackedge is a Termux-friendly app hosting system that allows you to run any web app (Node.js, PHP, Go, etc.) on your Android device.
+Inspired by the desire to build something decentralized, privacy-focused, and open-source, Stackedge integrates Tor onion services to make your apps accessible anywhere safely.
+
+Your apps start immediately, Tor bootstraps in the background, and you can manage them via a simple CLI (start, stop, restart, list, resurrect).
+
+**Features**
+
+- Run any app (Node.js, PHP, Go, Python…) from the folder you are in.
+
+- Tor integration for onion services.
+
+- Apps start immediately; Tor bootstraps in the background.
+
+- Resilient to Wi-Fi drops or Termux restarts.
+
+## CLI commands similar to pm2:
+
+- stackedge start <name> -- <command>
+
+- stackedge stop <name>
+
+- stackedge restart <name>
+
+- stackedge list
+
+- stackedge resurrect
+
+- Fallback command shows status and help.
+
+**Open-source and focused on privacy & decentralization.**
+---
+
+### Table of Contents
+
+**Requirements**
+
+1.Installation
+
+2.Setup
+
+**Usage**
+
+1.Termux Auto-Resurrect
+
+**Project Philosophy**
+
+## Support
+
+---
+
+### Requirements
+
+Android device
+
+Termux
+ installed
+
+**Installed Termux packages:**
+```
+pkg update && pkg upgrade -y
+pkg install nodejs git tor -y
+```
+
+**Optional for PHP apps:**
+```
+pkg install php -y
+```
+
+**Optional for Go apps:**
+```
+pkg install golang -y
+
+```
+**Optional for Python apps:**
+```
+pkg install python -y
+```
+### Installation
+
+**Clone the Stackedge repository:**
+```
+cd $HOME
+git clone https://github.com/Frost-bit-star/stackedge.git
+cd stackedge
+```
+
+
+**Install globally via npm:**
+```
+npm install -g stackedge
+```
+
+**Make sure the CLI is executable:**
+```
+chmod +x $HOME/.npm-global/bin/stackedge
+```
+
+**Verify installation:**
+```
+stackedge
+```
+
+**You should see a status summary and available commands.**
+
+### Setup
+
+Stackedge uses the following directory structure in Termux:
+```
+$HOME/.stackedge/
+ ├── apps.json             # Stores all app info
+ ├── tor/
+ │   ├── torrc             # Tor config
+ │   └── services/         # Onion services storage
+ └── logs/                 # App logs
+```
+
+**Stackedge automatically creates these directories on first run.**
+
+## Usage
+Start an app
+
+Navigate to the app folder and run:
+```
+cd ~/my-react-app
+stackedge start blog -- npm start
+```
+
+- blog is the app name.
+
+- Everything after -- is the command to start your app.
+
+**Tor starts in the background; your app starts immediately.**
+
+### The onion address will appear once Tor is fully bootstrapped.
+
+## Stop an app
+- stackedge stop blog
+
+## Restart an app
+- stackedge restart blog
+
+## List all apps
+- stackedge list
+
+---
+
+**Shows:**
+
+- App name
+
+- App state (running/stopped)
+
+- Port
+
+- Tor state (pending/online)
+
+- Onion address
+
+- Resurrect all apps
+
+**Use this to restore apps after Termux restart or Wi-Fi loss:**
+
+- stackedge resurrect
+
+- Termux Auto-Resurrect
+
+**To automatically restore apps when Termux opens:**
+```bash
+echo 'if command -v stackedge >/dev/null; then stackedge resurrect >/dev/null 2>&1 & fi' >> ~/.bashrc
+```
+
+- Apps will start immediately.
+
+- Tor will bootstrap in the background.
+
+- No manual intervention needed.
+
+- Project Philosophy
+
+## Stackedge is:
+
+### Open-source: Learn, modify, and contribute.
+
+- Privacy-focused: Tor integration keeps your apps secure and accessible anonymously.
+
+- Decentralized hosting on Android: Your device becomes your own server.
+
+- Inspired by a love for Termux and building something great, this project is for developers, hackers, and privacy enthusiasts.
+
+Check out my other projects and tutorials:
+ [here](https://www.youtube.com/@Mr_termux-r2l)
+
+
+---
+
+### ☕ Support This Project
+
+If you value open-source and anonymity, support me so I can keep building decentralized hosting tools on Android:
+
+<a href="https://buymeacoffee.com/morganmilsn" target="_blank"> <img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" height="50" alt="Buy Me A Coffee"> </a>
+
+
+License
+
+---
+
+MIT License – Open source for everyone.

package/bin/stackedge.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+const { program } = require("commander");
+const { loadApps, saveApps } = require("../lib/registry");
+const { startProcess } = require("../lib/process");
+const { listApps } = require("../lib/tui/list");
+const { resurrect } = require("../lib/resurrect");
+const { stopApp } = require("../lib/commands/stop");
+const { restartApp } = require("../lib/commands/restart");
+
+const { spawn } = require("child_process");
+const net = require("net");
+const fs = require("fs-extra");
+const path = require("path");
+
+/* =========================
+   TOR CONSTANTS
+========================= */
+
+const TOR_BIN = "/data/data/com.termux/files/usr/bin/tor";
+const TOR_BASE = path.join(process.env.HOME, ".tor");
+const TORRC = path.join(TOR_BASE, "torrc");
+const TOR_HS_DIR = path.join(TOR_BASE, "hidden");
+const CONTROL_PORT = 9051;
+
+/* =========================
+   UTILS
+========================= */
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+async function getFreePort(start = 3000, end = 9000) {
+  for (let p = start; p <= end; p++) {
+    try {
+      await new Promise((res, rej) => {
+        const s = net.createServer()
+          .once("error", rej)
+          .once("listening", () => s.close(res))
+          .listen(p, "127.0.0.1");
+      });
+      return p;
+    } catch {}
+  }
+  throw new Error("No free ports");
+}
+
+/* =========================
+   TOR MANAGEMENT
+========================= */
+
+async function ensureTorFilesystem() {
+  await fs.ensureDir(TOR_BASE);
+  await fs.ensureDir(TOR_HS_DIR);
+
+  await fs.chmod(TOR_BASE, 0o700);
+  await fs.chmod(TOR_HS_DIR, 0o700);
+
+  if (!await fs.pathExists(TORRC)) {
+    await fs.writeFile(TORRC, `
+DataDirectory ${TOR_BASE}
+ControlPort ${CONTROL_PORT}
+CookieAuthentication 1
+AvoidDiskWrites 1
+Log notice stdout
+`.trim() + "\n");
+  }
+}
+
+async function isTorRunning() {
+  return new Promise((resolve) => {
+    const socket = net.createConnection(CONTROL_PORT, "127.0.0.1");
+    socket.once("connect", () => {
+      socket.end();
+      resolve(true);
+    });
+    socket.once("error", () => resolve(false));
+  });
+}
+
+async function startTorOnce() {
+  await ensureTorFilesystem();
+
+  if (await isTorRunning()) return;
+
+  spawn(TOR_BIN, ["-f", TORRC], {
+    detached: true,
+    stdio: "ignore",
+  }).unref();
+
+  // wait for control port
+  for (let i = 0; i < 15; i++) {
+    if (await isTorRunning()) return;
+    await sleep(1000);
+  }
+
+  throw new Error("Tor failed to start");
+}
+
+/* =========================
+   TOR CONTROL PORT
+========================= */
+
+async function torControl(cmd) {
+  const cookie = await fs.readFile(
+    path.join(TOR_BASE, "control_auth_cookie")
+  );
+
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(CONTROL_PORT, "127.0.0.1");
+
+    socket.on("error", reject);
+
+    socket.on("data", (data) => {
+      if (data.toString().startsWith("250")) {
+        resolve(data.toString());
+        socket.end();
+      }
+    });
+
+    socket.once("connect", () => {
+      socket.write(`AUTHENTICATE ${cookie.toString("hex")}\r\n`);
+      socket.write(cmd + "\r\n");
+      socket.write("QUIT\r\n");
+    });
+  });
+}
+
+async function addHiddenService(name, port) {
+  const dir = path.join(TOR_HS_DIR, name);
+  await fs.ensureDir(dir);
+  await fs.chmod(dir, 0o700);
+
+  const res = await torControl(
+    `ADD_ONION NEW:ED25519-V3 Port=${port},127.0.0.1:${port}`
+  );
+
+  return res.match(/ServiceID=(\S+)/)[1] + ".onion";
+}
+
+/* =========================
+   START COMMAND
+========================= */
+
+program.command("start <name>")
+  .allowUnknownOption(true)
+  .action(async (name) => {
+
+    const idx = process.argv.indexOf("--");
+    if (idx === -1) {
+      console.log("Usage: stackedge start <name> -- <cmd>");
+      process.exit(1);
+    }
+
+    const command = process.argv.slice(idx + 1).join(" ");
+    const apps = await loadApps();
+
+    const port = process.env.PORT || await getFreePort();
+
+    await startTorOnce();
+
+    const onion = await addHiddenService(name, port);
+
+    startProcess({
+      name,
+      command,
+      cwd: process.cwd(),
+      env: { ...process.env, PORT: String(port) }
+    });
+
+    apps.push({
+      name,
+      port,
+      onion,
+      command,
+      appState: "online",
+      torState: "online",
+      autorestart: true
+    });
+
+    await saveApps(apps);
+
+    console.log(`✔ ${name} running`);
+    console.log(`🌐 ${onion}`);
+  });
+
+/* =========================
+   OTHER COMMANDS
+========================= */
+
+program.command("stop <name>").action(stopApp);
+program.command("restart <name>").action(restartApp);
+program.command("list").action(listApps);
+program.command("resurrect").action(resurrect);
+
+program.parse(process.argv);

package/lib/commands/delete.js

@@ -0,0 +1,44 @@
+const { loadApps, saveApps } = require("../registry");
+const { stopProcess } = require("../process");
+const fs = require("fs-extra");
+const path = require("path");
+
+/**
+ * Delete an app from the registry and stop it if running.
+ * @param {string} name - App name to delete
+ */
+async function deleteApp(name) {
+  const apps = await loadApps();
+  const index = apps.findIndex(a => a.name === name);
+
+  if (index === -1) {
+    console.log(`App '${name}' not found`);
+    return;
+  }
+
+  const app = apps[index];
+
+  // Stop the app if running
+  if (app.pid) {
+    stopProcess(app);
+    console.log(`Stopped '${name}'`);
+  }
+
+  // Remove app from registry
+  apps.splice(index, 1);
+  await saveApps(apps);
+  console.log(`Deleted '${name}' from registry`);
+
+  // Optional: delete app folder if you want
+  // await fs.remove(app.cwd);
+  // console.log(`Deleted folder: ${app.cwd}`);
+
+  // Optional: delete Tor hidden service if exists
+  // const hiddenServiceDir = path.join(process.env.HOME, ".tor", "hidden_service_" + name);
+  // if (await fs.pathExists(hiddenServiceDir)) {
+  //   await fs.remove(hiddenServiceDir);
+  //   console.log(`Deleted Tor hidden service: ${hiddenServiceDir}`);
+  // }
+}
+
+module.exports = { deleteApp };

package/lib/commands/restart.js

@@ -0,0 +1,38 @@
+const { loadApps, saveApps } = require("../registry");
+const { startProcess, stopProcess } = require("../process");
+
+/**
+ * Restart an app by stopping it and starting it again.
+ * @param {string} name - App name
+ */
+async function restartApp(name) {
+  const apps = await loadApps();
+  const app = apps.find(a => a.name === name);
+
+  if (!app) {
+    console.log(`App '${name}' not found`);
+    return;
+  }
+
+  // Stop the app
+  stopProcess(app);
+
+  // Reset port and state
+  app.port = null;
+  app.appState = "starting";
+  app.torState = "pending";
+
+  // Start it again
+  startProcess(app);
+
+  // Save updated apps registry
+  const index = apps.findIndex(a => a.name === name);
+  if (index !== -1) {
+    apps[index] = app;
+    await saveApps(apps);
+  }
+
+  console.log(`Restarted '${name}' successfully`);
+}
+
+module.exports = { restartApp };

package/lib/commands/stop.js

@@ -0,0 +1,13 @@
+const { loadApps, saveApps } = require("../registry");
+const { stopProcess } = require("../process");
+
+async function stopApp(name) {
+  const apps = await loadApps();
+  const app = apps.find(a => a.name === name);
+  if (!app) return console.log("App not found");
+  stopProcess(app);
+  await saveApps(apps);
+  console.log(`Stopped ${name}`);
+}
+
+module.exports = { stopApp };

package/lib/config.js

@@ -0,0 +1,11 @@
+const path = require("path");
+const HOME = process.env.HOME;
+
+module.exports = {
+  HOME,
+  BASE_DIR: path.join(HOME, ".stackedge"),
+  APPS_FILE: path.join(HOME, ".stackedge", "apps.json"),
+  LOG_DIR: path.join(HOME, ".stackedge", "logs"),
+  TOR_DIR: path.join(HOME, ".stackedge", "tor"),
+  TORRC: path.join(HOME, ".stackedge", "tor", "torrc")
+};

package/lib/process.js

@@ -0,0 +1,88 @@
+const { spawn } = require("child_process");
+const { loadApps, saveApps } = require("./registry");
+
+/**
+ * Start an application process
+ * @param {Object} app
+ */
+async function startProcess(app) {
+  if (!app || !app.command) {
+    throw new Error("App command is required to start a process.");
+  }
+
+  const child = spawn("sh", ["-c", app.command], {
+    cwd: app.cwd || process.cwd(),
+    env: { ...process.env, ...app.env },
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true
+  });
+
+  app.pid = child.pid;
+  app.appState = "running";
+
+  // Persist state immediately
+  const apps = await loadApps();
+  const idx = apps.findIndex(a => a.name === app.name);
+  if (idx !== -1) {
+    apps[idx] = app;
+  } else {
+    apps.push(app);
+  }
+  await saveApps(apps);
+
+  // Forward logs
+  child.stdout.on("data", data => {
+    process.stdout.write(`[${app.name}] ${data}`);
+  });
+
+  child.stderr.on("data", data => {
+    process.stderr.write(`[${app.name} ERROR] ${data}`);
+  });
+
+  child.on("exit", async (code, signal) => {
+    const apps = await loadApps();
+    const idx = apps.findIndex(a => a.name === app.name);
+    if (idx !== -1) {
+      apps[idx].appState = "stopped";
+      apps[idx].pid = null;
+      await saveApps(apps);
+    }
+    console.log(`${app.name} exited (${signal || code})`);
+  });
+
+  child.unref();
+}
+
+/**
+ * Stop a running application
+ * @param {Object} app
+ */
+async function stopProcess(app) {
+  if (!app || !app.pid) return;
+
+  try {
+    process.kill(app.pid, "SIGTERM");
+
+    // fallback kill after 3s
+    setTimeout(() => {
+      try {
+        process.kill(app.pid, "SIGKILL");
+      } catch {}
+    }, 3000);
+  } catch (err) {
+    console.error(`Failed to stop ${app.name}: ${err.message}`);
+  }
+
+  const apps = await loadApps();
+  const idx = apps.findIndex(a => a.name === app.name);
+  if (idx !== -1) {
+    apps[idx].appState = "stopped";
+    apps[idx].pid = null;
+    await saveApps(apps);
+  }
+}
+
+module.exports = {
+  startProcess,
+  stopProcess
+};

package/lib/registry.js

@@ -0,0 +1,58 @@
+// lib/registry.js
+const fs = require("fs-extra");
+const path = require("path");
+const { APPS_FILE } = require("./config");
+
+// Default fields for each app
+const DEFAULT_APP = {
+  name: "",
+  cwd: "",
+  command: "",
+  port: null,
+  pid: null,
+  appState: "starting",
+  torState: "pending",
+  onion: null,
+  autorestart: true
+};
+
+/**
+ * Load apps from registry
+ * @returns {Promise<Array>}
+ */
+async function loadApps() {
+  try {
+    if (!(await fs.pathExists(APPS_FILE))) return [];
+    const apps = await fs.readJson(APPS_FILE);
+    // Ensure all apps have default fields
+    return apps.map(a => ({ ...DEFAULT_APP, ...a }));
+  } catch (err) {
+    console.error("Failed to load apps registry:", err);
+    return [];
+  }
+}
+
+/**
+ * Save or update apps in registry
+ * Merges by app name to avoid overwriting other apps
+ * @param {Array} appsToSave
+ */
+async function saveApps(appsToSave) {
+  try {
+    // Ensure directory exists
+    await fs.ensureDir(path.dirname(APPS_FILE));
+
+    // Load existing apps
+    const existingApps = await loadApps();
+
+    // Merge apps by name
+    const merged = [...existingApps.filter(e => !appsToSave.some(a => a.name === e.name)), ...appsToSave];
+
+    // Write JSON to file
+    await fs.writeJson(APPS_FILE, merged, { spaces: 2 });
+  } catch (err) {
+    console.error("Failed to save apps registry:", err);
+  }
+}
+
+module.exports = { loadApps, saveApps };

package/lib/resurrect.js

@@ -0,0 +1,30 @@
+const { loadApps, saveApps } = require("./registry");
+const { startProcess } = require("./process");
+const { ensureTorConfig, startTor } = require("./tor/tor");
+const { waitForBootstrap } = require("./tor/bootstrap");
+const { createOnion } = require("./tor/control");
+
+async function resurrect() {
+  const apps = await loadApps();
+  if (!apps.length) return;
+
+  for (const app of apps) {
+    startProcess(app);
+    app.appState = "running";
+    app.torState = "pending";
+  }
+
+  await ensureTorConfig();
+  startTor();
+  await waitForBootstrap();
+
+  for (const app of apps) {
+    if (!app.onion) app.onion = await createOnion(app.port || 8080);
+    app.torState = "online";
+  }
+
+  await saveApps(apps);
+  console.log("All apps resurrected");
+}
+
+module.exports = { resurrect };

package/lib/tor/bootstrap.js

@@ -0,0 +1,54 @@
+const fs = require("fs");
+const path = require("path");
+const net = require("net");
+
+async function waitForBootstrap(torDir, timeout = 30000) {
+  return new Promise((resolve, reject) => {
+    const cookieFile = path.join(torDir, "control_auth_cookie");
+
+    let cookieHex;
+    try {
+      cookieHex = fs.readFileSync(cookieFile).toString("hex");
+    } catch (err) {
+      return reject(new Error("Cannot read Tor cookie: " + err.message));
+    }
+
+    const socket = net.connect(9051, "127.0.0.1");
+    const start = Date.now();
+
+    socket.on("connect", () => {
+      socket.write(`AUTHENTICATE ${cookieHex}\r\n`);
+      socket.write("SETEVENTS STATUS_GENERAL\r\n");
+    });
+
+    socket.on("data", (data) => {
+      const lines = data.toString().split("\r\n");
+
+      for (const line of lines) {
+        // Example:
+        // 650 STATUS_GENERAL BOOTSTRAP PROGRESS=100 TAG=done SUMMARY="Done"
+        if (line.includes("BOOTSTRAP") && line.includes("PROGRESS=100")) {
+          socket.end();
+          return resolve();
+        }
+
+        if (line.startsWith("515") || line.startsWith("550")) {
+          socket.end();
+          return reject(new Error("Tor control error: " + line));
+        }
+      }
+    });
+
+    socket.on("error", reject);
+
+    const timer = setInterval(() => {
+      if (Date.now() - start > timeout) {
+        clearInterval(timer);
+        socket.end();
+        reject(new Error("Tor bootstrap timed out"));
+      }
+    }, 1000);
+  });
+}
+
+module.exports = { waitForBootstrap };

package/lib/tor/control.js

@@ -0,0 +1,37 @@
+const net = require("net");
+const fs = require("fs");
+const path = require("path");
+
+async function createOnion(port, torDir) {
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(9051, "127.0.0.1", () => {
+      // Read cookie for authentication
+      const cookieFile = path.join(torDir, "control_auth_cookie");
+      let cookieHex = "";
+      try {
+        cookieHex = fs.readFileSync(cookieFile).toString("hex");
+      } catch (err) {
+        return reject("Cannot read Tor cookie: " + err.message);
+      }
+      socket.write(`AUTHENTICATE ${cookieHex}\r\n`);
+    });
+
+    socket.on("data", (data) => {
+      const lines = data.toString().split("\r\n");
+      for (const line of lines) {
+        if (line.startsWith("250-ServiceID=")) {
+          const id = line.split("=")[1].trim();
+          socket.end();
+          return resolve(`${id}.onion`);
+        } else if (line.startsWith("515") || line.startsWith("550")) {
+          socket.end();
+          return reject("Tor error: " + line);
+        }
+      }
+    });
+
+    socket.on("error", (err) => reject(err));
+  });
+}
+
+module.exports = { createOnion };

package/lib/tor/tor.js

@@ -0,0 +1,58 @@
+const fs = require("fs-extra");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const TOR_BIN = "/data/data/com.termux/files/usr/bin/tor"; // Termux Tor binary
+const TOR_DIR = path.join(process.env.HOME, ".tor");
+const TORRC = path.join(TOR_DIR, "torrc");
+
+async function ensureTorConfig() {
+  await fs.ensureDir(TOR_DIR);
+  const torrc = `
+DataDirectory ${TOR_DIR}
+ControlPort 9051
+CookieAuthentication 1
+AvoidDiskWrites 1
+  `.trim();
+  await fs.writeFile(TORRC, torrc);
+}
+
+async function startTor(appName, appPort) {
+  await ensureTorConfig();
+
+  // Hidden service for this app
+  const hiddenServiceDir = path.join(TOR_DIR, `hidden_service_${appName}`);
+  await fs.ensureDir(hiddenServiceDir);
+
+  // Append hidden service config to torrc
+  const hiddenServiceConfig = `
+HiddenServiceDir ${hiddenServiceDir}
+HiddenServicePort ${appPort} 127.0.0.1:${appPort}
+  `.trim();
+  await fs.appendFile(TORRC, "\n" + hiddenServiceConfig);
+
+  return new Promise((resolve, reject) => {
+    const tor = spawn(TOR_BIN, ["-f", TORRC], {
+      cwd: TOR_DIR,
+      detached: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+
+    tor.stdout.on("data", (data) => {
+      const text = data.toString();
+      process.stdout.write(text);
+
+      if (text.includes("Bootstrapped 100%")) {
+        // Tor fully online
+        resolve(hiddenServiceDir);
+      }
+    });
+
+    tor.stderr.on("data", (data) => process.stderr.write(data.toString()));
+    tor.on("error", (err) => reject(err));
+
+    tor.unref();
+  });
+}
+
+module.exports = { ensureTorConfig, startTor, TOR_DIR, TORRC };

package/lib/tui/list.js

@@ -0,0 +1,50 @@
+// lib/tui/list.js
+
+// For Chalk v5+, handle default export
+const chalkModule = require("chalk");
+const chalk = chalkModule.default ? chalkModule.default : chalkModule;
+
+const { loadApps, saveApps } = require("../registry");
+
+// Check if a PID is alive (works on Termux / Linux / Node)
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0); // signal 0 just tests for existence
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listApps() {
+  const apps = await loadApps();
+
+  console.log(chalk.bold("NAME     APP STATE   PORT   TOR STATE   ONION"));
+
+  for (const a of apps) {
+    // Real-time check if the app is actually running
+    const alive = a.pid && isProcessAlive(a.pid);
+    const appState = alive ? (a.appState || "running") : "stopped";
+
+    console.log(
+      `${a.name.padEnd(8)} ` +
+      `${(appState || "").padEnd(11)} ` +
+      `${String(a.port || "-").padEnd(6)} ` +
+      `${(a.torState || "").padEnd(10)} ` +
+      `${a.onion || "setting up"}`
+    );
+
+    // Update registry if state has changed
+    if (appState !== a.appState) {
+      a.appState = appState;
+      const allApps = await loadApps();
+      const index = allApps.findIndex(x => x.name === a.name);
+      if (index !== -1) {
+        allApps[index] = a;
+        await saveApps(allApps);
+      }
+    }
+  }
+}
+
+module.exports = { listApps };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "stackedge",
+  "version": "1.0.0",
+  "description": "Termux-friendly decentralized app hosting with Tor",
+  "bin": {
+    "stackedge": "bin/stackedge.js"
+  },
+  "type": "commonjs",
+  "keywords": [
+    "termux",
+    "tor",
+    "cli",
+    "hosting",
+    "node",
+    "decentralized",
+    "android"
+  ],
+  "author": "Mr_termux-r2l <hr@stackverify.site>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Frost-bit-star/stackedge.git"
+  },
+  "homepage": "https://www.youtube.com/@Mr_termux-r2l",
+  "dependencies": {
+    "commander": "^11.0.0",
+    "chalk": "^5.3.0",
+    "fs-extra": "^11.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "start": "node bin/stackedge.js"
+  }
+}