@cdo-ai/cli 0.1.0

package/lib/config.mjs

@@ -0,0 +1,392 @@
+import { createHash, randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
+import { lstat, mkdir, open, readFile, realpath, rename, stat, unlink, writeFile, chmod } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { promisify } from "node:util";
+
+export const ENVIRONMENTS = Object.freeze(["dev", "staging", "prod"]);
+const ROOT_DOMAINS = Object.freeze({ dev: "dev-agents.cdo.top", staging: "s-agents.cdo.top", prod: "agents.ttdd.work" });
+const OFFICIAL_API_ORIGINS = Object.freeze({ dev: "https://dev-api.cdo.top", staging: "https://s-api.cdo.top", prod: "https://api.ttdd.work" });
+const LOCK_TIMEOUT_MS = 5_000;
+const LOCK_STALE_MS = 30_000;
+const executeFile = promisify(execFile);
+
+export function validateEnvironment(value, source = "--env") {
+  if (!ENVIRONMENTS.includes(value)) throw new Error(`${source} 必须是 dev、staging 或 prod`);
+  return value;
+}
+
+export function validateEnterpriseCode(value) {
+  if (typeof value !== "string" || value.length > 63 || !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(value)) {
+    throw new Error("--enterprise 必须是有效企业码（小写字母、数字和中间短横线）");
+  }
+  return value;
+}
+
+export function endpointForEnvironment(environmentName, enterpriseCode) {
+  return `https://${validateEnterpriseCode(enterpriseCode)}.${ROOT_DOMAINS[validateEnvironment(environmentName)]}`;
+}
+
+export function apiOriginForEnvironment(environmentName) {
+  return OFFICIAL_API_ORIGINS[validateEnvironment(environmentName)];
+}
+
+export function validateEndpointEnvironment(value, environmentName, source = "CDO API 地址") {
+  const selected = validateEnvironment(environmentName);
+  let endpoint;
+  try { endpoint = new URL(value); } catch { throw new Error(`${source} 无效`); }
+  if (!["http:", "https:"].includes(endpoint.protocol) || endpoint.username || endpoint.password
+      || endpoint.pathname !== "/" || endpoint.search || endpoint.hash) {
+    throw new Error(`${source} 必须是无凭据的 HTTP(S) origin`);
+  }
+  const hostname = endpoint.hostname.toLowerCase();
+  const loopback = ["localhost", "127.0.0.1", "[::1]", "::1"].includes(hostname);
+  const enterpriseDomainMatches = selected === "dev"
+    ? loopback || hostname.endsWith(".dev-agents.cdo.top")
+    : selected === "staging"
+      ? hostname.endsWith(".s-agents.cdo.top") || hostname.endsWith(".s-agents.ttdd.work")
+      : hostname.endsWith(".agents.ttdd.work") && !hostname.endsWith(".s-agents.ttdd.work");
+  if (!(enterpriseDomainMatches || endpoint.origin === OFFICIAL_API_ORIGINS[selected])) {
+    throw new Error(`${source}与所选 ${selected} 环境不匹配`);
+  }
+  if (!loopback && endpoint.protocol !== "https:") throw new Error(`${source}必须使用 HTTPS`);
+  return endpoint;
+}
+
+export function inferEndpointEnvironment(value, source = "CDO API 地址") {
+  const matches = ENVIRONMENTS.filter((name) => {
+    try { validateEndpointEnvironment(value, name, source); return true; } catch { return false; }
+  });
+  if (matches.length !== 1) throw new Error(`${source}无法唯一确定部署环境`);
+  return matches[0];
+}
+
+export function stableProfileId(environmentName, enterpriseId, userId) {
+  if (![environmentName, enterpriseId, userId].every((value) => typeof value === "string" && value)) {
+    throw new Error("profile 身份缺少部署、企业或员工 ID");
+  }
+  const digest = createHash("sha256").update(`${environmentName}\0${enterpriseId}\0${userId}`).digest("hex");
+  return `p_${digest.slice(0, 20)}`;
+}
+
+function defaultAlias(profile) {
+  return `${profile.environment}/${profile.enterprise?.abbr || profile.enterprise?.id || "unknown"}`;
+}
+
+export function configPath(environment = process.env) {
+  return environment.CDO_CONFIG_PATH || join(homedir(), ".config", "cdo", "config.json");
+}
+
+function emptyConfig() { return { schema_version: 2, profiles: {}, default_profile_id: null }; }
+
+function uniqueAlias(profiles, requested, profileId, userId) {
+  const occupied = new Set(Object.values(profiles).filter((item) => item.id !== profileId).map((item) => item.alias));
+  if (!occupied.has(requested)) return requested;
+  const suffix = createHash("sha256").update(userId || profileId).digest("hex").slice(0, 6);
+  const candidate = `${requested}/${suffix}`;
+  if (occupied.has(candidate)) throw new Error(`profile 别名冲突：${candidate}`);
+  return candidate;
+}
+
+function normalizedProfile(id, value) {
+  if (!value || typeof value !== "object" || !ENVIRONMENTS.includes(value.environment)) return null;
+  return { ...value, id, alias: value.alias || defaultAlias(value) };
+}
+
+export function normalizeConfig(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("CDO 配置格式无效，原文件未修改");
+  if (raw.schema_version === 2) {
+    if (!raw.profiles || typeof raw.profiles !== "object" || Array.isArray(raw.profiles)
+        || !([null, undefined].includes(raw.default_profile_id) || typeof raw.default_profile_id === "string")) {
+      throw new Error("CDO v2 配置结构不完整，原文件未修改");
+    }
+    const profiles = {};
+    for (const [key, value] of Object.entries(raw.profiles)) {
+      if (value?.id && value.id !== key) throw new Error(`CDO v2 profile ID 不一致：${key}`);
+      const profile = normalizedProfile(key, value);
+      if (!profile?.id) throw new Error(`CDO v2 profile 无效：${key}`);
+      profiles[profile.id] = profile;
+    }
+    return { schema_version: 2, profiles, default_profile_id: raw.default_profile_id || null };
+  }
+  if (raw.schema_version !== 1) throw new Error(`不支持的 CDO 配置版本：${String(raw.schema_version)}`);
+  if (!raw.environments || typeof raw.environments !== "object" || Array.isArray(raw.environments)) {
+    throw new Error("CDO v1 配置结构不完整，原文件未修改");
+  }
+  const profiles = {};
+  for (const [environment, value] of Object.entries(raw.environments || {})) {
+    if (!ENVIRONMENTS.includes(environment) || !value || typeof value !== "object") continue;
+    let id;
+    try { id = stableProfileId(environment, value.enterprise?.id, value.user?.id); }
+    catch { id = `legacy_${createHash("sha256").update(environment).digest("hex").slice(0, 12)}`; }
+    const profile = { ...value, id, environment, alias: value.alias || defaultAlias({ ...value, environment }) };
+    if (!value.enterprise?.id || !value.user?.id) profile.migration_status = "identity_incomplete";
+    profiles[id] = profile;
+  }
+  const ids = Object.keys(profiles);
+  return { schema_version: 2, profiles, default_profile_id: ids.length === 1 ? ids[0] : null };
+}
+
+export async function loadConfig(environment = process.env) {
+  try { return normalizeConfig(JSON.parse(await readFile(configPath(environment), "utf8"))); }
+  catch (error) { if (error?.code === "ENOENT") return emptyConfig(); throw error; }
+}
+
+export async function ensureConfigV2(environment = process.env) {
+  try {
+    const raw = JSON.parse(await readFile(configPath(environment), "utf8"));
+    normalizeConfig(raw);
+    if (raw.schema_version === 2) return false;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+  await updateConfig((config) => ({ config, value: true }), environment);
+  return true;
+}
+
+async function rejectSymlink(path) {
+  try { if ((await lstat(path)).isSymbolicLink()) throw new Error(`拒绝写入符号链接配置：${path}`); }
+  catch (error) { if (error?.code !== "ENOENT") throw error; }
+}
+
+async function writeConfigAtomic(value, environment) {
+  const path = configPath(environment);
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  await rejectSymlink(path);
+  const temporary = `${path}.tmp-${process.pid}-${randomBytes(6).toString("hex")}`;
+  const handle = await open(temporary, "wx", 0o600);
+  try { await handle.writeFile(`${JSON.stringify(normalizeConfig(value), null, 2)}\n`, "utf8"); await handle.sync(); }
+  finally { await handle.close(); }
+  try { await rename(temporary, path); await chmod(path, 0o600); }
+  catch (error) { await unlink(temporary).catch(() => {}); throw error; }
+}
+
+async function withConfigLock(environment, operation) {
+  const path = configPath(environment);
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const lockPath = `${path}.lock`;
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  let handle;
+  while (!handle) {
+    try { handle = await open(lockPath, "wx", 0o600); await handle.writeFile(`${process.pid}\n`, "utf8"); }
+    catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      const age = await stat(lockPath).then((info) => Date.now() - info.mtimeMs).catch(() => 0);
+      if (age > LOCK_STALE_MS) { await unlink(lockPath).catch(() => {}); continue; }
+      if (Date.now() >= deadline) throw new Error("CDO 配置正被其他进程更新，请稍后重试");
+      await new Promise((done) => setTimeout(done, 20));
+    }
+  }
+  try { return await operation(); }
+  finally { await handle.close().catch(() => {}); await unlink(lockPath).catch(() => {}); }
+}
+
+export async function saveConfig(value, environment = process.env) {
+  return withConfigLock(environment, () => writeConfigAtomic(value, environment));
+}
+
+export async function updateConfig(updater, environment = process.env) {
+  return withConfigLock(environment, async () => {
+    const current = await loadConfig(environment);
+    const result = await updater(current);
+    await writeConfigAtomic(result?.config || current, environment);
+    return result?.value;
+  });
+}
+
+export async function upsertProfile(profile, { setDefault = false, environment = process.env } = {}) {
+  const id = stableProfileId(profile.environment, profile.enterprise?.id, profile.user?.id);
+  return updateConfig((config) => {
+    const previous = config.profiles[id] || {};
+    const alias = uniqueAlias(config.profiles, previous.alias || profile.alias || defaultAlias(profile), id, profile.user.id);
+    config.profiles[id] = { ...previous, ...profile, id, alias };
+    if (!config.default_profile_id || setDefault) config.default_profile_id = id;
+    return { config, value: config.profiles[id] };
+  }, environment);
+}
+
+export async function setDefaultProfile(selector, environment = process.env) {
+  return updateConfig((config) => {
+    const profile = findProfile(config, selector);
+    config.default_profile_id = profile.id;
+    return { config, value: profile };
+  }, environment);
+}
+
+export function listProfiles(config) {
+  return Object.values(config.profiles).sort((left, right) => left.alias.localeCompare(right.alias));
+}
+
+export function findProfile(config, selector) {
+  if (!selector) throw new Error("profile 不能为空");
+  if (config.profiles[selector]) return config.profiles[selector];
+  const matches = listProfiles(config).filter((profile) => profile.alias === selector);
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) throw new Error(`profile 别名不唯一：${selector}`);
+  throw new Error(`profile 不存在：${selector}`);
+}
+
+export function projectContextPath(cwd = process.cwd(), environment = process.env) {
+  return environment.CDO_CONTEXT_PATH || join(resolve(cwd), ".cdo", "context.local.json");
+}
+
+async function gitProjectMetadata(cwd) {
+  try {
+    const directory = resolve(cwd);
+    const root = (await executeFile("git", ["-C", directory, "rev-parse", "--show-toplevel"])).stdout.trim();
+    const exclude = (await executeFile("git", ["-C", directory, "rev-parse", "--git-path", "info/exclude"])).stdout.trim();
+    return { root: resolve(root), exclude: resolve(root, exclude) };
+  } catch {
+    return null;
+  }
+}
+
+async function resolvedProjectContextPath(cwd, environment, { search = false } = {}) {
+  if (environment.CDO_CONTEXT_PATH) return environment.CDO_CONTEXT_PATH;
+  const directory = resolve(cwd);
+  const metadata = await gitProjectMetadata(directory);
+  if (!metadata) return projectContextPath(directory, environment);
+  if (!search) return projectContextPath(metadata.root, environment);
+  let candidate = directory;
+  while (true) {
+    const path = projectContextPath(candidate, environment);
+    try {
+      await lstat(path);
+      return path;
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+    }
+    if (candidate === metadata.root) return projectContextPath(metadata.root, environment);
+    const parent = dirname(candidate);
+    if (parent === candidate) return projectContextPath(metadata.root, environment);
+    candidate = parent;
+  }
+}
+
+async function ensureProjectContextIgnored(metadata) {
+  if (!metadata) return;
+  const rule = "/.cdo/context.local.json";
+  let current = "";
+  try { current = await readFile(metadata.exclude, "utf8"); }
+  catch (error) { if (error?.code !== "ENOENT") throw error; }
+  if (current.split(/\r?\n/).includes(rule)) return;
+  await mkdir(dirname(metadata.exclude), { recursive: true, mode: 0o700 });
+  await rejectSymlink(metadata.exclude);
+  const separator = current && !current.endsWith("\n") ? "\n" : "";
+  const temporary = `${metadata.exclude}.tmp-${process.pid}-${randomBytes(6).toString("hex")}`;
+  await writeFile(temporary, `${current}${separator}${rule}\n`, { mode: 0o600, flag: "wx" });
+  try { await rename(temporary, metadata.exclude); }
+  catch (error) { await unlink(temporary).catch(() => {}); throw error; }
+}
+
+async function rejectTrackedProjectContext(cwd, path, environment) {
+  const metadata = await gitProjectMetadata(cwd);
+  if (!metadata) return;
+  // macOS may spell the same temporary/worktree path through /var and /private/var.
+  const canonicalRoot = await realpath(metadata.root);
+  const canonicalDirectory = await realpath(dirname(path)).catch((error) => {
+    if (error?.code === "ENOENT") return resolve(canonicalRoot, relative(metadata.root, dirname(path)));
+    throw error;
+  });
+  const repositoryPath = relative(canonicalRoot, join(canonicalDirectory, basename(path)));
+  if (!repositoryPath || repositoryPath.startsWith("..")) return;
+  try {
+    await executeFile("git", ["-C", metadata.root, "ls-files", "--error-unmatch", "--", repositoryPath]);
+  } catch (error) {
+    if (error?.code === 1) return;
+    throw error;
+  }
+  throw new Error(`项目 CDO context 已被 Git 跟踪，拒绝读取或覆盖：${repositoryPath}`);
+}
+
+export async function loadProjectContext(cwd = process.cwd(), environment = process.env) {
+  try {
+    const path = await resolvedProjectContextPath(cwd, environment, { search: true });
+    await rejectTrackedProjectContext(cwd, path, environment);
+    const data = JSON.parse(await readFile(path, "utf8"));
+    return typeof data?.profile_id === "string" ? { profile_id: data.profile_id } : null;
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw new Error(`项目 CDO context 无效：${error.message}`);
+  }
+}
+
+export async function saveProjectContext(profileId, cwd = process.cwd(), environment = process.env) {
+  const metadata = environment.CDO_CONTEXT_PATH ? null : await gitProjectMetadata(cwd);
+  const path = environment.CDO_CONTEXT_PATH
+    || projectContextPath(metadata?.root || cwd, environment);
+  await rejectTrackedProjectContext(cwd, path, environment);
+  await ensureProjectContextIgnored(metadata);
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  await rejectSymlink(path);
+  const temporary = `${path}.tmp-${process.pid}-${randomBytes(6).toString("hex")}`;
+  await writeFile(temporary, `${JSON.stringify({ schema_version: 1, profile_id: profileId }, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+  try { await rename(temporary, path); await chmod(path, 0o600); }
+  catch (error) { await unlink(temporary).catch(() => {}); throw error; }
+  return path;
+}
+
+export async function clearProjectContext(cwd = process.cwd(), environment = process.env) {
+  const path = await resolvedProjectContextPath(cwd, environment, { search: true });
+  await rejectTrackedProjectContext(cwd, path, environment);
+  await unlink(path).catch((error) => { if (error?.code !== "ENOENT") throw error; });
+}
+
+function candidateError(candidates, environmentName) {
+  const labels = candidates.map((profile) => `${profile.id} (${profile.alias})`).join(", ");
+  return new Error(candidates.length
+    ? `存在多个${environmentName ? ` ${environmentName}` : ""}身份，请显式选择 profile：${labels}`
+    : `没有可用${environmentName ? ` ${environmentName}` : ""}身份，请先运行 cdo login`);
+}
+
+/** Resolve one immutable command context using the LCLI-9 precedence contract. */
+export async function resolveContext({ requestedProfile = null, requestedEnvironment = null, environment = process.env, cwd = process.cwd(), requireKey = true } = {}) {
+  if (requestedEnvironment) validateEnvironment(requestedEnvironment, "--env");
+  const processProfile = environment.CDO_PROFILE || null;
+  const explicitSelector = requestedProfile || processProfile;
+  const directUrl = environment.CDO_BASE_URL;
+  const directKey = environment.CDO_PERSONAL_API_KEY;
+  const config = await loadConfig(environment);
+  const userDefaultProfileId = config.default_profile_id || null;
+
+  if (explicitSelector) {
+    const profile = findProfile(config, explicitSelector);
+    if (requestedEnvironment && profile.environment !== requestedEnvironment) throw new Error(`profile ${profile.id} 与 --env ${requestedEnvironment} 不匹配`);
+    if (profile.api_base_url) validateEndpointEnvironment(profile.api_base_url, profile.environment);
+    if (requireKey && (!profile.api_base_url || !profile.personal_api_key)) throw new Error(`profile ${profile.id} 缺少可用用户 Key`);
+    const source = requestedProfile ? "argument" : "process_profile";
+    return { config, environmentName: profile.environment, profile: { ...profile, source }, profileId: profile.id, selectionSource: source, userDefaultProfileId };
+  }
+
+  if (Boolean(directUrl) !== Boolean(directKey)) throw new Error("CDO_BASE_URL 与 CDO_PERSONAL_API_KEY 必须同时设置并绑定同一环境");
+  const fallbackEnvironment = requestedEnvironment || (environment.CDO_ENV ? validateEnvironment(environment.CDO_ENV, "CDO_ENV") : null);
+  if (directUrl) {
+    const environmentName = fallbackEnvironment || inferEndpointEnvironment(directUrl, "CDO_BASE_URL");
+    validateEndpointEnvironment(directUrl, environmentName, "CDO_BASE_URL");
+    return { config, environmentName, profile: { api_base_url: directUrl, personal_api_key: directKey, environment: environmentName, source: "direct_environment" }, profileId: null, selectionSource: "direct_environment", userDefaultProfileId };
+  }
+
+  const project = await loadProjectContext(cwd, environment);
+  const candidates = listProfiles(config).filter((profile) => !fallbackEnvironment || profile.environment === fallbackEnvironment);
+  const selectIfEligible = (id, source) => {
+    if (!id) return null;
+    const profile = config.profiles[id];
+    if (!profile) throw new Error(`${source === "project" ? "项目" : "用户默认"} profile 已失效：${id}`);
+    return !fallbackEnvironment || profile.environment === fallbackEnvironment ? { profile, source } : null;
+  };
+  const selected = selectIfEligible(project?.profile_id, "project")
+    || selectIfEligible(config.default_profile_id, "user_default")
+    || (candidates.length === 1 ? { profile: candidates[0], source: "unique_candidate" } : null);
+  if (!selected) {
+    if (!requireKey && candidates.length === 0) {
+      const environmentName = fallbackEnvironment || "prod";
+      return { config, environmentName, profile: { environment: environmentName, source: "none" }, profileId: null, selectionSource: "none", userDefaultProfileId };
+    }
+    throw candidateError(candidates, fallbackEnvironment);
+  }
+  if (selected.profile.api_base_url) validateEndpointEnvironment(selected.profile.api_base_url, selected.profile.environment);
+  if (requireKey && (!selected.profile.api_base_url || !selected.profile.personal_api_key)) throw new Error(`profile ${selected.profile.id} 缺少可用用户 Key`);
+  return { config, environmentName: selected.profile.environment, profile: { ...selected.profile, source: selected.source }, profileId: selected.profile.id, selectionSource: selected.source, userDefaultProfileId, projectProfileId: project?.profile_id || null };
+}

package/lib/doctor.mjs

@@ -0,0 +1,71 @@
+import { spawnSync } from "node:child_process";
+
+import { VERSION } from "./version.mjs";
+import { inspectSystemSkill } from "./skills.mjs";
+import { inspectGitAuth as inspectGitAuthLive } from "./git-auth.mjs";
+
+function executableStatus(command, run = spawnSync) {
+  const result = run(command, ["--version"], { encoding: "utf8", timeout: 5000 });
+  return {
+    available: !result.error && result.status === 0,
+    version: !result.error && result.status === 0
+      ? String(result.stdout || result.stderr || "").trim().split("\n")[0]
+      : null,
+  };
+}
+
+export async function diagnose({
+  context,
+  environment = process.env,
+  fetchImplementation = fetch,
+  run = spawnSync,
+  agent = null,
+  inspectSkill = inspectSystemSkill,
+  inspectGitAuth = inspectGitAuthLive,
+}) {
+  const profile = context.profile;
+  let identity = null;
+  let api = { reachable: false, authenticated: false, status: null };
+  if (profile.api_base_url && profile.personal_api_key) {
+    try {
+      const response = await fetchImplementation(new URL("/api/v1/auth/me", profile.api_base_url), {
+        headers: { Authorization: `ApiKey ${profile.personal_api_key}`, Accept: "application/json", "X-CDO-Client": "cdo-cli", "X-CDO-Version": VERSION },
+        redirect: "error",
+        signal: AbortSignal.timeout(10_000),
+      });
+      api = { reachable: true, authenticated: response.ok, status: response.status };
+      const body = await response.json().catch(() => null);
+      if (response.ok) identity = body?.data || null;
+    } catch (error) {
+      api = { reachable: false, authenticated: false, status: null, error: error?.code || error?.name || "request_failed" };
+    }
+  }
+  const liveUser = identity ? { id: identity.user_id || identity.id, name: identity.name || identity.display_name, role: identity.role, verified: true } : null;
+  const cachedUser = profile.user ? { ...profile.user, verified: false } : null;
+  const liveEnterpriseId = identity?.enterprise_id || null;
+  const enterprise = liveEnterpriseId
+    ? { id: liveEnterpriseId, cache_matches: profile.enterprise?.id === liveEnterpriseId, ...(profile.enterprise?.id === liveEnterpriseId ? profile.enterprise : {}) }
+    : profile.enterprise ? { ...profile.enterprise, verified: false } : null;
+  const systemSkill = agent
+    ? await inspectSkill({ agent, environment, fetchImplementation })
+    : { status: "not_checked", installed_version: null, latest_version: null };
+  const gitAuth = api.authenticated ? await inspectGitAuth({ context, fetchImplementation, run }) : {
+    status: "not_authenticated", tea_api_ready: false, git_ssh_ready: false,
+  };
+  return {
+    environment: context.environmentName,
+    profile_id: context.profileId || null,
+    selection_source: context.selectionSource,
+    user_default_profile_id: context.userDefaultProfileId || null,
+    api_base_url: profile.api_base_url || null,
+    enterprise,
+    user: liveUser || cachedUser,
+    key_available: Boolean(profile.personal_api_key),
+    api,
+    cli: { version: VERSION },
+    system_skill: systemSkill,
+    git_auth: gitAuth,
+    git: executableStatus("git", run),
+    tea: executableStatus("tea", run),
+  };
+}