@cimplify/sdk 0.44.33 → 0.44.34

package/dist/cli/commands/repo.mjs

@@ -0,0 +1,584 @@
+import { promises } from 'fs';
+import os from 'os';
+import path from 'path';
+import readline from 'readline';
+
+// src/cli/errors.ts
+var CLI_ERROR_CODE = {
+  NOT_LOGGED_IN: "NOT_LOGGED_IN",
+  NOT_LINKED: "NOT_LINKED",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  AUTH_FAILED: "AUTH_FAILED",
+  PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND",
+  INVALID_INPUT: "INVALID_INPUT",
+  ALREADY_LINKED: "ALREADY_LINKED",
+  SERVER_ERROR: "SERVER_ERROR",
+  ABORTED: "ABORTED",
+  /** Operation needs interactive confirmation and the shell is non-interactive. */
+  INTERACTIVE_REQUIRED: "INTERACTIVE_REQUIRED"
+};
+var EXIT_CODE = {
+  ABORTED: 3,
+  NOT_LINKED: 4,
+  ALREADY_LINKED: 5,
+  GIT_ERROR: 6,
+  INTERACTIVE_REQUIRED: 7,
+  PROJECT_NOT_FOUND: 8,
+  NETWORK_ERROR: 10,
+  SERVER_ERROR: 11,
+  TIMEOUT: 12,
+  NOT_LOGGED_IN: 20,
+  AUTH_FAILED: 21,
+  UNAUTHORIZED: 22,
+  INVALID_INPUT: 30
+};
+var EXIT_CODE_FOR = {
+  NOT_LOGGED_IN: EXIT_CODE.NOT_LOGGED_IN,
+  NOT_LINKED: EXIT_CODE.NOT_LINKED,
+  NETWORK_ERROR: EXIT_CODE.NETWORK_ERROR,
+  AUTH_FAILED: EXIT_CODE.AUTH_FAILED,
+  PROJECT_NOT_FOUND: EXIT_CODE.PROJECT_NOT_FOUND,
+  GIT_ERROR: EXIT_CODE.GIT_ERROR,
+  INVALID_INPUT: EXIT_CODE.INVALID_INPUT,
+  ALREADY_LINKED: EXIT_CODE.ALREADY_LINKED,
+  SERVER_ERROR: EXIT_CODE.SERVER_ERROR,
+  ABORTED: EXIT_CODE.ABORTED,
+  UNAUTHORIZED: EXIT_CODE.UNAUTHORIZED,
+  TIMEOUT: EXIT_CODE.TIMEOUT,
+  INTERACTIVE_REQUIRED: EXIT_CODE.INTERACTIVE_REQUIRED
+};
+var CliError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.exitCode = options.exitCode ?? EXIT_CODE_FOR[code];
+    this.remediation = options.remediation;
+  }
+};
+
+// src/cli/api-client.ts
+var DEFAULT_API_BASE_URL = "https://api.cimplify.io";
+var ENV_API_BASE_URL = "CIMPLIFY_API_URL";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var HEADER_AUTHORIZATION = "Authorization";
+var HEADER_CONTENT_TYPE = "Content-Type";
+var HEADER_ACCEPT = "Accept";
+var HEADER_USER_AGENT = "User-Agent";
+var BEARER_PREFIX = "Bearer ";
+var CONTENT_TYPE_JSON = "application/json";
+var USER_AGENT = "cimplify-cli";
+var METHOD_GET = "GET";
+var METHOD_POST = "POST";
+var METHOD_PUT = "PUT";
+var METHOD_DELETE = "DELETE";
+var STATUS_UNAUTHORIZED = 401;
+var STATUS_FORBIDDEN = 403;
+var STATUS_NOT_FOUND = 404;
+var STATUS_CONFLICT = 409;
+var STATUS_BAD_REQUEST_MIN = 400;
+var STATUS_SERVER_ERROR_MIN = 500;
+var ApiClient = class _ApiClient {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+  }
+  static fromAuth(auth) {
+    return new _ApiClient(auth.apiBaseUrl, auth.apiKey);
+  }
+  static unauthenticated(baseUrl = resolveBaseUrl()) {
+    return new _ApiClient(baseUrl, "");
+  }
+  static withKey(apiKey, baseUrl = resolveBaseUrl()) {
+    return new _ApiClient(baseUrl, apiKey);
+  }
+  get(pathname, options) {
+    return this.request(METHOD_GET, pathname, void 0, options);
+  }
+  post(pathname, body, options) {
+    return this.request(METHOD_POST, pathname, body, options);
+  }
+  put(pathname, body, options) {
+    return this.request(METHOD_PUT, pathname, body, options);
+  }
+  delete(pathname, options) {
+    return this.request(METHOD_DELETE, pathname, void 0, options);
+  }
+  async request(method, pathname, body, options) {
+    const url = this.buildUrl(pathname, options?.query);
+    const headers = {
+      [HEADER_ACCEPT]: CONTENT_TYPE_JSON,
+      [HEADER_USER_AGENT]: USER_AGENT
+    };
+    if (this.apiKey) {
+      headers[HEADER_AUTHORIZATION] = `${BEARER_PREFIX}${this.apiKey}`;
+    }
+    let payload;
+    if (body !== void 0) {
+      headers[HEADER_CONTENT_TYPE] = CONTENT_TYPE_JSON;
+      payload = JSON.stringify(body);
+    }
+    const controller = new AbortController();
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: payload,
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      throw toNetworkError(err);
+    }
+    clearTimeout(timer);
+    return parseResponse(response);
+  }
+  buildUrl(pathname, query) {
+    const base = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    const url = new URL(`${this.baseUrl}${base}`);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v === void 0 || v === null) continue;
+        url.searchParams.set(k, String(v));
+      }
+    }
+    return url.toString();
+  }
+};
+function resolveBaseUrl(override) {
+  const fromEnv = process.env[ENV_API_BASE_URL];
+  return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_API_BASE_URL;
+}
+async function parseResponse(response) {
+  const text = await response.text();
+  let body = void 0;
+  if (text.length > 0) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      throw new CliError(
+        CLI_ERROR_CODE.SERVER_ERROR,
+        `Server returned non-JSON response (status ${response.status}): ${truncate(text)}`
+      );
+    }
+  }
+  if (response.ok) {
+    if (body && typeof body === "object" && "data" in body) {
+      return body.data;
+    }
+    return body;
+  }
+  const code = mapStatusToCode(response.status);
+  const message = extractErrorMessage(body, response.status);
+  throw new CliError(code, message);
+}
+function mapStatusToCode(status) {
+  if (status === STATUS_UNAUTHORIZED) return CLI_ERROR_CODE.AUTH_FAILED;
+  if (status === STATUS_FORBIDDEN) return CLI_ERROR_CODE.AUTH_FAILED;
+  if (status === STATUS_NOT_FOUND) return CLI_ERROR_CODE.PROJECT_NOT_FOUND;
+  if (status === STATUS_CONFLICT) return CLI_ERROR_CODE.ALREADY_LINKED;
+  if (status >= STATUS_SERVER_ERROR_MIN) return CLI_ERROR_CODE.SERVER_ERROR;
+  if (status >= STATUS_BAD_REQUEST_MIN) return CLI_ERROR_CODE.INVALID_INPUT;
+  return CLI_ERROR_CODE.SERVER_ERROR;
+}
+function extractErrorMessage(body, status) {
+  if (body && typeof body === "object") {
+    const envelope = body;
+    if (envelope.error && typeof envelope.error.error_message === "string") {
+      return envelope.error.error_code ? `${envelope.error.error_code}: ${envelope.error.error_message}` : envelope.error.error_message;
+    }
+    if (typeof envelope.message === "string") return envelope.message;
+  }
+  return `HTTP ${status}`;
+}
+function toNetworkError(err) {
+  if (err instanceof DOMException && err.name === "AbortError") {
+    return new CliError(CLI_ERROR_CODE.NETWORK_ERROR, "Request timed out.");
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return new CliError(CLI_ERROR_CODE.NETWORK_ERROR, `Network error: ${message}`);
+}
+function truncate(value, max = 200) {
+  return value.length > max ? `${value.slice(0, max)}\u2026` : value;
+}
+
+// src/cli/args.ts
+function parseArgs(argv) {
+  const positional = [];
+  const flags = /* @__PURE__ */ new Map();
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const eq = arg.indexOf("=");
+    if (eq !== -1) {
+      flags.set(arg.slice(2, eq), arg.slice(eq + 1));
+      continue;
+    }
+    const name = arg.slice(2);
+    const next = argv[i + 1];
+    if (next !== void 0 && !next.startsWith("--")) {
+      flags.set(name, next);
+      i++;
+    } else {
+      flags.set(name, true);
+    }
+  }
+  return { positional, flags };
+}
+function flagString(args, name) {
+  const v = args.flags.get(name);
+  return typeof v === "string" ? v : void 0;
+}
+function flagBool(args, name) {
+  return args.flags.has(name);
+}
+var AUTH_FILE_NAME = "auth.json";
+var PROJECT_FILE_NAME = "project.json";
+var PROJECT_DIR_NAME = ".cimplify";
+var ENV_XDG_CONFIG_HOME = "XDG_CONFIG_HOME";
+var APP_CONFIG_DIR_NAME = "cimplify";
+var HOME_CONFIG_DIR_NAME = ".config";
+var ENCODING_UTF8 = "utf8";
+function authConfigDir() {
+  const xdg = process.env[ENV_XDG_CONFIG_HOME];
+  return xdg ? path.join(xdg, APP_CONFIG_DIR_NAME) : path.join(os.homedir(), HOME_CONFIG_DIR_NAME, APP_CONFIG_DIR_NAME);
+}
+function authConfigPath() {
+  return path.join(authConfigDir(), AUTH_FILE_NAME);
+}
+function projectConfigDir(cwd = process.cwd()) {
+  return path.join(cwd, PROJECT_DIR_NAME);
+}
+function projectConfigPath(cwd = process.cwd()) {
+  return path.join(projectConfigDir(cwd), PROJECT_FILE_NAME);
+}
+async function readJsonFile(filePath) {
+  try {
+    const raw = await promises.readFile(filePath, ENCODING_UTF8);
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function readAuth() {
+  const data = await readJsonFile(authConfigPath());
+  if (!data) {
+    throw new CliError(
+      CLI_ERROR_CODE.NOT_LOGGED_IN,
+      "Not logged in. Run `cimplify login` first."
+    );
+  }
+  return data;
+}
+async function readProjectLink(cwd = process.cwd()) {
+  const data = await readJsonFile(projectConfigPath(cwd));
+  if (!data) {
+    throw new CliError(
+      CLI_ERROR_CODE.NOT_LINKED,
+      "No project linked. Run `cimplify link <project-id>` first."
+    );
+  }
+  return data;
+}
+
+// src/cli/output.ts
+var RESET = "\x1B[0m";
+var BOLD_OPEN = "\x1B[1m";
+var DIM_OPEN = "\x1B[2m";
+var GREEN_OPEN = "\x1B[32m";
+var PREFIX_SUCCESS = "\u2713";
+var ENV_JSON = "CIMPLIFY_JSON";
+var ENV_YES = "CIMPLIFY_YES";
+function envFlag(name) {
+  const v = process.env[name];
+  return v === "1" || v === "true";
+}
+function isJsonMode() {
+  return envFlag(ENV_JSON);
+}
+function isAutoYes() {
+  return envFlag(ENV_YES);
+}
+function isInteractive() {
+  return Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY);
+}
+function wrap(open, value) {
+  return `${open}${value}${RESET}`;
+}
+function bold(value) {
+  return isJsonMode() ? value : wrap(BOLD_OPEN, value);
+}
+function dim(value) {
+  return isJsonMode() ? value : wrap(DIM_OPEN, value);
+}
+function green(value) {
+  return isJsonMode() ? value : wrap(GREEN_OPEN, value);
+}
+function success(message) {
+  if (isJsonMode()) return;
+  console.log(`${green(PREFIX_SUCCESS)} ${message}`);
+}
+function info(message) {
+  if (isJsonMode()) return;
+  console.log(message);
+}
+var ENV_EMITTED = "__CIMPLIFY_RESULT_EMITTED";
+function result(data) {
+  if (!isJsonMode()) return;
+  if (process.env[ENV_EMITTED] === "1") return;
+  process.env[ENV_EMITTED] = "1";
+  process.stdout.write(`${JSON.stringify({ ok: true, data })}
+`);
+}
+async function promptLine(question) {
+  if (!isInteractive()) {
+    throw new CliError(
+      CLI_ERROR_CODE.INTERACTIVE_REQUIRED,
+      "this operation needs interactive input but stdin is not a TTY",
+      { remediation: "run interactively, or supply the value via a flag" }
+    );
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await new Promise((resolve) => {
+      rl.question(question, (answer) => resolve(answer));
+    });
+  } finally {
+    rl.close();
+  }
+}
+async function promptYesNo(question, defaultNo = true) {
+  if (isAutoYes()) return true;
+  if (!isInteractive()) {
+    throw new CliError(
+      CLI_ERROR_CODE.INTERACTIVE_REQUIRED,
+      `this operation needs confirmation: ${question}`,
+      { remediation: "re-run with --yes to accept, or run interactively" }
+    );
+  }
+  const suffix = defaultNo ? " [y/N] " : " [Y/n] ";
+  const answer = (await promptLine(`${question}${suffix}`)).trim().toLowerCase();
+  if (answer === "") return !defaultNo;
+  return answer === "y" || answer === "yes";
+}
+var REPO_PROVIDER = {
+  FREESTYLE: "freestyle",
+  GITHUB: "github",
+  GITEA: "gitea",
+  EXTERNAL: "external"
+};
+var REPO_PROVIDER_VALUES = new Set(Object.values(REPO_PROVIDER));
+var TOKEN_PURPOSE = {
+  EDITOR: "editor"
+};
+
+// src/cli/commands/repo.ts
+var SUB_PROVISION = "provision";
+var SUB_CONNECT = "connect";
+var SUB_INFO = "info";
+var SUB_UNLINK = "unlink";
+var SUB_ROTATE_TOKEN = "rotate-token";
+var SUB_CLONE_URL = "clone-url";
+var FLAG_PURGE = "purge";
+var FLAG_YES = "yes";
+var FLAG_PROVIDER = "provider";
+var FLAG_NAME = "name";
+var FLAG_BRANCH = "branch";
+function repoEndpoint(businessId, projectId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/repo`;
+}
+function provisionEndpoint(businessId, projectId) {
+  return `${repoEndpoint(businessId, projectId)}/provision`;
+}
+function connectEndpoint(businessId, projectId) {
+  return `${repoEndpoint(businessId, projectId)}/connect`;
+}
+function cloneTokenEndpoint(businessId, projectId) {
+  return `${repoEndpoint(businessId, projectId)}/clone-token`;
+}
+async function fetchCloneToken(client, businessId, projectId, purpose = TOKEN_PURPOSE.EDITOR) {
+  return client.post(cloneTokenEndpoint(businessId, projectId), {
+    purpose
+  });
+}
+function resolveProvider(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!REPO_PROVIDER_VALUES.has(value)) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Invalid provider "${value}". Choose: ${[...REPO_PROVIDER_VALUES].join(", ")}.`
+    );
+  }
+  return value;
+}
+function detectProviderFromUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname === "git.freestyle.sh") return REPO_PROVIDER.FREESTYLE;
+    if (parsed.hostname === "github.com" || parsed.hostname.endsWith(".github.com")) {
+      return REPO_PROVIDER.GITHUB;
+    }
+    if (parsed.hostname.includes("gitea")) return REPO_PROVIDER.GITEA;
+  } catch {
+  }
+  return REPO_PROVIDER.EXTERNAL;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const sub = args.positional[0];
+  if (!sub) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Usage: cimplify repo <${SUB_PROVISION}|${SUB_CONNECT}|${SUB_INFO}|${SUB_UNLINK}|${SUB_ROTATE_TOKEN}|${SUB_CLONE_URL}>`
+    );
+  }
+  const auth = await readAuth();
+  const link = await readProjectLink();
+  const client = ApiClient.fromAuth(auth);
+  switch (sub) {
+    case SUB_PROVISION:
+      await provisionRepo(client, link.businessId, link.projectId, args);
+      return;
+    case SUB_CONNECT:
+      await connectRepo(client, link.businessId, link.projectId, args);
+      return;
+    case SUB_INFO:
+      await repoInfo(client, link.businessId, link.projectId);
+      return;
+    case SUB_UNLINK:
+      await unlinkRepo(client, link.businessId, link.projectId, args);
+      return;
+    case SUB_ROTATE_TOKEN:
+      await provisionRepo(client, link.businessId, link.projectId, args);
+      return;
+    case SUB_CLONE_URL:
+      await printCloneUrl(client, link.businessId, link.projectId);
+      return;
+    default:
+      throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `Unknown repo subcommand "${sub}"`);
+  }
+}
+async function printCloneUrl(client, businessId, projectId) {
+  const token = await fetchCloneToken(client, businessId, projectId);
+  if (isJsonMode()) {
+    result({
+      clone_url: token.clone_url,
+      token: token.token ?? null,
+      repo_id: token.repo_id,
+      provider: token.provider,
+      expires_in_seconds: token.expires_in_seconds
+    });
+    return;
+  }
+  process.stdout.write(`${token.clone_url}
+`);
+  const hints = [
+    "",
+    dim(`Token TTL: ${token.expires_in_seconds}s. Re-run to mint a fresh one.`),
+    dim("Example:"),
+    dim(`  git remote set-url origin "${token.clone_url}"`),
+    dim("  # or one-shot:"),
+    dim(`  git push "${token.clone_url}" main`)
+  ];
+  for (const line of hints) process.stderr.write(`${line}
+`);
+}
+async function provisionRepo(client, businessId, projectId, args) {
+  const provider = resolveProvider(flagString(args, FLAG_PROVIDER), REPO_PROVIDER.FREESTYLE);
+  if (provider !== REPO_PROVIDER.FREESTYLE) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Provisioning is only supported for ${REPO_PROVIDER.FREESTYLE} today. Use \`cimplify repo connect\` for ${provider}.`
+    );
+  }
+  const body = {
+    provider,
+    name_hint: flagString(args, FLAG_NAME) ?? void 0,
+    default_branch: flagString(args, FLAG_BRANCH) ?? void 0
+  };
+  const repo = await client.post(provisionEndpoint(businessId, projectId), body);
+  success(`Provisioned ${repo.provider} repo`);
+  printRepo(repo);
+  result({ repo: repoPayload(repo) });
+}
+async function connectRepo(client, businessId, projectId, args) {
+  const remoteUrl = args.positional[1];
+  if (!remoteUrl) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Usage: cimplify repo ${SUB_CONNECT} <https-clone-url> [--provider <p>] [--branch <name>]`
+    );
+  }
+  const provider = resolveProvider(flagString(args, FLAG_PROVIDER), detectProviderFromUrl(remoteUrl));
+  if (provider === REPO_PROVIDER.FREESTYLE) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      "Cannot connect a Freestyle URL \u2014 use `cimplify repo provision` instead."
+    );
+  }
+  const body = {
+    provider,
+    remote_url: remoteUrl,
+    default_branch: flagString(args, FLAG_BRANCH) ?? void 0
+  };
+  const repo = await client.post(connectEndpoint(businessId, projectId), body);
+  success(`Connected ${repo.provider} remote ${repo.remote_url}`);
+  printRepo(repo);
+  result({ repo: repoPayload(repo) });
+}
+async function repoInfo(client, businessId, projectId) {
+  const repo = await client.get(repoEndpoint(businessId, projectId));
+  if (!repo) {
+    info(dim("No repo attached. Run `cimplify repo provision` to mint a Freestyle repo,"));
+    info(dim("or `cimplify repo connect <url>` to link an existing remote."));
+    result({ repo: null });
+    return;
+  }
+  printRepo(repo);
+  result({ repo: repoPayload(repo) });
+}
+async function unlinkRepo(client, businessId, projectId, args) {
+  const purge = flagBool(args, FLAG_PURGE);
+  const skipPrompt = flagBool(args, FLAG_YES);
+  if (!skipPrompt) {
+    const message = purge ? "Unlink and DELETE the upstream Freestyle repo? This cannot be undone." : "Unlink the repo from this project? (Upstream repo will be preserved.)";
+    const proceed = await promptYesNo(message, false);
+    if (!proceed) {
+      throw new CliError(CLI_ERROR_CODE.ABORTED, "Aborted by user.");
+    }
+  }
+  await client.delete(repoEndpoint(businessId, projectId), {
+    query: purge ? { purge: "true" } : void 0
+  });
+  success(purge ? "Repo unlinked and purged" : "Repo unlinked (upstream preserved)");
+  result({ unlinked: true, purged: purge });
+}
+function printRepo(repo) {
+  info(bold("Repo:"));
+  info(`  provider:       ${repo.provider}`);
+  info(`  id:             ${repo.id}`);
+  info(`  remote_url:     ${repo.remote_url}`);
+  info(`  default_branch: ${repo.default_branch}`);
+  if (repo.last_pushed_commit) {
+    info(`  last_pushed:    ${repo.last_pushed_commit.slice(0, 12)} (${repo.last_pushed_at ?? "\u2014"})`);
+  }
+}
+function repoPayload(repo) {
+  return {
+    provider: repo.provider,
+    id: repo.id,
+    remote_url: repo.remote_url,
+    default_branch: repo.default_branch,
+    last_pushed_commit: repo.last_pushed_commit ?? null,
+    last_pushed_at: repo.last_pushed_at ?? null
+  };
+}
+
+export { run as default, fetchCloneToken };