@cimplify/cli 0.2.0

package/dist/chunk-JJYWETGA.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { CliError, CLI_ERROR_CODE } from './chunk-NZ4RG62Z.mjs';
+import { promises } from 'fs';
+import os from 'os';
+import path from 'path';
+
+var AUTH_FILE_NAME = "auth.json";
+var PROJECT_FILE_NAME = "project.json";
+var STATE_FILE_NAME = "state.json";
+var PROJECT_DIR_NAME = ".cimplify";
+var GITIGNORE_FILE_NAME = ".gitignore";
+var ENV_XDG_CONFIG_HOME = "XDG_CONFIG_HOME";
+var APP_CONFIG_DIR_NAME = "cimplify";
+var HOME_CONFIG_DIR_NAME = ".config";
+var FILE_MODE_PRIVATE = 384;
+var FILE_MODE_DIR = 448;
+var ENCODING_UTF8 = "utf8";
+var STATE_GITIGNORE_LINE = `${PROJECT_DIR_NAME}/${STATE_FILE_NAME}`;
+var STATE_GITIGNORE_HEADER = "# cimplify CLI state";
+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);
+}
+function projectStatePath(cwd = process.cwd()) {
+  return path.join(projectConfigDir(cwd), STATE_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 writeJsonFile(filePath, value, mode) {
+  await promises.mkdir(path.dirname(filePath), { recursive: true, mode: FILE_MODE_DIR });
+  const payload = `${JSON.stringify(value, null, 2)}
+`;
+  await promises.writeFile(filePath, payload, { encoding: ENCODING_UTF8, mode });
+  if (mode !== void 0) {
+    await promises.chmod(filePath, mode);
+  }
+}
+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 writeAuth(creds) {
+  await writeJsonFile(authConfigPath(), creds, FILE_MODE_PRIVATE);
+}
+async function clearAuth() {
+  try {
+    await promises.unlink(authConfigPath());
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+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;
+}
+async function writeProjectLink(link, cwd = process.cwd()) {
+  await writeJsonFile(projectConfigPath(cwd), link);
+  await ensureStateGitignored(cwd);
+}
+async function clearProjectLink(cwd = process.cwd()) {
+  let removed = false;
+  for (const target of [projectConfigPath(cwd), projectStatePath(cwd)]) {
+    try {
+      await promises.unlink(target);
+      removed = true;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  return removed;
+}
+async function readProjectState(cwd = process.cwd()) {
+  return readJsonFile(projectStatePath(cwd));
+}
+async function writeProjectState(state, cwd = process.cwd()) {
+  await writeJsonFile(projectStatePath(cwd), state);
+}
+async function ensureStateGitignored(cwd) {
+  const gitignore = path.join(cwd, GITIGNORE_FILE_NAME);
+  let current;
+  try {
+    current = await promises.readFile(gitignore, ENCODING_UTF8);
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+  const lines = current.split("\n").map((l) => l.trim());
+  if (lines.includes(STATE_GITIGNORE_LINE)) return;
+  const separator = current.endsWith("\n") ? "" : "\n";
+  const next = `${current}${separator}
+${STATE_GITIGNORE_HEADER}
+${STATE_GITIGNORE_LINE}
+`;
+  await promises.writeFile(gitignore, next, ENCODING_UTF8);
+}
+
+export { clearAuth, clearProjectLink, readAuth, readProjectLink, readProjectState, writeAuth, writeProjectLink, writeProjectState };

package/dist/chunk-L6474RPL.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { isAutoYes, isInteractive, CliError, CLI_ERROR_CODE } from './chunk-NZ4RG62Z.mjs';
+import readline from 'readline';
+
+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";
+}
+
+export { promptYesNo };

package/dist/chunk-MQMNWLMU.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// src/types.ts
+var ENV_SCOPE = {
+  DEVELOPMENT: "development",
+  PREVIEW: "preview",
+  STAGING: "staging",
+  PRODUCTION: "production"
+};
+var DEPLOY_TRIGGER = {
+  CLI: "cli",
+  ROLLBACK: "rollback",
+  UI_PUBLISH: "ui_publish",
+  WEBHOOK: "webhook",
+  SCHEDULE: "schedule"
+};
+var DEPLOYMENT_STATUS = {
+  QUEUED: "queued",
+  BUILDING: "building",
+  ACTIVE: "active",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+  SUPERSEDED: "superseded"
+};
+var TERMINAL_DEPLOYMENT_STATUSES = /* @__PURE__ */ new Set([
+  DEPLOYMENT_STATUS.ACTIVE,
+  DEPLOYMENT_STATUS.FAILED,
+  DEPLOYMENT_STATUS.CANCELLED,
+  DEPLOYMENT_STATUS.SUPERSEDED
+]);
+var DOMAIN_TYPE = {
+  CUSTOM: "custom",
+  CIMPLIFY: "cimplify"
+};
+var SECRET_MASK = "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+var PUBLIC_ENV_PREFIX = "NEXT_PUBLIC_";
+var REPO_PROVIDER = {
+  FREESTYLE: "freestyle",
+  GITHUB: "github",
+  GITEA: "gitea",
+  EXTERNAL: "external"
+};
+var REPO_PROVIDER_VALUES = new Set(Object.values(REPO_PROVIDER));
+var TOKEN_PURPOSE = {
+  BUILD: "build",
+  EDITOR: "editor"
+};
+
+export { DEPLOYMENT_STATUS, DEPLOY_TRIGGER, DOMAIN_TYPE, ENV_SCOPE, PUBLIC_ENV_PREFIX, REPO_PROVIDER, REPO_PROVIDER_VALUES, SECRET_MASK, TERMINAL_DEPLOYMENT_STATUSES, TOKEN_PURPOSE };

package/dist/chunk-NZ4RG62Z.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+// src/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",
+  GIT_ERROR: "GIT_ERROR",
+  INVALID_INPUT: "INVALID_INPUT",
+  ALREADY_LINKED: "ALREADY_LINKED",
+  SERVER_ERROR: "SERVER_ERROR",
+  ABORTED: "ABORTED",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  TIMEOUT: "TIMEOUT",
+  /** Operation needs interactive confirmation and the shell is non-interactive. */
+  INTERACTIVE_REQUIRED: "INTERACTIVE_REQUIRED",
+  /** Generic resource-not-found (e.g. unknown registry component, missing local fixture). */
+  NOT_FOUND: "NOT_FOUND"
+};
+var EXIT_CODE = {
+  OK: 0,
+  ERROR: 1,
+  SUPERSEDED: 2,
+  ABORTED: 3,
+  NOT_LINKED: 4,
+  ALREADY_LINKED: 5,
+  GIT_ERROR: 6,
+  INTERACTIVE_REQUIRED: 7,
+  PROJECT_NOT_FOUND: 8,
+  NOT_FOUND: 9,
+  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,
+  NOT_FOUND: EXIT_CODE.NOT_FOUND
+};
+var CliError = class extends Error {
+  code;
+  exitCode;
+  remediation;
+  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/output.ts
+var RESET = "\x1B[0m";
+var BOLD_OPEN = "\x1B[1m";
+var DIM_OPEN = "\x1B[2m";
+var RED_OPEN = "\x1B[31m";
+var GREEN_OPEN = "\x1B[32m";
+var YELLOW_OPEN = "\x1B[33m";
+var CYAN_OPEN = "\x1B[36m";
+var PREFIX_STEP = "\u25B8";
+var PREFIX_SUCCESS = "\u2713";
+var PREFIX_FAILURE = "\u2717";
+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 red(value) {
+  return isJsonMode() ? value : wrap(RED_OPEN, value);
+}
+function green(value) {
+  return isJsonMode() ? value : wrap(GREEN_OPEN, value);
+}
+function yellow(value) {
+  return isJsonMode() ? value : wrap(YELLOW_OPEN, value);
+}
+function cyan(value) {
+  return isJsonMode() ? value : wrap(CYAN_OPEN, value);
+}
+function step(message) {
+  if (isJsonMode()) return;
+  console.log(`${cyan(PREFIX_STEP)} ${message}`);
+}
+function success(message) {
+  if (isJsonMode()) return;
+  console.log(`${green(PREFIX_SUCCESS)} ${message}`);
+}
+function failure(message) {
+  if (isJsonMode()) return;
+  console.error(`${red(PREFIX_FAILURE)} ${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 })}
+`);
+}
+
+export { CLI_ERROR_CODE, CliError, EXIT_CODE, bold, dim, failure, green, info, isAutoYes, isInteractive, isJsonMode, red, result, step, success, yellow };

package/dist/chunk-TAMGCHIL.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { TERMINAL_DEPLOYMENT_STATUSES, DEPLOYMENT_STATUS } from './chunk-MQMNWLMU.mjs';
+import { dim, failure, success } from './chunk-NZ4RG62Z.mjs';
+
+// src/progress.ts
+var POLL_INTERVAL_MS = 1e3;
+var POLL_MAX_MS = 30 * 60 * 1e3;
+var BAR_WIDTH = 24;
+var PROGRESS_MIN = 0;
+var PROGRESS_MAX = 100;
+function progressEndpoint(businessId, projectId, deploymentId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/deployments/${encodeURIComponent(deploymentId)}/progress`;
+}
+function renderBar(percent) {
+  const clamped = Math.max(PROGRESS_MIN, Math.min(PROGRESS_MAX, percent));
+  const filled = Math.round(clamped / PROGRESS_MAX * BAR_WIDTH);
+  const empty = BAR_WIDTH - filled;
+  return `[${"#".repeat(filled)}${"-".repeat(empty)}] ${String(clamped).padStart(3)}%`;
+}
+function writeStatusLine(line) {
+  if (process.stdout.isTTY) {
+    process.stdout.write(`\r\x1B[2K${line}`);
+  } else {
+    process.stdout.write(`${line}
+`);
+  }
+}
+function endStatusLine() {
+  if (process.stdout.isTTY) process.stdout.write("\n");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function pollDeployment(client, businessId, projectId, deploymentId, options) {
+  const interval = options?.intervalMs ?? POLL_INTERVAL_MS;
+  const maxDuration = options?.maxDurationMs ?? POLL_MAX_MS;
+  const endpoint = progressEndpoint(businessId, projectId, deploymentId);
+  const startedAt = Date.now();
+  while (true) {
+    const progress = await client.get(endpoint);
+    const message = progress.status_message ?? progress.status;
+    writeStatusLine(`${renderBar(progress.progress ?? 0)} ${dim(message)}`);
+    if (TERMINAL_DEPLOYMENT_STATUSES.has(progress.status)) {
+      endStatusLine();
+      reportTerminal(progress);
+      return progress;
+    }
+    if (Date.now() - startedAt > maxDuration) {
+      endStatusLine();
+      throw new Error("Deployment polling timed out.");
+    }
+    await sleep(interval);
+  }
+}
+function reportTerminal(progress) {
+  switch (progress.status) {
+    case DEPLOYMENT_STATUS.ACTIVE: {
+      const url = progress.url;
+      success(url ? `Deployed: ${url}` : "Deployment active.");
+      return;
+    }
+    case DEPLOYMENT_STATUS.FAILED: {
+      failure(`Deployment failed: ${progress.error_message ?? progress.status_message ?? "no message"}`);
+      return;
+    }
+    case DEPLOYMENT_STATUS.CANCELLED: {
+      failure("Deployment cancelled.");
+      return;
+    }
+    case DEPLOYMENT_STATUS.SUPERSEDED: {
+      failure(
+        progress.superseded_by_deployment_id ? `Deployment superseded by ${progress.superseded_by_deployment_id}.` : "Deployment superseded."
+      );
+      return;
+    }
+    default:
+      return;
+  }
+}
+
+export { pollDeployment };