@wax0629/pi-manager 0.1.0

package/src/pi-native.mjs

@@ -0,0 +1,239 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { resolvePiAgentDir } from "./pi-import.mjs";
+
+export const FEATURED_NATIVE_PROVIDERS = Object.freeze([
+  "openai-codex",
+  "anthropic",
+  "github-copilot",
+  "google",
+  "xai",
+  "openrouter"
+]);
+
+export function resolvePiPackageDir(executable) {
+  try {
+    const real = fs.realpathSync(executable);
+    if (real.endsWith(`${path.sep}dist${path.sep}bundle${path.sep}cli.js`)) {
+      return path.resolve(path.dirname(real), "../..");
+    }
+  } catch {
+    // The executable may be missing in tests.
+  }
+  return "";
+}
+
+export async function loadPiSdk(executable) {
+  const packageDir = resolvePiPackageDir(executable);
+  if (!packageDir) throw new Error("无法定位本机 Pi 安装包");
+  return import(pathToFileURL(path.join(packageDir, "dist/index.js")).href);
+}
+
+function providerAuthMethods(provider) {
+  const methods = [];
+  if (provider?.auth?.oauth) methods.push("oauth");
+  if (provider?.auth?.apiKey?.login) methods.push("api_key");
+  return methods;
+}
+
+function summarizeNativeProvider(runtime, provider) {
+  const status = runtime.getProviderAuthStatus?.(provider.id) || { configured: false };
+  return {
+    id: provider.id,
+    name: provider.name || provider.id,
+    kind: "native-subscription",
+    piProvider: provider.id,
+    authMethods: providerAuthMethods(provider),
+    credentialConfigured: Boolean(status.configured),
+    authSource: status.source || "",
+    authLabel: status.label || "",
+    models: (runtime.getModels?.(provider.id) || []).map((model) => ({
+      id: model.id,
+      name: model.name || model.id,
+      reasoning: Boolean(model.reasoning),
+      thinkingLevelMap: model.thinkingLevelMap || {},
+      thinkingLevels: [],
+      thinkingMapSource: "provider-default",
+      thinkingMapVerified: false,
+      input: Array.isArray(model.input) && model.input.length ? model.input : ["text"],
+      contextWindow: Number(model.contextWindow) || 128000,
+      maxTokens: Number(model.maxTokens) || 32000,
+      cost: model.cost || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+    }))
+  };
+}
+
+export function createNativeAuth({
+  executable = "pi",
+  agentDir = resolvePiAgentDir(),
+  loadSdk,
+  openUrl
+} = {}) {
+  let runtimePromise;
+  const sessions = new Map();
+
+  function resetRuntime() {
+    runtimePromise = undefined;
+  }
+
+  async function getRuntime() {
+    if (!runtimePromise) {
+      runtimePromise = (async () => {
+        const sdk = loadSdk ? await loadSdk() : await loadPiSdk(executable);
+        if (!sdk?.ModelRuntime?.create) throw new Error("当前 Pi SDK 不支持 ModelRuntime");
+        return sdk.ModelRuntime.create({
+          refreshOnCreate: false,
+          allowModelNetwork: false,
+          authPath: path.join(agentDir, "auth.json"),
+          modelsPath: fs.existsSync(path.join(agentDir, "models.json")) ? path.join(agentDir, "models.json") : null
+        });
+      })();
+    }
+    return runtimePromise;
+  }
+
+  async function listNativeProviders({ featured = false } = {}) {
+    const runtime = await getRuntime();
+    const configured = new Set((await runtime.listCredentials?.() || []).map((item) => item.providerId));
+    const featuredIds = new Set(FEATURED_NATIVE_PROVIDERS);
+    return runtime.getProviders()
+      .filter((provider) => {
+        const methods = providerAuthMethods(provider);
+        if (methods.length === 0) return false;
+        const isConfigured = configured.has(provider.id) || Boolean(runtime.getProviderAuthStatus?.(provider.id)?.configured);
+        if (featured) return featuredIds.has(provider.id);
+        return featuredIds.has(provider.id) && isConfigured;
+      })
+      .map((provider) => summarizeNativeProvider(runtime, provider));
+  }
+
+  function getSession(loginId) {
+    const session = sessions.get(String(loginId || ""));
+    if (!session) throw new Error("登录会话不存在或已结束");
+    return session;
+  }
+
+  function publicSession(session) {
+    return {
+      loginId: session.id,
+      providerId: session.providerId,
+      type: session.type,
+      status: session.status,
+      authUrl: session.authUrl,
+      prompt: session.prompt,
+      error: session.error
+    };
+  }
+
+  async function login({ providerId, type, apiKey = "" }) {
+    const runtime = await getRuntime();
+    const provider = runtime.getProvider(providerId);
+    if (!provider) throw new Error("Pi 原生渠道不存在");
+    const methods = providerAuthMethods(provider);
+    const authType = type || (methods.includes("oauth") ? "oauth" : "api_key");
+    if (!methods.includes(authType)) throw new Error(`该渠道不支持 ${authType} 登录`);
+
+    if (authType === "api_key") {
+      const key = String(apiKey || "").trim();
+      if (!key) throw new Error("API Key 不能为空");
+      await runtime.login(providerId, "api_key", {
+        async prompt(prompt) {
+          if (prompt.type === "select") return prompt.options?.[0]?.id || "";
+          return key;
+        },
+        notify() {}
+      });
+      resetRuntime();
+      return { status: "completed", providerId, type: "api_key" };
+    }
+
+    const session = {
+      id: crypto.randomUUID(),
+      providerId,
+      type: "oauth",
+      status: "pending",
+      authUrl: "",
+      prompt: null,
+      error: "",
+      resolvePrompt: null
+    };
+    sessions.set(session.id, session);
+    session.promise = runtime.login(providerId, "oauth", {
+      async prompt(prompt) {
+        session.prompt = {
+          type: prompt.type,
+          message: prompt.message,
+          placeholder: prompt.placeholder || "",
+          options: prompt.options || []
+        };
+        session.status = "need_prompt";
+        return await new Promise((resolve, reject) => {
+          session.resolvePrompt = { resolve, reject };
+        });
+      },
+      notify(event) {
+        if (event.type === "auth_url" && event.url) {
+          session.authUrl = event.url;
+          session.status = "need_url";
+          if (typeof openUrl === "function") {
+            Promise.resolve(openUrl(event.url)).catch(() => {});
+          }
+        }
+      }
+    }).then(() => {
+      session.status = "completed";
+      session.prompt = null;
+      resetRuntime();
+      return publicSession(session);
+    }).catch((error) => {
+      session.status = "error";
+      session.error = error instanceof Error ? error.message : String(error);
+      throw error;
+    });
+
+    return publicSession(session);
+  }
+
+  function answerPrompt(loginId, value) {
+    const session = getSession(loginId);
+    if (!session.resolvePrompt) throw new Error("当前没有等待输入的登录步骤");
+    const answer = String(value || "").trim();
+    if (!answer) throw new Error("登录输入不能为空");
+    session.resolvePrompt.resolve(answer);
+    session.resolvePrompt = null;
+    session.prompt = null;
+    session.status = "pending";
+    return publicSession(session);
+  }
+
+  async function loginStatus(loginId) {
+    const session = getSession(loginId);
+    if (session.promise && session.status === "pending") {
+      try {
+        await Promise.race([session.promise, new Promise((resolve) => setTimeout(resolve, 20))]);
+      } catch {
+        // Status is already recorded on the session.
+      }
+    }
+    return publicSession(session);
+  }
+
+  async function logout(providerId) {
+    const runtime = await getRuntime();
+    await runtime.logout(providerId);
+    resetRuntime();
+    return { providerId, status: "logged_out" };
+  }
+
+  return {
+    getRuntime,
+    listNativeProviders,
+    listFeaturedNativeProviders: () => listNativeProviders({ featured: true }),
+    login,
+    loginStatus,
+    answerPrompt,
+    logout
+  };
+}

package/src/profile.mjs

@@ -0,0 +1,225 @@
+import fs from "node:fs";
+import path from "node:path";
+import { safeId, writeJsonAtomic } from "./store.mjs";
+import { assertSupportedThinkingLevel, getThinkingLevelValue } from "./thinking.mjs";
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function removeLegacyManagerFiles(runtimeDir) {
+  const legacyDir = path.join(runtimeDir, ".pi");
+  const legacyFiles = [
+    path.join(legacyDir, "settings.json"),
+    path.join(legacyDir, "models.json"),
+    path.join(legacyDir, "extensions", "pi-manager-provider.ts")
+  ];
+  for (const filePath of legacyFiles) {
+    try {
+      fs.unlinkSync(filePath);
+    } catch {
+      // A missing legacy file is expected for new profiles.
+    }
+  }
+  for (const dirPath of [path.join(legacyDir, "extensions"), legacyDir]) {
+    try {
+      fs.rmdirSync(dirPath);
+    } catch {
+      // Preserve any non-Manager files left in an older profile.
+    }
+  }
+}
+
+function piThinkingMap(provider, model) {
+  return model.thinkingLevelMap || {};
+}
+
+function providerApiKeyEnvName(providerId) {
+  const normalized = safeId(providerId).replaceAll("-", "_").toUpperCase();
+  return `PI_MANAGER_${normalized || "PROVIDER"}_API_KEY`;
+}
+
+function resolveModelReference(providers, ref) {
+  const normalizedRef = String(ref || "").trim();
+  if (!normalizedRef) return null;
+  const separatorIndex = normalizedRef.indexOf("/");
+  if (separatorIndex <= 0 || separatorIndex >= normalizedRef.length - 1) return null;
+  const providerId = normalizedRef.slice(0, separatorIndex);
+  const modelId = normalizedRef.slice(separatorIndex + 1);
+  const provider = providers.find((item) => item.id === providerId);
+  const model = provider?.models.find((item) => item.id === modelId);
+  if (!provider || !model) return null;
+  return { provider, model };
+}
+
+function buildEnabledModels(state) {
+  const cycleRefs = Array.isArray(state.cycle?.modelRefs) ? state.cycle.modelRefs : [];
+  const enabledModels = [];
+  const seen = new Set();
+  const missing = [];
+
+  for (const rawRef of cycleRefs) {
+    const ref = String(rawRef || "").trim();
+    if (!ref || seen.has(ref)) continue;
+    seen.add(ref);
+    if (!resolveModelReference(state.providers || [], ref)) missing.push(ref);
+    else enabledModels.push(ref);
+  }
+
+  if (missing.length > 0) {
+    throw new Error(`循环列表包含不存在的模型: ${missing.join(" / ")}`);
+  }
+
+  return enabledModels;
+}
+
+function buildModelOverrides(provider) {
+  const modelOverrides = Object.fromEntries(
+    provider.models.map((item) => [item.id, {
+      contextWindow: item.contextWindow,
+      ...(item.reasoning && item.thinkingLevelMap && Object.keys(item.thinkingLevelMap).length > 0
+        ? { thinkingLevelMap: item.thinkingLevelMap }
+        : {})
+    }])
+  );
+  return Object.keys(modelOverrides).length > 0 ? modelOverrides : null;
+}
+
+function toPiModel(provider, model) {
+  return {
+    id: model.id,
+    name: `${model.name} (${provider.name})`,
+    reasoning: Boolean(model.reasoning),
+    thinkingLevelMap: model.reasoning ? piThinkingMap(provider, model) : undefined,
+    input: model.input || ["text"],
+    cost: model.cost || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: model.contextWindow || 128000,
+    maxTokens: model.maxTokens || 32000,
+    compat: {
+      supportsDeveloperRole: false,
+      supportsStore: false,
+      maxTokensField: "max_tokens"
+    }
+  };
+}
+
+function buildModelsJson(state, credentials = {}) {
+  const providers = {};
+  for (const provider of state.providers || []) {
+    if (provider.kind === "native-subscription") {
+      const modelOverrides = buildModelOverrides(provider);
+      if (modelOverrides) {
+        providers[provider.piProvider || provider.id] = { modelOverrides };
+      }
+      continue;
+    }
+
+    const secret = String(credentials?.[provider.id] || "").trim();
+    if (!secret) continue;
+
+    providers[provider.id] = {
+      baseUrl: provider.baseUrl,
+      api: "openai-completions",
+      apiKey: `$${providerApiKeyEnvName(provider.id)}`,
+      models: provider.models.map((item) => toPiModel(provider, item))
+    };
+  }
+  return Object.keys(providers).length > 0 ? { providers } : null;
+}
+
+function buildCredentialExports(state, credentials) {
+  return (state.providers || [])
+    .filter((provider) => provider.kind !== "native-subscription")
+    .flatMap((provider) => {
+      const secret = credentials?.[provider.id];
+      const normalized = String(secret || "").trim();
+      if (!normalized) return [];
+      return [{ name: providerApiKeyEnvName(provider.id), value: normalized }];
+    });
+}
+
+function writeLauncher({ launcherPath, providerId, active, runtimeDir, targetProject, piExecutable, credentialExports = [] }) {
+  const args = ["--no-extensions", "--provider", providerId, "--model", active.modelId];
+  if (active.thinking) args.push("--thinking", active.thinking);
+
+  const lines = [
+    "#!/bin/zsh",
+    "set -e",
+    `cd ${shellQuote(targetProject)}`,
+    `export PI_CODING_AGENT_DIR=${shellQuote(runtimeDir)}`,
+    `export PI_CODING_AGENT_SESSION_DIR=${shellQuote(path.join(runtimeDir, "sessions"))}`
+  ];
+  for (const entry of credentialExports) {
+    lines.push(`export ${entry.name}=${shellQuote(entry.value)}`);
+  }
+  lines.push(`exec ${shellQuote(piExecutable)} ${args.map(shellQuote).join(" ")}`);
+  fs.writeFileSync(launcherPath, `${lines.join("\n")}\n`, { mode: 0o700 });
+  fs.chmodSync(launcherPath, 0o700);
+}
+
+export function writePiProfile({ dataDir, state, piExecutable = "pi", credentials = {} }) {
+  const provider = state.providers.find((item) => item.id === state.active.providerId);
+  if (!provider) throw new Error("当前渠道不存在");
+  const model = provider.models.find((item) => item.id === state.active.modelId);
+  if (!model) throw new Error("当前模型不存在");
+  assertSupportedThinkingLevel(model, state.active.thinking);
+
+  const runtimeDir = path.join(dataDir, "profiles", "active");
+  const piDir = runtimeDir;
+  fs.mkdirSync(runtimeDir, { recursive: true, mode: 0o700 });
+  fs.mkdirSync(path.join(runtimeDir, "sessions"), { recursive: true, mode: 0o700 });
+  removeLegacyManagerFiles(runtimeDir);
+  const settingsPath = path.join(piDir, "settings.json");
+  const modelsPath = path.join(piDir, "models.json");
+  const launcherPath = path.join(runtimeDir, process.platform === "darwin" ? "launch-pi.command" : "launch-pi.sh");
+  const extensionPath = "";
+
+  const native = provider.kind === "native-subscription";
+  const settings = {
+    defaultProvider: native ? provider.piProvider || provider.id : provider.id,
+    defaultModel: model.id,
+    enabledModels: buildEnabledModels(state)
+  };
+  writeJsonAtomic(settingsPath, settings);
+
+  const modelsConfig = buildModelsJson(state, credentials);
+  if (modelsConfig) {
+    writeJsonAtomic(modelsPath, modelsConfig);
+  } else {
+    try {
+      fs.unlinkSync(modelsPath);
+    } catch {
+      // No provider/model metadata needs to be injected for this profile.
+    }
+  }
+
+  const credentialExports = buildCredentialExports(state, credentials);
+
+  const manifestPath = path.join(runtimeDir, "profile.json");
+  writeJsonAtomic(manifestPath, {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    targetProject: state.targetProject,
+    providerId: provider.id,
+    providerName: provider.name,
+    modelId: model.id,
+    thinking: state.active.thinking,
+    thinkingValue: getThinkingLevelValue(model, state.active.thinking),
+    cycleModelRefs: buildEnabledModels(state),
+    mode: native ? "native-subscription" : "models-json"
+  });
+
+  writeLauncher({
+    launcherPath,
+    providerId: native ? provider.piProvider || provider.id : provider.id,
+    active: state.active,
+    runtimeDir,
+    targetProject: state.targetProject,
+    piExecutable,
+    credentialExports
+  });
+
+  return { runtimeDir, extensionPath, settingsPath, modelsPath, launcherPath, manifestPath, mode: native ? "native-subscription" : "models-json" };
+}
+
+export { piThinkingMap, shellQuote, toPiModel, providerApiKeyEnvName, buildEnabledModels, buildModelOverrides };

package/src/provider-discovery.mjs

@@ -0,0 +1,146 @@
+import { upstreamUrl } from "./gateway.mjs";
+import { classifyConnectionError, CONNECTION_TEST_CATEGORIES, sanitizeConnectionTestUrl } from "./provider-test.mjs";
+
+function normalizeModels(payload) {
+  const values = Array.isArray(payload)
+    ? payload
+    : Array.isArray(payload?.data)
+      ? payload.data
+      : Array.isArray(payload?.models)
+        ? payload.models
+        : null;
+  if (!values) throw new Error("上游 /models 返回格式无法识别");
+
+  const models = [];
+  const seen = new Set();
+  for (const item of values) {
+    const source = typeof item === "string" ? { id: item } : item;
+    const id = String(source?.id || source?.model || "").trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    models.push({
+      id,
+      name: String(source?.name || source?.display_name || id).trim() || id,
+      reasoning: Boolean(source?.reasoning || source?.supports_reasoning),
+      input: Array.isArray(source?.input) && source.input.length ? source.input.map(String) : ["text"],
+      contextWindow: Number(source?.contextWindow || source?.context_window || source?.context_length) || undefined,
+      maxTokens: Number(source?.maxTokens || source?.max_tokens || source?.max_output_tokens) || undefined,
+      ownedBy: String(source?.owned_by || source?.ownedBy || "").trim()
+    });
+  }
+  return models;
+}
+
+function errorResult({ category, message, detail, status = 0, durationMs }) {
+  return { ok: false, category, message, detail, status, durationMs, models: [] };
+}
+
+function modelsUrlCandidates(baseUrl) {
+  const normalized = String(baseUrl || "").trim();
+  const base = new URL(normalized);
+  base.username = "";
+  base.password = "";
+  base.search = "";
+  base.hash = "";
+  const candidates = [upstreamUrl(base.toString(), "models")];
+  if (!/\/v1\/?$/.test(base.pathname)) {
+    const withV1 = new URL(base.toString());
+    withV1.pathname = `${withV1.pathname.replace(/\/$/, "")}/v1`;
+    candidates.push(upstreamUrl(withV1.toString(), "models"));
+  }
+  return [...new Set(candidates)];
+}
+
+export async function discoverProviderModels({ baseUrl, apiKey = "", fetchImpl = fetch, timeoutMs = 5000 } = {}) {
+  const startedAt = Date.now();
+  let candidateUrls;
+  try {
+    candidateUrls = modelsUrlCandidates(baseUrl);
+  } catch (error) {
+    return errorResult({
+      ...classifyConnectionError(error),
+      detail: "Base URL 无效",
+      durationMs: Date.now() - startedAt
+    });
+  }
+
+  const headers = { accept: "application/json" };
+  if (String(apiKey || "").trim()) headers.authorization = `Bearer ${String(apiKey).trim()}`;
+  let response;
+  let modelsUrl = candidateUrls[0];
+  for (const candidateUrl of candidateUrls) {
+    modelsUrl = candidateUrl;
+    try {
+      response = await fetchImpl(candidateUrl, {
+        method: "GET",
+        headers,
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (error) {
+      const failed = classifyConnectionError(error);
+      return errorResult({
+        category: failed.category,
+        message: failed.message,
+        detail: sanitizeConnectionTestUrl(candidateUrl),
+        durationMs: Date.now() - startedAt
+      });
+    }
+    const contentType = response.headers.get("content-type") || "";
+    const canTryV1 = candidateUrl !== candidateUrls.at(-1)
+      && (response.status === 404 || (response.ok && !/application\/(?:[^;]+\+)?json/i.test(contentType)));
+    if (!canTryV1) break;
+  }
+
+  if (!response.ok) {
+    const status = response.status;
+    const classified = status === 401 || status === 403
+      ? { category: CONNECTION_TEST_CATEGORIES.AUTH, message: `认证失败（HTTP ${status}），请检查 API Key` }
+      : status === 404
+        ? { category: CONNECTION_TEST_CATEGORIES.NOT_FOUND, message: "上游没有提供 /models 目录，可手工填写模型" }
+        : status === 429
+          ? { category: CONNECTION_TEST_CATEGORIES.RATE_LIMIT, message: "上游模型目录触发限流，请稍后重试" }
+          : { category: CONNECTION_TEST_CATEGORIES.PROTOCOL, message: `上游返回 HTTP ${status}` };
+    return errorResult({
+      ...classified,
+      detail: sanitizeConnectionTestUrl(modelsUrl),
+      status,
+      durationMs: Date.now() - startedAt
+    });
+  }
+
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    return errorResult({
+      category: CONNECTION_TEST_CATEGORIES.PROTOCOL,
+      message: "上游 /models 返回的不是有效 JSON",
+      detail: sanitizeConnectionTestUrl(modelsUrl),
+      status: response.status,
+      durationMs: Date.now() - startedAt
+    });
+  }
+
+  try {
+    const models = normalizeModels(payload);
+    return {
+      ok: true,
+      category: CONNECTION_TEST_CATEGORIES.SUCCESS,
+      message: `已从上游读取 ${models.length} 个模型`,
+      detail: sanitizeConnectionTestUrl(modelsUrl),
+      status: response.status,
+      durationMs: Date.now() - startedAt,
+      models
+    };
+  } catch (error) {
+    return errorResult({
+      category: CONNECTION_TEST_CATEGORIES.PROTOCOL,
+      message: error instanceof Error ? error.message : String(error),
+      detail: sanitizeConnectionTestUrl(modelsUrl),
+      status: response.status,
+      durationMs: Date.now() - startedAt
+    });
+  }
+}
+
+export { normalizeModels };