claude-use 11.48.0 → 11.49.0

package/dist/types/index.d.ts

@@ -2281,6 +2281,8 @@ interface LayoutPaths {
     readonly frontdoorSessionsDir: string;
     /** Directory holding one `<supervisor-pid>.json` per live front door, recording that door's own direct port: every door still serving sessions forwards its headroom traffic back to its own direct origin, so headroom must admit each of them, not only the one `state.json` names. */
     readonly frontdoorDirectRecordsDir: string;
+    /** Directory holding one empty marker file per front door that has released its addresses and is finishing the connections it carried, named by its supervisor pid. */
+    readonly frontdoorDrainingDir: string;
     /**
      * Directory holding one `<cse-session-id>.json` Remote Control client credential per observed session, mode 0700 with 0600 files: the OAuth-kind bearer and protocol headers the door replays as the session's attached client, persisted so a door generation that starts after a session's create can still attach. The same secret the identity's own store holds, at the same owner-only protection.
      */
@@ -3194,6 +3196,8 @@ type ConnectRequestHandler = (request: IncomingMessage, response: ServerResponse
 /** A bound loopback listener and how to stop it. */
 interface ConnectListenerHandle {
     readonly port: number;
+    /** Stops accepting and releases the port at once, leaving every connection already accepted open: a successor can bind the same port while they finish. */
+    readonly stopAccepting: () => void;
     /** Stops accepting, ends every live connection, and resolves once the port is released. */
     readonly close: () => Promise<void>;
 }
@@ -3277,6 +3281,12 @@ interface ConnectServerHandle {
     readonly port: number;
     /** The transparent listener's port, when one was requested: what an operating-system redirect should point at. */
     readonly transparentPort?: number;
+    /** How many authenticated connections (blind tunnels and terminated sessions together) are open now: what closing this surface, or exiting its process, drops. */
+    readonly openTunnels: () => number;
+    /**
+     * Retires the surface without cutting off the tunnels it carries: the port is released at once so a successor can bind it, every connection that is not a blind tunnel (the terminated sessions, which carry this door's own routing state, and connections still waiting for their head) is ended, and the blind tunnels, which are byte pumps to hosts the door never looks into, keep running until they end by themselves or their launch ends. Resolves when the last has, with the surface fully closed.
+     */
+    readonly drain: () => Promise<void>;
     /** Stops the listener, drops every live tunnel and terminated session, and resolves once the port is released. */
     readonly close: () => Promise<void>;
 }
@@ -4192,7 +4202,7 @@ interface RcStreamHubDeps {
 interface RcStreamHub {
     /** Reconciles the attachments against the tracker: attaches a stream to every tracked session whose OAuth credential is known, and drops an attachment whose session has expired or lost its credential. Idempotent, synchronous and total (never throws): the door calls it after every observed Remote Control exchange, so an attachment follows the session it belongs to without any polling of its own. */
     readonly reconcile: () => void;
-    /** Stops every attachment and frees their dials. */
+    /** Stops every attachment and frees their dials. The hub then refuses to attach again: a later `reconcile` is a no-op, so an exchange that settles after the close cannot start a stream. */
     readonly close: () => void;
 }
 /** Creates the attachment hub. One per door process; everything it holds dies with it. */
@@ -5831,6 +5841,8 @@ interface RunDoctorParams {
         readonly supervisors: FrontDoorSupervisorListing;
         /** The launches registered with the front door whose launcher is still running, each naming the door it was sent to: what tells a superseded door still serving its launches from one serving nothing. */
         readonly liveSessions: readonly FrontDoorSessionSummary[];
+        /** The supervisors that released their addresses and are finishing the connections they carried: running by design, not duplicates. Omit when the platform cannot say. */
+        readonly draining?: readonly number[];
         /** What probing the serving door's listeners found: empty when no door serves or the platform cannot say. Omit to skip the listener checks. */
         readonly listeners?: readonly FrontDoorListenerReading[];
     };
@@ -8436,6 +8448,8 @@ interface FrontDoorSessionStatus extends FrontDoorSessionSummary {
 interface FrontDoorStatus {
     readonly state: FrontDoorState;
     readonly supervisorAlive: boolean;
+    /** The pids of earlier doors that released their addresses and are finishing the connections they carried, found from the marker each writes when it begins to drain: running, but not the serving door. */
+    readonly draining: readonly number[];
     readonly sessions: readonly FrontDoorSessionStatus[];
     /** The headroom daemon's socket as the door's hop reads and authenticates it live: undefined when no socket is recorded, a refusal when the recorded one fails the owner-only check. */
     readonly headroomSocket: HeadroomSocketTarget | undefined;
@@ -8691,6 +8705,7 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
                 lastError: zod.ZodOptional<zod.ZodString>;
             }, zod_v4_core.$strict>;
             supervisorAlive: zod.ZodBoolean;
+            draining: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
             sessions: zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
                 pid: zod.ZodInt;
                 startedAt: zod.ZodNumber;
@@ -9126,6 +9141,7 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
                 lastError: zod.ZodOptional<zod.ZodString>;
             }, zod_v4_core.$strict>;
             supervisorAlive: zod.ZodBoolean;
+            draining: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
             sessions: zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
                 pid: zod.ZodInt;
                 startedAt: zod.ZodNumber;
@@ -13392,6 +13408,7 @@ declare const FrontDoorStatusOutputSchema: z.ZodObject<{
         lastError: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     supervisorAlive: z.ZodBoolean;
+    draining: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
     sessions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         pid: z.ZodInt;
         startedAt: z.ZodNumber;
@@ -13901,6 +13918,16 @@ declare function readRcSelfHostRecord(fs: Pick<FarmFs, "readFileUtf8">, frontdoo
  */
 declare function mintRcSelfHostCredential(deps: RcSelfHostMintDeps): RcSelfHostMintResult;
 
+/**
+ * Why a launcher asked a running front door to exit. A closed set, so a log line can be grouped by it and a new cause has to be named here before it can be sent:
+ *
+ * `restart-command` is `agent-shim frontdoor restart`; `update-restart` is the restart `agent-shim update --restart-door` makes after installing a new binary; `protocol-older` is a launch finding a door that speaks an older protocol than its own; `probe-failed-restart` is a restart that found the door not answering; `probe-failed-idle` is a launch that found the door not answering while no other session was registered against it.
+ */
+declare const REPLACEMENT_REASONS: readonly ["restart-command", "update-restart", "protocol-older", "probe-failed-restart", "probe-failed-idle"];
+type ReplacementReason = (typeof REPLACEMENT_REASONS)[number];
+/** The reasons a caller may ask for a deliberate replacement with, as opposed to the ones a launch finds for itself. */
+type RequestedReplacementReason = Extract<ReplacementReason, "restart-command" | "update-restart">;
+
 /** Raised when the front door cannot be brought up in time or has recorded a fatal error: a routed launch has no other way to reach its provider, so it must fail rather than start a session that can never answer. */
 declare class FrontDoorStartError extends CliError {
     constructor(message: string);
@@ -13918,6 +13945,8 @@ interface EnsureFrontDoorPorts {
     readonly verifyListener: (port: number) => ListenerVerdict;
     /** Asks a running front-door supervisor to exit, without waiting for it to: the caller polls `isRunning`. Only ever called for a pid whose recorded listener has just authenticated as agent-shim's own, or whose process is agent-shim's front-door supervisor (`isFrontDoorSupervisor`). */
     readonly stopSupervisor: (pid: number) => void;
+    /** Appends one line to the front door's own log. Called before every signal sent to a door, so the door's log names the cause of its own exit. */
+    readonly recordReplacement: (line: string) => void;
     /** Ends a supervisor that did not exit when asked to, without giving it the chance to refuse: a door whose event loop is blocked never runs its signal handler. Called only for a pid `isFrontDoorSupervisor` has just confirmed, after `stopSupervisor` and a grace period. */
     readonly killSupervisor: (pid: number) => void;
     /** Whether `pid` is a live agent-shim front-door supervisor process, read from the process's own command line. This is what separates a wedged door of this tool, which a replacement must retire so the two never coexist, from an unrelated process that reuses the recorded pid, which must never be signalled. */
@@ -13932,8 +13961,8 @@ declare function ensureFrontDoor(params: {
     readonly paths: LayoutPaths;
     readonly launcherPid: number;
     readonly ports: EnsureFrontDoorPorts;
-    /** Replaces a serving door whatever its protocol, once: the restart a binary update asks for, so the new generation serves the sessions already running without waiting for the registry to empty. */
-    readonly replace?: boolean;
+    /** Replaces a serving door whatever its protocol, once, and names why: `update-restart` is the restart a binary update asks for, so the new generation serves the sessions already running without waiting for the registry to empty, and `restart-command` is the deliberate `frontdoor restart`. */
+    readonly replace?: RequestedReplacementReason;
     /** What this launch tells the door about itself beyond its token: the id its requests carry in their session header, and the models block it resolved when it added definitions of its own to the global one. Recorded in the launch's registry entry, so it lives and is pruned with the launch. */
     readonly session?: FrontDoorSessionDetails;
 }): {
@@ -13955,6 +13984,8 @@ interface FrontDoorListenerHandle {
     readonly port: number;
     /** Stops accepting, ends every live connection, and resolves once the port is released. */
     readonly close: () => Promise<void>;
+    /** Releases the port at once (before the first await) and leaves the work already in progress to finish; resolves when the listener has nothing left to carry. */
+    readonly drain: () => Promise<void>;
 }
 /**
  * The file identity of the executable this supervisor was spawned from, everything that distinguishes one installed binary from its replacement at the same path: `agent-shim update` installs by rename, so a newer release on disk is a different inode there, and the turnover check is a plain identity comparison rather than a version query (which would mean spawning a subprocess once per tick).
@@ -13992,13 +14023,19 @@ interface FrontDoorSupervisorPorts {
      */
     readonly startDirectListener: (preferredPort: number | undefined) => Promise<FrontDoorListenerHandle>;
     /**
-     * Stops the Remote Control stream hub: persists every live attachment's sequence cursor synchronously, then frees the dials. Called exactly once on every exit the supervisor owns, after every listener it started is down (a live listener could still settle an observed Remote Control exchange, and the reconcile that follows would re-attach a stream the close had just ended) and before the final state write and the process's exit.
+     * Stops the Remote Control stream hub: persists every live attachment's sequence cursor synchronously, then frees the dials. Called exactly once on every exit the supervisor owns, after every listener has stopped accepting. A closing exit has every listener down by then; a drain still has responses settling, which is safe because the hub refuses to attach once it is closed (otherwise the reconcile after an observed exchange would re-attach a stream the close had just ended).
      */
     readonly closeRcStreamHub: () => void;
     /**
      * Starts the watchdog that ends this process when its main event loop stops running: it lives on its own thread, so a loop that is blocked cannot stall it. The supervisor beats it every tick and stops it before it begins to retire, so it only ever judges a door that is meant to be serving. Optional because ending the process is only right when the process is the door: the CLI's `__frontdoor-supervisor` supplies it, and a library host that runs the door inside its own process does not get its application killed by default.
      */
     readonly startWatchdog?: () => DoorWatchdog;
+    /**
+     * Aborted when the process is asked to exit (the CLI's `__frontdoor-supervisor` aborts it on its first SIGTERM or SIGINT). The door then retires by draining: it releases its listening addresses at once, so a successor can bind the same sticky ports, ends what holds its own routing state, and stays up only as long as the connections it still carries (blind tunnels, a response being streamed) take to end. Optional for a host that decides when the door stops by other means.
+     */
+    readonly retire?: AbortSignal;
+    /** Stops the work the door runs on its own account rather than for a request (the usage, window, job and catalogue keepers), called once when a drain begins so the successor's are the only ones acting. Optional because a host without such work has nothing to stop. */
+    readonly stopBackgroundWork?: () => void;
     /**
      * Reports one tick's session-registry facts to the door's event backbone: the sessions the tick's listing saw (taken before the prune, so a pruned launch's record is still there to name its start time) and the pids the tick's prune removed. The launch lifecycle publisher turns the diff between ticks into source-tagged events; the listing is also this loop's own idle input, so the two read one fact instead of two.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "11.48.0",
+  "version": "11.49.0",
   "description": "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   "license": "MIT",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",