@cdo-ai/cli 0.1.0

package/bin/cdo.mjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+import { login } from "../lib/login.mjs";
+import { openBrowser } from "../lib/browser.mjs";
+import {
+  apiOriginForEnvironment,
+  clearProjectContext,
+  ensureConfigV2,
+  findProfile,
+  listProfiles,
+  loadConfig,
+  resolveContext,
+  saveProjectContext,
+  setDefaultProfile,
+  validateEnterpriseCode,
+} from "../lib/config.mjs";
+import { callApi } from "../lib/api.mjs";
+import { diagnose } from "../lib/doctor.mjs";
+import { installOrUpdateSkill } from "../lib/skills.mjs";
+import { gitAuth } from "../lib/git-auth.mjs";
+import { VERSION } from "../lib/version.mjs";
+
+const HELP = `用法：cdo <命令> [选项]
+命令：
+  login --env <dev|staging|prod> --enterprise <企业码> [--set-default] [--api-url <url>]
+  auth list --json | use <profile> | status|key [--profile <profile>] [--env <环境>]
+  context use <profile> | clear | show
+  doctor --agent <codex|claude> [--json] [--profile <profile>] [--env <环境>]
+  api <METHOD> <相对路径> [--profile <profile>] [--env <环境>]
+  git auth [--json] [--profile <profile>] [--env <环境>]
+  skills install|update cdo-sys-local --agent <codex|claude> [--source-env <环境>]
+`;
+
+function optionValue(args, name) {
+  const index = args.indexOf(name);
+  if (index === -1) return null;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${name} 缺少值`);
+  return value;
+}
+
+function hasOption(args, name) {
+  return args.includes(name);
+}
+
+function validateOptions(args, { values = [], flags = [], positional = 0 } = {}) {
+  const valueNames = new Set(values);
+  const flagNames = new Set(flags);
+  const seen = new Set();
+  const positionals = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (valueNames.has(argument)) {
+      if (seen.has(argument)) throw new Error(`重复选项：${argument}`);
+      seen.add(argument);
+      const value = args[index + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${argument} 缺少值`);
+      index += 1;
+    } else if (flagNames.has(argument)) {
+      if (seen.has(argument)) throw new Error(`重复选项：${argument}`);
+      seen.add(argument);
+    } else if (argument.startsWith("-")) {
+      throw new Error(`未知选项：${argument}`);
+    } else {
+      positionals.push(argument);
+    }
+  }
+  if (positionals.length !== positional) throw new Error("命令参数数量无效");
+}
+
+function validateCommandLine(args) {
+  const [top, second, third] = args;
+  const identityValues = ["--profile", "--env"];
+  if (top === "login") {
+    return validateOptions(args.slice(1), {
+      values: ["--env", "--enterprise", "--api-url"], flags: ["--set-default"],
+    });
+  }
+  if (top === "auth" && second === "list") {
+    return validateOptions(args.slice(2), { flags: ["--json"] });
+  }
+  if (top === "auth" && second === "use") return validateOptions(args.slice(2), { positional: 1 });
+  if (top === "auth" && ["status", "key"].includes(second)) {
+    return validateOptions(args.slice(2), { values: identityValues });
+  }
+  if (top === "context" && second === "use") return validateOptions(args.slice(2), { positional: 1 });
+  if (top === "context" && second === "clear") return validateOptions(args.slice(2));
+  if (top === "context" && second === "show") {
+    return validateOptions(args.slice(2), { values: identityValues });
+  }
+  if (top === "doctor") {
+    return validateOptions(args.slice(1), { values: [...identityValues, "--agent"], flags: ["--json"] });
+  }
+  if (top === "api") {
+    if (!second || !third || second.startsWith("-") || third.startsWith("-")) {
+      throw new Error("用法：cdo api <METHOD> <相对路径>");
+    }
+    return validateOptions(args.slice(3), {
+      values: [...identityValues, "--data", "--data-file", "--output"],
+    });
+  }
+  if (top === "git" && second === "auth") {
+    return validateOptions(args.slice(2), { values: identityValues, flags: ["--json"] });
+  }
+  if (top === "skills" && ["install", "update"].includes(second) && third === "cdo-sys-local") {
+    return validateOptions(args.slice(3), { values: ["--agent", "--source-env"] });
+  }
+  throw new Error(`未知或当前阶段不可用的命令：${[top, second].filter(Boolean).join(" ")}`);
+}
+
+const rawArgs = process.argv.slice(2);
+const [command, subcommand] = rawArgs;
+
+async function main() {
+  if (rawArgs.length === 1 && ["--version", "-V"].includes(command)) {
+    process.stdout.write(`${VERSION}\n`);
+    return;
+  }
+  if (!command || rawArgs.includes("--help") || rawArgs.includes("-h")) {
+    process.stdout.write(HELP);
+    return;
+  }
+  validateCommandLine(rawArgs);
+  const requestedEnvironment = optionValue(rawArgs, "--env");
+  const requestedProfile = optionValue(rawArgs, "--profile");
+  // System Skill repair is host/source scoped and must remain usable when identity config is unreadable.
+  if (command === "skills" && ["install", "update"].includes(subcommand)) {
+    if (rawArgs[2] !== "cdo-sys-local") throw new Error("只支持平台系统 Skill：cdo-sys-local");
+    const agent = optionValue(rawArgs, "--agent");
+    if (!agent) throw new Error("系统 Skill 安装更新必须显式提供 --agent");
+    const sourceEnvironment = optionValue(rawArgs, "--source-env");
+    const result = await installOrUpdateSkill({
+      action: subcommand, agent,
+      sourceEnvironment: sourceEnvironment || (subcommand === "install" ? "prod" : null),
+      sourceApiBaseUrl: sourceEnvironment || subcommand === "install"
+        ? apiOriginForEnvironment(sourceEnvironment || "prod") : null,
+    });
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+  await ensureConfigV2();
+  if (command === "login") {
+    const enterprise = optionValue(rawArgs, "--enterprise");
+    if (!enterprise) throw new Error("cdo login 必须显式提供 --enterprise");
+    await login({
+      environmentName: requestedEnvironment || process.env.CDO_ENV || "prod",
+      enterpriseCode: validateEnterpriseCode(enterprise),
+      apiBaseUrl: optionValue(rawArgs, "--api-url"),
+      setDefault: hasOption(rawArgs, "--set-default"),
+      openBrowser,
+    });
+    return;
+  }
+  if (command === "auth" && subcommand === "list") {
+    const config = await loadConfig();
+    const profiles = listProfiles(config).map(({ personal_api_key: _secret, ...profile }) => ({
+      ...profile,
+      default: profile.id === config.default_profile_id,
+      key_available: Boolean(_secret),
+    }));
+    process.stdout.write(`${JSON.stringify(profiles, null, 2)}\n`);
+    return;
+  }
+  if (command === "auth" && subcommand === "use") {
+    const selector = rawArgs[2];
+    if (!selector || selector.startsWith("--")) throw new Error("用法：cdo auth use <profile>");
+    const profile = await setDefaultProfile(selector);
+    process.stdout.write(`用户默认身份：${profile.alias} (${profile.id})\n`);
+    try {
+      const effective = await resolveContext({ requireKey: false });
+      process.stdout.write(
+        `当前有效身份：${effective.profile.alias || effective.profileId || "直接配置"}`
+        + `${effective.profileId ? ` (${effective.profileId})` : ""} | 来源：${effective.selectionSource}\n`,
+      );
+    } catch (error) {
+      process.stderr.write(`警告：用户默认身份已更新，但当前有效身份无法解析：${error.message || error}\n`);
+    }
+    return;
+  }
+  if (command === "auth" && subcommand === "key") {
+    const context = await resolveContext({ requestedEnvironment, requestedProfile });
+    process.stdout.write(`${context.profile.personal_api_key}\n`);
+    return;
+  }
+  if (command === "auth" && subcommand === "status") {
+    const context = await resolveContext({ requestedEnvironment, requestedProfile, requireKey: false });
+    const data = {
+      environment: context.environmentName,
+      api_base_url: context.profile.api_base_url || null,
+      enterprise: context.profile.enterprise || null,
+      user: context.profile.user || null,
+      key_available: Boolean(context.profile.personal_api_key),
+      source: context.profile.source,
+      profile_id: context.profileId || null,
+      profile_alias: context.profile.alias || null,
+      user_default_profile_id: context.userDefaultProfileId,
+      selection_source: context.selectionSource,
+    };
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+    return;
+  }
+  if (command === "context" && subcommand === "use") {
+    const selector = rawArgs[2];
+    if (!selector || selector.startsWith("--")) throw new Error("用法：cdo context use <profile>");
+    const config = await loadConfig();
+    const profile = findProfile(config, selector);
+    await saveProjectContext(profile.id);
+    process.stdout.write(`当前目录默认身份：${profile.alias} (${profile.id})\n`);
+    return;
+  }
+  if (command === "context" && subcommand === "clear") {
+    await clearProjectContext();
+    process.stdout.write("已清除当前目录默认身份\n");
+    return;
+  }
+  if (command === "context" && subcommand === "show") {
+    const context = await resolveContext({ requestedEnvironment, requestedProfile, requireKey: false });
+    process.stdout.write(`${JSON.stringify({
+      profile_id: context.profileId || null,
+      profile_alias: context.profile.alias || null,
+      environment: context.environmentName,
+      selection_source: context.selectionSource,
+      user_default_profile_id: context.userDefaultProfileId,
+      project_profile_id: context.projectProfileId || null,
+    }, null, 2)}\n`);
+    return;
+  }
+  if (command === "doctor") {
+    const agent = optionValue(rawArgs, "--agent");
+    if (!agent) throw new Error("cdo doctor 必须显式提供 --agent");
+    if (!["codex", "claude"].includes(agent)) throw new Error("--agent 必须是 codex 或 claude");
+    const context = await resolveContext({ requestedEnvironment, requestedProfile, requireKey: false });
+    const result = await diagnose({ context, agent });
+    if (hasOption(rawArgs, "--json")) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    else {
+      process.stdout.write([
+        `环境：${result.environment}`,
+        `CDO API：${result.api.reachable ? result.api.status : "不可达"}`,
+        `用户 Key：${result.key_available ? "已配置" : "未配置"}`,
+        `身份：${result.api.authenticated ? "服务端已验证" : "未验证"}`,
+        `系统 Skill：${result.system_skill.status}`,
+        `企业 Git：${result.git_auth.status}`,
+        `Git：${result.git.available ? result.git.version : "未安装"}`,
+        `Tea：${result.tea.available ? result.tea.version : "未安装"}`,
+      ].join("\n") + "\n");
+    }
+    return;
+  }
+  if (command === "api") {
+    if (!subcommand || !rawArgs[2] || subcommand.startsWith("--") || rawArgs[2].startsWith("--")) {
+      throw new Error("用法：cdo api <METHOD> <相对路径>");
+    }
+    const context = await resolveContext({ requestedEnvironment, requestedProfile });
+    await callApi({
+      profile: context.profile,
+      method: subcommand,
+      relativePath: rawArgs[2],
+      data: optionValue(rawArgs, "--data"),
+      dataFile: optionValue(rawArgs, "--data-file"),
+      outputFile: optionValue(rawArgs, "--output"),
+    });
+    return;
+  }
+  if (command === "git" && subcommand === "auth") {
+    const context = await resolveContext({ requestedEnvironment, requestedProfile });
+    const result = await gitAuth({ context, openBrowser });
+    process.stdout.write(hasOption(rawArgs, "--json")
+      ? `${JSON.stringify(result, null, 2)}\n`
+      : `企业 Git 认证完成：${result.enterprise_name}\nTea 配置：${result.tea_login}\n`);
+    return;
+  }
+  throw new Error(`未知或当前阶段不可用的命令：${[command, subcommand].filter(Boolean).join(" ")}`);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error.message || error}\n`);
+  process.exitCode = 1;
+});

package/lib/api.mjs

@@ -0,0 +1,64 @@
+import { readFile, writeFile } from "node:fs/promises";
+
+import { VERSION } from "./version.mjs";
+
+function errorMessage(response, body) {
+  return body?.error?.message || body?.message || `CDO API request failed (${response.status})`;
+}
+
+export function resolveApiUrl(apiBaseUrl, relativePath) {
+  if (typeof relativePath !== "string" || !relativePath.startsWith("/") || relativePath.startsWith("//")) {
+    throw new Error("API 路径必须是以 / 开头的相对路径");
+  }
+  const base = new URL(apiBaseUrl);
+  const url = new URL(relativePath, base);
+  if (url.origin !== base.origin) throw new Error("API 路径不得指向其他服务");
+  return url;
+}
+
+export async function callApi({
+  profile,
+  method,
+  relativePath,
+  data = null,
+  dataFile = null,
+  outputFile = null,
+  fetchImplementation = fetch,
+  stdout = process.stdout,
+}) {
+  if (data !== null && dataFile !== null) throw new Error("--data 与 --data-file 不能同时使用");
+  const normalizedMethod = String(method || "").toUpperCase();
+  if (!/^[A-Z]+$/.test(normalizedMethod)) throw new Error("METHOD 无效");
+  const headers = { Authorization: `ApiKey ${profile.personal_api_key}`, Accept: "application/json", "X-CDO-Client": "cdo-cli", "X-CDO-Version": VERSION };
+  let body;
+  if (data !== null || dataFile !== null) {
+    const source = dataFile !== null ? await readFile(dataFile, "utf8") : data;
+    try {
+      body = JSON.stringify(JSON.parse(source));
+    } catch {
+      throw new Error("请求数据必须是有效 JSON");
+    }
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await fetchImplementation(resolveApiUrl(profile.api_base_url, relativePath), {
+    method: normalizedMethod,
+    headers,
+    body,
+    redirect: "error",
+    signal: AbortSignal.timeout(30_000),
+  });
+  const bytes = Buffer.from(await response.arrayBuffer());
+  let parsed = null;
+  if ((response.headers.get("content-type") || "").includes("json")) {
+    try { parsed = JSON.parse(bytes.toString("utf8")); } catch { /* report the raw invalid response */ }
+  }
+  if (!response.ok) throw new Error(errorMessage(response, parsed));
+  if (outputFile) {
+    await writeFile(outputFile, bytes);
+  } else if (parsed !== null) {
+    stdout.write(`${JSON.stringify(parsed, null, 2)}\n`);
+  } else {
+    stdout.write(bytes);
+  }
+  return { status: response.status, bytes: bytes.length };
+}

package/lib/browser.mjs

@@ -0,0 +1,14 @@
+import { spawn } from "node:child_process";
+
+/** Build an OS URL opener command without routing an untrusted URL through a shell. */
+export function browserCommand(url, platform = process.platform) {
+  if (platform === "darwin") return { program: "open", args: [url] };
+  if (platform === "win32") return { program: "explorer.exe", args: [url] };
+  return { program: "xdg-open", args: [url] };
+}
+
+/** Open a URL in the user's browser while preserving it as one literal process argument. */
+export function openBrowser(url, platform = process.platform, spawnImplementation = spawn) {
+  const command = browserCommand(url, platform);
+  spawnImplementation(command.program, command.args, { detached: true, shell: false, stdio: "ignore" }).unref();
+}