@linghun/tools 0.1.2 → 0.1.3

package/dist/chunk-236QJATI.js

@@ -0,0 +1,678 @@
+// src/tools/Bash/service-kernel.ts
+import { spawn } from "child_process";
+import { createWriteStream } from "fs";
+import { readFile } from "fs/promises";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+import { connect as connectTcp } from "net";
+import { randomUUID } from "crypto";
+var DEFAULT_READY_TIMEOUT_MS = 1e4;
+var DEFAULT_READY_INTERVAL_MS = 100;
+var CONNECT_ATTEMPT_TIMEOUT_MS = 500;
+var FETCH_BODY_LIMIT_BYTES = 64e3;
+var MAX_MANAGED_SERVICES = 20;
+var DEFAULT_LOG_TAIL_BYTES = 4e3;
+var STOP_TERM_WAIT_MS = 900;
+var STOP_KILL_WAIT_MS = 500;
+async function startBashService(input) {
+  const startedAt = Date.now();
+  const startedAtIso = new Date(startedAt).toISOString();
+  const serviceId = `svc_${randomUUID()}`;
+  const detached = process.platform !== "win32";
+  const child = spawn(input.command, {
+    cwd: input.cwd,
+    shell: true,
+    windowsHide: true,
+    detached
+  });
+  const log = createWriteStream(input.fullOutputPath, { flags: "w" });
+  let closed = false;
+  let exitCode = null;
+  let signalCode = null;
+  let lastOutput = "";
+  let logClosed = false;
+  const targetFields = readReadinessTargetFields(input.readiness);
+  const serviceRecord = {
+    serviceId,
+    pid: child.pid,
+    cwd: input.cwd,
+    command: input.logCommand,
+    logPath: input.fullOutputPath,
+    ...targetFields,
+    readiness: input.readiness,
+    ready: false,
+    startedAt: startedAtIso,
+    updatedAt: startedAtIso,
+    lastOutputTail: "",
+    status: "starting",
+    process: child,
+    detached
+  };
+  rememberManagedService(input.context, serviceRecord);
+  const writeLog = (stream, text2) => {
+    const sanitized = input.sanitizeText(text2);
+    lastOutput = `${lastOutput}${sanitized}`.slice(-2e3);
+    updateManagedService(serviceRecord, {
+      lastOutputTail: lastOutput
+    });
+    if (!logClosed) {
+      log.write(`[${stream}] ${sanitized}`);
+      input.onProgress?.(stream, text2);
+    }
+  };
+  log.write(`$ ${input.sanitizeText(input.logCommand)}
+`);
+  log.write(`service cwd ${input.cwd}
+`);
+  child.stdout?.on("data", (chunk) => writeLog("stdout", chunk.toString("utf8")));
+  child.stderr?.on("data", (chunk) => writeLog("stderr", chunk.toString("utf8")));
+  child.on("close", (code, signal) => {
+    closed = true;
+    exitCode = code;
+    signalCode = signal;
+    updateManagedService(serviceRecord, {
+      ready: false,
+      status: serviceRecord.status === "stopped" ? "stopped" : "exited",
+      exitCode: code,
+      signalCode: signal
+    });
+    if (!logClosed) {
+      log.write(`
+service process closed exitCode=${code ?? "null"} signal=${signal ?? "null"}
+`);
+    }
+  });
+  child.on("error", (error) => {
+    closed = true;
+    exitCode = 1;
+    updateManagedService(serviceRecord, { ready: false, status: "error", exitCode: 1 });
+    writeLog("system", `service spawn error: ${error.message}
+`);
+  });
+  const trackOptions = {
+    detached,
+    cwd: input.cwd,
+    label: `BashService:${input.command.slice(0, 80)}`,
+    retainAfterExit: true
+  };
+  input.trackChildProcess?.(child, trackOptions);
+  const abort = () => {
+    writeLog("system", "service start cancelled; terminating process.\n");
+    child.kill();
+  };
+  input.abortSignal?.addEventListener("abort", abort, { once: true });
+  const ready = await waitForReadiness(input.readiness, () => ({
+    closed,
+    exitCode,
+    signalCode,
+    lastOutput
+  }));
+  input.abortSignal?.removeEventListener("abort", abort);
+  logClosed = true;
+  log.end(() => {
+    logClosed = true;
+  });
+  const pid = child.pid;
+  const alive = isChildAlive(child, closed);
+  const readinessTarget = formatReadinessTarget(input.readiness);
+  updateManagedService(serviceRecord, {
+    ready: ready.ok,
+    status: ready.ok ? "ready" : alive ? "not_ready" : "exited",
+    lastProbeAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const diagnostics = ready.ok ? [] : [
+    createServiceReadinessDiagnostic(
+      ready.evidence,
+      alive ? "Service process is running but readiness did not pass; inspect the log and retry bounded readiness checks." : "Service process exited before readiness; inspect the log before retrying.",
+      targetFields
+    )
+  ];
+  const text = [
+    ready.ok ? "Service started and ready." : "Service readiness failed.",
+    `serviceId ${serviceId}`,
+    `pid ${pid ?? "unknown"}`,
+    `cwd ${input.cwd}`,
+    `ready ${readinessTarget}`,
+    `alive ${alive ? "yes" : "no"}`,
+    `elapsedMs ${Date.now() - startedAt}`,
+    `log ${input.fullOutputPath}`,
+    ready.evidence ? `evidence ${ready.evidence}` : ""
+  ].filter(Boolean).join("\n");
+  return {
+    text,
+    details: [
+      `fullOutputPath: ${input.fullOutputPath}`,
+      `command: ${input.sanitizeText(input.logCommand)}`,
+      `serviceId: ${serviceId}`,
+      `pid: ${pid ?? "unknown"}`,
+      `cwd: ${input.cwd}`,
+      `ready: ${readinessTarget}`,
+      `alive: ${alive ? "yes" : "no"}`,
+      `evidence: ${ready.evidence}`
+    ].join("\n"),
+    data: {
+      exitCode: ready.ok ? 0 : 1,
+      outcome: ready.ok ? "service_ready" : alive ? "service_not_ready" : "service_exited",
+      service: {
+        serviceId,
+        pid,
+        command: input.logCommand,
+        cwd: input.cwd,
+        logPath: input.fullOutputPath,
+        status: ready.ok ? "ready" : alive ? "not_ready" : "exited",
+        ready: ready.ok,
+        target: targetFields.target,
+        targetHost: targetFields.targetHost,
+        targetPort: targetFields.targetPort,
+        alive,
+        readiness: {
+          ok: ready.ok,
+          target: readinessTarget,
+          elapsedMs: ready.elapsedMs,
+          evidence: ready.evidence
+        }
+      },
+      ...diagnostics.length > 0 ? { diagnostics } : {}
+    },
+    fullOutputPath: input.fullOutputPath
+  };
+}
+async function runBashServiceLifecycleAction(action, context) {
+  if (action.action === "fetch") {
+    return runServiceFetchCheck(action);
+  }
+  const service = findManagedService(context, action.serviceId);
+  if (!service) {
+    return serviceActionOutput({
+      action: action.action,
+      serviceId: action.serviceId,
+      outcome: "service_missing",
+      text: `Service ${action.serviceId} is not registered by Linghun.`,
+      service: { serviceId: action.serviceId, status: "missing", ready: false }
+    });
+  }
+  if (action.action === "status") {
+    refreshManagedServiceStatus(service);
+    return serviceActionOutput({
+      action: action.action,
+      serviceId: service.serviceId,
+      outcome: service.status === "ready" ? "service_ready" : `service_${service.status}`,
+      text: formatServiceStatusText(service),
+      service: serializeManagedService(service)
+    });
+  }
+  if (action.action === "probe") {
+    refreshManagedServiceStatus(service);
+    const probe = service.status === "exited" || service.status === "stopped" ? { ok: false, evidence: `service ${service.serviceId} is ${service.status}` } : await probeReadiness(service.readiness);
+    updateManagedService(service, {
+      ready: probe.ok,
+      status: probe.ok ? "ready" : service.status === "exited" || service.status === "stopped" ? service.status : "not_ready",
+      lastProbeAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const diagnostics = probe.ok ? [] : [
+      createServiceReadinessDiagnostic(
+        probe.evidence,
+        "Service lifecycle probe did not pass; inspect logs or stop/restart the registered service.",
+        service
+      )
+    ];
+    return serviceActionOutput({
+      action: action.action,
+      serviceId: service.serviceId,
+      outcome: probe.ok ? "service_ready" : "service_not_ready",
+      text: [
+        `Service probe ${probe.ok ? "ready" : "not-ready"}.`,
+        `serviceId ${service.serviceId}`,
+        `target ${service.target ?? formatReadinessTarget(service.readiness)}`,
+        `evidence ${probe.evidence}`
+      ].join("\n"),
+      service: { ...serializeManagedService(service), evidence: probe.evidence },
+      diagnostics
+    });
+  }
+  if (action.action === "logs") {
+    const tail = await readServiceTail(service, action.tailBytes ?? DEFAULT_LOG_TAIL_BYTES);
+    return serviceActionOutput({
+      action: action.action,
+      serviceId: service.serviceId,
+      outcome: "service_logs",
+      text: [
+        `Service logs tail.`,
+        `serviceId ${service.serviceId}`,
+        `status ${service.status}`,
+        tail ? `tail
+${tail}` : "tail <empty>"
+      ].join("\n"),
+      service: { ...serializeManagedService(service), logTail: tail }
+    });
+  }
+  refreshManagedServiceStatus(service);
+  if (service.status === "exited" || service.status === "stopped") {
+    return serviceActionOutput({
+      action: action.action,
+      serviceId: service.serviceId,
+      outcome: `service_${service.status}`,
+      text: `Service ${service.serviceId} is already ${service.status}.`,
+      service: serializeManagedService(service)
+    });
+  }
+  const stop = await stopManagedService(service);
+  refreshManagedServiceStatus(service);
+  if (!stop.stopped) {
+    updateManagedService(service, { ready: false, status: "not_ready" });
+    return serviceActionOutput({
+      action: action.action,
+      serviceId: service.serviceId,
+      outcome: "service_stop_failed",
+      text: [
+        "Service stop failed.",
+        `serviceId ${service.serviceId}`,
+        `pid ${service.pid ?? "unknown"}`,
+        `evidence ${stop.evidence}`
+      ].join("\n"),
+      service: { ...serializeManagedService(service), evidence: stop.evidence },
+      diagnostics: [
+        createServiceReadinessDiagnostic(
+          stop.evidence,
+          "Linghun could not confirm that the registered service stopped; inspect the process before retrying.",
+          service
+        )
+      ]
+    });
+  }
+  updateManagedService(service, { ready: false, status: "stopped" });
+  return serviceActionOutput({
+    action: action.action,
+    serviceId: service.serviceId,
+    outcome: "service_stopped",
+    text: [
+      "Service stopped.",
+      `serviceId ${service.serviceId}`,
+      `pid ${service.pid ?? "unknown"}`
+    ].join("\n"),
+    service: serializeManagedService(service)
+  });
+}
+async function runServiceFetchCheck(action) {
+  const startedAt = Date.now();
+  const retry = Math.max(0, Math.min(action.retry ?? 0, 10));
+  const intervalMs = Math.max(0, Math.min(action.intervalMs ?? DEFAULT_READY_INTERVAL_MS, 5e3));
+  let result = { ok: false, evidence: `http ${action.url} not attempted`, body: "" };
+  for (let attempt = 0; attempt <= retry; attempt += 1) {
+    result = await fetchHttp(action.url, action.timeoutMs ?? CONNECT_ATTEMPT_TIMEOUT_MS);
+    const statusOk = action.expectStatus === void 0 ? result.status !== void 0 && result.status >= 200 && result.status < 400 : result.status === action.expectStatus;
+    const requiredBody = normalizeStringList(action.bodyContains);
+    const missingBody = requiredBody.filter((item) => !result.body.includes(item));
+    if (result.ok && statusOk && missingBody.length === 0) {
+      return serviceFetchOutput(action, result, [], Date.now() - startedAt, missingBody);
+    }
+    result = {
+      ...result,
+      ok: false,
+      evidence: [
+        result.evidence,
+        statusOk ? "" : `expected status ${action.expectStatus ?? "2xx/3xx"}`,
+        missingBody.length > 0 ? `missing body ${missingBody.join(", ")}` : ""
+      ].filter(Boolean).join("; ")
+    };
+    if (attempt < retry) await delay(intervalMs);
+  }
+  const target = readReadinessTargetFields({ type: "http", url: action.url });
+  return serviceFetchOutput(
+    action,
+    result,
+    [
+      createServiceReadinessDiagnostic(
+        result.evidence,
+        "Explicit service fetch check failed; inspect the registered service or served index before final verification.",
+        target
+      )
+    ],
+    Date.now() - startedAt,
+    normalizeStringList(action.bodyContains).filter((item) => !result.body.includes(item))
+  );
+}
+function fetchHttp(url, timeoutMs) {
+  return new Promise((resolve) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      resolve({ ok: false, evidence: `invalid fetch url: ${url}`, body: "" });
+      return;
+    }
+    const request = (parsed.protocol === "https:" ? httpsRequest : httpRequest)(
+      parsed,
+      { method: "GET", timeout: Math.max(1, timeoutMs) },
+      (response) => {
+        const chunks = [];
+        let size = 0;
+        response.on("data", (chunk) => {
+          if (size >= FETCH_BODY_LIMIT_BYTES) return;
+          const remaining = FETCH_BODY_LIMIT_BYTES - size;
+          chunks.push(chunk.subarray(0, remaining));
+          size += Math.min(chunk.length, remaining);
+        });
+        response.on("end", () => {
+          const status = response.statusCode ?? 0;
+          const body = Buffer.concat(chunks).toString("utf8");
+          resolve({
+            ok: status >= 200 && status < 400,
+            status,
+            body,
+            evidence: `http ${url} status ${status}`
+          });
+        });
+      }
+    );
+    request.once("timeout", () => {
+      request.destroy();
+      resolve({ ok: false, evidence: `http ${url} timed out`, body: "" });
+    });
+    request.once("error", (error) => resolve({ ok: false, evidence: `http ${url} failed: ${error.message}`, body: "" }));
+    request.end();
+  });
+}
+function serviceFetchOutput(action, result, diagnostics, elapsedMs, missingBody) {
+  const target = readReadinessTargetFields({ type: "http", url: action.url });
+  return {
+    text: [
+      `Service fetch ${diagnostics.length === 0 ? "ready" : "not-ready"}.`,
+      `target ${action.url}`,
+      `status ${result.status ?? "unknown"}`,
+      `elapsedMs ${elapsedMs}`,
+      `evidence ${result.evidence}`,
+      missingBody.length > 0 ? `missingBody ${missingBody.join(", ")}` : ""
+    ].filter(Boolean).join("\n"),
+    data: {
+      exitCode: diagnostics.length === 0 ? 0 : 1,
+      outcome: diagnostics.length === 0 ? "service_ready" : "service_not_ready",
+      service: {
+        ...target,
+        ready: diagnostics.length === 0,
+        status: diagnostics.length === 0 ? "ready" : "not_ready",
+        fetch: {
+          status: result.status,
+          expectedStatus: action.expectStatus,
+          bodyContains: normalizeStringList(action.bodyContains),
+          missingBody
+        }
+      },
+      ...diagnostics.length > 0 ? { diagnostics } : {}
+    }
+  };
+}
+async function waitForReadiness(readiness, processState) {
+  const startedAt = Date.now();
+  const timeoutMs = readiness.timeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+  const intervalMs = readiness.intervalMs ?? DEFAULT_READY_INTERVAL_MS;
+  const deadline = startedAt + timeoutMs;
+  let lastEvidence = "";
+  while (Date.now() <= deadline) {
+    const state = processState();
+    if (state.closed) {
+      return {
+        ok: false,
+        evidence: `service process exited before readiness exitCode=${state.exitCode ?? "null"} signal=${state.signalCode ?? "null"} tail=${state.lastOutput.replace(/\s+/gu, " ").trim()}`,
+        elapsedMs: Date.now() - startedAt
+      };
+    }
+    const probe = readiness.type === "tcp" ? await probeTcp(readiness.host ?? "127.0.0.1", readiness.port) : await probeHttp(readiness.url);
+    if (probe.ok) {
+      return { ok: true, evidence: probe.evidence, elapsedMs: Date.now() - startedAt };
+    }
+    lastEvidence = probe.evidence;
+    await delay(Math.min(intervalMs, Math.max(0, deadline - Date.now())));
+  }
+  return {
+    ok: false,
+    evidence: `readiness timed out after ${timeoutMs}ms: ${lastEvidence || formatReadinessTarget(readiness)}`,
+    elapsedMs: Date.now() - startedAt
+  };
+}
+function probeTcp(host, port) {
+  return new Promise((resolve) => {
+    const socket = connectTcp({ host, port });
+    const finish = (ok, evidence) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve({ ok, evidence });
+    };
+    socket.setTimeout(CONNECT_ATTEMPT_TIMEOUT_MS);
+    socket.once("connect", () => finish(true, `tcp ${host}:${port} accepted connection`));
+    socket.once("timeout", () => finish(false, `tcp ${host}:${port} connection timed out`));
+    socket.once("error", (error) => finish(false, `tcp ${host}:${port} failed: ${error.message}`));
+  });
+}
+function probeHttp(url) {
+  return new Promise((resolve) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      resolve({ ok: false, evidence: `invalid health url: ${url}` });
+      return;
+    }
+    const request = (parsed.protocol === "https:" ? httpsRequest : httpRequest)(
+      parsed,
+      { method: "GET", timeout: CONNECT_ATTEMPT_TIMEOUT_MS },
+      (response) => {
+        response.resume();
+        const status = response.statusCode ?? 0;
+        resolve({
+          ok: status >= 200 && status < 400,
+          evidence: `http ${url} status ${status}`
+        });
+      }
+    );
+    request.once("timeout", () => {
+      request.destroy();
+      resolve({ ok: false, evidence: `http ${url} timed out` });
+    });
+    request.once("error", (error) => resolve({ ok: false, evidence: `http ${url} failed: ${error.message}` }));
+    request.end();
+  });
+}
+function probeReadiness(readiness) {
+  return readiness.type === "tcp" ? probeTcp(readiness.host ?? "127.0.0.1", readiness.port) : probeHttp(readiness.url);
+}
+function isChildAlive(child, closed) {
+  return !closed && child.exitCode === null && child.signalCode === null;
+}
+function createServiceReadinessDiagnostic(evidence, suggestion, target) {
+  return {
+    type: "service_readiness",
+    severity: "recoverable",
+    evidence,
+    suggestion,
+    ...target?.target ? { target: target.target } : {},
+    ...target?.targetHost ? { targetHost: target.targetHost } : {},
+    ...target?.targetPort !== void 0 ? { targetPort: target.targetPort } : {}
+  };
+}
+function formatReadinessTarget(readiness) {
+  if (readiness.type === "tcp") {
+    return `tcp://${readiness.host ?? "127.0.0.1"}:${readiness.port}`;
+  }
+  return readiness.url;
+}
+function readReadinessTargetFields(readiness) {
+  if (readiness.type === "tcp") {
+    const host = readiness.host ?? "127.0.0.1";
+    return {
+      target: `${host}:${readiness.port}`,
+      targetHost: host,
+      targetPort: readiness.port
+    };
+  }
+  try {
+    const url = new URL(readiness.url);
+    const port = Number(url.port || (url.protocol === "https:" ? 443 : 80));
+    return {
+      target: readiness.url,
+      targetHost: url.hostname,
+      targetPort: Number.isInteger(port) ? port : void 0
+    };
+  } catch {
+    return { target: readiness.url };
+  }
+}
+function rememberManagedService(context, record) {
+  context.services = [
+    record,
+    ...(context.services ?? []).filter((item) => item.serviceId !== record.serviceId)
+  ].slice(0, MAX_MANAGED_SERVICES);
+}
+function findManagedService(context, serviceId) {
+  return (context.services ?? []).find((service) => service.serviceId === serviceId);
+}
+function updateManagedService(service, patch) {
+  Object.assign(service, patch, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function refreshManagedServiceStatus(service) {
+  if (service.status === "stopped") return;
+  if (service.process && !isChildAlive(service.process, service.status === "exited")) {
+    updateManagedService(service, {
+      ready: false,
+      status: "exited",
+      exitCode: service.process.exitCode,
+      signalCode: service.process.signalCode
+    });
+  }
+}
+function serializeManagedService(service) {
+  const alive = service.process ? isChildAlive(service.process, service.status === "exited") : false;
+  return {
+    serviceId: service.serviceId,
+    pid: service.pid,
+    cwd: service.cwd,
+    command: service.command,
+    logPath: service.logPath,
+    target: service.target,
+    targetHost: service.targetHost,
+    targetPort: service.targetPort,
+    readiness: {
+      type: service.readiness.type,
+      target: formatReadinessTarget(service.readiness)
+    },
+    ready: service.ready,
+    alive,
+    status: service.status,
+    startedAt: service.startedAt,
+    updatedAt: service.updatedAt,
+    lastProbeAt: service.lastProbeAt,
+    lastOutputTail: service.lastOutputTail,
+    exitCode: service.exitCode,
+    signalCode: service.signalCode
+  };
+}
+function formatServiceStatusText(service) {
+  return [
+    `Service status ${service.status}.`,
+    `serviceId ${service.serviceId}`,
+    `pid ${service.pid ?? "unknown"}`,
+    `ready ${service.ready ? "yes" : "no"}`,
+    `target ${service.target ?? formatReadinessTarget(service.readiness)}`,
+    `log ${service.logPath}`
+  ].join("\n");
+}
+function serviceActionOutput(input) {
+  return {
+    text: input.text,
+    details: input.text,
+    data: {
+      exitCode: input.diagnostics && input.diagnostics.length > 0 ? 1 : 0,
+      outcome: input.outcome,
+      service: input.service,
+      ...input.diagnostics && input.diagnostics.length > 0 ? { diagnostics: input.diagnostics } : {}
+    }
+  };
+}
+async function readServiceTail(service, tailBytes) {
+  const boundedBytes = Math.max(1, Math.min(tailBytes, 16e3));
+  let diskTail = "";
+  try {
+    const text = await readFile(service.logPath, "utf8");
+    diskTail = text.slice(-boundedBytes);
+  } catch {
+    diskTail = "";
+  }
+  const combined = `${diskTail}${service.lastOutputTail ? `
+${service.lastOutputTail}` : ""}`;
+  return combined.replace(/\0/g, "").slice(-boundedBytes);
+}
+async function stopManagedService(service) {
+  if (process.platform === "win32" && service.pid) {
+    await taskkillWindowsPid(service.pid);
+    const stopped = await waitForServiceExit(service, STOP_KILL_WAIT_MS);
+    return {
+      stopped,
+      evidence: stopped ? `taskkill confirmed service ${service.serviceId} stopped` : `taskkill did not confirm service ${service.serviceId} stopped`
+    };
+  }
+  if (service.detached && service.pid) {
+    try {
+      process.kill(-service.pid, "SIGTERM");
+      if (await waitForServiceExit(service, STOP_TERM_WAIT_MS)) {
+        return { stopped: true, evidence: `SIGTERM process group ${service.pid} confirmed stopped` };
+      }
+    } catch {
+    }
+  } else {
+    service.process?.kill("SIGTERM");
+    if (await waitForServiceExit(service, STOP_TERM_WAIT_MS)) {
+      return { stopped: true, evidence: `SIGTERM pid ${service.pid ?? "unknown"} confirmed stopped` };
+    }
+  }
+  if (service.detached && service.pid) {
+    try {
+      process.kill(-service.pid, "SIGKILL");
+    } catch {
+      service.process?.kill("SIGKILL");
+    }
+  } else {
+    service.process?.kill("SIGKILL");
+  }
+  if (await waitForServiceExit(service, STOP_KILL_WAIT_MS)) {
+    return { stopped: true, evidence: `SIGKILL pid ${service.pid ?? "unknown"} confirmed stopped` };
+  }
+  return { stopped: false, evidence: `service ${service.serviceId} still appears alive after SIGTERM/SIGKILL` };
+}
+async function waitForServiceExit(service, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    refreshManagedServiceStatus(service);
+    if (service.status === "exited" || service.status === "stopped") return true;
+    if (!service.process || !isChildAlive(service.process, false)) return true;
+    await delay(50);
+  }
+  refreshManagedServiceStatus(service);
+  return service.status === "exited" || service.status === "stopped" || !service.process || !isChildAlive(service.process, false);
+}
+function taskkillWindowsPid(pid) {
+  return new Promise((resolve) => {
+    const killer = spawn("taskkill", ["/pid", String(pid), "/t", "/f"], { windowsHide: true });
+    const timeout = setTimeout(() => {
+      killer.kill("SIGKILL");
+      resolve();
+    }, 1e3);
+    const finish = () => {
+      clearTimeout(timeout);
+      resolve();
+    };
+    killer.once("error", finish);
+    killer.once("close", finish);
+  });
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeStringList(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+export {
+  startBashService,
+  runBashServiceLifecycleAction
+};

package/dist/{chunk-VZWMPUSS.js → chunk-2DIXRINW.js}

@@ -1,6 +1,6 @@
 import {
   prompt
-} from "./chunk-E75PYM7V.js";
+} from "./chunk-PKMIDA5A.js";
 import {
   userFacingName
 } from "./chunk-GAWMEMXB.js";