pinggy 0.6.0 → 0.6.3

package/README.md

@@ -14,6 +14,7 @@ Create secure, shareable tunnels to your localhost and manage them from the comm
 - Per-tunnel and per-daemon log files with `pinggy logs` (tail, follow, rotation-safe)
 - System-service install for auto-start at boot (systemd, launchd, Task Scheduler)
 - Remote management via secure WebSocket connection (works with Pinggy Dashboard)
+- Pinggy Devices: enrol the machine with `pinggy device` and keep it visible in the dashboard
 - Save and load configuration files
 - Config store for saving, listing, updating, and starting named tunnel configs
 - Auto-start support for launching saved tunnels automatically
@@ -226,6 +227,92 @@ You can control tunnels remotely using a secure WebSocket connection.
 ```
 
 
+## Pinggy Devices
+
+Enrol this machine as a Pinggy device. The agent opens 1 WebSocket to the dashboard, registers the machine, and holds the connection open so the dashboard can show the device as online.
+
+Devices and remote management are separate features. Remote management drives tunnels from the dashboard with an API key. A device is the machine itself, enrolled with its own token. The device agent owns no tunnels, and stopping it leaves every running tunnel alone.
+
+The agent runs in the foreground CLI process, not the daemon. It needs no daemon and starts none.
+
+### Connect a device
+```bash
+pinggy device connect --token <TOKEN>
+```
+
+Add the device in the dashboard first, then pass the token it gives you. The command stays in the foreground and reconnects on its own until you interrupt it.
+
+The token is written to disk on the first successful connect, so later runs need no flag:
+```bash
+pinggy device connect
+```
+
+Point the agent at a different dashboard with `--manage`:
+```bash
+pinggy device connect --token <TOKEN> --manage dashboard.pinggy.io
+```
+
+`--manage` takes a host. The scheme becomes `wss://` unless you type `ws://` or `wss://` yourself. The agent connects to `/backend/api/v1/device-agent/ws/connect` on that host and sends the token in the `X-Pinggy-Device-Token` header.
+
+`--token` here is the device token, not the tunnel token of the same flag name in [Options](#options). The 2 credentials are unrelated and the device agent never reads the tunnel one.
+
+### Show what this machine remembers
+```bash
+pinggy device status
+```
+
+Prints the device id, server, masked token, and enrolment time from the local file. It contacts nothing.
+
+### Forget the local credential
+```bash
+pinggy device remove
+```
+
+Deletes the local credential only. The device still exists in the dashboard. Delete it there to revoke it, because a machine that has lost its credential cannot authenticate the delete.
+
+### Reconnect and stop conditions
+
+The agent retries a dropped connection every 5 seconds. Some failures are terminal and it exits instead:
+
+| Event | Agent |
+|-------|-------|
+| HTTP 401 on the upgrade | Stops. The token is wrong or revoked. Re-enrol from the dashboard |
+| Dashboard refuses the handshake | Stops, and prints the reason |
+| Device is connected from another machine | Retries. The credential is fine, the other socket has to drop first |
+| Dashboard says it is shutting down | Retries |
+| Any other close, or a network error | Retries |
+
+Ctrl+C stops the retry loop. The agent exits once the current socket closes; a second Ctrl+C exits at once.
+
+### What the agent does today
+
+It enrols, learns its device id and heartbeat interval from the dashboard, and sends a heartbeat on that interval. CPU and memory reporting, and the browser terminal, are not built yet.
+
+### Combining `device` with other commands
+
+1 invocation runs 1 command. The first word decides which, and everything after it belongs to that command. `pinggy device connect start my-tunnel` runs the agent and ignores `start my-tunnel`; it does not start a tunnel.
+
+| Command | What happens |
+|---------|--------------|
+| `pinggy device connect -l 3000 -b --all --remote-management <KEY>` | Runs the agent. Those flags parse and are ignored. No tunnel, no remote management, no daemon. Only `--token` and `--manage` are read |
+| `pinggy device start`, `pinggy device daemon stop` | Error, exit 1. The verb after `device` is `login`, `connect`, `stop`, `status`, or `remove` |
+| `pinggy start device`, `pinggy stop device` | `device` reads as a tunnel name. No new config can be called `device`, so nothing matches |
+| `pinggy config save device ...` | Rejected. `device` is a reserved name |
+| `pinggy -l 3000 device` | An ordinary tunnel. `device` is not a valid domain, so it warns `Unknown extended option` and is ignored |
+| `pinggy device connect --typo` | Unknown options are rejected before anything runs |
+| `pinggy devices connect`, or `devices` with anything | Error, exit 1: `"pinggy devices" is now "pinggy device". Run: pinggy device connect`. Nothing runs |
+
+`pinggy device` and `pinggy device --help` print the command list. After a verb, `--help` is ignored, so `pinggy device connect --help` tries to connect.
+
+### Devices, tunnels, and the daemon do not interfere
+
+- The agent is its own process. `pinggy daemon stop` leaves it running, and Ctrl+C on the agent leaves every tunnel running.
+- `pinggy device connect` never starts the daemon. Run tunnels and the agent side by side in 2 terminals.
+- 1 enrolment per machine. The newest successful connect overwrites `device.json`, and a `--token` on the command line beats the stored one.
+- Running the agent twice on 1 machine does not work. The dashboard refuses the second connection because the device is already connected, and that copy keeps retrying until the first one drops.
+- `pinggy device remove` deletes the credential file but does not stop a running agent, which rewrites the file the next time it connects. Stop the agent first.
+
+
 ## Usage
 Basic syntax:
   pinggy [options] [user@domain]
@@ -403,6 +490,8 @@ Config dir varies by OS:
 - Linux/macOS: `~/.config/pinggy/`
 - Windows: `%APPDATA%\pinggy\`
 
+It holds `daemon.json` (discovery), `daemon-config.json` (persisted settings), `daemon-state.json` (crash recovery), `tunnels/` (saved configs), and `device.json` (the Pinggy Devices credential, written `0600`).
+
 Log dir varies by OS:
 - Linux: `~/.local/state/pinggy-cli/logs/` (honors `$XDG_STATE_HOME`)
 - macOS: `~/Library/Logs/Pinggy-CLI/`
@@ -421,6 +510,7 @@ Optionally combine with other flags (auth, IP whitelist) as needed.
 - **Foreground tunnel**: Ctrl+C closes the TUI. The daemon arms a 5-second grace timer and stops the tunnel if no other CLI re-attaches.
 - **Detached tunnel** (`-b`): the CLI already exited. Stop it with `pinggy stop <name|id>`.
 - **Everything at once**: `pinggy daemon stop` stops every tunnel and shuts the daemon down cleanly. `daemon-state.json` is cleared, so nothing replays on next start.
+- **Device agent** (`pinggy device connect`): Ctrl+C ends the agent. It runs outside the daemon, so no tunnel is affected.
 
 
 ## Versioning

package/dist/TunnelManager-NGSUBZYI.js

@@ -0,0 +1,13 @@
+import {
+  TunnelAlreadyRunningError,
+  TunnelManager,
+  TunnelRebuildInProgressError
+} from "./chunk-QNUVQ6KD.js";
+import "./chunk-UB26QJ4T.js";
+import "./chunk-MV56U3E6.js";
+import "./chunk-AFMTIELL.js";
+export {
+  TunnelAlreadyRunningError,
+  TunnelManager,
+  TunnelRebuildInProgressError
+};

package/dist/{TunnelTui-OZ6AVGTY.js → TunnelTui-UCG2YSLX.js}

@@ -1,30 +1,18 @@
+import {
+  createQrCodes
+} from "./chunk-XZ64ZAGO.js";
 import {
   TunnelManager
-} from "./chunk-J2U6P376.js";
+} from "./chunk-QNUVQ6KD.js";
 import "./chunk-UB26QJ4T.js";
 import {
   logger
-} from "./chunk-76SOSXXR.js";
-import "./chunk-GBYF2H4H.js";
+} from "./chunk-MV56U3E6.js";
+import "./chunk-AFMTIELL.js";
 
 // src/tui/blessed/TunnelTui.ts
 import blessed3 from "blessed";
 
-// src/tui/blessed/qrCodeGenerator.ts
-import QRCode from "qrcode";
-async function createQrCodes(urls) {
-  const codes = [];
-  for (const url of urls) {
-    const raw = await QRCode.toString(url, {
-      type: "utf8",
-      margin: 2,
-      errorCorrectionLevel: "L"
-    });
-    codes.push(raw);
-  }
-  return codes;
-}
-
 // src/tui/blessed/webDebuggerConnection.ts
 import WebSocket from "ws";
 

package/dist/{chunk-I4HXBP5G.js → chunk-7EQKHVQX.js}

@@ -20,7 +20,10 @@ var Route = {
   SetLogLevel: "POST /loglevel",
   GetTunnelLogging: "GET /config/tunnel-logging",
   SetTunnelLogging: "POST /config/tunnel-logging",
-  GetLogPaths: "GET /logs/paths"
+  GetLogPaths: "GET /logs/paths",
+  GetDeviceAgent: "GET /device",
+  StartDeviceAgent: "POST /device/start",
+  StopDeviceAgent: "POST /device/stop"
 };
 var DaemonHost = {
   CLI: "cli",
@@ -30,6 +33,12 @@ var ShutdownStatus = {
   ShuttingDown: "shutting_down",
   RefusedInApp: "refused_in_app"
 };
+var DeviceAgentState = {
+  Stopped: "stopped",
+  Connecting: "connecting",
+  Connected: "connected",
+  Reconnecting: "reconnecting"
+};
 var SessionMode = {
   Foreground: "foreground",
   Detached: "detached"
@@ -37,6 +46,14 @@ var SessionMode = {
 
 // src/daemon/ipc/ipcClient.ts
 var REQUEST_TIMEOUT_MS = 1e4;
+var IPCHttpError = class extends Error {
+  constructor(statusCode, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "IPCHttpError";
+  }
+};
+var HTTP_NOT_FOUND = 404;
 var IPCClient = class {
   constructor(port, origin = "cli") {
     this.port = port;
@@ -103,6 +120,15 @@ var IPCClient = class {
   async resolveLogPath(q) {
     return this.request("GET", `/logs/resolve?q=${encodeURIComponent(q)}`);
   }
+  async getDeviceAgentStatus(timeoutMs) {
+    return this.call(Route.GetDeviceAgent, void 0, timeoutMs);
+  }
+  async startDeviceAgent() {
+    return this.call(Route.StartDeviceAgent, {});
+  }
+  async stopDeviceAgent() {
+    return this.call(Route.StopDeviceAgent, {});
+  }
   /**
    * Get the WebSocket URL for event streaming.
    */
@@ -144,7 +170,10 @@ var IPCClient = class {
             const text = Buffer.concat(chunks).toString("utf-8");
             const statusCode = res.statusCode ?? 0;
             if (statusCode < 200 || statusCode >= 300) {
-              reject(new Error(`Daemon returned HTTP ${statusCode}: ${text.slice(0, 200)}`));
+              reject(new IPCHttpError(
+                statusCode,
+                `Daemon returned HTTP ${statusCode}: ${text.slice(0, 200)}`
+              ));
               return;
             }
             try {
@@ -171,6 +200,9 @@ export {
   Route,
   DaemonHost,
   ShutdownStatus,
+  DeviceAgentState,
   SessionMode,
+  IPCHttpError,
+  HTTP_NOT_FOUND,
   IPCClient
 };

package/dist/{chunk-GBYF2H4H.js → chunk-AFMTIELL.js}

@@ -57,6 +57,9 @@ function getTunnelLogPath(tunnelId, origin, name) {
 function getDaemonLogPath() {
   return path.join(getPinggyLogDir(), "daemon.log");
 }
+function getDeviceConfigPath() {
+  return path.join(getPinggyConfigDir(), "device.json");
+}
 function ensurePinggyConfigDir() {
   const dir = getPinggyConfigDir();
   fs.mkdirSync(dir, { recursive: true });
@@ -73,5 +76,6 @@ export {
   getTunnelLogDir,
   getTunnelLogPath,
   getDaemonLogPath,
+  getDeviceConfigPath,
   ensurePinggyConfigDir
 };

package/dist/{chunk-2HGC37SK.js → chunk-GESMZQHI.js}

@@ -4,130 +4,32 @@ import {
   IPC_VERSION,
   SessionMode,
   ShutdownStatus
-} from "./chunk-I4HXBP5G.js";
+} from "./chunk-7EQKHVQX.js";
 import {
+  ErrorCode,
+  NewErrorResponseObject,
+  NewResponseObject,
+  RemoteManagementStatus,
   TunnelAlreadyRunningError,
   TunnelManager,
+  TunnelRebuildInProgressError,
   errorMessage,
   getLocalAddress,
   getVersion,
+  isErrorResponse,
   isValidPort,
+  newErrorResponse,
+  newStats,
+  newStatus,
   printer_default
-} from "./chunk-J2U6P376.js";
+} from "./chunk-QNUVQ6KD.js";
 import {
   logger
-} from "./chunk-76SOSXXR.js";
+} from "./chunk-MV56U3E6.js";
 import {
   getDaemonInfoPath,
   getDaemonLogPath
-} from "./chunk-GBYF2H4H.js";
-
-// src/types.ts
-var TunnelStateType = /* @__PURE__ */ ((TunnelStateType2) => {
-  TunnelStateType2["New"] = "idle";
-  TunnelStateType2["Starting"] = "starting";
-  TunnelStateType2["Running"] = "running";
-  TunnelStateType2["Live"] = "live";
-  TunnelStateType2["Closed"] = "closed";
-  TunnelStateType2["Exited"] = "exited";
-  return TunnelStateType2;
-})(TunnelStateType || {});
-var TunnelErrorCodeType = /* @__PURE__ */ ((TunnelErrorCodeType2) => {
-  TunnelErrorCodeType2["NonResponsive"] = "non_responsive";
-  TunnelErrorCodeType2["FailedToConnect"] = "failed_to_connect";
-  TunnelErrorCodeType2["ErrorInAdditionalForwarding"] = "additional_forwarding_error";
-  TunnelErrorCodeType2["WebdebuggerError"] = "webdebugger_error";
-  TunnelErrorCodeType2["NoError"] = "";
-  return TunnelErrorCodeType2;
-})(TunnelErrorCodeType || {});
-var TunnelWarningCode = /* @__PURE__ */ ((TunnelWarningCode2) => {
-  TunnelWarningCode2["InvalidTunnelServePath"] = "INVALID_TUNNEL_SERVE_PATH";
-  TunnelWarningCode2["UnknownWarning"] = "UNKNOWN_WARNING";
-  return TunnelWarningCode2;
-})(TunnelWarningCode || {});
-var ErrorCode = {
-  InvalidRequestMethodError: "INVALID_REQUEST_METHOD",
-  InvalidRequestBodyError: "COULD_NOT_READ_BODY",
-  InternalServerError: "INTERNAL_SERVER_ERROR",
-  InvalidBodyFormatError: "INVALID_DATA_FORMAT",
-  ErrorStartingTunnel: "ERROR_STARTING_TUNNEL",
-  TunnelNotFound: "TUNNEL_WITH_ID_OR_CONFIG_ID_NOT_FOUND",
-  TunnelAlreadyRunningError: "TUNNEL_WITH_ID_OR_CONFIG_ID_ALREADY_RUNNING",
-  WebsocketUpgradeFailError: "WEBSOCKET_UPGRADE_FAILED",
-  RemoteManagementAlreadyRunning: "REMOTE_MANAGEMENT_ALREADY_RUNNING",
-  RemoteManagementNotRunning: "REMOTE_MANAGEMENT_NOT_RUNNING",
-  RemoteManagementDeserializationFailed: "REMOTE_MANAGEMENT_DESERIALIZATION_FAILED"
-};
-function isErrorResponse(obj) {
-  return typeof obj === "object" && obj !== null && "code" in obj && "message" in obj && typeof obj.message === "string" && Object.values(ErrorCode).includes(obj.code);
-}
-function newErrorResponse(codeOrError, message) {
-  if (typeof codeOrError === "object") {
-    return codeOrError;
-  }
-  return {
-    code: codeOrError,
-    message
-  };
-}
-function NewResponseObject(data) {
-  const encoder = new TextEncoder();
-  const bytes = encoder.encode(JSON.stringify(data));
-  return {
-    response: bytes,
-    requestid: "",
-    command: "",
-    error: false,
-    errorresponse: {}
-  };
-}
-function NewErrorResponseObject(errorResponse) {
-  return {
-    response: new Uint8Array(),
-    requestid: "",
-    command: "",
-    error: true,
-    errorresponse: errorResponse
-  };
-}
-function newStatus(tunnelState, errorCode, errorMsg) {
-  let assignedState = tunnelState;
-  if (tunnelState === "live" /* Live */) {
-    assignedState = "running" /* Running */;
-  } else if (tunnelState === "idle" /* New */) {
-    assignedState = "idle" /* New */;
-  } else if (tunnelState === "closed" /* Closed */) {
-    assignedState = "exited" /* Exited */;
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    state: assignedState,
-    errorcode: errorCode,
-    errormsg: errorMsg,
-    createdtimestamp: now,
-    starttimestamp: now,
-    endtimestamp: now,
-    warnings: []
-  };
-}
-function newStats() {
-  return {
-    numLiveConnections: 0,
-    numTotalConnections: 0,
-    numTotalReqBytes: 0,
-    numTotalResBytes: 0,
-    numTotalTxBytes: 0,
-    elapsedTime: 0
-  };
-}
-var RemoteManagementStatus = {
-  Connecting: "CONNECTING",
-  Disconnecting: "DISCONNECTING",
-  Reconnecting: "RECONNECTING",
-  Running: "RUNNING",
-  NotRunning: "NOT_RUNNING",
-  Error: "ERROR"
-};
+} from "./chunk-AFMTIELL.js";
 
 // src/remote_management/remote_schema.ts
 import { HaProxyVersion, TunnelType } from "@pinggy/pinggy";
@@ -428,6 +330,9 @@ var TunnelOperations = class {
       }
       if (managed?.lastError) {
         status.lastError = managed.lastError;
+        if (managed.lastError.isFatal) {
+          status.errormsg = managed.lastError.message;
+        }
       }
     } catch (e) {
     }
@@ -492,6 +397,14 @@ var TunnelOperations = class {
       message: err instanceof Error ? err.message : fallback
     });
   }
+  /**
+   * A restart or update of a tunnel another one is still rebuilding. A no-wait call checks this before
+   * it answers, because a throw from the call it does not await is only logged.
+   */
+  rebuildInProgress(tunnelid) {
+    const err = new TunnelRebuildInProgressError(tunnelid);
+    return this.error(ErrorCode.TunnelAlreadyRunningError, err, err.message);
+  }
   // --- Operations ---
   async handleStart(config, noWait = false, origin = "cli") {
     try {
@@ -554,6 +467,7 @@ var TunnelOperations = class {
       if (noWait) {
         const existing = this.tunnelManager.getManagedTunnel(config.configid);
         if (!existing.tunnelConfig) throw new Error("Invalid tunnel state before configuration update");
+        if (existing.rebuild) return this.rebuildInProgress(existing.tunnelid);
         if (!existing.isStopped) {
           this.tunnelManager.updateConfig(updateOpts).catch((err) => {
             logger.error("No-wait updateConfig failed", { configid: config.configid, err: String(err) });
@@ -574,6 +488,7 @@ var TunnelOperations = class {
       if (noWait) {
         const existing = this.tunnelManager.getManagedTunnel(config.configId);
         if (!existing.tunnelConfig) throw new Error("Invalid tunnel state before configuration update");
+        if (existing.rebuild) return this.rebuildInProgress(existing.tunnelid);
         if (!existing.isStopped) {
           this.tunnelManager.updateConfig(config).catch((err) => {
             logger.error("No-wait updateConfigV2 failed", { configId: config.configId, err: String(err) });
@@ -672,6 +587,7 @@ var TunnelOperations = class {
       if (noWait) {
         const managed2 = this.tunnelManager.getManagedTunnel("", tunnelid);
         if (!managed2?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
+        if (managed2.rebuild) return this.rebuildInProgress(tunnelid);
         this.tunnelManager.restartTunnel(tunnelid).catch((err) => {
           logger.error("No-wait restartTunnel failed", { tunnelid, err: String(err) });
         });
@@ -682,6 +598,9 @@ var TunnelOperations = class {
       if (!managed?.tunnelConfig) throw new Error(`Tunnel config for ID "${tunnelid}" not found`);
       return this.buildTunnelResponse(tunnelid, managed.tunnelConfig, managed.configId, managed.tunnelName, managed.serve);
     } catch (err) {
+      if (err instanceof TunnelRebuildInProgressError) {
+        return this.rebuildInProgress(tunnelid);
+      }
       return this.error(ErrorCode.TunnelNotFound, err, "Failed to restart tunnel");
     }
   }
@@ -1682,7 +1601,7 @@ async function ensureDaemonRunning() {
     return existing;
   }
   if (process.versions.electron) {
-    const { runDaemonChild } = await import("./daemonChild-CV2UTL6T.js");
+    const { runDaemonChild } = await import("./daemonChild-E73NFWKE.js");
     const handle = await runDaemonChild({
       installSignalHandlers: false,
       exitOnFailure: false,
@@ -1705,7 +1624,7 @@ function getInProcessDaemonHandle() {
 async function getActiveTunnelSummaries(origin = "app") {
   const info = getDaemonInfo();
   if (!info) return [];
-  const { IPCClient: IPCClient2 } = await import("./ipcClient-URHJKNEH.js");
+  const { IPCClient: IPCClient2 } = await import("./ipcClient-XGF2KCQO.js");
   const client = new IPCClient2(info.port, origin);
   let tunnels;
   try {
@@ -1752,7 +1671,7 @@ async function stopDaemon() {
   if (!info) return { ok: false, error: "No daemon is running." };
   let daemonErrors = [];
   try {
-    const { IPCClient: IPCClient2 } = await import("./ipcClient-URHJKNEH.js");
+    const { IPCClient: IPCClient2 } = await import("./ipcClient-XGF2KCQO.js");
     const client = new IPCClient2(info.port);
     const result = await client.shutdown();
     logger.debug("Sent shutdown command to daemon", { result });
@@ -2297,6 +2216,20 @@ var TunnelClient = class _TunnelClient {
     this.assertClient();
     await this.ipc.restartTunnel(tunnelId);
   }
+  // Device agent (`pinggy device connect -b`). The daemon reads the token and the server from
+  // device.json, so none of these takes either.
+  async getDeviceAgentStatus() {
+    this.assertClient();
+    return this.ipc.getDeviceAgentStatus();
+  }
+  async startDeviceAgent() {
+    this.assertClient();
+    return this.ipc.startDeviceAgent();
+  }
+  async stopDeviceAgent() {
+    this.assertClient();
+    return this.ipc.stopDeviceAgent();
+  }
   // Streaming — delegate to WsStream, guarded by daemon-lost
   async attach(tunnelId, mode = SessionMode.Foreground) {
     if (this.health.isLost()) return;
@@ -2432,11 +2365,6 @@ var TunnelClient = class _TunnelClient {
 };
 
 export {
-  TunnelStateType,
-  TunnelErrorCodeType,
-  TunnelWarningCode,
-  ErrorCode,
-  isErrorResponse,
   TunnelConfigV1Schema,
   TUNNEL_CONFIG_V1_KEYS,
   TunnelOperations,

package/dist/{chunk-76SOSXXR.js → chunk-MV56U3E6.js}

@@ -14,9 +14,9 @@ function setLogLevel(level) {
   if (_sdkLogFilePath) {
     enableLoggingByLogLevelInSdk(level, _sdkLogFilePath);
   }
-  import("./daemonConfig-G6S46GPJ.js").then(({ writeDaemonConfig }) => writeDaemonConfig({ logLevel: level })).catch(() => {
+  import("./daemonConfig-QVXQ47XH.js").then(({ writeDaemonConfig }) => writeDaemonConfig({ logLevel: level })).catch(() => {
   });
-  import("./TunnelManager-I3NW6UXU.js").then(({ TunnelManager }) => TunnelManager.getInstance().applyLogLevelToActiveTunnels(level)).catch(() => {
+  import("./TunnelManager-NGSUBZYI.js").then(({ TunnelManager }) => TunnelManager.getInstance().applyLogLevelToActiveTunnels(level)).catch(() => {
   });
 }
 var _logger = null;

package/dist/{chunk-MT44NAXX.js → chunk-PD7HXVQ3.js}

@@ -1,7 +1,7 @@
 import {
   ensurePinggyConfigDir,
   getDaemonConfigPath
-} from "./chunk-GBYF2H4H.js";
+} from "./chunk-AFMTIELL.js";
 
 // src/daemon/lifecycle/daemonConfig.ts
 import fs from "fs";