@mycadet/cli 0.12.10 → 0.12.11

package/src/lib/tunnels/cloudflare.ts

@@ -1,4 +1,11 @@
-import type { ProviderMeta, ProviderTunnelResult } from "../tunnel.js";
+import { clearRootProcess, stampRootProcess } from "../assistant-config.js";
+import { readProcessCommandLine } from "../process.js";
+import { stopOwnedTunnelAgent } from "./process-lifecycle.js";
+import type {
+  TunnelProvider,
+  ProviderMeta,
+  ProviderTunnelResult,
+} from "../tunnel.js";
 
 import { execFileSync, spawn, type ChildProcess } from "node:child_process";
 
@@ -106,6 +113,7 @@ export function waitForCloudflareTunnelUrl(
     });
 
     child.on("exit", (code) => {
+      if (child.pid) clearRootProcess("tunnel", child.pid);
       if (resolved) return;
       clearTimeout(timer);
       reject(
@@ -177,6 +185,7 @@ export async function runCloudflareTunnel(
 
   const cleanup = (): void => {
     if (!child.killed) child.kill("SIGTERM");
+    if (child.pid) clearRootProcess("tunnel", child.pid);
     if (publicUrl) {
       console.log("\nClearing ingress URL from config...");
       clearIngressUrl(workspaceDir, opts.assistantId);
@@ -198,6 +207,7 @@ export async function runCloudflareTunnel(
   });
 
   child.on("exit", (code) => {
+    if (child.pid) clearRootProcess("tunnel", child.pid);
     // Always clear the saved ingress URL when the tunnel process ends so
     // webhook integrations don't keep hitting a dead endpoint.
     if (publicUrl !== undefined) {
@@ -233,6 +243,13 @@ export async function runCloudflareTunnel(
   console.log("");
 
   saveIngressUrl(workspaceDir, publicUrl, opts.assistantId, "cloudflare");
+  if (child.pid)
+    stampRootProcess("tunnel", {
+      pid: child.pid,
+      provider: "cloudflare",
+      assistantId: opts.assistantId,
+      startedAt: new Date().toISOString(),
+    });
   console.log("Ingress URL saved to config.");
   console.log("");
   console.log("Press Ctrl+C to stop the tunnel and clear the ingress URL.");
@@ -251,3 +268,21 @@ export const CLOUDFLARE_TUNNEL_META: ProviderMeta = {
   notes: ["No Cloudflare account required for quick tunnels."],
   supportsReservedDomain: false,
 };
+
+export const CLOUDFLARE_PROVIDER: TunnelProvider = {
+  run: runCloudflareTunnel,
+  stop: (opts) =>
+    stopOwnedTunnelAgent(
+      opts,
+      (pid) => {
+        try {
+          return /(?:^|[\\/\s])cloudflared(?:\.exe)?(?:\s|$)/i.test(
+            readProcessCommandLine(pid),
+          );
+        } catch {
+          return false;
+        }
+      },
+      "cloudflared",
+    ),
+};

package/src/lib/tunnels/ngrok.ts

@@ -25,7 +25,12 @@ import { getCurrentEnvironment } from "../environments/resolve.js";
 import { loopbackSafeFetch } from "../loopback-fetch.js";
 import { readProcessCommandLine } from "../process.js";
 import { z } from "zod";
-import type { ProviderMeta, ProviderTunnelResult } from "../tunnel.js";
+import { stopOwnedTunnelAgent } from "./process-lifecycle.js";
+import type {
+  TunnelProvider,
+  ProviderMeta,
+  ProviderTunnelResult,
+} from "../tunnel.js";
 import { notifyGatewayOfPublicUrl } from "./gateway-notify.js";
 
 const NGROK_API_URL = "http://127.0.0.1:4040/api/tunnels";
@@ -631,8 +636,12 @@ export async function runNgrokTunnel(
     console.log("Ingress URL saved to config.");
     console.log("");
     console.log(
-      "Tunnel is already running. Press Ctrl+C to detach (tunnel stays active).",
+      `An ngrok agent from an earlier run is still up serving 127.0.0.1:${port} (${existingUrl}) — this run adopts it instead of starting a new agent.`,
     );
+    console.log(
+      "Adopted agents do not appear in `cadet ps` because this run does not own the process.",
+    );
+    console.log("Press Ctrl+C to detach (tunnel stays active).");
 
     // Block until SIGINT/SIGTERM
     const waitForExit = new Promise<void>((resolve) => {
@@ -783,3 +792,8 @@ export async function runNgrokTunnel(
   // Unreachable: the loop only exits via return, process.exit, or a throw.
   throw new Error("ngrok tunnel did not start.");
 }
+
+export const NGROK_PROVIDER: TunnelProvider = {
+  run: runNgrokTunnel,
+  stop: (opts) => stopOwnedTunnelAgent(opts, isNgrokProcess, "ngrok"),
+};

package/src/lib/tunnels/process-lifecycle.ts

@@ -0,0 +1,26 @@
+import { clearIngressUrl } from "../ingress-config.js";
+import { stopProcess } from "../process.js";
+import type { ProviderStopOptions } from "../tunnel.js";
+
+/** Stop only an identified provider process and retain state on termination failure. */
+export async function stopOwnedTunnelAgent(
+  opts: ProviderStopOptions,
+  matches: (pid: number) => boolean,
+  label: string,
+): Promise<boolean> {
+  let stopped = false;
+  if (matches(opts.record.pid)) {
+    stopped = await stopProcess(opts.record.pid, "tunnel");
+    if (!stopped && matches(opts.record.pid)) {
+      throw new Error(
+        `Could not stop ${label} process ${opts.record.pid}; saved tunnel state was retained.`,
+      );
+    }
+  }
+  if (opts.workspaceDir)
+    clearIngressUrl(
+      opts.workspaceDir,
+      opts.assistantId ?? opts.record.assistantId,
+    );
+  return stopped;
+}

package/src/lib/tunnels/tailscale.ts

@@ -1,4 +1,16 @@
-import type { ProviderMeta, ProviderTunnelResult } from "../tunnel.js";
+import { z } from "zod";
+import {
+  clearRootProcess,
+  readRootProcesses,
+  stampRootProcess,
+} from "../assistant-config.js";
+import { readProcessCommandLine, stopProcess } from "../process.js";
+import type {
+  TunnelProvider,
+  ProviderStopOptions,
+  ProviderMeta,
+  ProviderTunnelResult,
+} from "../tunnel.js";
 
 import { spawnSync } from "node:child_process";
 import { win32 } from "node:path";
@@ -7,6 +19,7 @@ import { GATEWAY_PORT } from "../constants.js";
 import { ensureBinaryInstalled } from "../ensure-binary.js";
 import {
   clearIngressUrl,
+  loadRawConfig,
   getDefaultWorkspaceDir,
   readLockfileIngressUrl,
   saveIngressUrl,
@@ -418,6 +431,16 @@ export async function runTailscaleTunnel(
   );
   console.log("or stop it later with: tailscale serve --https=443 off");
 
+  const previous = opts.preserveIngressUrl
+    ? readRootProcesses().tunnel
+    : undefined;
+  stampRootProcess("tunnel", {
+    ...(previous?.provider !== "tailscale" ? { previous } : {}),
+    pid: process.pid,
+    provider: "tailscale",
+    assistantId: opts.assistantId,
+    startedAt: new Date().toISOString(),
+  });
   const teardown = (): void => {
     console.log(
       `\nStopping tailscale serve and clearing the ${publishedLabel}...`,
@@ -441,6 +464,7 @@ export async function runTailscaleTunnel(
       );
     }
     if (shouldClearIngressUrl(result)) {
+      clearRootProcess("tunnel", process.pid);
       retractServeUrl(opts, workspaceDir, previousLockfileIngressUrl);
     } else {
       console.error(
@@ -475,3 +499,57 @@ export const TAILSCALE_TUNNEL_META: ProviderMeta = {
   ],
   supportsReservedDomain: false,
 };
+
+const stoppedTailscaleStateSchema = z.object({
+  ingress: z
+    .object({
+      publicBaseUrl: z.string().optional(),
+      pairingTunnel: z.object({ provider: z.string() }).optional(),
+    })
+    .optional(),
+});
+
+export async function stopTailscaleTunnel(
+  opts: ProviderStopOptions,
+  deps: TailscaleDeps = {
+    findBinary: async () => probeTailscaleBinary(),
+    run: realRun,
+  },
+): Promise<boolean> {
+  const binary = await deps.findBinary();
+  if (!binary) throw new Error(getTailscaleInstallMessage());
+  const result = stopTailscaleServe(binary, deps);
+  if (result.status !== 0)
+    throw new Error(`Could not stop tailscale serve: ${joinOutput(result)}`);
+  // The serve belongs to tailscaled; only the Cadet supervisor may be signaled.
+  let supervisor = false;
+  try {
+    const command = readProcessCommandLine(opts.record.pid);
+    supervisor =
+      /cadet/i.test(command) && /(?:^|\s)tunnel(?:\s|$)/.test(command);
+  } catch {
+    /* The supervisor may already have exited. */
+  }
+  if (supervisor && opts.record.pid !== process.pid)
+    await stopProcess(opts.record.pid, "tunnel supervisor");
+  if (opts.workspaceDir) {
+    const state = stoppedTailscaleStateSchema.parse(
+      loadRawConfig(opts.workspaceDir),
+    ).ingress;
+    const assistantId = opts.assistantId ?? opts.record.assistantId;
+    retractServeUrl(
+      {
+        assistantId,
+        preserveIngressUrl: state?.pairingTunnel?.provider === "tailscale",
+      },
+      opts.workspaceDir,
+      state?.publicBaseUrl ?? null,
+    );
+  }
+  return true;
+}
+
+export const TAILSCALE_PROVIDER: TunnelProvider = {
+  run: runTailscaleTunnel,
+  stop: stopTailscaleTunnel,
+};

package/src/lib/xdg-log.ts

@@ -142,3 +142,14 @@ export function pipeToLogFile(
     stream.on("error", onDone);
   }
 }
+
+/** Runtime output belongs to the instance, alongside its service state. */
+export function openRuntimeLogFile(instanceDir: string, service: "assistant" | "gateway"): number | "ignore" {
+  try {
+    const dir = join(instanceDir, "logs");
+    mkdirSync(dir, { recursive: true });
+    return openSync(join(dir, `${service}-stdout.log`), "a", 0o600);
+  } catch {
+    return "ignore";
+  }
+}