@love-moon/conductor-cli 0.2.29 → 0.2.31

package/src/fire/resume.js

@@ -6,6 +6,11 @@ import readline from "node:readline";
 import crypto from "node:crypto";
 
 import yaml from "js-yaml";
+import {
+  getExternalRuntimeBackendDescriptor,
+  isRuntimeSupportedBackend,
+  normalizeRuntimeBackendAlias,
+} from "../runtime-backends.js";
 
 function normalizeBackend(backend) {
   return String(backend || "").trim().toLowerCase();
@@ -166,6 +171,10 @@ export async function resolveResumeContext(backend, sessionId, options = {}) {
   }
   const provider = resumeProviderForBackend(backend);
   if (!provider) {
+    const externalContext = await resolveExternalResumeContext(backend, normalizedSessionId, options);
+    if (externalContext) {
+      return externalContext;
+    }
     throw new Error(`--resume is not supported for backend "${backend}"`);
   }
 
@@ -424,7 +433,10 @@ async function loadConductorSessionRecords(options = {}) {
       if (!entry || typeof entry !== "object") {
         continue;
       }
-      records.push(entry);
+      records.push({
+        ...entry,
+        __conductorSourcePath: filePath,
+      });
     }
   }
   return records;
@@ -434,6 +446,94 @@ function normalizeProjectPathCandidate(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
 
+function normalizeConductorRecordSourcePath(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+async function resolveExternalResumeContext(backend, sessionId, options = {}) {
+  const configFilePath =
+    typeof options?.configFilePath === "string" && options.configFilePath.trim()
+      ? options.configFilePath.trim()
+      : undefined;
+  const normalizedBackend = await normalizeRuntimeBackendAlias(backend, { configFilePath });
+  if (!normalizedBackend || resumeProviderForBackend(normalizedBackend)) {
+    return null;
+  }
+  if (!(await isRuntimeSupportedBackend(normalizedBackend, { configFilePath }))) {
+    return null;
+  }
+
+  const descriptor = await getExternalRuntimeBackendDescriptor(normalizedBackend, { configFilePath });
+  if (typeof descriptor?.resolveResumeContext === "function") {
+    const resolvedContext = await descriptor.resolveResumeContext(sessionId, options);
+    const cwd = normalizeProjectPathCandidate(resolvedContext?.cwd);
+    if (!cwd) {
+      throw new Error(`Could not resolve workspace for backend "${normalizedBackend}" session ${sessionId}`);
+    }
+    if (!(await isExistingDirectory(cwd))) {
+      throw new Error(`Resume workspace path does not exist: ${cwd}`);
+    }
+    const sessionPath = normalizeProjectPathCandidate(resolvedContext?.sessionPath);
+    return {
+      provider: normalizedBackend,
+      sessionId,
+      sessionPath,
+      cwd,
+      debugMetadata: {
+        cwdSource:
+          typeof resolvedContext?.debugMetadata?.cwdSource === "string" && resolvedContext.debugMetadata.cwdSource.trim()
+            ? resolvedContext.debugMetadata.cwdSource.trim()
+            : "provider",
+        sessionPath,
+        ...(resolvedContext?.debugMetadata && typeof resolvedContext.debugMetadata === "object"
+          ? resolvedContext.debugMetadata
+          : {}),
+      },
+    };
+  }
+
+  const records = await loadConductorSessionRecords(options);
+  for (const record of records) {
+    const recordSessionId = normalizeSessionId(record?.session_id);
+    const recordBackend = normalizeBackend(record?.backend_type);
+    const projectPath = normalizeProjectPathCandidate(record?.project_path);
+    if (recordSessionId !== sessionId || recordBackend !== normalizedBackend || !projectPath) {
+      continue;
+    }
+    if (!(await isExistingDirectory(projectPath))) {
+      continue;
+    }
+    const sessionPath = normalizeConductorRecordSourcePath(record?.__conductorSourcePath);
+    return {
+      provider: normalizedBackend,
+      sessionId,
+      sessionPath,
+      cwd: projectPath,
+      debugMetadata: {
+        cwdSource: "conductor_session_record",
+        sessionPath,
+      },
+    };
+  }
+
+  for (const candidate of listCandidateWorkingDirectories(options)) {
+    if (await isExistingDirectory(candidate)) {
+      return {
+        provider: normalizedBackend,
+        sessionId,
+        sessionPath: null,
+        cwd: candidate,
+        debugMetadata: {
+          cwdSource: "current_working_directory",
+          sessionPath: null,
+        },
+      };
+    }
+  }
+
+  throw new Error(`Could not resolve workspace for backend "${normalizedBackend}" session ${sessionId}`);
+}
+
 async function resolveKimiResumeCwd(sessionPath, sessionId, options = {}) {
   const sessionDirectory = typeof sessionPath === "string" ? sessionPath.trim() : "";
   if (!sessionDirectory) {

package/src/native-deps.js

@@ -315,8 +315,16 @@ export async function repairAndVerifyGlobalNodePty({
     await ensurePnpmOnlyBuiltDependencies({ runCommand, dependencies, global: true });
   }
 
+  const packageDirectory = await resolveGlobalPackageDirectory({
+    packageManager,
+    packageName,
+    runCommand,
+  });
+
   if (packageManager === "pnpm") {
-    const rebuildResult = await runCommand("pnpm", ["rebuild", "-g", ...dependencies]);
+    const rebuildResult = await runCommand("pnpm", ["rebuild", ...dependencies], {
+      cwd: packageDirectory,
+    });
     if (!rebuildResult.success) {
       throw new Error(
         `pnpm rebuild failed: ${String(rebuildResult.stderr || rebuildResult.stdout || "unknown error").trim()}`,
@@ -336,12 +344,6 @@ export async function repairAndVerifyGlobalNodePty({
       );
     }
   }
-
-  const packageDirectory = await resolveGlobalPackageDirectory({
-    packageManager,
-    packageName,
-    runCommand,
-  });
   await verifyNodePtyForPackageDirectory({
     packageDirectory,
     runCommand,

package/src/runtime-backends.js

@@ -1,22 +1,226 @@
-export const RUNTIME_SUPPORTED_BACKENDS = ["codex", "claude", "kimi", "opencode"];
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
 
-export function normalizeRuntimeBackendName(backend) {
+import yaml from "js-yaml";
+
+const BUILT_IN_RUNTIME_BACKENDS = ["codex", "claude", "kimi", "opencode"];
+const BUILT_IN_RUNTIME_BACKEND_SET = new Set(BUILT_IN_RUNTIME_BACKENDS);
+const LEGACY_RUNTIME_BACKEND_ALIASES = new Set([
+  "code",
+  "claude-code",
+  "open-code",
+  "open_code",
+  "kimi-cli",
+  "kimi-code",
+]);
+const externalRuntimeCatalogPromises = new Map();
+let externalRuntimeImportNonce = 0;
+
+function normalizeProviderPathEnv(value) {
+  return String(value || "").trim();
+}
+
+function listProviderModulePaths(providerPathEnv) {
+  const raw = normalizeProviderPathEnv(providerPathEnv);
+  if (!raw) {
+    return [];
+  }
+  return [...new Set(raw.split(process.platform === "win32" ? ";" : ":").map((item) => item.trim()).filter(Boolean))];
+}
+
+function normalizeRuntimeBackendName(backend) {
   return String(backend || "").trim().toLowerCase();
 }
 
-export function isRuntimeSupportedBackend(backend) {
-  return RUNTIME_SUPPORTED_BACKENDS.includes(normalizeRuntimeBackendName(backend));
+function readConfigEnvValue(configFilePath, key) {
+  const targetPath =
+    typeof configFilePath === "string" && configFilePath.trim()
+      ? path.resolve(configFilePath.trim())
+      : path.join(process.env.HOME || "", ".conductor", "config.yaml");
+  try {
+    if (!targetPath || !fs.existsSync(targetPath)) {
+      return "";
+    }
+    const parsed = yaml.load(fs.readFileSync(targetPath, "utf8"));
+    if (!parsed || typeof parsed !== "object") {
+      return "";
+    }
+    const value = parsed?.envs?.[key];
+    return typeof value === "string" ? value.trim() : "";
+  } catch {
+    return "";
+  }
+}
+
+function resolveProviderPathEnv(options = {}) {
+  return (
+    normalizeProviderPathEnv(process.env.AISDK_PROVIDER_PATH) ||
+    normalizeProviderPathEnv(readConfigEnvValue(options.configFilePath, "AISDK_PROVIDER_PATH"))
+  );
+}
+
+function createEmptyExternalCatalog() {
+  return {
+    backends: [],
+    backendSet: new Set(),
+    aliasToBackend: new Map(),
+    descriptors: [],
+  };
+}
+
+function validateDescriptor(descriptor, sourcePath) {
+  if (!descriptor || typeof descriptor !== "object") {
+    throw new Error(`External AI SDK provider module ${sourcePath} contains an invalid provider descriptor.`);
+  }
+  const backend = normalizeRuntimeBackendName(descriptor.backend);
+  if (!backend) {
+    throw new Error(`External AI SDK provider module ${sourcePath} is missing provider.backend.`);
+  }
+  if (BUILT_IN_RUNTIME_BACKEND_SET.has(backend)) {
+    throw new Error(`External AI SDK provider backend "${backend}" from ${sourcePath} conflicts with a built-in backend.`);
+  }
+  if (LEGACY_RUNTIME_BACKEND_ALIASES.has(backend)) {
+    throw new Error(`External AI SDK provider backend "${backend}" from ${sourcePath} conflicts with a reserved CLI alias.`);
+  }
+  const variant = String(descriptor.variant || "").trim();
+  if (!variant) {
+    throw new Error(`External AI SDK provider "${backend}" from ${sourcePath} is missing provider.variant.`);
+  }
+  if (typeof descriptor.createSession !== "function") {
+    throw new Error(`External AI SDK provider "${backend}" from ${sourcePath} is missing provider.createSession().`);
+  }
+  const aliases = Array.isArray(descriptor.aliases)
+    ? descriptor.aliases.map((item) => normalizeRuntimeBackendName(item)).filter(Boolean)
+    : [];
+  return {
+    backend,
+    aliases,
+    resolveResumeContext: typeof descriptor.resolveResumeContext === "function" ? descriptor.resolveResumeContext : null,
+  };
+}
+
+async function importExternalProviderModule(modulePath) {
+  const resolvedPath = path.isAbsolute(modulePath) ? modulePath : path.resolve(modulePath);
+  const moduleUrl = pathToFileURL(resolvedPath);
+  moduleUrl.searchParams.set("conductor-external-provider-attempt", String(++externalRuntimeImportNonce));
+  return import(moduleUrl.href);
+}
+
+function registerExternalAlias(catalog, alias, backend, sourcePath) {
+  if (!alias) {
+    return;
+  }
+  if (BUILT_IN_RUNTIME_BACKEND_SET.has(alias)) {
+    throw new Error(`External AI SDK provider alias "${alias}" from ${sourcePath} conflicts with a built-in backend.`);
+  }
+  if (LEGACY_RUNTIME_BACKEND_ALIASES.has(alias)) {
+    throw new Error(`External AI SDK provider alias "${alias}" from ${sourcePath} conflicts with a reserved CLI alias.`);
+  }
+  const existingBackend = catalog.aliasToBackend.get(alias);
+  if (existingBackend && existingBackend !== backend) {
+    throw new Error(
+      `External AI SDK provider alias "${alias}" from ${sourcePath} conflicts with backend "${existingBackend}".`,
+    );
+  }
+  catalog.aliasToBackend.set(alias, backend);
+}
+
+async function loadExternalRuntimeCatalog(providerPathEnv) {
+  const catalog = createEmptyExternalCatalog();
+  for (const modulePath of listProviderModulePaths(providerPathEnv)) {
+    let importedModule;
+    try {
+      importedModule = await importExternalProviderModule(modulePath);
+    } catch (error) {
+      throw new Error(`Failed to load external AI SDK provider module ${modulePath}: ${error?.message || error}`);
+    }
+    const providers = Array.isArray(importedModule?.providers) ? importedModule.providers : [];
+    if (providers.length === 0) {
+      throw new Error(`External AI SDK provider module ${modulePath} must export a non-empty providers array.`);
+    }
+    for (const rawDescriptor of providers) {
+      const descriptor = validateDescriptor(rawDescriptor, modulePath);
+      if (catalog.backendSet.has(descriptor.backend)) {
+        throw new Error(
+          `External AI SDK provider backend "${descriptor.backend}" is declared more than once (latest: ${modulePath}).`,
+        );
+      }
+      catalog.descriptors.push(descriptor);
+      catalog.backends.push(descriptor.backend);
+      catalog.backendSet.add(descriptor.backend);
+      registerExternalAlias(catalog, descriptor.backend, descriptor.backend, modulePath);
+      for (const alias of descriptor.aliases) {
+        registerExternalAlias(catalog, alias, descriptor.backend, modulePath);
+      }
+    }
+  }
+  return catalog;
+}
+
+async function getExternalRuntimeCatalog(options = {}) {
+  const providerPathEnv = resolveProviderPathEnv(options);
+  if (!externalRuntimeCatalogPromises.has(providerPathEnv)) {
+    const loadPromise = loadExternalRuntimeCatalog(providerPathEnv).catch((error) => {
+      externalRuntimeCatalogPromises.delete(providerPathEnv);
+      throw error;
+    });
+    externalRuntimeCatalogPromises.set(providerPathEnv, loadPromise);
+  }
+  return externalRuntimeCatalogPromises.get(providerPathEnv);
+}
+
+export async function normalizeRuntimeBackendAlias(backend, options = {}) {
+  const normalized = normalizeRuntimeBackendName(backend);
+  if (!normalized) {
+    return "";
+  }
+  if (LEGACY_RUNTIME_BACKEND_ALIASES.has(normalized) || BUILT_IN_RUNTIME_BACKEND_SET.has(normalized)) {
+    return normalized;
+  }
+  const catalog = await getExternalRuntimeCatalog(options);
+  return catalog.aliasToBackend.get(normalized) || normalized;
+}
+
+export async function listRuntimeSupportedBackends(options = {}) {
+  const catalog = await getExternalRuntimeCatalog(options);
+  return [...BUILT_IN_RUNTIME_BACKENDS, ...catalog.backends];
+}
+
+export async function getExternalRuntimeBackendDescriptor(backend, options = {}) {
+  const normalized = await normalizeRuntimeBackendAlias(backend, options);
+  if (!normalized || BUILT_IN_RUNTIME_BACKEND_SET.has(normalized) || LEGACY_RUNTIME_BACKEND_ALIASES.has(normalized)) {
+    return null;
+  }
+  const catalog = await getExternalRuntimeCatalog(options);
+  return catalog.backendSet.has(normalized)
+    ? {
+        backend: normalized,
+        ...(catalog.descriptors.find((descriptor) => descriptor.backend === normalized) || {}),
+      }
+    : null;
+}
+
+export async function isRuntimeSupportedBackend(backend, options = {}) {
+  const normalized = await normalizeRuntimeBackendAlias(backend, options);
+  if (BUILT_IN_RUNTIME_BACKEND_SET.has(normalized)) {
+    return true;
+  }
+  if (LEGACY_RUNTIME_BACKEND_ALIASES.has(normalized)) {
+    return false;
+  }
+  const catalog = await getExternalRuntimeCatalog(options);
+  return catalog.backendSet.has(normalized);
 }
 
-export function filterRuntimeSupportedAllowCliList(allowCliList) {
+export async function filterRuntimeSupportedAllowCliList(allowCliList, options = {}) {
   if (!allowCliList || typeof allowCliList !== "object") {
     return {};
   }
-
   const filtered = {};
   for (const [backend, command] of Object.entries(allowCliList)) {
-    const normalizedBackend = normalizeRuntimeBackendName(backend);
-    if (!RUNTIME_SUPPORTED_BACKENDS.includes(normalizedBackend)) {
+    const normalizedBackend = await normalizeRuntimeBackendAlias(backend, options);
+    if (!(await isRuntimeSupportedBackend(normalizedBackend, options))) {
       continue;
     }
     if (typeof command !== "string" || !command.trim()) {
@@ -25,7 +229,13 @@ export function filterRuntimeSupportedAllowCliList(allowCliList) {
     if (filtered[normalizedBackend] !== undefined) {
       continue;
     }
-    filtered[normalizedBackend] = command;
+    filtered[normalizedBackend] = command.trim();
   }
   return filtered;
 }
+
+export { BUILT_IN_RUNTIME_BACKENDS as RUNTIME_SUPPORTED_BACKENDS, normalizeRuntimeBackendName };
+
+export function resetRuntimeBackendCacheForTests() {
+  externalRuntimeCatalogPromises.clear();
+}