@dxos/phoenix 0.1.58-main.88ec9da → 0.1.58-main.935caa2

package/dist/lib/node/index.cjs

@@ -30,77 +30,110 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // packages/common/phoenix/src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  Phoenix: () => Phoenix,
+  DaemonManager: () => DaemonManager,
   WatchDog: () => WatchDog
 });
 module.exports = __toCommonJS(src_exports);
 
-// packages/common/phoenix/src/phoenix.ts
+// packages/common/phoenix/src/daemon-manager.ts
 var import_node_child_process = require("node:child_process");
 var import_node_fs2 = require("node:fs");
+var import_promises = require("node:fs/promises");
 var import_node_path = require("node:path");
 var import_pkg_up = __toESM(require("pkg-up"));
 var import_invariant = require("@dxos/invariant");
+var import_lock_file2 = require("@dxos/lock-file");
 var import_log = require("@dxos/log");
 
 // packages/common/phoenix/src/utils.ts
 var import_node_fs = require("node:fs");
 var import_async = require("@dxos/async");
+var import_lock_file = require("@dxos/lock-file");
 
 // packages/common/phoenix/src/defs.ts
-var WATCHDOG_START_TIMEOUT = 1e4;
-var WATCHDOG_STOP_TIMEOUT = 1e3;
-var WATCHDOG_CHECK_INTERVAL = 50;
+var LOCK_TIMEOUT = 1e3;
+var LOCK_CHECK_INTERVAL = 50;
 
 // packages/common/phoenix/src/utils.ts
-var waitForPidDeletion = async (pidFile) => (0, import_async.waitForCondition)({
-  condition: () => !(0, import_node_fs.existsSync)(pidFile),
-  timeout: WATCHDOG_STOP_TIMEOUT,
-  interval: WATCHDOG_CHECK_INTERVAL
+var waitForLockAcquisition = async (lockFile) => (0, import_async.waitForCondition)({
+  condition: async () => await import_lock_file.LockFile.isLocked(lockFile),
+  timeout: LOCK_TIMEOUT,
+  interval: LOCK_CHECK_INTERVAL,
+  error: new Error("Lock file is not being acquired.")
 });
-var waitForPidFileBeingFilledWithInfo = async (pidFile) => (0, import_async.waitForCondition)({
-  condition: () => (0, import_node_fs.readFileSync)(pidFile, {
+var waitForLockFileBeingFilledWithInfo = async (lockFile) => (0, import_async.waitForCondition)({
+  condition: () => (0, import_node_fs.readFileSync)(lockFile, {
     encoding: "utf-8"
   }).includes("pid"),
-  timeout: WATCHDOG_START_TIMEOUT,
-  interval: WATCHDOG_CHECK_INTERVAL,
+  timeout: LOCK_TIMEOUT,
+  interval: LOCK_CHECK_INTERVAL,
   error: new Error("Lock file is not being propagated with info.")
 });
+var waitForLockRelease = async (lockFile) => (0, import_async.waitForCondition)({
+  condition: async () => !await import_lock_file.LockFile.isLocked(lockFile),
+  timeout: LOCK_TIMEOUT,
+  interval: LOCK_CHECK_INTERVAL,
+  error: new Error("Lock file is not being released.")
+});
 
-// packages/common/phoenix/src/phoenix.ts
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/phoenix/src/phoenix.ts";
-var Phoenix = class _Phoenix {
-  /**
-  * Starts detached watchdog process which starts and monitors selected command.
-  */
-  static async start(params) {
-    {
-      if ((0, import_node_fs2.existsSync)(params.pidFile)) {
-        await _Phoenix.stop(params.pidFile);
-      }
-      await waitForPidDeletion(params.pidFile);
+// packages/common/phoenix/src/daemon-manager.ts
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/phoenix/src/daemon-manager.ts";
+var LOCK_FILE_NAME = "lockfile";
+var DaemonManager = class {
+  constructor(_rootPath) {
+    this._rootPath = _rootPath;
+    if (!(0, import_node_fs2.existsSync)((0, import_node_path.join)(_rootPath, "profile"))) {
+      (0, import_node_fs2.mkdirSync)((0, import_node_path.join)(_rootPath, "profile"), {
+        recursive: true
+      });
     }
+  }
+  _getConfigFiles(uid) {
+    const defaultConfigDir = (0, import_node_path.join)(this._rootPath, "profile", uid);
+    if (!(0, import_node_fs2.existsSync)(defaultConfigDir)) {
+      (0, import_node_fs2.mkdirSync)(defaultConfigDir, {
+        recursive: true
+      });
+    }
+    return {
+      lockFile: (0, import_node_path.join)(defaultConfigDir, LOCK_FILE_NAME),
+      logFile: (0, import_node_path.join)(defaultConfigDir, "file.log"),
+      errFile: (0, import_node_path.join)(defaultConfigDir, "err.log")
+    };
+  }
+  async start(params) {
+    (0, import_invariant.invariant)(params.command, "command is required", {
+      F: __dxlog_file,
+      L: 46,
+      S: this,
+      A: [
+        "params.command",
+        "'command is required'"
+      ]
+    });
+    const watchDogParams = {
+      ...this._getConfigFiles(params.uid),
+      ...params
+    };
     {
-      [
-        params.logFile,
-        params.errFile,
-        params.pidFile
-      ].forEach((filename) => {
-        if (!(0, import_node_fs2.existsSync)(filename)) {
-          (0, import_node_fs2.mkdirSync)((0, import_node_path.dirname)(filename), {
-            recursive: true
-          });
-          (0, import_node_fs2.writeFileSync)(filename, "", {
-            encoding: "utf-8"
-          });
-        }
+      (0, import_node_fs2.mkdirSync)((0, import_node_path.dirname)(watchDogParams.logFile), {
+        recursive: true
+      });
+      (0, import_node_fs2.mkdirSync)((0, import_node_path.dirname)(watchDogParams.errFile), {
+        recursive: true
       });
     }
+    {
+      if (await import_lock_file2.LockFile.isLocked(watchDogParams.lockFile)) {
+        throw new Error("Lock file is already locked.");
+      }
+      (0, import_node_fs2.unlinkSync)(watchDogParams.lockFile);
+    }
     const watchdogPath = (0, import_node_path.join)((0, import_node_path.dirname)(import_pkg_up.default.sync({
       cwd: __dirname
     })), "bin", "watchdog");
     const watchDog = (0, import_node_child_process.fork)(watchdogPath, [
-      JSON.stringify(params)
+      JSON.stringify(watchDogParams)
     ], {
       detached: true,
       cwd: __dirname
@@ -112,63 +145,87 @@ var Phoenix = class _Phoenix {
           signal
         }, {
           F: __dxlog_file,
-          L: 52,
+          L: 75,
           S: this,
           C: (f, a) => f(...a)
         });
       }
     });
-    await waitForPidFileBeingFilledWithInfo(params.pidFile);
+    await waitForLockAcquisition(watchDogParams.lockFile);
+    await waitForLockFileBeingFilledWithInfo(watchDogParams.lockFile);
     watchDog.disconnect();
     watchDog.unref();
-    return _Phoenix.info(params.pidFile);
+    return this.getInfo(params.uid);
   }
-  /**
-  * Stops detached watchdog process by PID info written down in PID file.
-  */
-  static async stop(pidFile, force = false) {
-    if (!(0, import_node_fs2.existsSync)(pidFile)) {
-      throw new Error("PID file does not exist");
-    }
-    const fileContent = (0, import_node_fs2.readFileSync)(pidFile, {
+  async stop(uid, force) {
+    const lockFile = this._getConfigFiles(uid).lockFile;
+    const processInfo = JSON.parse((0, import_node_fs2.readFileSync)(lockFile, {
       encoding: "utf-8"
-    });
-    if (!fileContent.includes("pid")) {
-      throw new Error("Invalid PID file content");
-    }
-    const { pid } = JSON.parse(fileContent);
-    const signal = force ? "SIGKILL" : "SIGINT";
+    }));
     try {
-      process.kill(pid, signal);
+      if (force) {
+        process.kill(processInfo.pid, "SIGKILL");
+      } else {
+        process.kill(processInfo.pid, "SIGINT");
+      }
     } catch (err) {
-      (0, import_invariant.invariant)(err instanceof Error, "Invalid error type", {
+      (0, import_invariant.invariant)(err instanceof Error, "Invalid error type.", {
         F: __dxlog_file,
-        L: 81,
+        L: 98,
         S: this,
         A: [
           "err instanceof Error",
-          "'Invalid error type'"
+          "'Invalid error type.'"
         ]
       });
-      if (err.message.includes("ESRCH") || err.name.includes("ESRCH")) {
-        (0, import_node_fs2.unlinkSync)(pidFile);
-      } else {
+      if (!err.name.includes("ESRCH") && !err.message.includes("ESRCH")) {
         throw err;
       }
     }
+    await waitForLockRelease(lockFile);
+    return this.getInfo(uid);
   }
-  static info(pidFile) {
-    return JSON.parse((0, import_node_fs2.readFileSync)(pidFile, {
-      encoding: "utf-8"
+  async list() {
+    const uids = (await (0, import_promises.readdir)((0, import_node_path.join)(this._rootPath, "profile"))).filter((uid) => !uid.startsWith("."));
+    return Promise.all(uids.map(async (uid) => {
+      return this.getInfo(uid);
     }));
   }
+  async getInfo(uid) {
+    const files = this._getConfigFiles(uid);
+    let info = {
+      running: await import_lock_file2.LockFile.isLocked(files.lockFile),
+      uid,
+      ...files
+    };
+    if ((0, import_node_fs2.existsSync)(files.lockFile)) {
+      try {
+        info = {
+          ...info,
+          ...JSON.parse((0, import_node_fs2.readFileSync)(files.lockFile, {
+            encoding: "utf-8"
+          }))
+        };
+      } catch (err) {
+      }
+    }
+    return info;
+  }
+  async isRunning(uid) {
+    const lockFile = this._getConfigFiles(uid).lockFile;
+    return import_lock_file2.LockFile.isLocked(lockFile);
+  }
 };
 
 // packages/common/phoenix/src/watchdog.ts
 var import_node_child_process2 = require("node:child_process");
 var import_node_fs3 = require("node:fs");
+var import_node_util = require("node:util");
+var import_ps_tree = __toESM(require("ps-tree"));
 var import_async2 = require("@dxos/async");
+var import_context = require("@dxos/context");
 var import_invariant2 = require("@dxos/invariant");
+var import_lock_file3 = require("@dxos/lock-file");
 var import_log2 = require("@dxos/log");
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -187,43 +244,79 @@ var WatchDog = class {
     this._restarts = 0;
   }
   async start() {
+    await this._acquireLock();
+    this._log("Lock acquired.");
     const { cwd, shell, env, command, args } = {
       cwd: process.cwd(),
       ...this._params
     };
-    this._log(`Spawning process \`\`\`${command} ${args?.join(" ")}\`\`\``);
+    (0, import_invariant2.invariant)(command, "Command is not defined.", {
+      F: __dxlog_file2,
+      L: 86,
+      S: this,
+      A: [
+        "command",
+        "'Command is not defined.'"
+      ]
+    });
+    this._log(`Spawning process ${command} ${args?.join(" ")}`);
     this._child = (0, import_node_child_process2.spawn)(command, args, {
       cwd,
       shell,
       env,
       stdio: "pipe"
     });
+    this._processCtx = new import_context.Context();
+    const childInfo = {
+      pid: process.pid,
+      timestamp: Date.now(),
+      restarts: this._restarts,
+      ...this._params
+    };
+    (0, import_node_fs3.writeFileSync)(this._params.lockFile, JSON.stringify(childInfo, void 0, 2), {
+      encoding: "utf-8"
+    });
     this._child.stdout.on("data", (data) => {
       this._log(String(data));
     });
     this._child.stderr.on("data", (data) => {
       this._err(data);
     });
-    this._child.on("close", async (code, signal) => {
-      if (code && code !== 0 && signal !== "SIGINT" && signal !== "SIGKILL") {
-        this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);
-        await this.restart();
-      }
+    {
+      const restartHandler = async (code, signal) => {
+        if (code && code !== 0) {
+          this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);
+          await this.restart();
+        }
+      };
+      this._child.on("close", restartHandler);
+      this._processCtx.onDispose(() => {
+        this._child.off("close", restartHandler);
+      });
+    }
+    this._child.on("close", (code, signal) => {
       this._log(`Stopped with exit code ${code} (signal: ${signal}).`);
-      if ((0, import_node_fs3.existsSync)(this._params.pidFile)) {
-        (0, import_node_fs3.unlinkSync)(this._params.pidFile);
-      }
     });
-    const childInfo = {
-      pid: this._child.pid,
-      started: Date.now(),
-      restarts: this._restarts,
-      ...this._params
-    };
-    (0, import_node_fs3.writeFileSync)(this._params.pidFile, JSON.stringify(childInfo, void 0, 2), {
-      encoding: "utf-8"
+    (0, import_invariant2.invariant)(this._child.pid, "Child process has no pid.", {
+      F: __dxlog_file2,
+      L: 129,
+      S: this,
+      A: [
+        "this._child.pid",
+        "'Child process has no pid.'"
+      ]
     });
-    await waitForPidFileBeingFilledWithInfo(this._params.pidFile);
+    this._log(`Started with pid ${this._child.pid}.`);
+  }
+  /**
+  * Sends SIGINT to the child process and the tree it spawned (if `killTree` param is `true`).
+  */
+  async stop() {
+    if (!this._child) {
+      return;
+    }
+    await this._killWithSignal("SIGKILL");
+    await this._releaseLock();
   }
   /**
   * Sends SIGKILL to the child process and the tree it spawned (if `killTree` param is `true`).
@@ -233,10 +326,7 @@ var WatchDog = class {
       return;
     }
     await this._killWithSignal("SIGKILL");
-    if ((0, import_node_fs3.existsSync)(this._params.pidFile)) {
-      (0, import_node_fs3.unlinkSync)(this._params.pidFile);
-    }
-    await waitForPidDeletion(this._params.pidFile);
+    await this._releaseLock();
   }
   async restart() {
     await this.kill();
@@ -245,7 +335,7 @@ var WatchDog = class {
     } else {
       (0, import_log2.log)("Restarting...", void 0, {
         F: __dxlog_file2,
-        L: 120,
+        L: 166,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -254,9 +344,45 @@ var WatchDog = class {
     }
   }
   async _killWithSignal(signal) {
+    (0, import_invariant2.invariant)(this._processCtx, "Process context is not defined.", {
+      F: __dxlog_file2,
+      L: 173,
+      S: this,
+      A: [
+        "this._processCtx",
+        "'Process context is not defined.'"
+      ]
+    });
+    await this._processCtx.dispose();
+    if (this._params.killTree) {
+      if (process.platform !== "win32") {
+        (0, import_invariant2.invariant)(this._child?.pid, "Child process has no pid.", {
+          F: __dxlog_file2,
+          L: 179,
+          S: this,
+          A: [
+            "this._child?.pid",
+            "'Child process has no pid.'"
+          ]
+        });
+        const children = await (0, import_node_util.promisify)(import_ps_tree.default)(this._child.pid);
+        children.map((p) => p.PID).forEach((tpid) => {
+          (0, import_invariant2.invariant)(tpid, "Process id is not defined.", {
+            F: __dxlog_file2,
+            L: 184,
+            S: this,
+            A: [
+              "tpid",
+              "'Process id is not defined.'"
+            ]
+          });
+          process.kill(Number(tpid), signal);
+        });
+      }
+    }
     (0, import_invariant2.invariant)(this._child?.pid, "Child process has no pid.", {
       F: __dxlog_file2,
-      L: 127,
+      L: 190,
       S: this,
       A: [
         "this._child?.pid",
@@ -266,6 +392,27 @@ var WatchDog = class {
     this._child.kill(signal);
     this._child = void 0;
   }
+  async _acquireLock() {
+    if (await import_lock_file3.LockFile.isLocked(this._params.lockFile)) {
+      throw new Error("Lock file is already locked.");
+    }
+    this._lock = await import_lock_file3.LockFile.acquire(this._params.lockFile);
+    await waitForLockAcquisition(this._params.lockFile);
+  }
+  async _releaseLock() {
+    (0, import_invariant2.invariant)(this._lock, "Lock is not defined.", {
+      F: __dxlog_file2,
+      L: 204,
+      S: this,
+      A: [
+        "this._lock",
+        "'Lock is not defined.'"
+      ]
+    });
+    await import_lock_file3.LockFile.release(this._lock);
+    await waitForLockRelease(this._params.lockFile);
+    this._lock = void 0;
+  }
   _log(message) {
     (0, import_node_fs3.writeFileSync)(this._params.logFile, message + "\n", {
       flag: "a+",
@@ -283,12 +430,15 @@ var WatchDog = class {
 _ts_decorate([
   import_async2.synchronized
 ], WatchDog.prototype, "start", null);
+_ts_decorate([
+  import_async2.synchronized
+], WatchDog.prototype, "stop", null);
 _ts_decorate([
   import_async2.synchronized
 ], WatchDog.prototype, "kill", null);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Phoenix,
+  DaemonManager,
   WatchDog
 });
 //# sourceMappingURL=index.cjs.map

package/dist/lib/node/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../../../src/index.ts", "../../../src/phoenix.ts", "../../../src/utils.ts", "../../../src/defs.ts", "../../../src/watchdog.ts"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n// Inspired by https://github.com/foreversd/forever\n// Their copyright notice is included below.\n// Copyright (C) 2010 Charlie Robbins & the Contributors\n//\n\nexport * from './phoenix';\nexport * from './watchdog';\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { fork } from 'node:child_process';\nimport { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport pkgUp from 'pkg-up';\n\nimport { invariant } from '@dxos/invariant';\nimport { log } from '@dxos/log';\n\nimport { waitForPidDeletion, waitForPidFileBeingFilledWithInfo } from './utils';\nimport { ProcessInfo, WatchDogParams } from './watchdog';\n\n/**\n * Utils to start/stop detached process with errors and logs handling.\n */\nexport class Phoenix {\n  /**\n   * Starts detached watchdog process which starts and monitors selected command.\n   */\n  static async start(params: WatchDogParams) {\n    {\n      // Clear stale pid file.\n      if (existsSync(params.pidFile)) {\n        await Phoenix.stop(params.pidFile);\n      }\n\n      await waitForPidDeletion(params.pidFile);\n    }\n\n    {\n      // Create log folders.\n      [params.logFile, params.errFile, params.pidFile].forEach((filename) => {\n        if (!existsSync(filename)) {\n          mkdirSync(dirname(filename), { recursive: true });\n          writeFileSync(filename, '', { encoding: 'utf-8' });\n        }\n      });\n    }\n\n    const watchdogPath = join(dirname(pkgUp.sync({ cwd: __dirname })!), 'bin', 'watchdog');\n\n    const watchDog = fork(watchdogPath, [JSON.stringify(params)], {\n      detached: true,\n      cwd: __dirname,\n    });\n\n    watchDog.on('exit', (code, signal) => {\n      if (code && code !== 0) {\n        log.error('Monitor died unexpectedly', { code, signal });\n      }\n    });\n\n    await waitForPidFileBeingFilledWithInfo(params.pidFile);\n\n    watchDog.disconnect();\n    watchDog.unref();\n\n    return Phoenix.info(params.pidFile);\n  }\n\n  /**\n   * Stops detached watchdog process by PID info written down in PID file.\n   */\n  static async stop(pidFile: string, force = false) {\n    if (!existsSync(pidFile)) {\n      throw new Error('PID file does not exist');\n    }\n    const fileContent = readFileSync(pidFile, { encoding: 'utf-8' });\n    if (!fileContent.includes('pid')) {\n      throw new Error('Invalid PID file content');\n    }\n\n    const { pid } = JSON.parse(fileContent);\n    const signal: NodeJS.Signals = force ? 'SIGKILL' : 'SIGINT';\n    try {\n      process.kill(pid, signal);\n    } catch (err) {\n      invariant(err instanceof Error, 'Invalid error type');\n      if (err.message.includes('ESRCH') || err.name.includes('ESRCH')) {\n        // Process is already dead.\n        unlinkSync(pidFile);\n      } else {\n        throw err;\n      }\n    }\n  }\n\n  static info(pidFile: string): ProcessInfo {\n    return JSON.parse(readFileSync(pidFile, { encoding: 'utf-8' }));\n  }\n}\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { existsSync, readFileSync } from 'node:fs';\n\nimport { waitForCondition } from '@dxos/async';\n\nimport { WATCHDOG_CHECK_INTERVAL, WATCHDOG_START_TIMEOUT, WATCHDOG_STOP_TIMEOUT } from './defs';\n\nexport const waitForPidCreation = async (pidFile: string) =>\n  waitForCondition({\n    condition: () => existsSync(pidFile),\n    timeout: WATCHDOG_START_TIMEOUT,\n    interval: WATCHDOG_CHECK_INTERVAL,\n  });\n\nexport const waitForPidDeletion = async (pidFile: string) =>\n  waitForCondition({\n    condition: () => !existsSync(pidFile),\n    timeout: WATCHDOG_STOP_TIMEOUT,\n    interval: WATCHDOG_CHECK_INTERVAL,\n  });\n\nexport const waitForPidFileBeingFilledWithInfo = async (pidFile: string) =>\n  waitForCondition({\n    condition: () => readFileSync(pidFile, { encoding: 'utf-8' }).includes('pid'),\n    timeout: WATCHDOG_START_TIMEOUT,\n    interval: WATCHDOG_CHECK_INTERVAL,\n    error: new Error('Lock file is not being propagated with info.'),\n  });\n", "//\n// Copyright 2023 DXOS.org\n//\n\nexport const LOCK_TIMEOUT = 1_000;\nexport const LOCK_CHECK_INTERVAL = 50;\nexport const WATCHDOG_START_TIMEOUT = 10_000;\nexport const WATCHDOG_STOP_TIMEOUT = 1_000;\nexport const WATCHDOG_CHECK_INTERVAL = 50;\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { ChildProcessWithoutNullStreams, spawn } from 'node:child_process';\nimport { existsSync, unlinkSync, writeFileSync } from 'node:fs';\nimport { FileHandle } from 'node:fs/promises';\n\nimport { synchronized } from '@dxos/async';\nimport { invariant } from '@dxos/invariant';\nimport { log } from '@dxos/log';\n\nimport { waitForPidDeletion, waitForPidFileBeingFilledWithInfo } from './utils';\n\nexport type ProcessInfo = WatchDogParams & {\n  pid?: number;\n  started?: number;\n  restarts?: number;\n  running?: boolean;\n};\n\nexport type WatchDogParams = {\n  profile?: string; // Human readable process identifier\n  pidFile: string; // Path to PID file\n\n  //\n  // Log files and associated logging options for this instance\n  //\n  logFile: string; // Path to log output all logs\n  errFile: string; // Path to log output from child stderr\n\n  //\n  // Basic configuration options\n  //\n  maxRestarts?: number | undefined; // Sets the maximum number of times a given script should run\n  killTree?: boolean | undefined; // Kills the entire child process tree on `exit`\n\n  //\n  // Command to spawn as well as options and other vars\n  // (env, cwd, etc) to pass along\n  //\n  command: string; // Binary to run (default: 'node')\n  args?: string[] | undefined; // Additional arguments to pass to the script,\n\n  //\n  // More specific options to pass along to `child_process.spawn` which\n  // will override anything passed to the `spawnWith` option\n  //\n  env?: NodeJS.ProcessEnv | undefined;\n  cwd?: string | undefined;\n  shell?: boolean | undefined;\n};\n\nexport class WatchDog {\n  private _lock?: FileHandle;\n  private _child?: ChildProcessWithoutNullStreams;\n  private _restarts = 0;\n\n  constructor(private readonly _params: WatchDogParams) {}\n\n  @synchronized\n  async start() {\n    const { cwd, shell, env, command, args } = { cwd: process.cwd(), ...this._params };\n\n    this._log(`Spawning process \\`\\`\\`${command} ${args?.join(' ')}\\`\\`\\``);\n    this._child = spawn(command, args, { cwd, shell, env, stdio: 'pipe' });\n\n    this._child.stdout.on('data', (data: Uint8Array) => {\n      this._log(String(data));\n    });\n    this._child.stderr.on('data', (data: Uint8Array) => {\n      this._err(data);\n    });\n    this._child.on('close', async (code: number, signal: number | NodeJS.Signals) => {\n      if (code && code !== 0 && signal !== 'SIGINT' && signal !== 'SIGKILL') {\n        this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);\n        await this.restart();\n      }\n      this._log(`Stopped with exit code ${code} (signal: ${signal}).`);\n      if (existsSync(this._params.pidFile)) {\n        unlinkSync(this._params.pidFile);\n      }\n    });\n\n    const childInfo: ProcessInfo = {\n      pid: this._child.pid,\n      started: Date.now(),\n      restarts: this._restarts,\n      ...this._params,\n    };\n\n    writeFileSync(this._params.pidFile, JSON.stringify(childInfo, undefined, 2), { encoding: 'utf-8' });\n\n    await waitForPidFileBeingFilledWithInfo(this._params.pidFile);\n  }\n\n  /**\n   * Sends SIGKILL to the child process and the tree it spawned (if `killTree` param is `true`).\n   */\n  @synchronized\n  async kill() {\n    if (!this._child) {\n      return;\n    }\n\n    await this._killWithSignal('SIGKILL');\n\n    if (existsSync(this._params.pidFile)) {\n      unlinkSync(this._params.pidFile);\n    }\n\n    await waitForPidDeletion(this._params.pidFile);\n  }\n\n  async restart() {\n    await this.kill();\n    if (this._params.maxRestarts !== undefined && this._restarts >= this._params.maxRestarts) {\n      this._err('Max restarts number is reached');\n    } else {\n      log('Restarting...');\n      this._restarts++;\n      await this.start();\n    }\n  }\n\n  async _killWithSignal(signal: number | NodeJS.Signals) {\n    invariant(this._child?.pid, 'Child process has no pid.');\n    this._child.kill(signal);\n    this._child = undefined;\n  }\n\n  private _log(message: string | Uint8Array) {\n    writeFileSync(this._params.logFile, message + '\\n', {\n      flag: 'a+',\n      encoding: 'utf-8',\n    });\n  }\n\n  private _err(message: string | Uint8Array) {\n    this._log(message);\n    writeFileSync(this._params.errFile, message + '\\n', {\n      flag: 'a+',\n      encoding: 'utf-8',\n    });\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["import_node_fs", "WATCHDOG_START_TIMEOUT", "WATCHDOG_STOP_TIMEOUT", "WATCHDOG_CHECK_INTERVAL", "waitForPidDeletion", "pidFile", "waitForCondition", "condition", "existsSync", "timeout", "WATCHDOG_STOP_TIMEOUT", "interval", "WATCHDOG_CHECK_INTERVAL", "waitForPidFileBeingFilledWithInfo", "readFileSync", "encoding", "includes", "WATCHDOG_START_TIMEOUT", "error", "Error", "Phoenix", "start", "params", "existsSync", "pidFile", "stop", "waitForPidDeletion", "logFile", "errFile", "forEach", "filename", "mkdirSync", "dirname", "recursive", "writeFileSync", "encoding", "watchdogPath", "join", "pkgUp", "sync", "cwd", "__dirname", "watchDog", "fork", "JSON", "stringify", "detached", "on", "code", "signal", "log", "error", "waitForPidFileBeingFilledWithInfo", "disconnect", "unref", "info", "force", "Error", "fileContent", "readFileSync", "includes", "pid", "parse", "process", "kill", "err", "invariant", "message", "name", "unlinkSync", "import_node_child_process", "import_node_fs", "import_async", "import_invariant", "import_log", "WatchDog", "constructor", "_params", "_restarts", "start", "cwd", "shell", "env", "command", "args", "process", "_log", "join", "_child", "spawn", "stdio", "stdout", "on", "data", "String", "stderr", "_err", "code", "signal", "restart", "existsSync", "pidFile", "unlinkSync", "childInfo", "pid", "started", "Date", "now", "restarts", "writeFileSync", "JSON", "stringify", "undefined", "encoding", "waitForPidFileBeingFilledWithInfo", "kill", "_killWithSignal", "waitForPidDeletion", "maxRestarts", "log", "invariant", "message", "logFile", "flag", "errFile", "synchronized"]
+  "sources": ["../../../src/index.ts", "../../../src/daemon-manager.ts", "../../../src/utils.ts", "../../../src/defs.ts", "../../../src/watchdog.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n// Inspired by https://github.com/foreversd/forever\n// Their copyright notice is included below.\n// Copyright (C) 2010 Charlie Robbins & the Contributors\n//\n\nexport * from './daemon-manager';\nexport * from './watchdog';\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { fork } from 'node:child_process';\nimport { existsSync, mkdirSync, readFileSync, unlinkSync } from 'node:fs';\nimport { readdir } from 'node:fs/promises';\nimport { dirname, join } from 'node:path';\nimport pkgUp from 'pkg-up';\n\nimport { invariant } from '@dxos/invariant';\nimport { LockFile } from '@dxos/lock-file';\nimport { log } from '@dxos/log';\n\nimport { waitForLockAcquisition, waitForLockFileBeingFilledWithInfo, waitForLockRelease } from './utils';\nimport { ChildParams, Logs, Lock, ProcessInfo, WatchDogParams } from './watchdog';\n\nconst LOCK_FILE_NAME = 'lockfile';\n\n/**\n * Params to start a daemon.\n * User have no control over the lock file.\n */\nexport type StartParams = ChildParams & Partial<Logs>;\n\nexport class DaemonManager {\n  constructor(private readonly _rootPath: string) {\n    if (!existsSync(join(_rootPath, 'profile'))) {\n      mkdirSync(join(_rootPath, 'profile'), { recursive: true });\n    }\n  }\n\n  private _getConfigFiles(uid: string): Logs & Lock {\n    const defaultConfigDir = join(this._rootPath, 'profile', uid);\n    if (!existsSync(defaultConfigDir)) {\n      mkdirSync(defaultConfigDir, { recursive: true });\n    }\n    return {\n      lockFile: join(defaultConfigDir, LOCK_FILE_NAME),\n      logFile: join(defaultConfigDir, 'file.log'),\n      errFile: join(defaultConfigDir, 'err.log'),\n    };\n  }\n\n  async start(params: StartParams) {\n    invariant(params.command, 'command is required');\n    const watchDogParams: WatchDogParams = {\n      ...this._getConfigFiles(params.uid),\n      ...params,\n    };\n\n    {\n      // Create log folders.\n      mkdirSync(dirname(watchDogParams.logFile), { recursive: true });\n      mkdirSync(dirname(watchDogParams.errFile), { recursive: true });\n    }\n\n    {\n      // Clear stale lock file if process is not running.\n      if (await LockFile.isLocked(watchDogParams.lockFile)) {\n        throw new Error('Lock file is already locked.');\n      }\n      unlinkSync(watchDogParams.lockFile);\n    }\n\n    const watchdogPath = join(dirname(pkgUp.sync({ cwd: __dirname })!), 'bin', 'watchdog');\n\n    const watchDog = fork(watchdogPath, [JSON.stringify(watchDogParams)], {\n      detached: true,\n      cwd: __dirname,\n    });\n\n    watchDog.on('exit', (code, signal) => {\n      if (code && code !== 0) {\n        log.error('Monitor died unexpectedly', { code, signal });\n      }\n    });\n\n    await waitForLockAcquisition(watchDogParams.lockFile);\n    await waitForLockFileBeingFilledWithInfo(watchDogParams.lockFile);\n\n    watchDog.disconnect();\n    watchDog.unref();\n\n    return this.getInfo(params.uid);\n  }\n\n  async stop(uid: string, force?: boolean) {\n    const lockFile = this._getConfigFiles(uid).lockFile;\n    const processInfo = JSON.parse(readFileSync(lockFile, { encoding: 'utf-8' }));\n    try {\n      if (force) {\n        process.kill(processInfo.pid, 'SIGKILL');\n      } else {\n        process.kill(processInfo.pid, 'SIGINT');\n      }\n    } catch (err) {\n      invariant(err instanceof Error, 'Invalid error type.');\n      if (!err.name.includes('ESRCH') && !err.message.includes('ESRCH')) {\n        throw err;\n      }\n    }\n    await waitForLockRelease(lockFile);\n\n    return this.getInfo(uid);\n  }\n\n  async list(): Promise<ProcessInfo[]> {\n    const uids = (await readdir(join(this._rootPath, 'profile'))).filter((uid) => !uid.startsWith('.'));\n\n    return Promise.all(\n      uids.map(async (uid) => {\n        return this.getInfo(uid);\n      }),\n    );\n  }\n\n  async getInfo(uid: string): Promise<ProcessInfo> {\n    const files = this._getConfigFiles(uid);\n\n    let info: ProcessInfo = { running: await LockFile.isLocked(files.lockFile), uid, ...files };\n    if (existsSync(files.lockFile)) {\n      try {\n        info = {\n          ...info,\n          ...JSON.parse(readFileSync(files.lockFile, { encoding: 'utf-8' })),\n        };\n      } catch (err) {}\n    }\n\n    return info;\n  }\n\n  async isRunning(uid: string): Promise<boolean> {\n    const lockFile = this._getConfigFiles(uid).lockFile;\n    return LockFile.isLocked(lockFile);\n  }\n}\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { readFileSync } from 'node:fs';\n\nimport { waitForCondition } from '@dxos/async';\nimport { LockFile } from '@dxos/lock-file';\n\nimport { LOCK_CHECK_INTERVAL, LOCK_TIMEOUT } from './defs';\n\nexport const waitForLockAcquisition = async (lockFile: string) =>\n  waitForCondition({\n    condition: async () => await LockFile.isLocked(lockFile),\n    timeout: LOCK_TIMEOUT,\n    interval: LOCK_CHECK_INTERVAL,\n    error: new Error('Lock file is not being acquired.'),\n  });\n\nexport const waitForLockFileBeingFilledWithInfo = async (lockFile: string) =>\n  waitForCondition({\n    condition: () => readFileSync(lockFile, { encoding: 'utf-8' }).includes('pid'),\n    timeout: LOCK_TIMEOUT,\n    interval: LOCK_CHECK_INTERVAL,\n    error: new Error('Lock file is not being propagated with info.'),\n  });\n\nexport const waitForLockRelease = async (lockFile: string) =>\n  waitForCondition({\n    condition: async () => !(await LockFile.isLocked(lockFile)),\n    timeout: LOCK_TIMEOUT,\n    interval: LOCK_CHECK_INTERVAL,\n    error: new Error('Lock file is not being released.'),\n  });\n", "//\n// Copyright 2023 DXOS.org\n//\n\nexport const LOCK_TIMEOUT = 1_000;\nexport const LOCK_CHECK_INTERVAL = 50;\nexport const DAEMON_START_TIMEOUT = 10_000;\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { ChildProcessWithoutNullStreams, spawn } from 'node:child_process';\nimport { writeFileSync } from 'node:fs';\nimport { FileHandle } from 'node:fs/promises';\nimport { promisify } from 'node:util';\nimport psTree from 'ps-tree';\n\nimport { synchronized } from '@dxos/async';\nimport { Context } from '@dxos/context';\nimport { invariant } from '@dxos/invariant';\nimport { LockFile } from '@dxos/lock-file';\nimport { log } from '@dxos/log';\n\nimport { waitForLockAcquisition, waitForLockRelease } from './utils';\n\nexport type DaemonInfo = {\n  pid: number;\n  command: string;\n  args: string[];\n  cwd: string;\n  timestamp: number;\n};\n\nexport type ProcessInfo = WatchDogParams & {\n  pid?: number;\n  timestamp?: number;\n  restarts?: number;\n  running?: boolean;\n};\n\nexport type Lock = {\n  lockFile: string; // Path to lock file\n};\n\nexport type Logs = {\n  //\n  // Log files and associated logging options for this instance\n  //\n  logFile: string; // Path to log output all logs\n  errFile: string; // Path to log output from child stderr\n};\n\nexport type ChildParams = {\n  uid: string; // Unique identifier for this instance\n\n  //\n  // Basic configuration options\n  //\n  maxRestarts?: number | undefined; // Sets the maximum number of times a given script should run\n  killTree?: boolean | undefined; // Kills the entire child process tree on `exit`\n\n  //\n  // Command to spawn as well as options and other vars\n  // (env, cwd, etc) to pass along\n  //\n  command?: string; // Binary to run (default: 'node')\n  args?: string[] | undefined; // Additional arguments to pass to the script,\n\n  //\n  // More specific options to pass along to `child_process.spawn` which\n  // will override anything passed to the `spawnWith` option\n  //\n  env?: NodeJS.ProcessEnv | undefined;\n  cwd?: string | undefined;\n  shell?: boolean | undefined;\n};\n\nexport type WatchDogParams = ChildParams & Lock & Logs;\n\nexport class WatchDog {\n  private _lock?: FileHandle;\n  private _child?: ChildProcessWithoutNullStreams;\n  private _restarts = 0;\n  private _processCtx?: Context;\n\n  constructor(private readonly _params: WatchDogParams) {}\n\n  @synchronized\n  async start() {\n    await this._acquireLock();\n    this._log('Lock acquired.');\n    const { cwd, shell, env, command, args } = { cwd: process.cwd(), ...this._params };\n    invariant(command, 'Command is not defined.');\n\n    this._log(`Spawning process ${command} ${args?.join(' ')}`);\n    this._child = spawn(command, args, { cwd, shell, env, stdio: 'pipe' });\n    this._processCtx = new Context();\n\n    const childInfo: ProcessInfo = {\n      pid: process.pid,\n      timestamp: Date.now(),\n      restarts: this._restarts,\n      ...this._params,\n    };\n\n    writeFileSync(this._params.lockFile, JSON.stringify(childInfo, undefined, 2), { encoding: 'utf-8' });\n\n    this._child.stdout.on('data', (data: Uint8Array) => {\n      this._log(String(data));\n    });\n    this._child.stderr.on('data', (data: Uint8Array) => {\n      this._err(data);\n    });\n\n    // Setup restart handler.\n    {\n      const restartHandler = async (code: number, signal: number | NodeJS.Signals) => {\n        if (code && code !== 0) {\n          this._err(`Died unexpectedly with exit code ${code} (signal: ${signal}).`);\n          await this.restart();\n        }\n      };\n\n      this._child.on('close', restartHandler);\n\n      // We should unsubscribe from the event when the process is killed by us to not try to restart it.\n      this._processCtx.onDispose(() => {\n        this._child!.off('close', restartHandler);\n      });\n    }\n\n    this._child.on('close', (code: number, signal: number | NodeJS.Signals) => {\n      this._log(`Stopped with exit code ${code} (signal: ${signal}).`);\n    });\n\n    invariant(this._child.pid, 'Child process has no pid.');\n    this._log(`Started with pid ${this._child.pid}.`);\n  }\n\n  /**\n   * Sends SIGINT to the child process and the tree it spawned (if `killTree` param is `true`).\n   */\n  @synchronized\n  async stop() {\n    if (!this._child) {\n      return;\n    }\n\n    await this._killWithSignal('SIGKILL');\n\n    await this._releaseLock();\n  }\n\n  /**\n   * Sends SIGKILL to the child process and the tree it spawned (if `killTree` param is `true`).\n   */\n  @synchronized\n  async kill() {\n    if (!this._child) {\n      return;\n    }\n\n    await this._killWithSignal('SIGKILL');\n\n    await this._releaseLock();\n  }\n\n  async restart() {\n    await this.kill();\n    if (this._params.maxRestarts !== undefined && this._restarts >= this._params.maxRestarts) {\n      this._err('Max restarts number is reached');\n    } else {\n      log('Restarting...');\n      this._restarts++;\n      await this.start();\n    }\n  }\n\n  async _killWithSignal(signal: number | NodeJS.Signals) {\n    invariant(this._processCtx, 'Process context is not defined.');\n    await this._processCtx.dispose();\n\n    // Kill child process tree.\n    if (this._params.killTree) {\n      if (process.platform !== 'win32') {\n        invariant(this._child?.pid, 'Child process has no pid.');\n        const children = await promisify(psTree)(this._child.pid);\n        children\n          .map((p) => p.PID)\n          .forEach((tpid) => {\n            invariant(tpid, 'Process id is not defined.');\n            process.kill(Number(tpid), signal);\n          });\n      }\n    }\n\n    invariant(this._child?.pid, 'Child process has no pid.');\n    this._child.kill(signal);\n    this._child = undefined;\n  }\n\n  private async _acquireLock() {\n    if (await LockFile.isLocked(this._params.lockFile)) {\n      throw new Error('Lock file is already locked.');\n    }\n    this._lock = await LockFile.acquire(this._params.lockFile);\n    await waitForLockAcquisition(this._params.lockFile);\n  }\n\n  private async _releaseLock() {\n    invariant(this._lock, 'Lock is not defined.');\n\n    await LockFile.release(this._lock);\n    await waitForLockRelease(this._params.lockFile);\n\n    this._lock = undefined;\n  }\n\n  private _log(message: string | Uint8Array) {\n    writeFileSync(this._params.logFile, message + '\\n', {\n      flag: 'a+',\n      encoding: 'utf-8',\n    });\n  }\n\n  private _err(message: string | Uint8Array) {\n    this._log(message);\n    writeFileSync(this._params.errFile, message + '\\n', {\n      flag: 'a+',\n      encoding: 'utf-8',\n    });\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["import_node_fs", "import_lock_file", "LOCK_TIMEOUT", "LOCK_CHECK_INTERVAL", "waitForLockAcquisition", "lockFile", "waitForCondition", "condition", "LockFile", "isLocked", "timeout", "LOCK_TIMEOUT", "interval", "LOCK_CHECK_INTERVAL", "error", "Error", "waitForLockFileBeingFilledWithInfo", "readFileSync", "encoding", "includes", "waitForLockRelease", "LOCK_FILE_NAME", "DaemonManager", "constructor", "_rootPath", "existsSync", "join", "mkdirSync", "recursive", "_getConfigFiles", "uid", "defaultConfigDir", "lockFile", "logFile", "errFile", "start", "params", "invariant", "command", "watchDogParams", "dirname", "LockFile", "isLocked", "Error", "unlinkSync", "watchdogPath", "pkgUp", "sync", "cwd", "__dirname", "watchDog", "fork", "JSON", "stringify", "detached", "on", "code", "signal", "log", "error", "waitForLockAcquisition", "waitForLockFileBeingFilledWithInfo", "disconnect", "unref", "getInfo", "stop", "force", "processInfo", "parse", "readFileSync", "encoding", "process", "kill", "pid", "err", "name", "includes", "message", "waitForLockRelease", "list", "uids", "readdir", "filter", "startsWith", "Promise", "all", "map", "files", "info", "running", "isRunning", "import_node_child_process", "import_node_fs", "import_async", "import_invariant", "import_lock_file", "import_log", "WatchDog", "constructor", "_params", "_restarts", "start", "_acquireLock", "_log", "cwd", "shell", "env", "command", "args", "process", "invariant", "join", "_child", "spawn", "stdio", "_processCtx", "Context", "childInfo", "pid", "timestamp", "Date", "now", "restarts", "writeFileSync", "lockFile", "JSON", "stringify", "undefined", "encoding", "stdout", "on", "data", "String", "stderr", "_err", "restartHandler", "code", "signal", "restart", "onDispose", "off", "stop", "_killWithSignal", "_releaseLock", "kill", "maxRestarts", "log", "dispose", "killTree", "platform", "children", "promisify", "psTree", "map", "p", "PID", "forEach", "tpid", "Number", "LockFile", "isLocked", "Error", "_lock", "acquire", "waitForLockAcquisition", "release", "waitForLockRelease", "message", "logFile", "flag", "errFile", "synchronized"]
 }

package/dist/lib/node/meta.json

@@ -1 +1 @@
-{"inputs":{"packages/common/phoenix/src/defs.ts":{"bytes":1201,"imports":[],"format":"esm"},"packages/common/phoenix/src/utils.ts":{"bytes":3673,"imports":[{"path":"node:fs","kind":"import-statement","external":true},{"path":"@dxos/async","kind":"import-statement","external":true},{"path":"packages/common/phoenix/src/defs.ts","kind":"import-statement","original":"./defs"}],"format":"esm"},"packages/common/phoenix/src/phoenix.ts":{"bytes":10474,"imports":[{"path":"node:child_process","kind":"import-statement","external":true},{"path":"node:fs","kind":"import-statement","external":true},{"path":"node:path","kind":"import-statement","external":true},{"path":"pkg-up","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/log","kind":"import-statement","external":true},{"path":"packages/common/phoenix/src/utils.ts","kind":"import-statement","original":"./utils"}],"format":"esm"},"packages/common/phoenix/src/watchdog.ts":{"bytes":14340,"imports":[{"path":"node:child_process","kind":"import-statement","external":true},{"path":"node:fs","kind":"import-statement","external":true},{"path":"@dxos/async","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/log","kind":"import-statement","external":true},{"path":"packages/common/phoenix/src/utils.ts","kind":"import-statement","original":"./utils"}],"format":"esm"},"packages/common/phoenix/src/index.ts":{"bytes":987,"imports":[{"path":"packages/common/phoenix/src/phoenix.ts","kind":"import-statement","original":"./phoenix"},{"path":"packages/common/phoenix/src/watchdog.ts","kind":"import-statement","original":"./watchdog"}],"format":"esm"}},"outputs":{"packages/common/phoenix/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":14468},"packages/common/phoenix/dist/lib/node/index.cjs":{"imports":[{"path":"node:child_process","kind":"require-call","external":true},{"path":"node:fs","kind":"require-call","external":true},{"path":"node:path","kind":"require-call","external":true},{"path":"pkg-up","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"require-call","external":true},{"path":"@dxos/log","kind":"require-call","external":true},{"path":"node:fs","kind":"require-call","external":true},{"path":"@dxos/async","kind":"require-call","external":true},{"path":"node:child_process","kind":"require-call","external":true},{"path":"node:fs","kind":"require-call","external":true},{"path":"@dxos/async","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"require-call","external":true},{"path":"@dxos/log","kind":"require-call","external":true}],"exports":[],"entryPoint":"packages/common/phoenix/src/index.ts","inputs":{"packages/common/phoenix/src/index.ts":{"bytesInOutput":147},"packages/common/phoenix/src/phoenix.ts":{"bytesInOutput":3063},"packages/common/phoenix/src/utils.ts":{"bytesInOutput":646},"packages/common/phoenix/src/defs.ts":{"bytesInOutput":101},"packages/common/phoenix/src/watchdog.ts":{"bytesInOutput":3933}},"bytes":9727}}}
+{"inputs":{"packages/common/phoenix/src/defs.ts":{"bytes":844,"imports":[],"format":"esm"},"packages/common/phoenix/src/utils.ts":{"bytes":4044,"imports":[{"path":"node:fs","kind":"import-statement","external":true},{"path":"@dxos/async","kind":"import-statement","external":true},{"path":"@dxos/lock-file","kind":"import-statement","external":true},{"path":"packages/common/phoenix/src/defs.ts","kind":"import-statement","original":"./defs"}],"format":"esm"},"packages/common/phoenix/src/daemon-manager.ts":{"bytes":15641,"imports":[{"path":"node:child_process","kind":"import-statement","external":true},{"path":"node:fs","kind":"import-statement","external":true},{"path":"node:fs/promises","kind":"import-statement","external":true},{"path":"node:path","kind":"import-statement","external":true},{"path":"pkg-up","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/lock-file","kind":"import-statement","external":true},{"path":"@dxos/log","kind":"import-statement","external":true},{"path":"packages/common/phoenix/src/utils.ts","kind":"import-statement","original":"./utils"}],"format":"esm"},"packages/common/phoenix/src/watchdog.ts":{"bytes":22416,"imports":[{"path":"node:child_process","kind":"import-statement","external":true},{"path":"node:fs","kind":"import-statement","external":true},{"path":"node:util","kind":"import-statement","external":true},{"path":"ps-tree","kind":"import-statement","external":true},{"path":"@dxos/async","kind":"import-statement","external":true},{"path":"@dxos/context","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"@dxos/lock-file","kind":"import-statement","external":true},{"path":"@dxos/log","kind":"import-statement","external":true},{"path":"packages/common/phoenix/src/utils.ts","kind":"import-statement","original":"./utils"}],"format":"esm"},"packages/common/phoenix/src/index.ts":{"bytes":1006,"imports":[{"path":"packages/common/phoenix/src/daemon-manager.ts","kind":"import-statement","original":"./daemon-manager"},{"path":"packages/common/phoenix/src/watchdog.ts","kind":"import-statement","original":"./watchdog"}],"format":"esm"}},"outputs":{"packages/common/phoenix/dist/lib/node/index.cjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":20862},"packages/common/phoenix/dist/lib/node/index.cjs":{"imports":[{"path":"node:child_process","kind":"require-call","external":true},{"path":"node:fs","kind":"require-call","external":true},{"path":"node:fs/promises","kind":"require-call","external":true},{"path":"node:path","kind":"require-call","external":true},{"path":"pkg-up","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"require-call","external":true},{"path":"@dxos/lock-file","kind":"require-call","external":true},{"path":"@dxos/log","kind":"require-call","external":true},{"path":"node:fs","kind":"require-call","external":true},{"path":"@dxos/async","kind":"require-call","external":true},{"path":"@dxos/lock-file","kind":"require-call","external":true},{"path":"node:child_process","kind":"require-call","external":true},{"path":"node:fs","kind":"require-call","external":true},{"path":"node:util","kind":"require-call","external":true},{"path":"ps-tree","kind":"require-call","external":true},{"path":"@dxos/async","kind":"require-call","external":true},{"path":"@dxos/context","kind":"require-call","external":true},{"path":"@dxos/invariant","kind":"require-call","external":true},{"path":"@dxos/lock-file","kind":"require-call","external":true},{"path":"@dxos/log","kind":"require-call","external":true}],"exports":[],"entryPoint":"packages/common/phoenix/src/index.ts","inputs":{"packages/common/phoenix/src/index.ts":{"bytesInOutput":159},"packages/common/phoenix/src/daemon-manager.ts":{"bytesInOutput":4716},"packages/common/phoenix/src/utils.ts":{"bytesInOutput":1027},"packages/common/phoenix/src/defs.ts":{"bytesInOutput":54},"packages/common/phoenix/src/watchdog.ts":{"bytesInOutput":6674}},"bytes":14487}}}

package/dist/types/src/daemon-manager.d.ts

@@ -0,0 +1,17 @@
+import { ChildParams, Logs, ProcessInfo } from './watchdog';
+/**
+ * Params to start a daemon.
+ * User have no control over the lock file.
+ */
+export type StartParams = ChildParams & Partial<Logs>;
+export declare class DaemonManager {
+    private readonly _rootPath;
+    constructor(_rootPath: string);
+    private _getConfigFiles;
+    start(params: StartParams): Promise<ProcessInfo>;
+    stop(uid: string, force?: boolean): Promise<ProcessInfo>;
+    list(): Promise<ProcessInfo[]>;
+    getInfo(uid: string): Promise<ProcessInfo>;
+    isRunning(uid: string): Promise<boolean>;
+}
+//# sourceMappingURL=daemon-manager.d.ts.map

package/dist/types/src/daemon-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-manager.d.ts","sourceRoot":"","sources":["../../../src/daemon-manager.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,WAAW,EAAE,IAAI,EAAQ,WAAW,EAAkB,MAAM,YAAY,CAAC;AAIlF;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEtD,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,MAAM;IAM9C,OAAO,CAAC,eAAe;IAYjB,KAAK,CAAC,MAAM,EAAE,WAAW;IA2CzB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;IAoBjC,IAAI,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAU9B,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAgB1C,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAI/C"}