petadep 1.0.1 → 1.0.3

package/README.md

@@ -16,6 +16,14 @@ chmod +x bin/petadep.js
 
 ## Initialize config
 
+```bash
+petadep
+```
+
+Interactive setup will ask for port, webhook path, secret, deployment info, and where to save the config.
+
+If you prefer the non-interactive command:
+
 ```bash
 petadep init --config ./data/config.json
 ```
@@ -39,6 +47,12 @@ petadep add --config ./data/config.json \
 petadep agent --config ./data/config.json
 ```
 
+To install/use PM2 and run the agent under it:
+
+```bash
+petadep agent --config ./data/config.json --pm2
+```
+
 The server exposes:
 
 - `POST /webhook` (or `config.path`)
@@ -63,6 +77,7 @@ The agent clones via SSH using `git@github.com:owner/repo.git`. Your VPS must ha
   "port": 8787,
   "path": "/webhook",
   "secret": "<random>",
+  "sshKeyPath": "/root/.ssh/petadep_ed25519",
   "deployments": [
     {
       "repo": "owner/repo",
@@ -76,3 +91,5 @@ The agent clones via SSH using `git@github.com:owner/repo.git`. Your VPS must ha
   "logsDir": "./logs"
 }
 ```
+
+`sshKeyPath` is optional and forces git to use that SSH key for clone/fetch.

package/bin/petadep.js

@@ -1,12 +1,23 @@
 #!/usr/bin/env node
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { initConfig, addDeployment } from "../src/cli.js";
+import { execa } from "execa";
+import path from "path";
+import { fileURLToPath } from "url";
+import { initConfig, initConfigInteractive, addDeployment } from "../src/cli.js";
 import { startAgent } from "../src/agent.js";
 
 async function main() {
   yargs(hideBin(process.argv))
     .scriptName("petadep")
+    .command(
+      "$0",
+      "Interactive setup",
+      () => {},
+      async () => {
+        await initConfigInteractive();
+      }
+    )
     .command(
       "init",
       "Initialize a config file",
@@ -70,21 +81,61 @@ async function main() {
       "agent",
       "Start the webhook server",
       (y) =>
-        y.option("config", {
-          type: "string",
-          demandOption: true,
-          describe: "Path to config JSON",
-        }),
+        y
+          .option("config", {
+            type: "string",
+            demandOption: true,
+            describe: "Path to config JSON",
+          })
+          .option("pm2", {
+            type: "boolean",
+            default: false,
+            describe: "Install/use pm2 and run the agent under it",
+          }),
       async (argv) => {
+        if (argv.pm2) {
+          await startWithPm2({ configPath: argv.config });
+          return;
+        }
         await startAgent({ configPath: argv.config });
       }
     )
-    .demandCommand(1, "Choose a command")
     .strict()
     .help()
     .parse();
 }
 
+async function ensurePm2() {
+  try {
+    await execa("pm2", ["-v"], { stdio: "ignore" });
+    return;
+  } catch {
+    await execa("npm", ["i", "-g", "pm2"], { stdio: "inherit" });
+  }
+}
+
+async function startWithPm2({ configPath }) {
+  await ensurePm2();
+  const name = "petadep";
+  const resolvedConfig = path.resolve(configPath);
+  const binPath = fileURLToPath(import.meta.url);
+
+  try {
+    await execa("pm2", ["start", binPath, "--name", name, "--", "agent", "--config", resolvedConfig], {
+      stdio: "inherit",
+    });
+  } catch (err) {
+    await execa("pm2", ["restart", name], { stdio: "inherit" });
+    console.log(
+      `PM2 already had '${name}'. Restarted it; if you changed config path, run 'pm2 delete ${name}' then rerun.`
+    );
+    return;
+  }
+
+  await execa("pm2", ["save"], { stdio: "inherit" }).catch(() => {});
+  console.log(`PM2 running. Use 'pm2 status' to check.`);
+}
+
 main().catch((err) => {
   console.error(err?.message || err);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "petadep",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Deploy GitHub repos to a VPS on push via webhooks",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -31,6 +31,7 @@ const configSchema = z.object({
   secret: z.string().min(1),
   deployments: z.array(deploymentSchema).default([]),
   security: securitySchema,
+  sshKeyPath: z.string().min(1).optional(),
   logsDir: z.string().default("./logs"),
 });
 

package/src/cli.js

@@ -1,6 +1,7 @@
 import fs from "fs/promises";
 import path from "path";
 import crypto from "crypto";
+import readline from "readline";
 
 function defaultConfig(secret) {
   return {
@@ -13,6 +14,7 @@ function defaultConfig(secret) {
       lockPerTarget: true,
       timeoutSeconds: 900,
     },
+    sshKeyPath: undefined,
     logsDir: "./logs",
   };
 }
@@ -37,6 +39,128 @@ export async function initConfig({ configPath }) {
   );
 }
 
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+const colors = {
+  reset: "\u001b[0m",
+  bold: "\u001b[1m",
+  cyan: "\u001b[36m",
+  green: "\u001b[32m",
+  yellow: "\u001b[33m",
+  magenta: "\u001b[35m",
+};
+
+function color(text, code) {
+  return `${code}${text}${colors.reset}`;
+}
+
+function prompt(rl, question, defaultValue) {
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      const trimmed = answer.trim();
+      resolve(trimmed.length ? trimmed : defaultValue);
+    });
+  });
+}
+
+function promptHidden(question) {
+  return new Promise((resolve) => {
+    const input = process.stdin;
+    const output = process.stdout;
+    let value = "";
+
+    output.write(`${question}: `);
+    input.setRawMode(true);
+    input.resume();
+
+    function onData(chunk) {
+      const char = chunk.toString("utf8");
+      if (char === "\r" || char === "\n") {
+        input.setRawMode(false);
+        input.pause();
+        input.removeListener("data", onData);
+        output.write("\n");
+        resolve(value.trim());
+        return;
+      }
+      if (char === "\u0003") {
+        process.exit(1);
+      }
+      if (char === "\u007f") {
+        value = value.slice(0, -1);
+        return;
+      }
+      value += char;
+    }
+
+    input.on("data", onData);
+  });
+}
+
+async function promptRequired(rl, question) {
+  let value = "";
+  while (!value) {
+    const answer = await prompt(rl, question, "");
+    value = answer?.trim() || "";
+    if (!value) {
+      console.log(color("This value is required. Try again.", colors.yellow));
+    }
+  }
+  return value;
+}
+
+export async function initConfigInteractive() {
+  const rl = createInterface();
+  try {
+    console.log(color("petadep setup", colors.bold + colors.magenta));
+    console.log(color("Let's create your webhook config.", colors.cyan));
+    const port = await prompt(rl, "Port", "8787");
+    const hookPath = await prompt(rl, "Webhook path", "/webhook");
+    const secretInput = await promptHidden("Secret (leave blank to auto-generate)");
+    const repo = await promptRequired(rl, "Repo (owner/repo)");
+    const branch = await prompt(rl, "Branch", "main");
+    const env = await prompt(rl, "Env name", "production");
+    const workdir = await promptRequired(rl, "Workdir");
+    const script = await prompt(rl, "Script path", "./deploy.sh");
+    const logsDir = await prompt(rl, "Logs dir", "./logs");
+    const sshKeyPath = await prompt(rl, "SSH key path (optional)", "");
+    const savePath = await prompt(rl, "Save config to", "./config.json");
+
+    const secret =
+      secretInput && secretInput.length > 0
+        ? secretInput
+        : crypto.randomBytes(32).toString("hex");
+
+    const config = defaultConfig(secret);
+    config.port = Number(port);
+    config.path = hookPath;
+    config.logsDir = logsDir;
+    if (sshKeyPath) {
+      config.sshKeyPath = sshKeyPath;
+    } else {
+      delete config.sshKeyPath;
+    }
+
+    config.deployments = [{ repo, branch, env, workdir, script }];
+
+    const resolvedPath = path.resolve(savePath);
+    await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+    await fs.writeFile(resolvedPath, JSON.stringify(config, null, 2));
+
+    console.log(color("Config created:", colors.green), resolvedPath);
+    console.log(color("Webhook secret:", colors.green), secret);
+    console.log(color("Start agent:", colors.cyan), `petadep agent --config ${resolvedPath}`);
+  } finally {
+    rl.close();
+  }
+}
+
 export async function addDeployment({
   configPath,
   repo,

package/src/deployer.js

@@ -14,6 +14,14 @@ function toIsoLine(message) {
   return `[${new Date().toISOString()}] ${message}\n`;
 }
 
+function buildGitEnv(config) {
+  if (!config?.sshKeyPath) {
+    return {};
+  }
+  const sshCommand = `ssh -i ${config.sshKeyPath} -o IdentitiesOnly=yes`;
+  return { GIT_SSH_COMMAND: sshCommand };
+}
+
 async function runCommand(command, args, options, logStream) {
   const child = execa(command, args, options);
   if (child.stdout) {
@@ -40,25 +48,32 @@ async function ensureRepo(target, config, logStream, timeoutMs) {
       logPathForTarget(config, target),
       toIsoLine(`Cloning ${sshUrl} into ${target.workdir}`)
     );
+    const env = buildGitEnv(config);
     await runCommand(
       "git",
       ["clone", sshUrl, target.workdir],
-      { timeout: timeoutMs },
+      { timeout: timeoutMs, env: { ...process.env, ...env } },
       logStream
     );
   }
 }
 
-async function checkoutBranch(target, logStream, timeoutMs) {
+async function checkoutBranch(target, config, logStream, timeoutMs) {
   const cwd = target.workdir;
-  await runCommand("git", ["fetch", "--all", "--prune"], { cwd, timeout: timeoutMs }, logStream);
+  const env = buildGitEnv(config);
+  await runCommand(
+    "git",
+    ["fetch", "--all", "--prune"],
+    { cwd, timeout: timeoutMs, env: { ...process.env, ...env } },
+    logStream
+  );
 
   let hasBranch = true;
   try {
     await runCommand(
       "git",
       ["rev-parse", "--verify", target.branch],
-      { cwd, timeout: timeoutMs },
+      { cwd, timeout: timeoutMs, env: { ...process.env, ...env } },
       logStream
     );
   } catch {
@@ -69,14 +84,14 @@ async function checkoutBranch(target, logStream, timeoutMs) {
     await runCommand(
       "git",
       ["checkout", target.branch],
-      { cwd, timeout: timeoutMs },
+      { cwd, timeout: timeoutMs, env: { ...process.env, ...env } },
       logStream
     );
   } else {
     await runCommand(
       "git",
       ["checkout", "-b", target.branch, `origin/${target.branch}`],
-      { cwd, timeout: timeoutMs },
+      { cwd, timeout: timeoutMs, env: { ...process.env, ...env } },
       logStream
     );
   }
@@ -84,7 +99,7 @@ async function checkoutBranch(target, logStream, timeoutMs) {
   await runCommand(
     "git",
     ["reset", "--hard", `origin/${target.branch}`],
-    { cwd, timeout: timeoutMs },
+    { cwd, timeout: timeoutMs, env: { ...process.env, ...env } },
     logStream
   );
 }
@@ -109,7 +124,7 @@ export async function deployTarget(target, config) {
     const logStream = fs.createWriteStream(logFile, { flags: "a" });
     try {
       await ensureRepo(target, config, logStream, timeoutMs);
-      await checkoutBranch(target, logStream, timeoutMs);
+      await checkoutBranch(target, config, logStream, timeoutMs);
       await runScript(target, logStream, timeoutMs);
       await appendLog(logFile, toIsoLine("Deployment finished"));
     } catch (err) {