pi-orchestrator-config 4.2.0 → 4.3.2

package/extensions/cli-provider/discover.ts

@@ -5,11 +5,13 @@
  * IMPORTANT: These IDs are CLI `--model` values, NOT acpx model ids.
  */
 
-import { cliProviderLog } from "../shared/file-logger.js";
+import { createLogger } from "../shared/logger.js";
 import { CLI_PROVIDERS, isCliAgentName, type CliAgentName } from "./providers.js";
 import type { DiscoveredCliModel } from "./types.js";
 import { modelIdToDisplayName, resolveBinary } from "./shared/discover-cache.js";
 
+const log = createLogger("cli_provider");
+
 export type { DiscoveredCliModel } from "./types.js";
 export { modelIdToDisplayName } from "./shared/discover-cache.js";
 export { parseAgentListModels } from "./agents/cursor.js";
@@ -33,9 +35,7 @@ export async function discoverCliModelsDetailed(
 ): Promise<DiscoveredCliModel[]> {
   if (!isCliAgentName(agent)) return [];
   if (!isCliBinaryAvailable(agent)) {
-    cliProviderLog(
-      "warn",
-      `${agent}: binary not found (${CLI_PROVIDERS[agent].binary})`,
+    log.warn(`${agent}: binary not found (${CLI_PROVIDERS[agent].binary})`,
     );
     return [];
   }
@@ -44,13 +44,13 @@ export async function discoverCliModelsDetailed(
   try {
     discovered = CLI_PROVIDERS[agent].discoverModels();
   } catch (err) {
-    cliProviderLog("error", `${agent}: discovery error`, err);
+    log.error(`${agent}: discovery error`, err);
   }
 
   if (discovered.length > 0) {
-    cliProviderLog("info", `${agent}: discovered ${discovered.length} model(s)`);
+    log.info(`${agent}: discovered ${discovered.length} model(s)`);
   } else {
-    cliProviderLog("warn", `${agent}: discovery returned no models`);
+    log.warn(`${agent}: discovery returned no models`);
   }
   return discovered;
 }

package/extensions/cli-provider/index.ts

@@ -14,6 +14,11 @@
  * @module cli-provider (shim)
  */
 
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("cli_provider");
+log.debug("cli-provider shim module loaded");
+
 // Re-export discovery APIs (consumed by pi-sidecar via jiti)
 export {
   discoverCliModels,

package/extensions/cli-provider/runtime-models.ts

@@ -4,11 +4,16 @@
  */
 
 import { buildRuntimeModel } from "../shared/create-runtime-provider.js";
+import {
+  fillRuntimeModelFromCatalog,
+  type ModelsDevCatalog,
+} from "../shared/models-dev.js";
 import type { DiscoveredCliModel } from "./discover.js";
 
 export function mapCliDiscoveredModels(
   agent: string,
   discovered: readonly DiscoveredCliModel[],
+  catalog?: ModelsDevCatalog | null,
 ): ReturnType<typeof buildRuntimeModel>[] {
   const provider = `cli-${agent}`;
   if (discovered.length === 0) {
@@ -22,11 +27,18 @@ export function mapCliDiscoveredModels(
     ];
   }
   return discovered.map((m) =>
-    buildRuntimeModel({
-      id: `${agent}:${m.id}`,
-      name: `${m.name} (${agent})`,
-      api: "cli",
-      provider,
-    }),
+    buildRuntimeModel(
+      fillRuntimeModelFromCatalog(
+        {
+          id: `${agent}:${m.id}`,
+          name: `${m.name} (${agent})`,
+          api: "cli",
+          provider,
+        },
+        catalog,
+        agent,
+        m.id,
+      ),
+    ),
   );
 }

package/extensions/cli-provider/session-reaper.ts

@@ -5,9 +5,11 @@
  */
 
 import { unlinkSync } from "node:fs";
-import { cliProviderLog } from "../shared/file-logger.js";
+import { createLogger } from "../shared/logger.js";
 import { listCliSessions } from "./sessions.js";
 
+const log = createLogger("cli_provider");
+
 export const DEFAULT_INACTIVITY_THRESHOLD_MS = 30 * 60 * 1000;
 export const DEFAULT_SWEEP_INTERVAL_MS = 5 * 60 * 1000;
 
@@ -51,16 +53,12 @@ export function reapStaleCliSessions(options?: ReapOptions): number {
     try {
       unlinkSync(path);
       reaped += 1;
-      cliProviderLog(
-        "info",
-        `reaped session ${record.agent}/${record.model} ` +
+      log.info(`reaped session ${record.agent}/${record.model} ` +
           `(status=${record.status}, piSessionId=${record.piSessionId}, ` +
           `lastSeen=${record.lastSeenAt})`,
       );
     } catch (err) {
-      cliProviderLog(
-        "error",
-        `failed to reap session ${record.agent}/${record.model} at ${path}`,
+      log.error(`failed to reap session ${record.agent}/${record.model} at ${path}`,
         err,
       );
     }

package/extensions/cli-provider/sessions.ts

@@ -11,11 +11,15 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
+import { createLogger } from "../shared/logger.js";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 import type { CliSessionKey, CliSessionRecord } from "./types.js";
 
+const sessionLog = createLogger("cli_provider");
+sessionLog.debug("cli-provider sessions module loaded");
+
 export type { CliSessionKey, CliSessionRecord } from "./types.js";
 
 /** Prefix for per-process ids used before the real pi session UUID is known. */

package/extensions/cli-provider/shared/discover-cache.ts

@@ -1,22 +1,35 @@
 /**
  * Shared helpers for CLI model discovery (cache + binary resolve).
+ *
+ * Binary resolution functions have been moved to `extensions/shared/resolve-binary.ts`
+ * and are re-exported here for backward compatibility with existing cli-provider consumers.
  */
 
 import {
-  accessSync,
-  constants,
   existsSync,
   mkdirSync,
   readFileSync,
-  realpathSync,
   statSync,
   writeFileSync,
 } from "node:fs";
-import { extname, isAbsolute, join, posix, win32 } from "node:path";
+import { join } from "node:path";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
 import type { DiscoveredCliModel } from "../types.js";
 
+// Re-export binary resolution from shared location
+export {
+  resolveBinary,
+  resolveBinaryForPlatform,
+  clearResolveBinaryCache,
+  parsePathext,
+  isLaunchableWin32,
+  candidateSuffixesFor,
+  pathDelimiterFor,
+  isExecutableForPlatform,
+  type ResolveBinaryEnv,
+} from "../../shared/resolve-binary.js";
+
 export function modelIdToDisplayName(modelId: string): string {
   const bracketIdx = modelId.indexOf("[");
   const baseName = bracketIdx >= 0 ? modelId.substring(0, bracketIdx) : modelId;
@@ -25,178 +38,6 @@ export function modelIdToDisplayName(modelId: string): string {
     .replace(/\b\w/g, (c) => c.toUpperCase());
 }
 
-/** Cache keyed by `${platform}\0${binary}\0${PATH}\0${PATHEXT}` — successful resolves only. */
-const resolveBinaryCache = new Map<string, string>();
-
-export type ResolveBinaryEnv = {
-  PATH?: string;
-  PATHEXT?: string;
-};
-
-/** Parse PATHEXT into uppercase extensions (e.g. ".EXE"). Exported for tests. */
-export function parsePathext(pathextEnv?: string): string[] {
-  const raw = pathextEnv ?? process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM";
-  return raw
-    .split(";")
-    .map((s) => s.trim())
-    .filter(Boolean)
-    .map((s) => (s.startsWith(".") ? s : `.${s}`).toUpperCase());
-}
-
-/**
- * True when filePath has an extension listed in PATHEXT (case-insensitive).
- * Extensionless files are not CreateProcess-launchable on Windows.
- */
-export function isLaunchableWin32(
-  filePath: string,
-  pathextEnv?: string,
-): boolean {
-  const ext = extname(filePath);
-  if (!ext) return false;
-  return parsePathext(pathextEnv).includes(ext.toUpperCase());
-}
-
-/**
- * Suffixes to try when scanning PATH for `binary`.
- * On win32: if `binary` already has a PATHEXT extension, try as-is only;
- * otherwise try each PATHEXT suffix (no bare/empty suffix).
- */
-export function candidateSuffixesFor(
-  binary: string,
-  platform: NodeJS.Platform = process.platform,
-  pathextEnv?: string,
-): string[] {
-  if (platform !== "win32") return [""];
-  const ext = extname(binary);
-  if (ext && parsePathext(pathextEnv).includes(ext.toUpperCase())) {
-    return [""];
-  }
-  return parsePathext(pathextEnv);
-}
-
-/**
- * PATH list separator for the *resolved* platform (not the host OS).
- * Needed so win32 simulation on Unix splits semicolon-separated PATH correctly.
- */
-export function pathDelimiterFor(platform: NodeJS.Platform): string {
-  return platform === "win32" ? win32.delimiter : posix.delimiter;
-}
-
-/** Exported for tests — regular file + platform launchability rules. */
-export function isExecutableForPlatform(
-  filePath: string,
-  platform: NodeJS.Platform,
-  pathextEnv?: string,
-): boolean {
-  let st;
-  try {
-    st = statSync(filePath);
-  } catch {
-    return false;
-  }
-  // Directories are often X_OK (searchable); only regular files are binaries.
-  if (!st.isFile()) return false;
-  // Win32: never treat any regular file as executable — require PATHEXT.
-  if (platform === "win32") return isLaunchableWin32(filePath, pathextEnv);
-  try {
-    accessSync(filePath, constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function finalizeResolved(filePath: string): string {
-  try {
-    return realpathSync(filePath);
-  } catch {
-    return filePath;
-  }
-}
-
-function cacheKeyFor(
-  binary: string,
-  platform: NodeJS.Platform,
-  pathEnv: string,
-  pathextEnv: string,
-): string {
-  return `${platform}\0${binary}\0${pathEnv}\0${pathextEnv}`;
-}
-
-/**
- * Resolve a binary for an explicit platform (injectable for win32 tests on Unix).
- * Absolute paths still require a launchable PATHEXT extension on win32.
- */
-export function resolveBinaryForPlatform(
-  binary: string,
-  platform: NodeJS.Platform,
-  env: ResolveBinaryEnv = {},
-): string | null {
-  if (!binary) return null;
-
-  const pathEnv = env.PATH ?? process.env.PATH ?? "";
-  const pathextEnv =
-    env.PATHEXT ?? process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM";
-  const cacheKey = cacheKeyFor(binary, platform, pathEnv, pathextEnv);
-  const cached = resolveBinaryCache.get(cacheKey);
-  if (cached !== undefined) {
-    if (isExecutableForPlatform(cached, platform, pathextEnv)) return cached;
-    resolveBinaryCache.delete(cacheKey);
-  }
-
-  const isExec = (p: string) =>
-    isExecutableForPlatform(p, platform, pathextEnv);
-
-  // Absolute or explicit relative path — check directly (mirrors `which /path`).
-  if (isAbsolute(binary) || binary.includes("/") || binary.includes("\\")) {
-    if (!isExec(binary)) return null;
-    const resolved = finalizeResolved(binary);
-    resolveBinaryCache.set(cacheKey, resolved);
-    return resolved;
-  }
-
-  const suffixes = candidateSuffixesFor(binary, platform, pathextEnv);
-  const envDelimiter = pathDelimiterFor(platform);
-  for (const dir of pathEnv.split(envDelimiter)) {
-    if (!dir) continue;
-    for (const suffix of suffixes) {
-      // PATHEXT is typically uppercase; Windows FS is case-insensitive.
-      // On case-sensitive hosts (win32 simulation in tests), also try lowercase.
-      const variants =
-        platform === "win32" && suffix && suffix !== suffix.toLowerCase()
-          ? [binary + suffix, binary + suffix.toLowerCase()]
-          : [binary + suffix];
-      for (const name of variants) {
-        const candidate = join(dir, name);
-        if (!isExec(candidate)) continue;
-        const resolved = finalizeResolved(candidate);
-        resolveBinaryCache.set(cacheKey, resolved);
-        return resolved;
-      }
-    }
-  }
-
-  // Do not cache misses — mid-session install with same PATH must rediscover.
-  return null;
-}
-
-/**
- * Resolve a binary name (or absolute path) via an in-process PATH scan.
- * Avoids spawnSync("which") on auth/filter hot paths.
- * Returns realpath when possible, null if missing.
- */
-export function resolveBinary(binary: string): string | null {
-  return resolveBinaryForPlatform(binary, process.platform, {
-    PATH: process.env.PATH,
-    PATHEXT: process.env.PATHEXT,
-  });
-}
-
-/** Clear PATH resolve cache (tests / PATH mutation). */
-export function clearResolveBinaryCache(): void {
-  resolveBinaryCache.clear();
-}
-
 function cacheDir(): string {
   return join(homedir(), ".pi", "cli-model-cache");
 }