@pinegrovedev/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/setup.ts
+import { existsSync, mkdirSync, readdirSync } from "node:fs";
+import { execSync as execSync2, spawnSync } from "node:child_process";
+import { join as join2 } from "node:path";
+import { confirm } from "@inquirer/prompts";
+
+// src/platform.ts
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function detectPlatform() {
+  const os = process.platform === "darwin" ? "darwin" : "linux";
+  if (process.platform !== "darwin" && process.platform !== "linux") {
+    throw new Error(`Unsupported platform: ${process.platform}. Pinegrove supports macOS and Linux.`);
+  }
+  let arch;
+  switch (process.arch) {
+    case "arm64":
+      arch = "aarch64";
+      break;
+    case "x64":
+      arch = "x86_64";
+      break;
+    default:
+      throw new Error(`Unsupported architecture: ${process.arch}`);
+  }
+  return { os, arch, key: `${os}-${arch}` };
+}
+function stateDir(os) {
+  if (os === "darwin") {
+    return join(homedir(), "Library", "Application Support", "Pinegrove");
+  }
+  return join(homedir(), ".pinegrove");
+}
+function binDir(os) {
+  return join(stateDir(os), "bin");
+}
+function daemonPath(os) {
+  return join(binDir(os), "pinegrove-daemon");
+}
+function isDaemonInstalled(os) {
+  try {
+    const path = daemonPath(os);
+    execSync(`test -x "${path}"`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function daemonVersion(os) {
+  try {
+    return execSync(`"${daemonPath(os)}" --version`, { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/log.ts
+var RESET = "\x1B[0m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+function info(msg) {
+  console.log(`${GREEN}✓${RESET} ${msg}`);
+}
+function warn(msg) {
+  console.log(`${YELLOW}!${RESET} ${msg}`);
+}
+function error(msg) {
+  console.error(`${RED}✗${RESET} ${msg}`);
+}
+function step(msg) {
+  console.log(`
+${BOLD}${msg}${RESET}`);
+}
+function dim(msg) {
+  console.log(`${DIM}  ${msg}${RESET}`);
+}
+
+// src/commands/setup.ts
+var MANIFEST_URL = "https://updates.pinegrove.dev/daemon/latest.json";
+async function fetchManifest() {
+  const res = await fetch(MANIFEST_URL);
+  if (!res.ok)
+    throw new Error(`Failed to fetch version manifest: HTTP ${res.status}`);
+  return res.json();
+}
+function downloadAndExtract(url, destDir) {
+  mkdirSync(destDir, { recursive: true });
+  const archive = "/tmp/pinegrove-daemon.tar.gz";
+  execSync2(`curl -fsSL "${url}" -o "${archive}"`, { stdio: "inherit" });
+  execSync2(`tar -xzf "${archive}" -C "${destDir}"`, { stdio: "inherit" });
+  const expectedPath = join2(destDir, "pinegrove-daemon");
+  if (!existsSync(expectedPath)) {
+    const files = readdirSync(destDir);
+    const extracted = files.find((f) => f !== "pinegrove-daemon" && !f.startsWith("."));
+    if (extracted) {
+      execSync2(`mv "${join2(destDir, extracted)}" "${expectedPath}"`);
+    }
+  }
+  execSync2(`chmod 755 "${expectedPath}"`);
+  execSync2(`rm -f "${archive}"`);
+}
+function registerService(daemon) {
+  spawnSync(daemon, ["uninstall"], { stdio: "ignore" });
+  const result = spawnSync(daemon, ["install", "--port", "19284"], { stdio: "inherit" });
+  if (result.status !== 0) {
+    throw new Error("Failed to register daemon service");
+  }
+}
+function runPrereqs(daemon) {
+  const result = spawnSync(daemon, ["prereqs", "install"], { stdio: "inherit" });
+  return result.status === 0;
+}
+function runSetup(daemon, opts) {
+  const args = ["setup"];
+  if (opts.token && opts.name) {
+    args.push("--token", opts.token, "--name", opts.name);
+  }
+  args.push("--api-url", opts.apiUrl);
+  const result = spawnSync(daemon, args, { stdio: "inherit" });
+  return result.status === 0;
+}
+function waitForDaemon(daemon, timeoutMs = 15000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = spawnSync(daemon, ["status"], { encoding: "utf-8", stdio: "pipe" });
+    if (result.stdout?.includes("running"))
+      return true;
+    execSync2("sleep 1");
+  }
+  return false;
+}
+async function setup(opts) {
+  const platform = detectPlatform();
+  step(`Pinegrove Setup (${platform.os}/${platform.arch})`);
+  step("Step 1: Daemon binary");
+  const existingVersion = daemonVersion(platform.os);
+  let manifest = null;
+  try {
+    manifest = await fetchManifest();
+  } catch (e) {
+    if (existingVersion) {
+      warn(`Could not fetch latest version (${e.message}). Using installed v${existingVersion}.`);
+    } else {
+      error(`Could not fetch latest version: ${e.message}`);
+      process.exit(1);
+    }
+  }
+  if (manifest) {
+    const platformEntry = manifest.platforms[platform.key];
+    if (!platformEntry) {
+      error(`No daemon build available for ${platform.key}`);
+      dim(`Available platforms: ${Object.keys(manifest.platforms).join(", ")}`);
+      process.exit(1);
+    }
+    if (existingVersion === manifest.version) {
+      info(`Daemon v${existingVersion} is already the latest`);
+    } else {
+      if (existingVersion) {
+        info(`Upgrading daemon v${existingVersion} → v${manifest.version}`);
+      } else {
+        info(`Installing daemon v${manifest.version}`);
+      }
+      downloadAndExtract(platformEntry.url, binDir(platform.os));
+      info(`Installed to ${binDir(platform.os)}`);
+    }
+  }
+  const daemon = daemonPath(platform.os);
+  if (!isDaemonInstalled(platform.os)) {
+    error("Daemon binary not found after installation");
+    process.exit(1);
+  }
+  step("Step 2: System service");
+  try {
+    registerService(daemon);
+    info("Daemon service registered");
+  } catch (e) {
+    error(e.message);
+    process.exit(1);
+  }
+  if (!opts.skipPrereqs) {
+    step("Step 3: Prerequisites (nix, devbox, bubblewrap)");
+    dim("Some installers may ask for sudo password");
+    console.log();
+    const ok = runPrereqs(daemon);
+    if (!ok) {
+      warn("Some prerequisites need manual installation (see above)");
+      const cont = await confirm({ message: "Continue anyway?" });
+      if (!cont)
+        process.exit(1);
+    }
+  } else {
+    step("Step 3: Prerequisites (skipped)");
+  }
+  step("Step 4: Starting daemon");
+  if (!waitForDaemon(daemon)) {
+    warn("Daemon not responding — it may need a manual start");
+    dim(`Try: ${daemon} start`);
+  } else {
+    info("Daemon is running");
+  }
+  step("Step 5: Connect to your team");
+  console.log();
+  const setupOk = runSetup(daemon, opts);
+  if (!setupOk) {
+    error("Setup failed — try running manually:");
+    dim(`${daemon} setup`);
+    process.exit(1);
+  }
+  step("Setup complete!");
+  info("Daemon is installed, provisioned, and connected to your team's mesh");
+  dim(`Binary: ${daemon}`);
+  dim(`State:  ${stateDir(platform.os)}`);
+  const bin = binDir(platform.os);
+  if (!process.env.PATH?.includes(bin)) {
+    console.log();
+    warn(`Add to your shell profile: export PATH="${bin}:$PATH"`);
+  }
+}
+
+// src/commands/status.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+async function status() {
+  const platform = detectPlatform();
+  step(`Pinegrove Status (${platform.os}/${platform.arch})`);
+  if (!isDaemonInstalled(platform.os)) {
+    error("Daemon not installed");
+    dim("Run: npx @pinegrove/cli setup");
+    return;
+  }
+  const version = daemonVersion(platform.os);
+  info(`Daemon v${version} installed at ${daemonPath(platform.os)}`);
+  const daemon = daemonPath(platform.os);
+  const statusResult = spawnSync2(daemon, ["status"], { encoding: "utf-8", stdio: "pipe" });
+  if (statusResult.stdout?.includes("running")) {
+    info(statusResult.stdout.trim());
+  } else {
+    warn(statusResult.stdout?.trim() || "Daemon not running");
+  }
+  console.log();
+  spawnSync2(daemon, ["prereqs", "status"], { stdio: "inherit" });
+}
+
+// src/commands/uninstall.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { confirm as confirm2 } from "@inquirer/prompts";
+async function uninstall() {
+  const platform = detectPlatform();
+  if (!isDaemonInstalled(platform.os)) {
+    error("Daemon not installed");
+    return;
+  }
+  const daemon = daemonPath(platform.os);
+  const state = stateDir(platform.os);
+  const ok = await confirm2({
+    message: `This will stop and uninstall the Pinegrove daemon.
+State directory (${state}) will be preserved.
+Continue?`
+  });
+  if (!ok)
+    return;
+  step("Stopping daemon");
+  spawnSync3(daemon, ["stop"], { stdio: "inherit" });
+  step("Removing service");
+  spawnSync3(daemon, ["uninstall"], { stdio: "inherit" });
+  info("Daemon uninstalled. State directory preserved at " + state);
+  dim("To fully remove: rm -rf " + state);
+}
+
+// src/index.ts
+var program = new Command().name("pinegrove").description("Pinegrove CLI — install and provision the Pinegrove daemon").version("0.1.0");
+program.command("setup").description("Install the daemon, prerequisites, and connect to your team").option("--api-url <url>", "Pinegrove API base URL", "https://api.pinegrove.dev").option("--skip-prereqs", "Skip prerequisite installation").option("--token <token>", "Provisioning token (headless mode)").option("--name <name>", "Device name (headless mode)").action(setup);
+program.command("status").description("Show daemon and prerequisite status").action(status);
+program.command("uninstall").description("Stop and remove the daemon").action(uninstall);
+if (process.argv.length <= 2) {
+  process.argv.push("setup");
+}
+program.parse();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@pinegrovedev/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "pinegrove": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --external commander --external @inquirer/prompts",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "commander": "^13",
+    "@inquirer/prompts": "^7"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}