agent-shim 8.29.0 → 8.30.0

package/dist/cli.cjs

@@ -61796,7 +61796,7 @@ function registerIdentityCommand(program2, deps) {
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.29.0",
+  version: "8.30.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>",
@@ -69906,6 +69906,10 @@ var CheckRunInputSchema = external_exports.strictObject({
   path: external_exports.string().min(1),
   identity: external_exports.string().min(1).optional()
 }).refine((input2) => import_node_path33.default.isAbsolute(input2.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+var PoolPickInputSchema = external_exports.strictObject({
+  pool: external_exports.string().min(1),
+  path: external_exports.string().min(1)
+}).refine((input2) => import_node_path33.default.isAbsolute(input2.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
 var DoctorFindingSchema = external_exports.strictObject({
   section: external_exports.enum(DOCTOR_SECTIONS),
   subject: external_exports.string().optional(),
@@ -73965,6 +73969,7 @@ var USAGE_API_TAG = "usage";
 var FRONTDOOR_API_TAG = "frontdoor";
 var CHECK_API_TAG = "check";
 var DOCTOR_API_TAG = "doctor";
+var POOL_API_TAG = "pool";
 function createControlApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
@@ -74008,6 +74013,18 @@ function createControlApiRouter(deps) {
     },
     doctor: {
       run: authed.route({ method: "GET", path: "/rest/doctor", summary: "Run the doctor report", tags: [DOCTOR_API_TAG] }).output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
+    },
+    pool: {
+      pick: authed.route({ method: "GET", path: "/rest/pool/pick", summary: "Rank one pool exactly as a launch from a directory would right now", tags: [POOL_API_TAG] }).input(PoolPickInputSchema).output(PoolPickReportSchema).handler(({ input: input2 }) => {
+        const report = deps.poolPick(input2.pool, input2.path);
+        if (report === void 0) {
+          const live = deps.poolNames();
+          throw new ORPCError("NOT_FOUND", {
+            message: live.length === 0 ? `no pools are configured, so none is named ${input2.pool}` : `no pool is named ${input2.pool}; the live pools are ${live.map((name) => `"${name}"`).join(", ")}`
+          });
+        }
+        return report;
+      })
     }
   };
 }
@@ -78614,7 +78631,13 @@ function realFrontDoorSupervisorPorts(paths) {
         now: () => Date.now(),
         frontDoorStatus: () => collectFrontDoorStatus(realFarmFs, realHeadroomSocketTrust, paths, realIsProcessRunning),
         checkReport: (target, identity) => collectCheckReport({ paths, cwd: target, ...identity === void 0 ? {} : { identity }, env: process.env }),
-        doctorReport: () => collectDoctorReport({ paths, env: process.env })
+        doctorReport: () => collectDoctorReport({ paths, env: process.env }),
+        // The pool table is read per call, not captured here, so a pool created or removed after the door started is ranked or refused by its live name the same moment the CLI would see it.
+        poolPick: (pool, directory) => {
+          const pools = readPools(paths);
+          return pools[pool] === void 0 ? void 0 : collectPoolPick({ paths, fs: realFsPort, usageFs: realFarmFs, poolName: pool, pools, directory, nowMs: Date.now() });
+        },
+        poolNames: () => Object.keys(readPools(paths)).sort()
       };
       realFarmFs.mkdirp(paths.frontdoorDir);
       realFarmFs.writeFilePrivate(paths.frontdoorControlTokenFile, `${rcControlToken}

package/dist/index.cjs

@@ -5342,7 +5342,7 @@ var import_undici = require("undici");
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.29.0",
+  version: "8.30.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>",
@@ -10180,6 +10180,10 @@ var CheckRunInputSchema = import_zod19.z.strictObject({
   path: import_zod19.z.string().min(1),
   identity: import_zod19.z.string().min(1).optional()
 }).refine((input) => import_node_path27.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+var PoolPickInputSchema = import_zod19.z.strictObject({
+  pool: import_zod19.z.string().min(1),
+  path: import_zod19.z.string().min(1)
+}).refine((input) => import_node_path27.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
 var DoctorFindingSchema = import_zod19.z.strictObject({
   section: import_zod19.z.enum(DOCTOR_SECTIONS),
   subject: import_zod19.z.string().optional(),
@@ -10259,6 +10263,7 @@ var USAGE_API_TAG = "usage";
 var FRONTDOOR_API_TAG = "frontdoor";
 var CHECK_API_TAG = "check";
 var DOCTOR_API_TAG = "doctor";
+var POOL_API_TAG = "pool";
 function createControlApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
@@ -10302,6 +10307,18 @@ function createControlApiRouter(deps) {
     },
     doctor: {
       run: authed.route({ method: "GET", path: "/rest/doctor", summary: "Run the doctor report", tags: [DOCTOR_API_TAG] }).output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
+    },
+    pool: {
+      pick: authed.route({ method: "GET", path: "/rest/pool/pick", summary: "Rank one pool exactly as a launch from a directory would right now", tags: [POOL_API_TAG] }).input(PoolPickInputSchema).output(PoolPickReportSchema).handler(({ input }) => {
+        const report = deps.poolPick(input.pool, input.path);
+        if (report === void 0) {
+          const live = deps.poolNames();
+          throw new import_client3.ORPCError("NOT_FOUND", {
+            message: live.length === 0 ? `no pools are configured, so none is named ${input.pool}` : `no pool is named ${input.pool}; the live pools are ${live.map((name) => `"${name}"`).join(", ")}`
+          });
+        }
+        return report;
+      })
     }
   };
 }

package/dist/index.mjs

@@ -5037,7 +5037,7 @@ import { Agent as Agent3, fetch as undiciFetch } from "undici";
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.29.0",
+  version: "8.30.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>",
@@ -9875,6 +9875,10 @@ var CheckRunInputSchema = z19.strictObject({
   path: z19.string().min(1),
   identity: z19.string().min(1).optional()
 }).refine((input) => path27.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+var PoolPickInputSchema = z19.strictObject({
+  pool: z19.string().min(1),
+  path: z19.string().min(1)
+}).refine((input) => path27.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
 var DoctorFindingSchema = z19.strictObject({
   section: z19.enum(DOCTOR_SECTIONS),
   subject: z19.string().optional(),
@@ -9954,6 +9958,7 @@ var USAGE_API_TAG = "usage";
 var FRONTDOOR_API_TAG = "frontdoor";
 var CHECK_API_TAG = "check";
 var DOCTOR_API_TAG = "doctor";
+var POOL_API_TAG = "pool";
 function createControlApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
@@ -9997,6 +10002,18 @@ function createControlApiRouter(deps) {
     },
     doctor: {
       run: authed.route({ method: "GET", path: "/rest/doctor", summary: "Run the doctor report", tags: [DOCTOR_API_TAG] }).output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
+    },
+    pool: {
+      pick: authed.route({ method: "GET", path: "/rest/pool/pick", summary: "Rank one pool exactly as a launch from a directory would right now", tags: [POOL_API_TAG] }).input(PoolPickInputSchema).output(PoolPickReportSchema).handler(({ input }) => {
+        const report = deps.poolPick(input.pool, input.path);
+        if (report === void 0) {
+          const live = deps.poolNames();
+          throw new ORPCError3("NOT_FOUND", {
+            message: live.length === 0 ? `no pools are configured, so none is named ${input.pool}` : `no pool is named ${input.pool}; the live pools are ${live.map((name) => `"${name}"`).join(", ")}`
+          });
+        }
+        return report;
+      })
     }
   };
 }

package/dist/types/index.d.ts

@@ -3915,6 +3915,7 @@ declare function formatFrontDoorStatus(status: FrontDoorStatus, caCertPath: stri
  * - `usage.*` reads the per-identity usage snapshots the door's own middleware writes, reads a provider's quota windows the way every in-process consumer does (`effectiveWindow`: a window past its reset is empty and carries no status), and reads the live rate-limit observations the event backbone files off the Remote Control client stream (`live`: per-session latest state, exactly as fresh as the last turn a session completed, never a timer's derivation of it).
  * - `frontdoor.*` returns what `agent-shim frontdoor status` returns: the supervisor state, its liveness, the session registry's launches and the headroom hop.
  * - `check.run` and `doctor.run` return the reports `agent-shim check` and `agent-shim doctor` print, as data, `check.run` parameterised by an absolute directory path.
+ * - `pool.pick` returns what `agent-shim pool pick` prints, the ranked pick for one pool exactly as a launch from the named absolute directory would make it right now, so a programmatic consumer can ask which identity to use without reading the door host's files.
  *
  * Read-only by design: identity, configuration-profile, provider, pool and directory-rule management stay CLI-side, and adding writes over this mount is a decision of its own rather than a gap here. `createDoorApiNodeHandler` mounts these routers and the door-wide `events.subscribe` router beside the Remote Control router on the one prefix the provider listener already serves, so a consumer dials one address with one token for the whole door.
  */
@@ -3940,6 +3941,10 @@ interface ControlApiDeps {
     readonly checkReport: (path: string, identity?: string) => CheckReport;
     /** The doctor report, as `collectDoctorReport` collects it. */
     readonly doctorReport: () => DoctorReport;
+    /** The ranked pick for one pool as a launch from one absolute directory would make it right now, exactly `pool pick`'s own product; undefined when the pool table names no such pool. */
+    readonly poolPick: (pool: string, directory: string) => PoolPickReport | undefined;
+    /** The pool table's live names, so an unknown pool is refused naming the real ones rather than answered as an empty ranking. */
+    readonly poolNames: () => readonly string[];
 }
 /** Builds the control-plane routers: one procedure per read, every one behind the control-token middleware. */
 declare function createControlApiRouter(deps: ControlApiDeps): {
@@ -4441,13 +4446,13 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
                     "config-profile": "config-profile";
                     identity: "identity";
                     provider: "provider";
+                    pool: "pool";
+                    keychain: "keychain";
                     "ambient-credential": "ambient-credential";
                     "binary-discovery": "binary-discovery";
                     "claude-shim": "claude-shim";
                     "path-resolution": "path-resolution";
                     "legacy-name": "legacy-name";
-                    pool: "pool";
-                    keychain: "keychain";
                     "directory-rules": "directory-rules";
                     "categories-local": "categories-local";
                     "active-identity": "active-identity";
@@ -4463,6 +4468,44 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
             }, zod_v4_core.$strict>>>;
         }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
     };
+    pool: {
+        pick: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            pool: zod.ZodString;
+            path: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            pool: zod.ZodString;
+            directory: zod.ZodString;
+            pick: zod.ZodOptional<zod.ZodString>;
+            candidates: zod.ZodArray<zod.ZodObject<{
+                identity: zod.ZodString;
+                class: zod.ZodEnum<{
+                    unknown: "unknown";
+                    scored: "scored";
+                    "pay-per-use": "pay-per-use";
+                    ineligible: "ineligible";
+                }>;
+                score: zod.ZodOptional<zod.ZodNumber>;
+                feasible: zod.ZodBoolean;
+                blockedUntil: zod.ZodOptional<zod.ZodISODateTime>;
+                plan: zod.ZodUnion<readonly [zod.ZodObject<{
+                    kind: zod.ZodLiteral<"subscription">;
+                    capacity: zod.ZodNumber;
+                    recognised: zod.ZodBoolean;
+                    tier: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strict>, zod.ZodObject<{
+                    kind: zod.ZodLiteral<"pay-per-use">;
+                    tier: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strict>]>;
+                reasons: zod.ZodArray<zod.ZodString>;
+            }, zod_v4_core.$strict>>;
+            missing: zod.ZodArray<zod.ZodString>;
+            earliestReturn: zod.ZodOptional<zod.ZodObject<{
+                identity: zod.ZodString;
+                at: zod.ZodISODateTime;
+            }, zod_v4_core.$strict>>;
+            stickyProblem: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+    };
 };
 /** The control-plane routers, as the merged mount's and the client's own types are derived from them. */
 type ControlApiRouter = ReturnType<typeof createControlApiRouter>;
@@ -4976,13 +5019,13 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
                     "config-profile": "config-profile";
                     identity: "identity";
                     provider: "provider";
+                    pool: "pool";
+                    keychain: "keychain";
                     "ambient-credential": "ambient-credential";
                     "binary-discovery": "binary-discovery";
                     "claude-shim": "claude-shim";
                     "path-resolution": "path-resolution";
                     "legacy-name": "legacy-name";
-                    pool: "pool";
-                    keychain: "keychain";
                     "directory-rules": "directory-rules";
                     "categories-local": "categories-local";
                     "active-identity": "active-identity";
@@ -4998,6 +5041,44 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
             }, zod_v4_core.$strict>>>;
         }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
     };
+    pool: {
+        pick: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            pool: zod.ZodString;
+            path: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            pool: zod.ZodString;
+            directory: zod.ZodString;
+            pick: zod.ZodOptional<zod.ZodString>;
+            candidates: zod.ZodArray<zod.ZodObject<{
+                identity: zod.ZodString;
+                class: zod.ZodEnum<{
+                    unknown: "unknown";
+                    scored: "scored";
+                    "pay-per-use": "pay-per-use";
+                    ineligible: "ineligible";
+                }>;
+                score: zod.ZodOptional<zod.ZodNumber>;
+                feasible: zod.ZodBoolean;
+                blockedUntil: zod.ZodOptional<zod.ZodISODateTime>;
+                plan: zod.ZodUnion<readonly [zod.ZodObject<{
+                    kind: zod.ZodLiteral<"subscription">;
+                    capacity: zod.ZodNumber;
+                    recognised: zod.ZodBoolean;
+                    tier: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strict>, zod.ZodObject<{
+                    kind: zod.ZodLiteral<"pay-per-use">;
+                    tier: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$strict>]>;
+                reasons: zod.ZodArray<zod.ZodString>;
+            }, zod_v4_core.$strict>>;
+            missing: zod.ZodArray<zod.ZodString>;
+            earliestReturn: zod.ZodOptional<zod.ZodObject<{
+                identity: zod.ZodString;
+                at: zod.ZodISODateTime;
+            }, zod_v4_core.$strict>>;
+            stickyProblem: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+    };
     rc: {
         list: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, Schema<unknown, unknown>, zod.ZodObject<{
             sessions: zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
@@ -5424,13 +5505,13 @@ declare const DoctorFindingSchema: z.ZodObject<{
         "config-profile": "config-profile";
         identity: "identity";
         provider: "provider";
+        pool: "pool";
+        keychain: "keychain";
         "ambient-credential": "ambient-credential";
         "binary-discovery": "binary-discovery";
         "claude-shim": "claude-shim";
         "path-resolution": "path-resolution";
         "legacy-name": "legacy-name";
-        pool: "pool";
-        keychain: "keychain";
         "directory-rules": "directory-rules";
         "categories-local": "categories-local";
         "active-identity": "active-identity";
@@ -5453,13 +5534,13 @@ declare const DoctorRunOutputSchema: z.ZodObject<{
             "config-profile": "config-profile";
             identity: "identity";
             provider: "provider";
+            pool: "pool";
+            keychain: "keychain";
             "ambient-credential": "ambient-credential";
             "binary-discovery": "binary-discovery";
             "claude-shim": "claude-shim";
             "path-resolution": "path-resolution";
             "legacy-name": "legacy-name";
-            pool: "pool";
-            keychain: "keychain";
             "directory-rules": "directory-rules";
             "categories-local": "categories-local";
             "active-identity": "active-identity";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-shim",
-  "version": "8.29.0",
+  "version": "8.30.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>",