@wax0629/pi-manager 0.1.0

package/src/gateway.mjs

@@ -0,0 +1,199 @@
+import crypto from "node:crypto";
+import http from "node:http";
+import { getThinkingLevelValue } from "./thinking.mjs";
+
+function sendJson(res, status, value) {
+  const body = JSON.stringify(value);
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json; charset=utf-8");
+  res.setHeader("cache-control", "no-store");
+  res.end(body);
+}
+
+function sameSecret(left, right) {
+  if (!left || !right) return false;
+  const a = Buffer.from(left);
+  const b = Buffer.from(right);
+  return a.length === b.length && crypto.timingSafeEqual(a, b);
+}
+
+function bearerToken(req) {
+  const header = req.headers.authorization || "";
+  return header.startsWith("Bearer ") ? header.slice(7) : "";
+}
+
+function upstreamUrl(baseUrl, endpoint) {
+  const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  return new URL(endpoint.replace(/^\//, ""), root).toString();
+}
+
+async function readJson(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > 8 * 1024 * 1024) throw new Error("请求体过大");
+    chunks.push(chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf8");
+  try {
+    return JSON.parse(raw || "{}");
+  } catch {
+    throw new Error("请求体不是有效 JSON");
+  }
+}
+
+function copyResponseHeaders(upstream, response) {
+  for (const name of ["content-type", "cache-control", "x-request-id", "x-ratelimit-limit-requests", "x-ratelimit-remaining-requests", "x-ratelimit-reset-requests"]) {
+    const value = upstream.headers.get(name);
+    if (value) response.setHeader(name, value);
+  }
+}
+
+async function pipeResponse(upstream, response) {
+  copyResponseHeaders(upstream, response);
+  response.statusCode = upstream.status;
+  if (!upstream.body) {
+    response.end();
+    return;
+  }
+  for await (const chunk of upstream.body) response.write(Buffer.from(chunk));
+  response.end();
+}
+
+export function createGateway({ getState, getCredential, onRequest = () => {} }) {
+  let server = null;
+  const stats = {
+    requests: 0,
+    successful: 0,
+    failed: 0,
+    lastRequestAt: null,
+    lastError: null
+  };
+
+  function currentProvider() {
+    const state = getState();
+    return state.providers.find((provider) => provider.id === state.active.providerId);
+  }
+
+  function currentModel() {
+    const state = getState();
+    const provider = currentProvider();
+    return provider?.models.find((model) => model.id === state.active.modelId);
+  }
+
+  async function handle(req, res) {
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    if (req.method === "OPTIONS") {
+      res.statusCode = 204;
+      res.setHeader("access-control-allow-origin", "*");
+      res.setHeader("access-control-allow-headers", "authorization, content-type");
+      res.setHeader("access-control-allow-methods", "GET, POST, OPTIONS");
+      res.end();
+      return;
+    }
+
+    const state = getState();
+    if (!sameSecret(bearerToken(req), state.gateway.clientKey)) {
+      sendJson(res, 401, { error: { message: "Invalid Manager gateway key", type: "authentication_error" } });
+      return;
+    }
+
+    const provider = currentProvider();
+    if (url.pathname === "/health" && req.method === "GET") {
+      const model = currentModel();
+      sendJson(res, 200, {
+        status: "ok",
+        route: {
+          providerId: provider?.id || "",
+          modelId: state.active.modelId,
+          thinking: state.active.thinking,
+          upstreamThinking: getThinkingLevelValue(model, state.active.thinking)
+        },
+        stats
+      });
+      return;
+    }
+
+    if (url.pathname === "/v1/models" && req.method === "GET") {
+      const models = provider?.models || [];
+      sendJson(res, 200, {
+        object: "list",
+        data: models.map((model) => ({ id: model.id, object: "model", created: 0, owned_by: provider.id }))
+      });
+      return;
+    }
+
+    if (url.pathname !== "/v1/chat/completions" || req.method !== "POST") {
+      sendJson(res, 404, { error: { message: "Not Found", type: "invalid_request_error" } });
+      return;
+    }
+
+    stats.requests += 1;
+    stats.lastRequestAt = new Date().toISOString();
+    const startedAt = Date.now();
+    try {
+      if (!provider) throw new Error("当前渠道不存在");
+      if (provider.kind === "native-subscription") throw new Error("官方订阅由 Pi 原生 provider 直连，不经过 Manager gateway");
+      const body = await readJson(req);
+      const requestedModel = String(body.model || "");
+      const modelId = requestedModel.startsWith("pi-manager/") ? requestedModel.slice("pi-manager/".length) : requestedModel;
+      if (!provider.models.some((model) => model.id === modelId)) throw new Error(`模型不可用: ${requestedModel || "(empty)"}`);
+      const credential = getCredential(provider);
+      if (!credential) throw new Error(`渠道 ${provider.name} 尚未配置凭据`);
+
+      const upstreamResponse = await fetch(upstreamUrl(provider.baseUrl, "chat/completions"), {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${credential}`,
+          "content-type": "application/json",
+          accept: body.stream ? "text/event-stream" : "application/json"
+        },
+        body: JSON.stringify({ ...body, model: modelId })
+      });
+      await pipeResponse(upstreamResponse, res);
+      if (upstreamResponse.ok) stats.successful += 1;
+      else stats.failed += 1;
+      onRequest({ providerId: provider.id, modelId, status: upstreamResponse.status, durationMs: Date.now() - startedAt });
+    } catch (error) {
+      stats.failed += 1;
+      stats.lastError = error.message;
+      onRequest({ providerId: provider?.id || "", modelId: state.active.modelId, status: 502, error: error.message, durationMs: Date.now() - startedAt });
+      sendJson(res, 502, { error: { message: error.message, type: "upstream_error" } });
+    }
+  }
+
+  return {
+    getStats() {
+      return { ...stats };
+    },
+    isRunning() {
+      return Boolean(server);
+    },
+    start() {
+      if (server) return Promise.resolve();
+      const state = getState();
+      return new Promise((resolve, reject) => {
+        const nextServer = http.createServer((req, res) => {
+          handle(req, res).catch((error) => sendJson(res, 500, { error: { message: error.message, type: "server_error" } }));
+        });
+        nextServer.once("error", (error) => {
+          nextServer.close();
+          reject(error);
+        });
+        nextServer.listen(state.gateway.port, state.gateway.host, () => {
+          server = nextServer;
+          resolve();
+        });
+      });
+    },
+    stop() {
+      if (!server) return Promise.resolve();
+      const oldServer = server;
+      server = null;
+      return new Promise((resolve) => oldServer.close(() => resolve()));
+    }
+  };
+}
+
+export { upstreamUrl };

package/src/pi-apply.mjs

@@ -0,0 +1,230 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { buildEnabledModels, buildModelOverrides, toPiModel } from "./profile.mjs";
+import { resolvePiAgentDir } from "./pi-import.mjs";
+import { writeJsonAtomic } from "./store.mjs";
+
+const LIVE_FILES = ["settings.json", "models.json", "auth.json"];
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+
+function readJsonIfExists(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    if (error && error.code === "ENOENT") return null;
+    throw new Error(`无法解析 ${filePath}`);
+  }
+}
+
+function copyIfExists(source, destination) {
+  if (!fs.existsSync(source)) return false;
+  ensureDir(path.dirname(destination));
+  fs.copyFileSync(source, destination);
+  try {
+    fs.chmodSync(destination, 0o600);
+  } catch {
+    // Best effort on filesystems without POSIX permissions.
+  }
+  return true;
+}
+
+function timestampId(now = new Date()) {
+  return now.toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}
+
+export function parsePiListModels(output) {
+  const refs = [];
+  for (const line of String(output || "").split(/\r?\n/)) {
+    const match = line.trim().match(/^(\S+)\s+(\S+)\s+/);
+    if (!match) continue;
+    const [, providerId, modelId] = match;
+    if (!providerId || providerId === "provider" || !modelId || modelId === "model") continue;
+    refs.push(`${providerId}/${modelId}`);
+  }
+  return refs;
+}
+
+export function mergeLiveSettings(existing, state) {
+  const provider = (state.providers || []).find((item) => item.id === state.active?.providerId);
+  if (!provider) throw new Error("当前渠道不存在");
+  const current = existing && typeof existing === "object" ? existing : {};
+  return {
+    ...current,
+    defaultProvider: provider.kind === "native-subscription" ? provider.piProvider || provider.id : provider.id,
+    defaultModel: state.active.modelId,
+    defaultThinkingLevel: state.active.thinking,
+    enabledModels: buildEnabledModels(state)
+  };
+}
+
+export function mergeLiveModels(existing, state) {
+  const current = existing && typeof existing === "object" ? existing : {};
+  const providers = { ...(current.providers && typeof current.providers === "object" ? current.providers : {}) };
+
+  for (const provider of state.providers || []) {
+    if (provider.kind === "native-subscription") {
+      const modelOverrides = buildModelOverrides(provider);
+      const key = provider.piProvider || provider.id;
+      if (modelOverrides) {
+        providers[key] = { ...(providers[key] || {}), modelOverrides };
+      }
+      continue;
+    }
+    if (!provider.baseUrl) continue;
+    const entry = {
+      ...(providers[provider.id] || {}),
+      name: provider.name,
+      baseUrl: provider.baseUrl,
+      api: "openai-completions",
+      models: provider.models.map((model) => toPiModel(provider, model))
+    };
+    if (provider.credentialEnv) entry.apiKey = `$${provider.credentialEnv}`;
+    else delete entry.apiKey;
+    providers[provider.id] = entry;
+  }
+
+  return { ...current, providers };
+}
+
+export function mergeLiveAuth(existing, state, credentials = {}) {
+  const next = existing && typeof existing === "object" ? { ...existing } : {};
+  for (const provider of state.providers || []) {
+    if (provider.kind === "native-subscription") continue;
+    const secret = String(credentials?.[provider.id] || "").trim();
+    if (!secret) continue;
+    const current = next[provider.id];
+    if (current && typeof current === "object" && current.type === "oauth") continue;
+    next[provider.id] = { type: "api_key", key: secret };
+  }
+  return next;
+}
+
+export function backupLivePiConfig({ agentDir, backupRoot, now = new Date() }) {
+  ensureDir(backupRoot);
+  const backupDir = path.join(backupRoot, timestampId(now));
+  ensureDir(backupDir);
+  const files = {};
+  for (const name of LIVE_FILES) {
+    files[name] = copyIfExists(path.join(agentDir, name), path.join(backupDir, name));
+  }
+  const manifest = {
+    createdAt: now.toISOString(),
+    agentDir,
+    files
+  };
+  writeJsonAtomic(path.join(backupDir, "manifest.json"), manifest);
+  return { backupDir, manifest };
+}
+
+export function restoreLivePiBackup({ agentDir, backupDir }) {
+  if (!backupDir || !fs.existsSync(backupDir)) throw new Error("没有可回滚的本机 Pi 备份");
+  ensureDir(agentDir);
+  for (const name of LIVE_FILES) {
+    const source = path.join(backupDir, name);
+    const destination = path.join(agentDir, name);
+    if (fs.existsSync(source)) {
+      copyIfExists(source, destination);
+      continue;
+    }
+    try {
+      fs.unlinkSync(destination);
+    } catch {
+      // File was created by a later import and should disappear on rollback.
+    }
+  }
+  return { agentDir, backupDir };
+}
+
+function verifyLiveModels({ agentDir, piExecutable, enabledModels, listModels }) {
+  if (typeof listModels === "function") {
+    const output = listModels({ agentDir, piExecutable });
+    return { ok: true, output: String(output || ""), refs: parsePiListModels(output) };
+  }
+  if (!piExecutable) {
+    return { ok: false, output: "", refs: [], error: "未提供 Pi 可执行文件" };
+  }
+  try {
+    const output = execFileSync(piExecutable, ["--list-models", "--offline"], {
+      encoding: "utf8",
+      env: {
+        ...process.env,
+        PI_CODING_AGENT_DIR: agentDir,
+        PI_OFFLINE: "1"
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const refs = parsePiListModels(output);
+    const missing = (enabledModels || []).filter((ref) => !refs.includes(ref));
+    return {
+      ok: missing.length === 0,
+      output,
+      refs,
+      missing,
+      error: missing.length ? `Pi 未列出循环列表模型: ${missing.join(" / ")}` : ""
+    };
+  } catch (error) {
+    const stderr = typeof error?.stderr === "string" ? error.stderr : "";
+    const stdout = typeof error?.stdout === "string" ? error.stdout : "";
+    return {
+      ok: false,
+      output: stdout,
+      refs: parsePiListModels(stdout),
+      error: stderr || (error instanceof Error ? error.message : String(error))
+    };
+  }
+}
+
+export function applyLivePiConfig({
+  agentDir = resolvePiAgentDir(),
+  backupRoot,
+  state,
+  credentials = {},
+  piExecutable = "pi",
+  listModels,
+  now = new Date()
+}) {
+  if (!backupRoot) throw new Error("缺少备份目录");
+  ensureDir(agentDir);
+  const settingsPath = path.join(agentDir, "settings.json");
+  const modelsPath = path.join(agentDir, "models.json");
+  const authPath = path.join(agentDir, "auth.json");
+  const existingSettings = readJsonIfExists(settingsPath);
+  const existingModels = readJsonIfExists(modelsPath);
+  const existingAuth = readJsonIfExists(authPath);
+  const nextSettings = mergeLiveSettings(existingSettings, state);
+  const nextModels = mergeLiveModels(existingModels, state);
+  const nextAuth = mergeLiveAuth(existingAuth, state, credentials);
+  const backup = backupLivePiConfig({ agentDir, backupRoot, now });
+
+  try {
+    writeJsonAtomic(settingsPath, nextSettings);
+    writeJsonAtomic(modelsPath, nextModels);
+    writeJsonAtomic(authPath, nextAuth, 0o600);
+  } catch (error) {
+    restoreLivePiBackup({ agentDir, backupDir: backup.backupDir });
+    throw error;
+  }
+
+  const verify = verifyLiveModels({
+    agentDir,
+    piExecutable,
+    enabledModels: nextSettings.enabledModels,
+    listModels
+  });
+
+  return {
+    agentDir,
+    backupDir: backup.backupDir,
+    settingsPath,
+    modelsPath,
+    authPath,
+    enabledModels: nextSettings.enabledModels,
+    defaultProvider: nextSettings.defaultProvider,
+    defaultModel: nextSettings.defaultModel,
+    verify
+  };
+}

package/src/pi-auth.mjs

@@ -0,0 +1,109 @@
+import { execFileSync as defaultExecFileSync } from "node:child_process";
+
+const READY_STATUSES = new Set(["ready", "authenticated"]);
+const AUTH_TYPES = new Set(["api_key", "oauth", "subscription"]);
+const AUTH_REASONS = new Set([
+  "auth_required",
+  "check_failed",
+  "credentials_not_configured",
+  "expired",
+  "invalid_credentials",
+  "invalid_response",
+  "unknown_provider"
+]);
+
+function booleanFlag(value) {
+  return value === true || value === "true";
+}
+
+function safeAuthType(value) {
+  const normalized = String(value || "").trim().toLowerCase().replaceAll("-", "_");
+  return AUTH_TYPES.has(normalized) ? normalized : "";
+}
+
+function safeReason(value) {
+  const normalized = String(value || "").trim().toLowerCase().replaceAll("-", "_");
+  return AUTH_REASONS.has(normalized) ? normalized : "";
+}
+
+export function parsePiAuthCheck(raw, { providerId = "", checkedAt = Date.now() } = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(String(raw || ""));
+  } catch {
+    return {
+      providerId,
+      ready: false,
+      status: "error",
+      authType: "",
+      reason: "invalid_response",
+      checkedAt
+    };
+  }
+
+  const status = typeof parsed?.status === "string" ? parsed.status.trim().toLowerCase() : "unknown";
+  const ready = READY_STATUSES.has(status)
+    || booleanFlag(parsed?.authenticated)
+    || booleanFlag(parsed?.ready)
+    || booleanFlag(parsed?.ok);
+  return {
+    providerId,
+    ready,
+    status,
+    authType: safeAuthType(parsed?.authType),
+    reason: safeReason(parsed?.reason),
+    checkedAt
+  };
+}
+
+export function createPiAuthProbe({
+  executable = "pi",
+  cacheTtlMs = 2000,
+  now = () => Date.now(),
+  execFileSync = defaultExecFileSync
+} = {}) {
+  const cache = new Map();
+
+  function check(providerId, { force = false } = {}) {
+    const normalizedProviderId = String(providerId || "").trim();
+    const checkedAt = Number(now());
+    if (!normalizedProviderId) {
+      return parsePiAuthCheck("", { providerId: normalizedProviderId, checkedAt });
+    }
+
+    const previous = cache.get(normalizedProviderId);
+    if (!force && previous && checkedAt - previous.checkedAt < cacheTtlMs) return previous;
+
+    let result;
+    try {
+      const raw = execFileSync(executable, ["auth", "check", "--provider", normalizedProviderId, "--json", "--no-refresh"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      result = parsePiAuthCheck(raw, { providerId: normalizedProviderId, checkedAt });
+    } catch (error) {
+      const stdout = typeof error?.stdout === "string"
+        ? error.stdout
+        : Buffer.isBuffer(error?.stdout) ? error.stdout.toString("utf8") : "";
+      result = stdout.trim()
+        ? parsePiAuthCheck(stdout, { providerId: normalizedProviderId, checkedAt })
+        : {
+            providerId: normalizedProviderId,
+            ready: false,
+            status: "error",
+            authType: "",
+            reason: "check_failed",
+            checkedAt
+          };
+    }
+    cache.set(normalizedProviderId, result);
+    return result;
+  }
+
+  function clear(providerId) {
+    if (providerId === undefined) cache.clear();
+    else cache.delete(String(providerId || "").trim());
+  }
+
+  return { check, clear };
+}

package/src/pi-import.mjs

@@ -0,0 +1,120 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const OPENAI_COMPAT_APIS = new Set(["openai-completions", "openai-responses"]);
+
+export function resolvePiAgentDir(env = process.env) {
+  return env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".pi", "agent");
+}
+
+export function classifyPiApiKey(value) {
+  const raw = String(value || "").trim();
+  if (!raw) return { kind: "missing", env: "", hasLiteral: false };
+  if (raw.startsWith("!")) return { kind: "command", env: "", hasLiteral: false };
+  const braced = raw.match(/^\$\{([A-Z][A-Z0-9_]*)\}$/);
+  if (braced) return { kind: "env", env: braced[1], hasLiteral: false };
+  const plain = raw.match(/^\$([A-Z][A-Z0-9_]*)$/);
+  if (plain) return { kind: "env", env: plain[1], hasLiteral: false };
+  return { kind: "literal", env: "", hasLiteral: true };
+}
+
+function providerApi(config) {
+  return String(config?.api || config?.models?.[0]?.api || "").trim();
+}
+
+export function isImportablePiProvider(id, config) {
+  if (!id || !config || typeof config !== "object") return false;
+  if (!Array.isArray(config.models) || config.models.length === 0) return false;
+  if (!String(config.baseUrl || "").trim()) return false;
+  const api = providerApi(config);
+  return !api || OPENAI_COMPAT_APIS.has(api);
+}
+
+export function summarizePiProvider(id, config) {
+  const apiKey = classifyPiApiKey(config?.apiKey);
+  const models = Array.isArray(config?.models)
+    ? config.models.map((model) => {
+        if (typeof model === "string") return { id: model, name: model };
+        return {
+          id: String(model?.id || "").trim(),
+          name: String(model?.name || model?.id || "").trim(),
+          reasoning: Boolean(model?.reasoning),
+          thinkingLevelMap: model?.thinkingLevelMap && typeof model.thinkingLevelMap === "object" ? model.thinkingLevelMap : undefined,
+          input: Array.isArray(model?.input) ? model.input : ["text"],
+          contextWindow: model?.contextWindow,
+          maxTokens: model?.maxTokens,
+          cost: model?.cost
+        };
+      }).filter((model) => model.id)
+    : [];
+  return {
+    id: String(id),
+    name: String(config?.name || id).trim() || String(id),
+    baseUrl: String(config?.baseUrl || "").trim().replace(/\/$/, ""),
+    api: providerApi(config) || "openai-completions",
+    models,
+    credentialEnv: apiKey.env,
+    credentialKind: apiKey.kind,
+    credentialConfigured: apiKey.kind === "env" || apiKey.kind === "literal" || apiKey.kind === "command"
+  };
+}
+
+export function readPiModelsConfig(agentDir = resolvePiAgentDir()) {
+  const modelsPath = path.join(agentDir, "models.json");
+  let raw = "";
+  try {
+    raw = fs.readFileSync(modelsPath, "utf8");
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return { modelsPath, exists: false, providers: {} };
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`无法解析 ${modelsPath}`);
+  }
+  const providers = parsed?.providers && typeof parsed.providers === "object" ? parsed.providers : {};
+  return { modelsPath, exists: true, providers };
+}
+
+export function previewPiProviderImport({ modelsConfig, existingProviders = [] }) {
+  const existingById = new Map((existingProviders || []).map((provider) => [provider.id, provider]));
+  const candidates = [];
+  const skipped = [];
+
+  for (const [id, config] of Object.entries(modelsConfig?.providers || {})) {
+    if (!isImportablePiProvider(id, config)) {
+      skipped.push({
+        id,
+        reason: Array.isArray(config?.models) && config.models.length
+          ? "not-openai-compatible"
+          : "missing-models-or-baseurl"
+      });
+      continue;
+    }
+    const summary = summarizePiProvider(id, config);
+    const existing = existingById.get(id);
+    candidates.push({
+      ...summary,
+      conflict: Boolean(existing),
+      existingKind: existing?.kind || "",
+      existingName: existing?.name || ""
+    });
+  }
+
+  return {
+    modelsPath: modelsConfig?.modelsPath || "",
+    candidates,
+    skipped,
+    conflicts: candidates.filter((item) => item.conflict)
+  };
+}
+
+export function literalApiKeyFromPiProvider(config) {
+  const classified = classifyPiApiKey(config?.apiKey);
+  return classified.kind === "literal" ? String(config.apiKey).trim() : "";
+}