pyre-cli 9.5.2 → 10.1.0

package/dist/serveCmd-2H5VLF3P.js

@@ -0,0 +1,153 @@
+import {
+  collectAll,
+  collectBattery,
+  collectContainers,
+  collectCpu,
+  collectDisk,
+  collectGpu,
+  collectMemory,
+  collectNetwork,
+  collectProcesses,
+  collectSystem,
+  collectThermal
+} from "./chunk-GHRDW646.js";
+import "./chunk-M73HCQD2.js";
+import "./chunk-VIACN2RU.js";
+import "./chunk-MZO5QKUR.js";
+
+// src/serveCmd.ts
+import http from "http";
+import os from "os";
+import chalk from "chalk";
+async function runServeCommand(opts = {}) {
+  const port = opts.port || 8080;
+  const apiKey = opts.apiKey || process.env.PYRE_API_KEY || "";
+  const server = http.createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const urlObj = new URL(req.url || "/", `http://localhost:${port}`);
+    const pathname = urlObj.pathname;
+    if (apiKey) {
+      const authHeader = req.headers["authorization"] || "";
+      const xApiKey = req.headers["x-api-key"] || "";
+      const queryKey = urlObj.searchParams.get("key") || "";
+      const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
+      if (token !== apiKey && xApiKey !== apiKey && queryKey !== apiKey) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Unauthorized: Invalid or missing API key" }));
+        return;
+      }
+    }
+    try {
+      let data;
+      switch (pathname) {
+        case "/api/all":
+        case "/api/stats":
+        case "/api":
+          data = await collectAll({ detailed: opts.detailed });
+          break;
+        case "/api/cpu":
+          data = await collectCpu();
+          break;
+        case "/api/memory":
+        case "/api/mem":
+          data = await collectMemory();
+          break;
+        case "/api/gpu":
+          data = await collectGpu(opts.detailed);
+          break;
+        case "/api/battery":
+        case "/api/power":
+          data = await collectBattery();
+          break;
+        case "/api/thermal":
+        case "/api/temp":
+          data = await collectThermal(opts.detailed);
+          break;
+        case "/api/network":
+        case "/api/net":
+          data = await collectNetwork();
+          break;
+        case "/api/disk":
+          data = await collectDisk();
+          break;
+        case "/api/processes":
+        case "/api/proc":
+          data = await collectProcesses(50);
+          break;
+        case "/api/containers":
+          data = await collectContainers();
+          break;
+        case "/api/system":
+        case "/api/info":
+          data = await collectSystem();
+          break;
+        case "/health":
+        case "/api/health":
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ status: "ok", uptime: os.uptime(), timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+          return;
+        default:
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Not found",
+            availableEndpoints: [
+              "/api/all",
+              "/api/cpu",
+              "/api/memory",
+              "/api/gpu",
+              "/api/battery",
+              "/api/thermal",
+              "/api/network",
+              "/api/disk",
+              "/api/processes",
+              "/api/containers",
+              "/api/system",
+              "/api/health"
+            ]
+          }));
+          return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(data, null, 2));
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: err.message || "Internal metric collection error" }));
+    }
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(chalk.red(`
+  \u2716 Error: Port ${port} is already in use. Use --port <port> to select an alternate port.
+`));
+    } else {
+      console.error(chalk.red(`
+  \u2716 Server error: ${err.message}
+`));
+    }
+    process.exit(1);
+  });
+  await new Promise((resolve) => server.listen(port, "0.0.0.0", resolve));
+  console.log(chalk.bold("\n  \u{1F525} pyre serve \u2014 REST API Server\n"));
+  console.log(`  ${chalk.green("\u2714")} API base URL: ${chalk.cyan(`http://0.0.0.0:${port}/api/all`)}`);
+  console.log(`  ${chalk.green("\u2714")} Health check: ${chalk.cyan(`http://0.0.0.0:${port}/api/health`)}`);
+  if (apiKey) {
+    console.log(`  ${chalk.yellow("\u{1F512}")} API Key protection: ${chalk.bold("ENABLED")} (Pass via header x-api-key or ?key=)`);
+  } else {
+    console.log(`  ${chalk.dim("\u{1F513}")} API Key protection: ${chalk.dim("DISABLED (Public local network access)")}`);
+  }
+  console.log(`
+  ${chalk.dim("Endpoints: /api/cpu, /api/memory, /api/gpu, /api/battery, /api/thermal, /api/network, /api/disk, /api/processes")}`);
+  console.log(chalk.dim("\n  Press Ctrl+C to stop.\n"));
+  await new Promise(() => {
+  });
+}
+export {
+  runServeCommand
+};

package/dist/service-Q74BBILO.js

@@ -0,0 +1,181 @@
+// src/service.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execSync } from "child_process";
+import chalk from "chalk";
+var SERVICE_LABEL = "com.pyre.web";
+var PLIST_PATH = path.join(os.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+var SYSTEMD_USER_DIR = path.join(os.homedir(), ".config", "systemd", "user");
+var SYSTEMD_UNIT_PATH = path.join(SYSTEMD_USER_DIR, "pyre-web.service");
+var TASK_NAME = "PyreWeb";
+function installService(port = 3e3) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    installLaunchd(port);
+  } else if (platform === "linux") {
+    installSystemd(port);
+  } else if (platform === "win32") {
+    installWindowsTask(port);
+  } else {
+    console.log(chalk.yellow(`\u26A0 Background service installation not supported on ${platform}.`));
+  }
+}
+function uninstallService() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    uninstallLaunchd();
+  } else if (platform === "linux") {
+    uninstallSystemd();
+  } else if (platform === "win32") {
+    uninstallWindowsTask();
+  } else {
+    console.log(chalk.yellow(`\u26A0 Background service uninstallation not supported on ${platform}.`));
+  }
+}
+var installLaunchdAgent = installService;
+var uninstallLaunchdAgent = uninstallService;
+function installLaunchd(port) {
+  const nodePath = process.execPath;
+  const scriptPath = path.resolve(process.argv[1]);
+  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${SERVICE_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${scriptPath}</string>
+        <string>web</string>
+        <string>--port</string>
+        <string>${port}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${path.join(os.homedir(), ".config", "pyre", "web.log")}</string>
+    <key>StandardErrorPath</key>
+    <string>${path.join(os.homedir(), ".config", "pyre", "web.err")}</string>
+</dict>
+</plist>
+`;
+  try {
+    const launchAgentsDir = path.dirname(PLIST_PATH);
+    if (!fs.existsSync(launchAgentsDir)) {
+      fs.mkdirSync(launchAgentsDir, { recursive: true });
+    }
+    fs.writeFileSync(PLIST_PATH, plistContent);
+    try {
+      execSync(`launchctl unload ${PLIST_PATH} 2>/dev/null`);
+    } catch {
+    }
+    execSync(`launchctl load ${PLIST_PATH}`);
+    console.log(chalk.green(`\u2714 Installed and started launchd agent at ${PLIST_PATH}`));
+    console.log(chalk.dim(`  Service label: ${SERVICE_LABEL}`));
+  } catch (err) {
+    console.log(chalk.red(`\u2716 Failed to install launchd agent: ${err.message}`));
+  }
+}
+function uninstallLaunchd() {
+  try {
+    if (fs.existsSync(PLIST_PATH)) {
+      try {
+        execSync(`launchctl unload ${PLIST_PATH} 2>/dev/null`);
+      } catch {
+      }
+      fs.unlinkSync(PLIST_PATH);
+      console.log(chalk.green(`\u2714 Uninstalled launchd agent ${PLIST_PATH}`));
+    } else {
+      console.log(chalk.yellow(`  No launchd agent found at ${PLIST_PATH}`));
+    }
+  } catch (err) {
+    console.log(chalk.red(`\u2716 Failed to uninstall launchd agent: ${err.message}`));
+  }
+}
+function installSystemd(port) {
+  const nodePath = process.execPath;
+  const scriptPath = path.resolve(process.argv[1]);
+  const logDir = path.join(os.homedir(), ".config", "pyre");
+  if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+  if (!fs.existsSync(SYSTEMD_USER_DIR)) fs.mkdirSync(SYSTEMD_USER_DIR, { recursive: true });
+  const unitContent = `[Unit]
+Description=Pyre System Monitor Web Service
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} "${scriptPath}" web --port ${port}
+Restart=always
+RestartSec=5
+StandardOutput=append:${path.join(logDir, "web.log")}
+StandardError=append:${path.join(logDir, "web.err")}
+
+[Install]
+WantedBy=default.target
+`;
+  try {
+    fs.writeFileSync(SYSTEMD_UNIT_PATH, unitContent);
+    try {
+      execSync("systemctl --user daemon-reload");
+      execSync("systemctl --user enable --now pyre-web.service");
+    } catch (cmdErr) {
+      console.log(chalk.yellow(`  Unit file written to ${SYSTEMD_UNIT_PATH}, but could not auto-enable: ${cmdErr.message}`));
+      console.log(chalk.dim("  You can manually enable it using: systemctl --user enable --now pyre-web.service"));
+      return;
+    }
+    console.log(chalk.green(`\u2714 Installed and started systemd user service at ${SYSTEMD_UNIT_PATH}`));
+    console.log(chalk.dim("  Service name: pyre-web.service"));
+  } catch (err) {
+    console.log(chalk.red(`\u2716 Failed to install systemd user service: ${err.message}`));
+  }
+}
+function uninstallSystemd() {
+  try {
+    if (fs.existsSync(SYSTEMD_UNIT_PATH)) {
+      try {
+        execSync("systemctl --user disable --now pyre-web.service 2>/dev/null");
+      } catch {
+      }
+      fs.unlinkSync(SYSTEMD_UNIT_PATH);
+      try {
+        execSync("systemctl --user daemon-reload 2>/dev/null");
+      } catch {
+      }
+      console.log(chalk.green(`\u2714 Uninstalled systemd user service ${SYSTEMD_UNIT_PATH}`));
+    } else {
+      console.log(chalk.yellow(`  No systemd service found at ${SYSTEMD_UNIT_PATH}`));
+    }
+  } catch (err) {
+    console.log(chalk.red(`\u2716 Failed to uninstall systemd service: ${err.message}`));
+  }
+}
+function installWindowsTask(port) {
+  const nodePath = process.execPath;
+  const scriptPath = path.resolve(process.argv[1]);
+  try {
+    const cmd = `schtasks /create /tn "${TASK_NAME}" /tr "\\"${nodePath}\\" \\"${scriptPath}\\" web --port ${port}" /sc onlogon /f`;
+    execSync(cmd, { stdio: "pipe" });
+    console.log(chalk.green(`\u2714 Installed Windows scheduled task '${TASK_NAME}' (runs on logon)`));
+  } catch (err) {
+    console.log(chalk.red(`\u2716 Failed to register Windows scheduled task: ${err.message}`));
+  }
+}
+function uninstallWindowsTask() {
+  try {
+    const cmd = `schtasks /delete /tn "${TASK_NAME}" /f`;
+    execSync(cmd, { stdio: "pipe" });
+    console.log(chalk.green(`\u2714 Uninstalled Windows scheduled task '${TASK_NAME}'`));
+  } catch (err) {
+    console.log(chalk.yellow(`  No scheduled task '${TASK_NAME}' found or deletion failed: ${err.message}`));
+  }
+}
+export {
+  installLaunchdAgent,
+  installService,
+  uninstallLaunchdAgent,
+  uninstallService
+};

package/dist/smartCmd-ODWKSFNG.js

@@ -0,0 +1,166 @@
+// src/smartCmd.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import chalk from "chalk";
+var execFileAsync = promisify(execFile);
+async function runCmd(cmd, args, timeoutMs = 5e3) {
+  try {
+    const { stdout } = await execFileAsync(cmd, args, { timeout: timeoutMs });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+async function getPhysicalDisks() {
+  const scanRaw = await runCmd("smartctl", ["--scan", "--json"]);
+  if (scanRaw) {
+    try {
+      const parsed = JSON.parse(scanRaw);
+      if (Array.isArray(parsed.devices) && parsed.devices.length > 0) {
+        return parsed.devices.map((d) => d.name).filter(Boolean);
+      }
+    } catch {
+    }
+  }
+  if (process.platform === "linux") {
+    const lsblk = await runCmd("lsblk", ["-dpno", "NAME"]);
+    if (lsblk) {
+      const disks = lsblk.split("\n").map((s) => s.trim()).filter((d) => /^\/dev\/(sd[a-z]|nvme\d+n\d+|vd[a-z])/.test(d));
+      if (disks.length > 0) return disks;
+    }
+    return ["/dev/sda"];
+  }
+  if (process.platform === "win32") {
+    return ["/dev/sda", "/dev/csmi0,0"];
+  }
+  const raw = await runCmd("diskutil", ["list", "-plist"]);
+  if (!raw) return ["/dev/disk0"];
+  const matches = raw.match(/\/dev\/disk\d+(?!s)/g) ?? [];
+  return [...new Set(matches)].filter((d) => /^\/dev\/disk\d+$/.test(d));
+}
+async function collectSmartctlDisk(device) {
+  const raw = await runCmd("smartctl", ["-a", "--json", device], 6e3);
+  if (!raw) return null;
+  try {
+    const j = JSON.parse(raw);
+    const model = j.model_name ?? j.device?.name ?? "Unknown";
+    const serial = j.serial_number ?? "";
+    const protocol = j.device?.protocol ?? "";
+    const passed = j.smart_status?.passed;
+    const health = passed === true ? "PASSED" : passed === false ? "FAILED" : "Unknown";
+    let tempC;
+    if (j.temperature?.current !== void 0) tempC = j.temperature.current;
+    const poh = j.power_on_time?.hours;
+    let reallocated;
+    if (Array.isArray(j.ata_smart_attributes?.table)) {
+      const attr = j.ata_smart_attributes.table.find((a) => a.id === 5);
+      if (attr) reallocated = attr.raw?.value ?? 0;
+    }
+    let percentUsed;
+    if (j.nvme_smart_health_information_log?.percentage_used !== void 0) {
+      percentUsed = j.nvme_smart_health_information_log.percentage_used;
+    }
+    let bytesRead;
+    let bytesWritten;
+    if (j.nvme_smart_health_information_log) {
+      const unitsRead = j.nvme_smart_health_information_log.data_units_read;
+      const unitsWritten = j.nvme_smart_health_information_log.data_units_written;
+      if (unitsRead !== void 0) bytesRead = unitsRead * 512e3;
+      if (unitsWritten !== void 0) bytesWritten = unitsWritten * 512e3;
+    }
+    const userCap = j.user_capacity?.bytes;
+    const capacity = userCap !== void 0 ? userCap >= 1e12 ? `${(userCap / 1e12).toFixed(1)} TB` : userCap >= 1e9 ? `${(userCap / 1e9).toFixed(0)} GB` : `${(userCap / 1e6).toFixed(0)} MB` : void 0;
+    return {
+      device,
+      model,
+      serialNumber: serial,
+      health,
+      tempC,
+      powerOnHours: poh,
+      reallocatedSectors: reallocated,
+      percentUsed,
+      bytesRead,
+      bytesWritten,
+      protocol,
+      capacity
+    };
+  } catch {
+    return null;
+  }
+}
+async function collectDiskutilFallback(device) {
+  const raw = await runCmd("diskutil", ["info", device]);
+  if (!raw) return null;
+  const nameMatch = raw.match(/(?:Device \/ Media Name|Volume Name|Media Name):\s*(.+)/i);
+  const sizeMatch = raw.match(/Disk Size:\s*(.+?\([^)]+\))/i);
+  return {
+    device,
+    model: nameMatch?.[1]?.trim() || "Unknown",
+    serialNumber: "",
+    health: "Unknown",
+    capacity: sizeMatch?.[1]?.trim()
+  };
+}
+function formatBytes(bytes) {
+  if (bytes >= 1e15) return `${(bytes / 1e15).toFixed(1)} PB`;
+  if (bytes >= 1e12) return `${(bytes / 1e12).toFixed(1)} TB`;
+  if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)} GB`;
+  if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(0)} MB`;
+  return `${bytes} B`;
+}
+function healthColor(h) {
+  if (h === "PASSED") return chalk.green(h);
+  if (h === "FAILED") return chalk.red.bold(h);
+  return chalk.dim(h);
+}
+async function runSmartCommand() {
+  console.log(chalk.bold("\n  \u{1F525} pyre \u2014 S.M.A.R.T. Disk Health\n"));
+  const smartctlVersion = await runCmd("smartctl", ["--version"], 2e3);
+  const hasSmartctl = smartctlVersion.includes("smartmontools");
+  if (!hasSmartctl) {
+    console.log(chalk.yellow("  \u26A0 smartctl not found. Showing basic disk info."));
+    console.log(chalk.dim("  For full SMART data: ") + chalk.cyan("brew install smartmontools") + "\n");
+  }
+  const devices = await getPhysicalDisks();
+  if (devices.length === 0) {
+    console.log(chalk.yellow("  No physical disks found.\n"));
+    return;
+  }
+  for (const device of devices) {
+    let info = null;
+    if (hasSmartctl) info = await collectSmartctlDisk(device);
+    if (!info) info = await collectDiskutilFallback(device);
+    if (!info) continue;
+    console.log(chalk.bold(`  ${info.device}`));
+    console.log(`    Model:            ${info.model}`);
+    if (info.serialNumber) console.log(`    Serial:           ${chalk.dim(info.serialNumber)}`);
+    if (info.protocol) console.log(`    Protocol:         ${info.protocol}`);
+    if (info.capacity) console.log(`    Capacity:         ${info.capacity}`);
+    console.log(`    Health:           ${healthColor(info.health)}`);
+    if (info.tempC !== void 0) {
+      const tc = info.tempC >= 60 ? chalk.red : info.tempC >= 45 ? chalk.yellow : chalk.green;
+      console.log(`    Temperature:      ${tc(`${info.tempC}\xB0C`)}`);
+    }
+    if (info.powerOnHours !== void 0) {
+      const days = Math.floor(info.powerOnHours / 24);
+      console.log(`    Power-On Hours:   ${info.powerOnHours.toLocaleString()} h (${days} days)`);
+    }
+    if (info.reallocatedSectors !== void 0) {
+      const sc = info.reallocatedSectors > 0 ? chalk.yellow : chalk.green;
+      console.log(`    Reallocated Secs: ${sc(info.reallocatedSectors.toString())}`);
+    }
+    if (info.percentUsed !== void 0) {
+      const wc = info.percentUsed >= 90 ? chalk.red : info.percentUsed >= 50 ? chalk.yellow : chalk.green;
+      console.log(`    Wear Level:       ${wc(`${info.percentUsed}% used`)}`);
+    }
+    if (info.bytesRead !== void 0) console.log(`    Data Read:        ${formatBytes(info.bytesRead)}`);
+    if (info.bytesWritten !== void 0) console.log(`    Data Written:     ${formatBytes(info.bytesWritten)}`);
+    console.log();
+  }
+  if (!hasSmartctl) {
+    console.log(chalk.dim("  Install smartmontools for full SMART attributes.\n"));
+  }
+}
+export {
+  runSmartCommand
+};

package/dist/syncCmd-A2W3QB3S.js

@@ -0,0 +1,126 @@
+import {
+  getConfigFile,
+  getProfilesDir,
+  writeConfig
+} from "./chunk-53O2RGSL.js";
+
+// src/syncCmd.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+import chalk from "chalk";
+function getDefaultSyncDir() {
+  if (process.env.PYRE_SYNC_DIR) return process.env.PYRE_SYNC_DIR;
+  const icloudPath = path.join(os.homedir(), "Library", "Mobile Documents", "com~apple~CloudDocs", "PyreSync");
+  if (fs.existsSync(path.dirname(icloudPath))) {
+    return icloudPath;
+  }
+  return path.join(os.homedir(), ".pyre-sync");
+}
+function computeDirChecksum(dirPath) {
+  const hash = crypto.createHash("sha256");
+  if (!fs.existsSync(dirPath)) return "";
+  const files = fs.readdirSync(dirPath).sort();
+  for (const file of files) {
+    const full = path.join(dirPath, file);
+    if (fs.statSync(full).isFile()) {
+      hash.update(file);
+      hash.update(fs.readFileSync(full));
+    }
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+async function runSyncCommand(subcommand = "status", opts = {}) {
+  const syncDir = opts.syncDir || getDefaultSyncDir();
+  const manifestPath = path.join(syncDir, "sync-manifest.json");
+  const remoteProfilesDir = path.join(syncDir, "profiles");
+  const remoteConfigFile = path.join(syncDir, "config.json");
+  const localProfilesDir = getProfilesDir();
+  const localConfigFile = getConfigFile();
+  console.log(chalk.bold("\n  \u{1F525} pyre sync \u2014 Configuration & Profile Cloud Sync\n"));
+  console.log(`  Sync Target Directory: ${chalk.cyan(syncDir)}`);
+  if (subcommand === "status" || !subcommand) {
+    const hasSyncDir = fs.existsSync(syncDir);
+    const hasManifest = fs.existsSync(manifestPath);
+    console.log(`  Local Profiles:        ${chalk.bold(String(fs.existsSync(localProfilesDir) ? fs.readdirSync(localProfilesDir).filter((f) => f.endsWith(".json")).length : 0))}`);
+    console.log(`  Sync Target Available: ${hasSyncDir ? chalk.green("YES") : chalk.yellow("NO (will be created on push)")}`);
+    if (hasManifest) {
+      try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+        console.log(`  Remote Last Updated:   ${chalk.green(manifest.lastUpdated)} (from ${chalk.bold(manifest.sourceHost)})`);
+        console.log(`  Remote Profiles Count: ${chalk.bold(String(manifest.profilesCount))}`);
+        console.log(`  Remote Checksum:       ${chalk.dim(manifest.checksum)}`);
+      } catch {
+        console.log(chalk.yellow("  Remote manifest corrupted."));
+      }
+    } else {
+      console.log(chalk.dim('  No remote sync bundle detected yet. Run "pyre sync push" to initialize.'));
+    }
+    console.log();
+    return;
+  }
+  if (subcommand === "push") {
+    if (!fs.existsSync(syncDir)) {
+      fs.mkdirSync(syncDir, { recursive: true });
+    }
+    if (!fs.existsSync(remoteProfilesDir)) {
+      fs.mkdirSync(remoteProfilesDir, { recursive: true });
+    }
+    if (fs.existsSync(localConfigFile)) {
+      fs.copyFileSync(localConfigFile, remoteConfigFile);
+    }
+    let profileCount = 0;
+    if (fs.existsSync(localProfilesDir)) {
+      const files = fs.readdirSync(localProfilesDir).filter((f) => f.endsWith(".json"));
+      profileCount = files.length;
+      for (const f of files) {
+        fs.copyFileSync(path.join(localProfilesDir, f), path.join(remoteProfilesDir, f));
+      }
+    }
+    const checksum = computeDirChecksum(remoteProfilesDir);
+    const manifest = {
+      version: 1,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceHost: os.hostname(),
+      checksum,
+      profilesCount: profileCount
+    };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    console.log(chalk.green(`  \u2714 Successfully pushed config and ${profileCount} profile(s) to sync target.`));
+    console.log(`  Checksum: ${chalk.dim(checksum)}  |  Timestamp: ${chalk.dim(manifest.lastUpdated)}
+`);
+    return;
+  }
+  if (subcommand === "pull") {
+    if (!fs.existsSync(manifestPath) || !fs.existsSync(remoteConfigFile)) {
+      console.error(chalk.red(`  \u2716 Error: No sync manifest found at ${syncDir}. Run "pyre sync push" first from another machine.
+`));
+      process.exit(1);
+    }
+    if (fs.existsSync(remoteConfigFile)) {
+      const remoteConfig = JSON.parse(fs.readFileSync(remoteConfigFile, "utf-8"));
+      writeConfig(remoteConfig);
+    }
+    let pulledCount = 0;
+    if (fs.existsSync(remoteProfilesDir)) {
+      if (!fs.existsSync(localProfilesDir)) {
+        fs.mkdirSync(localProfilesDir, { recursive: true });
+      }
+      const files = fs.readdirSync(remoteProfilesDir).filter((f) => f.endsWith(".json"));
+      pulledCount = files.length;
+      for (const f of files) {
+        fs.copyFileSync(path.join(remoteProfilesDir, f), path.join(localProfilesDir, f));
+      }
+    }
+    console.log(chalk.green(`  \u2714 Successfully pulled latest configuration and ${pulledCount} profile(s).`));
+    console.log(chalk.dim(`  Applied to ${localConfigFile}
+`));
+    return;
+  }
+  console.log(chalk.yellow(`  Unknown subcommand: "${subcommand}". Available: status, push, pull
+`));
+}
+export {
+  runSyncCommand
+};