@ratio-app/cli 0.1.1

package/dist/commands/app/dev.js

@@ -0,0 +1,701 @@
+// src/lib/manifest/write-client-id.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+
+// src/lib/errors.ts
+var RatioCLIError = class extends Error {
+  code;
+  exitCode;
+  hint;
+  docsUrl;
+  constructor(opts) {
+    super(opts.message);
+    this.name = new.target.name;
+    this.code = opts.code;
+    this.exitCode = opts.exitCode;
+    if (opts.hint !== void 0) this.hint = opts.hint;
+    if (opts.docsUrl !== void 0) this.docsUrl = opts.docsUrl;
+  }
+};
+var ValidationError = class extends RatioCLIError {
+  constructor(message, hint) {
+    const opts = {
+      code: "VALIDATION_ERROR",
+      exitCode: 8,
+      message
+    };
+    if (hint !== void 0) opts.hint = hint;
+    super(opts);
+  }
+};
+var OrchestratorSpawnError = class extends RatioCLIError {
+  constructor(message, hint = "Could not start your app's dev command \u2014 check that the command in ratio.config.jsonc runs from this directory.") {
+    super({ code: "ORCHESTRATOR_SPAWN", exitCode: 10, message, hint });
+  }
+};
+var OrchestratorDrainTimeoutError = class extends RatioCLIError {
+  constructor(message, hint = "Your dev command did not exit cleanly within 5 seconds \u2014 it was forcibly terminated.") {
+    super({ code: "ORCHESTRATOR_DRAIN", exitCode: 11, message, hint });
+  }
+};
+function isRatioCLIError(err) {
+  return err instanceof RatioCLIError;
+}
+
+// src/lib/manifest/write-client-id.ts
+var MANIFEST_FILE_NAME = "ratio.config.jsonc";
+
+// src/lib/manifest/read-manifest.ts
+import fs2 from "fs";
+import path2 from "path";
+var DEV_COMMAND_ROW = /^\s*"devCommand"\s*:\s*"([^"]*)"/m;
+var DEV_SERVER_PORT_ROW = /^\s*"devServerPort"\s*:\s*(\d+)/m;
+var DEV_SERVER_PORT_KEY = /^\s*"devServerPort"\s*:/m;
+var APP_NAME_ROW = /^\s*"appName"\s*:\s*"([^"]*)"/m;
+var CLIENT_ID_READ_ROW = /^\s*"clientId"\s*:\s*"([^"]*)"/m;
+var DEV_COMMAND_HINT = 'Add a "devCommand" entry to ratio.config.jsonc (e.g. "npm run dev") and re-run.';
+function readManifest(cwd) {
+  const filePath = path2.join(cwd, MANIFEST_FILE_NAME);
+  let content;
+  try {
+    content = fs2.readFileSync(filePath, "utf8");
+  } catch {
+    throw new ValidationError(
+      `${MANIFEST_FILE_NAME} not found in ${cwd}.`,
+      `Run this command from the app's repo root; ${MANIFEST_FILE_NAME} not found in ${cwd}.`
+    );
+  }
+  const devCommand = DEV_COMMAND_ROW.exec(content)?.[1];
+  if (devCommand === void 0 || devCommand.trim() === "") {
+    throw new ValidationError(
+      `${MANIFEST_FILE_NAME} has no usable "devCommand" entry.`,
+      DEV_COMMAND_HINT
+    );
+  }
+  let devServerPort;
+  if (DEV_SERVER_PORT_KEY.test(content)) {
+    const rawPort = DEV_SERVER_PORT_ROW.exec(content)?.[1];
+    const port = rawPort === void 0 ? Number.NaN : Number.parseInt(rawPort, 10);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+      throw new ValidationError(
+        `${MANIFEST_FILE_NAME} has an invalid "devServerPort" value.`,
+        '"devServerPort" must be an unquoted integer between 1 and 65535 (e.g. "devServerPort": 3001).'
+      );
+    }
+    devServerPort = port;
+  }
+  return {
+    path: filePath,
+    devCommand,
+    devServerPort,
+    appName: APP_NAME_ROW.exec(content)?.[1],
+    clientId: CLIENT_ID_READ_ROW.exec(content)?.[1]
+  };
+}
+
+// src/lib/orchestrator/child-runner.ts
+import { spawn } from "child_process";
+var DRAIN_MS = 5e3;
+var SIGNAL_FORCE_EXIT_WINDOW_MS = 2e3;
+var CHILD_BUFFER_MAX_BYTES = 64 * 1024;
+var DEV_COMMAND_TOKENIZE_HINT = "devCommand must be a simple whitespace-separated command; complex shell pipelines are not supported.";
+var DEFAULT_FORWARD_PORT = 3001;
+function tokenizeDevCommand(raw) {
+  const tokens = [];
+  let current = "";
+  let quote;
+  let hasToken = false;
+  for (let i = 0; i < raw.length; i += 1) {
+    const ch = raw.charAt(i);
+    if (quote !== void 0) {
+      if (ch === quote) {
+        quote = void 0;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      hasToken = true;
+      continue;
+    }
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      if (hasToken) {
+        tokens.push(current);
+        current = "";
+        hasToken = false;
+      }
+      continue;
+    }
+    if (ch === "|" || ch === "&" || ch === ";" || ch === "<" || ch === ">" || ch === "`") {
+      throw new ValidationError(
+        `devCommand contains an unsupported shell operator: ${ch}`,
+        DEV_COMMAND_TOKENIZE_HINT
+      );
+    }
+    if (ch === "$" && raw.charAt(i + 1) === "(") {
+      throw new ValidationError(
+        "devCommand contains an unsupported shell substitution.",
+        DEV_COMMAND_TOKENIZE_HINT
+      );
+    }
+    current += ch;
+    hasToken = true;
+  }
+  if (quote !== void 0) {
+    throw new ValidationError(
+      "devCommand has an unterminated quote.",
+      DEV_COMMAND_TOKENIZE_HINT
+    );
+  }
+  if (hasToken) {
+    tokens.push(current);
+  }
+  if (tokens.length === 0 || tokens[0] === "") {
+    throw new ValidationError("devCommand is empty.", DEV_COMMAND_HINT);
+  }
+  return tokens;
+}
+var LinePrefixer = class {
+  constructor(prefix, write) {
+    this.prefix = prefix;
+    this.write = write;
+  }
+  prefix;
+  write;
+  buffer = Buffer.alloc(0);
+  push(chunk) {
+    const incoming = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+    if (incoming.length === 0) {
+      return;
+    }
+    this.buffer = this.buffer.length === 0 ? incoming : Buffer.concat([this.buffer, incoming]);
+    this.drainCompleteLines();
+    if (this.buffer.length > CHILD_BUFFER_MAX_BYTES) {
+      this.flush();
+    }
+  }
+  /** Emit any buffered partial line (with prefix + newline), then reset. */
+  flush() {
+    if (this.buffer.length > 0) {
+      this.write(`${this.prefix}${this.buffer.toString("utf8")}
+`);
+      this.buffer = Buffer.alloc(0);
+    }
+  }
+  drainCompleteLines() {
+    let newlineAt = this.buffer.indexOf(10);
+    while (newlineAt !== -1) {
+      const line = this.buffer.subarray(0, newlineAt).toString("utf8");
+      this.buffer = this.buffer.subarray(newlineAt + 1);
+      this.write(`${this.prefix}${line}
+`);
+      newlineAt = this.buffer.indexOf(10);
+    }
+  }
+};
+var SIGNAL_EXIT_CODES = {
+  SIGHUP: 129,
+  SIGINT: 130,
+  SIGQUIT: 131,
+  SIGKILL: 137,
+  SIGTERM: 143
+};
+function exitCodeFrom(code, signal) {
+  if (code !== null) {
+    return code;
+  }
+  if (signal !== null) {
+    return SIGNAL_EXIT_CODES[signal] ?? 1;
+  }
+  return 1;
+}
+var ExitArbiter = class {
+  decidingChildCode;
+  signalCode;
+  get shutdownInitiated() {
+    return this.decidingChildCode !== void 0 || this.signalCode !== void 0;
+  }
+  observeChildExit(code, signal) {
+    if (this.shutdownInitiated) {
+      return;
+    }
+    this.decidingChildCode = exitCodeFrom(code, signal);
+  }
+  observeSignal(sig) {
+    if (this.shutdownInitiated) {
+      return;
+    }
+    this.signalCode = sig === "SIGINT" ? 130 : 143;
+  }
+  finalCode() {
+    return this.signalCode ?? this.decidingChildCode ?? 0;
+  }
+};
+var defaultSpawn = (command, args, options) => spawn(command, [...args], {
+  cwd: options.cwd,
+  env: options.env,
+  stdio: options.stdio,
+  shell: options.shell
+});
+function buildListenInvocation(env, devServerPort, argv1) {
+  const override = env.RATIO_DEV_LISTEN_BIN;
+  const listenBin = override ?? argv1;
+  if (listenBin === void 0 || listenBin === "") {
+    throw new OrchestratorSpawnError(
+      "Could not locate the CLI binary to start the webhook listener.",
+      "Re-install the CLI, or invoke it through its bin entry point."
+    );
+  }
+  const listenArgs = override ? [] : [
+    "dev",
+    "listen",
+    "--forward-to",
+    `localhost:${devServerPort ?? DEFAULT_FORWARD_PORT}/webhooks`
+  ];
+  return { command: process.execPath, args: [listenBin, ...listenArgs] };
+}
+function describeCause(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+async function orchestrate(options) {
+  const { io } = options;
+  const drainMs = options.drainMs ?? DRAIN_MS;
+  const spawnApp = options.spawnApp ?? defaultSpawn;
+  const spawnListen = options.spawnListen ?? defaultSpawn;
+  const trace = (line) => {
+    if (options.verbose) {
+      io.writeErr(`[verbose] ${line}
+`);
+    }
+  };
+  const appCommand = options.appArgv[0];
+  if (appCommand === void 0 || appCommand === "") {
+    throw new ValidationError("devCommand is empty.", DEV_COMMAND_HINT);
+  }
+  const appEnv = {
+    ...options.env,
+    ...options.devServerPort !== void 0 ? { PORT: String(options.devServerPort) } : {},
+    RATIO_ORCHESTRATED: "1"
+  };
+  let app;
+  try {
+    app = spawnApp(appCommand, options.appArgv.slice(1), {
+      cwd: options.cwd,
+      env: appEnv,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false
+    });
+  } catch (cause) {
+    throw new OrchestratorSpawnError(
+      `Could not start the dev command (${appCommand}): ${describeCause(cause)}`
+    );
+  }
+  trace(`spawn app: ${appCommand} (${app.pid ?? "-"})`);
+  const invocation = buildListenInvocation(
+    options.env,
+    options.devServerPort,
+    options.argv1 ?? process.argv[1]
+  );
+  const listenEnv = { ...options.env, RATIO_ORCHESTRATED: "1" };
+  let listen;
+  try {
+    listen = spawnListen(invocation.command, invocation.args, {
+      cwd: options.cwd,
+      env: listenEnv,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false
+    });
+  } catch (cause) {
+    app.kill("SIGTERM");
+    throw new OrchestratorSpawnError(
+      `Could not start the webhook listener: ${describeCause(cause)}`,
+      "The bundled webhook listener could not be started; re-install the CLI if this persists."
+    );
+  }
+  trace(`spawn listen: (${listen.pid ?? "-"})`);
+  const appOut = new LinePrefixer("[app] ", (chunk) => io.writeOut(chunk));
+  const appErrOut = new LinePrefixer("[app] ", (chunk) => io.writeOut(chunk));
+  const listenOut = new LinePrefixer("[listen] ", (chunk) => io.writeOut(chunk));
+  const listenErrOut = new LinePrefixer("[listen] ", (chunk) => io.writeOut(chunk));
+  const pipe = (stream, prefixer) => {
+    if (stream !== null) {
+      stream.on("data", (chunk) => prefixer.push(chunk));
+    }
+  };
+  pipe(app.stdout, appOut);
+  pipe(app.stderr, appErrOut);
+  pipe(listen.stdout, listenOut);
+  pipe(listen.stderr, listenErrOut);
+  const arbiter = new ExitArbiter();
+  let appExited = false;
+  let listenExited = false;
+  let spawnFailure;
+  let drainEscalated = false;
+  let drainTimer;
+  let drainStartedAt = 0;
+  let firstSignalAt = 0;
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      options.signalSource.removeListener("SIGINT", onSigint);
+      options.signalSource.removeListener("SIGTERM", onSigterm);
+      if (drainTimer !== void 0) {
+        clearTimeout(drainTimer);
+        drainTimer = void 0;
+      }
+      appOut.flush();
+      appErrOut.flush();
+      listenOut.flush();
+      listenErrOut.flush();
+    };
+    const settle = (code) => {
+      if (!settled) {
+        settled = true;
+        cleanup();
+        resolve(code);
+      }
+    };
+    const fail = (err) => {
+      if (!settled) {
+        settled = true;
+        cleanup();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    };
+    const startDrain = () => {
+      if (drainTimer !== void 0) {
+        return;
+      }
+      drainStartedAt = Date.now();
+      drainTimer = setTimeout(() => {
+        if (!appExited) {
+          app.kill("SIGKILL");
+          drainEscalated = true;
+        }
+        if (!listenExited) {
+          listen.kill("SIGKILL");
+          drainEscalated = true;
+        }
+      }, drainMs);
+    };
+    const finishIfDone = () => {
+      if (!appExited || !listenExited) {
+        return;
+      }
+      if (drainStartedAt > 0) {
+        trace(`drain elapsed: ${Date.now() - drainStartedAt}ms`);
+      }
+      const code = arbiter.finalCode();
+      void options.preview.onShutdown().then(
+        () => {
+          if (spawnFailure !== void 0) {
+            fail(spawnFailure);
+            return;
+          }
+          if (drainEscalated && code === 0) {
+            fail(
+              new OrchestratorDrainTimeoutError(
+                "A child process had to be forcibly terminated during shutdown."
+              )
+            );
+            return;
+          }
+          settle(code);
+        },
+        (err) => fail(err)
+      );
+    };
+    const onAppExit = (code, signal) => {
+      appExited = true;
+      appOut.flush();
+      appErrOut.flush();
+      trace(`app exited: code=${code} signal=${signal}`);
+      const alreadyShuttingDown = arbiter.shutdownInitiated;
+      arbiter.observeChildExit(code, signal);
+      if (!alreadyShuttingDown && !listenExited) {
+        listen.kill("SIGTERM");
+        startDrain();
+      }
+      finishIfDone();
+    };
+    const onListenExit = (code, signal) => {
+      listenExited = true;
+      listenOut.flush();
+      listenErrOut.flush();
+      trace(`listen exited: code=${code} signal=${signal}`);
+      const alreadyShuttingDown = arbiter.shutdownInitiated;
+      arbiter.observeChildExit(code, signal);
+      if (!alreadyShuttingDown && !appExited) {
+        app.kill("SIGTERM");
+        startDrain();
+      }
+      finishIfDone();
+    };
+    const onAppError = (err) => {
+      appExited = true;
+      if (spawnFailure === void 0) {
+        spawnFailure = new OrchestratorSpawnError(
+          `Could not start the dev command (${appCommand}): ${err.message}`
+        );
+      }
+      arbiter.observeChildExit(1, null);
+      if (!listenExited) {
+        listen.kill("SIGTERM");
+        startDrain();
+      }
+      finishIfDone();
+    };
+    const onListenError = (err) => {
+      listenExited = true;
+      if (spawnFailure === void 0) {
+        spawnFailure = new OrchestratorSpawnError(
+          `Could not start the webhook listener: ${err.message}`,
+          "The bundled webhook listener could not be started; re-install the CLI if this persists."
+        );
+      }
+      arbiter.observeChildExit(1, null);
+      if (!appExited) {
+        app.kill("SIGTERM");
+        startDrain();
+      }
+      finishIfDone();
+    };
+    const onSignal = (sig) => {
+      trace(`signal received: ${sig}`);
+      if (arbiter.shutdownInitiated) {
+        if (firstSignalAt === 0) {
+          firstSignalAt = Date.now();
+          return;
+        }
+        if (Date.now() - firstSignalAt <= SIGNAL_FORCE_EXIT_WINDOW_MS) {
+          options.hardExit(130);
+        }
+        return;
+      }
+      firstSignalAt = Date.now();
+      arbiter.observeSignal(sig);
+      io.writeErr("shutting down: stopping the dev command and the webhook listener\n");
+      if (!appExited) {
+        app.kill("SIGTERM");
+      }
+      if (!listenExited) {
+        listen.kill("SIGTERM");
+      }
+      startDrain();
+    };
+    const onSigint = () => onSignal("SIGINT");
+    const onSigterm = () => onSignal("SIGTERM");
+    options.signalSource.on("SIGINT", onSigint);
+    options.signalSource.on("SIGTERM", onSigterm);
+    app.once("exit", onAppExit);
+    app.once("error", onAppError);
+    listen.once("exit", onListenExit);
+    listen.once("error", onListenError);
+    trace(`preview: onDevServerReady(${options.devServerPort ?? 0})`);
+    void options.preview.onDevServerReady(options.devServerPort ?? 0).catch((err) => fail(err));
+  });
+}
+
+// src/lib/preview/types.ts
+var NullPreviewController = class {
+  async onDevServerReady(_port) {
+  }
+  async onShutdown() {
+  }
+};
+
+// src/lib/preview/index.ts
+function createPreviewController() {
+  return new NullPreviewController();
+}
+
+// src/lib/ratio-command.ts
+import { Command, Errors } from "@oclif/core";
+
+// src/lib/render-error.ts
+function isOclifParserError(err) {
+  return err instanceof Error && "parse" in err && err.parse !== null && err.parse !== void 0;
+}
+function buildErrorEnvelope(code, message, hint, docsUrl) {
+  const obj = { ok: false, code, message };
+  if (hint !== void 0) obj["hint"] = hint;
+  if (docsUrl !== void 0) obj["docsUrl"] = docsUrl;
+  return JSON.stringify(obj) + "\n";
+}
+function renderError(input) {
+  const { err, verbose, json } = input;
+  if (isRatioCLIError(err)) {
+    const ratioErr = err;
+    if (ratioErr.exitCode === 0) {
+      if (json) {
+        return {
+          stdout: JSON.stringify({ ok: true, data: null }) + "\n",
+          stderr: "",
+          exitCode: 0
+        };
+      }
+      return {
+        stdout: ratioErr.message + "\n",
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    let stderrLines = `${ratioErr.code}: ${ratioErr.message}
+`;
+    if (ratioErr.hint !== void 0) stderrLines += `${ratioErr.hint}
+`;
+    if (ratioErr.docsUrl !== void 0) stderrLines += `${ratioErr.docsUrl}
+`;
+    if (json) {
+      return {
+        stdout: buildErrorEnvelope(ratioErr.code, ratioErr.message, ratioErr.hint, ratioErr.docsUrl),
+        stderr: verbose && ratioErr.stack ? ratioErr.stack + "\n" : "",
+        exitCode: ratioErr.exitCode
+      };
+    }
+    if (verbose && ratioErr.stack) {
+      stderrLines += ratioErr.stack + "\n";
+    }
+    return { stdout: "", stderr: stderrLines, exitCode: ratioErr.exitCode };
+  }
+  if (isOclifParserError(err)) {
+    const parserErr = err;
+    const msg = parserErr.message || "Unknown parse error";
+    const coercedErr = new ValidationError(msg);
+    let stderrText2 = `${coercedErr.code}: ${msg}
+`;
+    if (json) {
+      return {
+        stdout: buildErrorEnvelope(coercedErr.code, msg),
+        stderr: verbose && parserErr.stack ? parserErr.stack + "\n" : "",
+        exitCode: 8
+      };
+    }
+    if (verbose && parserErr.stack) {
+      stderrText2 += parserErr.stack + "\n";
+    }
+    return { stdout: "", stderr: stderrText2, exitCode: 8 };
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  const stack = err instanceof Error ? err.stack : void 0;
+  const stderrPrefix = `INTERNAL: ${message}
+`;
+  if (json) {
+    return {
+      stdout: buildErrorEnvelope("INTERNAL", message),
+      stderr: verbose && stack ? stack + "\n" : "",
+      exitCode: 1
+    };
+  }
+  let stderrText = stderrPrefix;
+  if (verbose && stack) {
+    stderrText += stack + "\n";
+  }
+  return { stdout: "", stderr: stderrText, exitCode: 1 };
+}
+
+// src/lib/ratio-command.ts
+var RatioCommand = class extends Command {
+  _getRenderFlags() {
+    const argv = this.argv;
+    return {
+      verbose: argv.includes("--verbose"),
+      json: argv.includes("--json")
+    };
+  }
+  async catch(err) {
+    const { verbose, json } = this._getRenderFlags();
+    const output = renderError({ err, verbose, json });
+    if (output.stdout) process.stdout.write(output.stdout);
+    if (output.stderr) process.stderr.write(output.stderr);
+    if (output.exitCode === 0) {
+      throw new Errors.ExitError(0);
+    }
+    err.skipOclifErrorHandling = true;
+    err.oclif = { exit: output.exitCode };
+    throw err;
+  }
+};
+
+// src/lib/verbose-flag.ts
+import { Flags } from "@oclif/core";
+var verboseFlag = {
+  verbose: Flags.boolean({
+    description: "Show diagnostic detail: HTTP status/timing lines for auth requests (stderr) and stack traces for internal errors."
+  })
+};
+var jsonFlag = {
+  json: Flags.boolean({
+    description: "Emit machine-readable JSON on stdout."
+  })
+};
+
+// src/commands/app/dev.ts
+var AppDev = class _AppDev extends RatioCommand {
+  static description = `Run the current app locally: starts the manifest's dev command and a webhook listener side by side with prefixed logs from both.
+
+Reads ratio.config.jsonc from the current directory ("devCommand" is required; "devServerPort" is optional and, when set, is passed to your dev command as PORT). If either process stops, the other is shut down and the failing exit code is propagated. Ctrl+C stops both cleanly.
+
+Exit codes: 0 success; 3 not signed in; 5 network failure; 8 invalid configuration; 10 a child process could not be started; 11 a child had to be forcibly terminated during shutdown; 130/143 interrupted or terminated.`;
+  static examples = [
+    "<%= config.bin %> app dev",
+    "<%= config.bin %> app dev --verbose"
+  ];
+  static flags = {
+    ...verboseFlag
+  };
+  // ── Seams: overridable in tests; defaults hit the real process. ──────────
+  writeOut = (chunk) => {
+    process.stdout.write(chunk);
+  };
+  writeErr = (chunk) => {
+    process.stderr.write(chunk);
+  };
+  signalSource = process;
+  hardExit = (code) => {
+    process.exit(code);
+  };
+  getCwd = () => process.cwd();
+  envReader = () => process.env;
+  /** Test seam: spawner for the app child (real spawn when undefined). */
+  spawnApp;
+  /** Test seam: spawner for the listener child (real spawn when undefined). */
+  spawnListen;
+  /** Test seam: SIGTERM → SIGKILL grace override (default drain when undefined). */
+  drainMs;
+  async run() {
+    const { flags } = await this.parse(_AppDev);
+    const cwd = this.getCwd();
+    const env = this.envReader();
+    const manifest = readManifest(cwd);
+    const appArgv = tokenizeDevCommand(manifest.devCommand);
+    const preview = createPreviewController();
+    const code = await orchestrate({
+      appArgv,
+      devServerPort: manifest.devServerPort,
+      cwd,
+      env,
+      preview,
+      verbose: flags.verbose === true,
+      io: {
+        writeOut: (chunk) => this.writeOut(chunk),
+        writeErr: (chunk) => this.writeErr(chunk)
+      },
+      signalSource: this.signalSource,
+      hardExit: (exitCode) => this.hardExit(exitCode),
+      ...this.spawnApp !== void 0 ? { spawnApp: this.spawnApp } : {},
+      ...this.spawnListen !== void 0 ? { spawnListen: this.spawnListen } : {},
+      ...this.drainMs !== void 0 ? { drainMs: this.drainMs } : {}
+    });
+    if (code !== 0) {
+      this.hardExit(code);
+    }
+  }
+};
+export {
+  AppDev as default
+};
+//# sourceMappingURL=dev.js.map