pinggy 0.4.8 → 0.5.0

package/dist/chunk-GBYF2H4H.js

@@ -0,0 +1,77 @@
+// src/utils/configDir.ts
+import os from "os";
+import path from "path";
+import fs from "fs";
+function getPinggyConfigDir() {
+  const platform = os.platform();
+  let baseDir;
+  if (platform === "win32") {
+    baseDir = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+  } else {
+    baseDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  }
+  return path.join(baseDir, "pinggy");
+}
+function getTunnelConfigDir() {
+  return path.join(getPinggyConfigDir(), "tunnels");
+}
+function ensureTunnelConfigDir() {
+  const dir = getTunnelConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function getDaemonInfoPath() {
+  return path.join(getPinggyConfigDir(), "daemon.json");
+}
+function getDaemonConfigPath() {
+  return path.join(getPinggyConfigDir(), "daemon-config.json");
+}
+function getPinggyLogDir() {
+  const platform = os.platform();
+  if (platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    return path.join(localAppData, "Pinggy-CLI", "Logs");
+  }
+  if (platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Logs", "Pinggy-CLI");
+  }
+  const stateHome = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
+  return path.join(stateHome, "pinggy-cli", "logs");
+}
+function ensurePinggyLogDir() {
+  const dir = getPinggyLogDir();
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function getTunnelLogDir() {
+  return path.join(getPinggyLogDir(), "tunnels");
+}
+function getTunnelLogPath(tunnelId, origin, name) {
+  const dir = getTunnelLogDir();
+  if (name) {
+    const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return path.join(dir, `${origin}__${sanitized}.log`);
+  }
+  return path.join(dir, `${origin}__${tunnelId}.log`);
+}
+function getDaemonLogPath() {
+  return path.join(getPinggyLogDir(), "daemon.log");
+}
+function ensurePinggyConfigDir() {
+  const dir = getPinggyConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export {
+  getPinggyConfigDir,
+  getTunnelConfigDir,
+  ensureTunnelConfigDir,
+  getDaemonInfoPath,
+  getDaemonConfigPath,
+  ensurePinggyLogDir,
+  getTunnelLogDir,
+  getTunnelLogPath,
+  getDaemonLogPath,
+  ensurePinggyConfigDir
+};

package/dist/chunk-HUP6YWH6.js

@@ -0,0 +1,269 @@
+import {
+  logger
+} from "./chunk-7G6SJEEA.js";
+import {
+  ensureTunnelConfigDir,
+  getTunnelConfigDir
+} from "./chunk-GBYF2H4H.js";
+
+// src/cli/configStore.ts
+import fs from "fs";
+import path from "path";
+import pico from "picocolors";
+function buildFilename(name, configId) {
+  return `${name}_${configId}.json`;
+}
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+var Subcommand = {
+  Config: "config",
+  Start: "start",
+  Stop: "stop",
+  Ps: "ps",
+  Attach: "attach",
+  Daemon: "daemon",
+  DaemonAlias: "d",
+  Logs: "logs",
+  Log: "log",
+  Restart: "restart"
+};
+var ConfigVerb = {
+  List: "list",
+  Ls: "ls",
+  Show: "show",
+  Save: "save",
+  Update: "update",
+  Delete: "delete",
+  Auto: "auto",
+  Noauto: "noauto"
+};
+var SUBCOMMANDS = Object.values(Subcommand);
+var CONFIG_VERBS = Object.values(ConfigVerb);
+var RESERVED_NAMES = /* @__PURE__ */ new Set([...SUBCOMMANDS, ...CONFIG_VERBS]);
+function validateName(name) {
+  if (!name || name.trim().length === 0) {
+    return new Error("Tunnel name cannot be empty.");
+  }
+  if (name.length > 128) {
+    return new Error("Tunnel name cannot exceed 128 characters.");
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    return new Error("Tunnel name can only contain alphanumeric characters, hyphens, and underscores.");
+  }
+  if (RESERVED_NAMES.has(name.toLowerCase())) {
+    return new Error(`"${name}" is a reserved subcommand name. Use a different name.`);
+  }
+  return null;
+}
+function readConfigFile(filePath) {
+  try {
+    const data = fs.readFileSync(filePath, { encoding: "utf-8" });
+    return JSON.parse(data);
+  } catch (err) {
+    logger.warn(`Failed to read config file ${filePath}:`, err);
+    return null;
+  }
+}
+function writeConfigFile(filePath, config) {
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2), { encoding: "utf-8" });
+}
+function listSavedConfigs() {
+  const dir = getTunnelConfigDir();
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const configs = [];
+  for (const file of files) {
+    const config = readConfigFile(path.join(dir, file));
+    if (config && config.name && config.configId) {
+      configs.push(config);
+    }
+  }
+  return configs;
+}
+function findConfigFile(nameOrId) {
+  const dir = getTunnelConfigDir();
+  if (!fs.existsSync(dir)) return null;
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const sanitized = sanitizeName(nameOrId);
+  const nameMatch = files.find((f) => f.startsWith(sanitized + "_"));
+  if (nameMatch) {
+    const filePath = path.join(dir, nameMatch);
+    const config = readConfigFile(filePath);
+    if (config && config.name === nameOrId) return { filePath, config };
+  }
+  const idCandidates = files.filter((f) => {
+    const withoutExt = f.replace(/\.json$/, "");
+    const lastUnderscore = withoutExt.indexOf("_");
+    if (lastUnderscore === -1) return false;
+    const idPart = withoutExt.slice(lastUnderscore + 1);
+    return idPart.startsWith(nameOrId);
+  });
+  if (idCandidates.length === 1) {
+    const filePath = path.join(dir, idCandidates[0]);
+    const config = readConfigFile(filePath);
+    if (config) return { filePath, config };
+  }
+  return null;
+}
+function findConfigByName(name) {
+  const resolved = findConfigFile(name);
+  return resolved?.config.name === name ? resolved.config : null;
+}
+function findConfig(nameOrId) {
+  return findConfigFile(nameOrId)?.config ?? null;
+}
+function saveConfig(name, configId, tunnelConfig, autoStart = false) {
+  const nameErr = validateName(name);
+  if (nameErr) {
+    throw nameErr;
+  }
+  const existing = findConfigByName(name);
+  if (existing) {
+    throw new Error(
+      `A tunnel config with the name "${name}" already exists (configId: ${existing.configId}). Please use a different name.`
+    );
+  }
+  const dir = ensureTunnelConfigDir();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const saved = {
+    name,
+    configId,
+    autoStart,
+    createdAt: now,
+    updatedAt: now,
+    tunnelConfig
+  };
+  const filename = buildFilename(sanitizeName(name), configId);
+  const filePath = path.join(dir, filename);
+  fs.writeFileSync(filePath, JSON.stringify(saved, null, 2), { encoding: "utf-8" });
+  logger.info(`Config "${name}" saved to ${filePath}`);
+  return saved;
+}
+function loadConfigByName(name) {
+  return findConfigByName(name);
+}
+function deleteConfig(nameOrId) {
+  const resolved = findConfigFile(nameOrId);
+  if (!resolved) return null;
+  fs.unlinkSync(resolved.filePath);
+  logger.info(`Config "${resolved.config.name}" deleted.`);
+  return resolved.config.name;
+}
+function updateConfigAutoStart(nameOrId, autoStart) {
+  const resolved = findConfigFile(nameOrId);
+  if (!resolved) return null;
+  resolved.config.autoStart = autoStart;
+  resolved.config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeConfigFile(resolved.filePath, resolved.config);
+  logger.info(`Config "${resolved.config.name}" auto-start set to ${autoStart}`);
+  return resolved.config;
+}
+function updateTunnelConfig(nameOrId, tunnelConfig) {
+  const resolved = findConfigFile(nameOrId);
+  if (!resolved) return null;
+  resolved.config.tunnelConfig = tunnelConfig;
+  resolved.config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeConfigFile(resolved.filePath, resolved.config);
+  logger.info(`Config "${resolved.config.name}" tunnel configuration updated`);
+  return resolved.config;
+}
+function getAutoStartConfigs() {
+  return listSavedConfigs().filter((c) => c.autoStart);
+}
+function printConfigList() {
+  const configs = listSavedConfigs();
+  if (configs.length === 0) {
+    console.log(pico.yellow("No saved tunnel configs found."));
+    console.log(pico.gray(`Config directory: ${getTunnelConfigDir()}`));
+    return;
+  }
+  const nameW = 20;
+  const idW = 12;
+  const typeW = 8;
+  const fwdW = 25;
+  const serverW = 22;
+  const autoW = 10;
+  const header = pico.bold("Name".padEnd(nameW)) + pico.bold("Config ID".padEnd(idW)) + pico.bold("Type".padEnd(typeW)) + pico.bold("Forwarding".padEnd(fwdW)) + pico.bold("Server".padEnd(serverW)) + pico.bold("Auto-start".padEnd(autoW));
+  console.log("\n" + header);
+  console.log(pico.gray("\u2500".repeat(nameW + idW + typeW + fwdW + serverW + autoW)));
+  for (const c of configs) {
+    const tc = c.tunnelConfig;
+    const forwarding = Array.isArray(tc.forwarding) ? tc.forwarding[0]?.address : String(tc.forwarding || "");
+    const type = (Array.isArray(tc.forwarding) ? tc.forwarding[0]?.type : void 0) || "http";
+    const server = tc.serverAddress || "a.pinggy.io";
+    const line = pico.cyanBright(c.name.padEnd(nameW)) + pico.gray(c.configId.slice(0, 8).padEnd(idW)) + type.padEnd(typeW) + forwarding.slice(0, fwdW - 2).padEnd(fwdW) + server.slice(0, serverW - 2).padEnd(serverW) + (c.autoStart ? pico.green("yes") : pico.gray("no")).padEnd(autoW);
+    console.log(line);
+  }
+  console.log();
+}
+function printConfigDetail(config) {
+  console.log(pico.bold(`
+Tunnel Config: ${pico.cyanBright(config.name)}`));
+  console.log(pico.gray("\u2500".repeat(40)));
+  console.log(`  Config ID:   ${config.configId}`);
+  console.log(`  Auto-start:  ${config.autoStart ? pico.green("yes") : pico.gray("no")}`);
+  console.log(`  Created:     ${config.createdAt}`);
+  console.log(`  Updated:     ${config.updatedAt}`);
+  console.log(pico.gray("\u2500".repeat(40)));
+  console.log(`  Server:      ${config.tunnelConfig.serverAddress || "a.pinggy.io"}`);
+  console.log(`  Token:       ${config.tunnelConfig.token ? "***" + config.tunnelConfig.token.slice(-4) : "(none)"}`);
+  const fwd = config.tunnelConfig.forwarding;
+  if (Array.isArray(fwd)) {
+    const defaultFwds = [];
+    const customFwds = [];
+    for (const f of fwd) {
+      if (typeof f === "string") {
+        defaultFwds.push(f);
+      } else if (f.listenAddress) {
+        customFwds.push(f);
+      } else {
+        defaultFwds.push(f);
+      }
+    }
+    for (const f of defaultFwds) {
+      const addr = typeof f === "string" ? f : `${f.address} (${f.type || "http"})`;
+      console.log(`  Forwarding:  ${addr}`);
+      if (config.tunnelConfig.webDebugger) {
+        console.log(`  Debugger:    ${config.tunnelConfig.webDebugger}`);
+      }
+    }
+    if (customFwds.length > 0) {
+      console.log(pico.gray("\u2500".repeat(40)));
+      console.log(pico.bold("  Domain Mappings:"));
+      for (const f of customFwds) {
+        if (typeof f === "string") continue;
+        const domain = f.listenAddress;
+        const target = f.address;
+        const type = f.type || "http";
+        console.log(`    ${pico.cyanBright(domain)} \u2192 ${target} (${type})`);
+      }
+    }
+  } else if (fwd) {
+    console.log(`  Forwarding:  ${fwd}`);
+  }
+  console.log();
+}
+
+export {
+  sanitizeName,
+  Subcommand,
+  ConfigVerb,
+  SUBCOMMANDS,
+  CONFIG_VERBS,
+  RESERVED_NAMES,
+  validateName,
+  listSavedConfigs,
+  findConfigByName,
+  findConfig,
+  saveConfig,
+  loadConfigByName,
+  deleteConfig,
+  updateConfigAutoStart,
+  updateTunnelConfig,
+  getAutoStartConfigs,
+  printConfigList,
+  printConfigDetail
+};

package/dist/chunk-MT44NAXX.js

@@ -0,0 +1,36 @@
+import {
+  ensurePinggyConfigDir,
+  getDaemonConfigPath
+} from "./chunk-GBYF2H4H.js";
+
+// src/daemon/lifecycle/daemonConfig.ts
+import fs from "fs";
+function readDaemonConfig() {
+  try {
+    const p = getDaemonConfigPath();
+    if (!fs.existsSync(p)) return null;
+    const raw = fs.readFileSync(p, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeDaemonConfig(partial) {
+  try {
+    ensurePinggyConfigDir();
+    const current = readDaemonConfig() ?? {};
+    const next = { ...current, ...partial };
+    const p = getDaemonConfigPath();
+    const tmp = p + ".tmp";
+    fs.writeFileSync(tmp, JSON.stringify(next, null, 2), "utf-8");
+    fs.renameSync(tmp, p);
+  } catch {
+  }
+}
+
+export {
+  readDaemonConfig,
+  writeDaemonConfig
+};

package/dist/chunk-UB26QJ4T.js

@@ -0,0 +1,10 @@
+// src/workers/fileServerMessages.ts
+var FileServerMessage = {
+  Started: "started",
+  Warning: "warning",
+  Error: "error"
+};
+
+export {
+  FileServerMessage
+};