@cimplify/sdk 0.40.1 → 0.42.0

package/dist/cli/commands/login.mjs

@@ -0,0 +1,515 @@
+import os from 'os';
+import { promises } from 'fs';
+import path from 'path';
+import { randomBytes, createHash } from 'crypto';
+import { createServer } from 'http';
+import { spawn } from 'child_process';
+
+// src/cli/commands/login.ts
+
+// src/cli/errors.ts
+var CLI_ERROR_CODE = {
+  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",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  TIMEOUT: "TIMEOUT"
+};
+var EXIT_CODE = {
+  ERROR: 1};
+var CliError = class extends Error {
+  constructor(code, message, exitCode = EXIT_CODE.ERROR) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.exitCode = exitCode;
+  }
+};
+
+// 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) {
+  if (override && override.length > 0) return 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 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";
+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);
+}
+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 });
+  {
+    await promises.chmod(filePath, mode);
+  }
+}
+async function writeAuth(creds) {
+  await writeJsonFile(authConfigPath(), creds, FILE_MODE_PRIVATE);
+}
+var CODE_VERIFIER_BYTES = 32;
+var STATE_BYTES = 16;
+var LOOPBACK_HOST = "127.0.0.1";
+var CALLBACK_PATH = "/callback";
+var CALLBACK_TIMEOUT_MS = 10 * 60 * 1e3;
+function generatePkcePair() {
+  const codeVerifier = base64UrlEncode(randomBytes(CODE_VERIFIER_BYTES));
+  const codeChallenge = base64UrlEncode(
+    createHash("sha256").update(codeVerifier).digest()
+  );
+  return { codeVerifier, codeChallenge, codeChallengeMethod: "S256" };
+}
+function generateState() {
+  return base64UrlEncode(randomBytes(STATE_BYTES));
+}
+function base64UrlEncode(buf) {
+  return buf.toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+var HTML_SUCCESS = (apiBaseUrl) => `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Cimplify CLI</title>
+<style>
+body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;
+  background:#0a0a0a;color:#e5e5e5;display:flex;align-items:center;
+  justify-content:center;height:100vh;margin:0}
+.card{background:#141414;border:1px solid #262626;border-radius:12px;
+  padding:32px 40px;max-width:420px;text-align:center}
+.tick{color:#22c55e;font-size:32px}
+h1{margin:8px 0 4px;font-size:20px;font-weight:600}
+p{margin:4px 0;color:#a3a3a3;font-size:14px}
+.host{color:#737373;font-family:ui-monospace,monospace;font-size:12px;margin-top:16px}
+</style></head><body><div class="card">
+<div class="tick">\u2713</div>
+<h1>You're logged in</h1>
+<p>Return to your terminal \u2014 it'll continue from here.</p>
+<p>You can close this tab.</p>
+<div class="host">${apiBaseUrl}</div>
+</div></body></html>`;
+var HTML_ERROR = (msg) => `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Cimplify CLI</title>
+<style>body{font-family:sans-serif;padding:40px;max-width:480px;margin:auto}
+h1{color:#dc2626}</style></head><body>
+<h1>Sign-in failed</h1><p>${escapeHtml(msg)}</p>
+<p>Return to your terminal and try <code>cimplify login</code> again.</p>
+</body></html>`;
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+async function startLoopbackServer(apiBaseUrl) {
+  let resolveCb = null;
+  let rejectCb = null;
+  const callbackPromise = new Promise((resolve, reject) => {
+    resolveCb = resolve;
+    rejectCb = reject;
+  });
+  const server = createServer((req, res) => {
+    if (!req.url) {
+      res.writeHead(400).end();
+      return;
+    }
+    const parsed = new URL(req.url, `http://${LOOPBACK_HOST}`);
+    if (parsed.pathname !== CALLBACK_PATH) {
+      res.writeHead(404).end("Not Found");
+      return;
+    }
+    const code = parsed.searchParams.get("code");
+    const state = parsed.searchParams.get("state");
+    const error = parsed.searchParams.get("error");
+    if (error) {
+      res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" }).end(HTML_ERROR(error));
+      rejectCb?.(new CliError(CLI_ERROR_CODE.UNAUTHORIZED, `OAuth error: ${error}`));
+      return;
+    }
+    if (!code || !state) {
+      res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" }).end(HTML_ERROR("Missing code or state in callback"));
+      rejectCb?.(new CliError(CLI_ERROR_CODE.UNAUTHORIZED, "Malformed callback"));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" }).end(HTML_SUCCESS(apiBaseUrl));
+    resolveCb?.({ code, state });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, LOOPBACK_HOST, resolve);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    server.close();
+    throw new CliError(
+      CLI_ERROR_CODE.UNAUTHORIZED,
+      "Could not bind loopback server"
+    );
+  }
+  const redirectUri = `http://${LOOPBACK_HOST}:${address.port}${CALLBACK_PATH}`;
+  return {
+    redirectUri,
+    async awaitCallback(timeoutMs = CALLBACK_TIMEOUT_MS) {
+      let timer = null;
+      const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          reject(
+            new CliError(
+              CLI_ERROR_CODE.TIMEOUT,
+              `Login timed out after ${Math.round(timeoutMs / 1e3)}s`
+            )
+          );
+        }, timeoutMs);
+      });
+      try {
+        return await Promise.race([callbackPromise, timeoutPromise]);
+      } finally {
+        if (timer) clearTimeout(timer);
+        server.close();
+      }
+    },
+    close() {
+      server.close();
+    }
+  };
+}
+function openBrowser(url) {
+  const platformCommand = (() => {
+    switch (process.platform) {
+      case "darwin":
+        return { cmd: "open", args: [url] };
+      case "win32":
+        return { cmd: "cmd", args: ["/c", "start", '""', url] };
+      default:
+        return { cmd: "xdg-open", args: [url] };
+    }
+  })();
+  try {
+    const child = spawn(platformCommand.cmd, platformCommand.args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+// src/cli/output.ts
+var RESET = "\x1B[0m";
+var DIM_OPEN = "\x1B[2m";
+var GREEN_OPEN = "\x1B[32m";
+var CYAN_OPEN = "\x1B[36m";
+var PREFIX_STEP = "\u25B8";
+var PREFIX_SUCCESS = "\u2713";
+function wrap(open, value) {
+  return `${open}${value}${RESET}`;
+}
+function dim(value) {
+  return wrap(DIM_OPEN, value);
+}
+function green(value) {
+  return wrap(GREEN_OPEN, value);
+}
+function cyan(value) {
+  return wrap(CYAN_OPEN, value);
+}
+function step(message) {
+  console.log(`${cyan(PREFIX_STEP)} ${message}`);
+}
+function success(message) {
+  console.log(`${green(PREFIX_SUCCESS)} ${message}`);
+}
+function info(message) {
+  console.log(message);
+}
+
+// src/cli/commands/login.ts
+var FLAG_API_KEY = "api-key";
+var FLAG_BASE_URL = "base-url";
+var FLAG_NO_BROWSER = "no-browser";
+var ENDPOINT_AUTH_ME = "/v1/auth/me";
+var ENDPOINT_CLI_START = "/v1/auth/cli/start";
+var ENDPOINT_CLI_TOKEN = "/v1/auth/cli/token";
+var KEY_PREFIX_DK = "dk_";
+var KEY_PREFIX_SK = "sk_";
+var PRODUCT_NAME = "cimplify-cli";
+async function run(argv) {
+  const args = parseArgs(argv);
+  const baseUrl = resolveBaseUrl(flagString(args, FLAG_BASE_URL));
+  const explicitKey = flagString(args, FLAG_API_KEY);
+  if (explicitKey) {
+    await loginWithKey(baseUrl, explicitKey);
+    return;
+  }
+  await loginWithBrowser(baseUrl, flagBool(args, FLAG_NO_BROWSER));
+}
+async function loginWithKey(baseUrl, apiKey) {
+  if (!apiKey.startsWith(KEY_PREFIX_DK) && !apiKey.startsWith(KEY_PREFIX_SK)) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `API key must start with "${KEY_PREFIX_DK}" or "${KEY_PREFIX_SK}".`
+    );
+  }
+  const client = ApiClient.withKey(apiKey, baseUrl);
+  const me = await client.get(ENDPOINT_AUTH_ME);
+  await writeAuth({
+    apiKey,
+    apiBaseUrl: baseUrl,
+    accountId: me.id,
+    businessId: me.business_id,
+    email: me.email,
+    name: me.name,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  success(`Logged in as ${me.email ?? me.name ?? me.id} (business ${me.business_id})`);
+}
+async function loginWithBrowser(baseUrl, noBrowser) {
+  const pkce = generatePkcePair();
+  const state = generateState();
+  const loopback = await startLoopbackServer(baseUrl);
+  const startBody = {
+    code_challenge: pkce.codeChallenge,
+    code_challenge_method: pkce.codeChallengeMethod,
+    redirect_uri: loopback.redirectUri,
+    state,
+    client_meta: {
+      hostname: os.hostname(),
+      platform: process.platform,
+      arch: process.arch,
+      node_version: process.version,
+      product: PRODUCT_NAME
+    }
+  };
+  const unauthClient = ApiClient.unauthenticated(baseUrl);
+  const startResponse = await unauthClient.post(
+    ENDPOINT_CLI_START,
+    startBody
+  );
+  step("Opening browser to authorize this CLI...");
+  info(dim(startResponse.approval_url));
+  if (!noBrowser) {
+    openBrowser(startResponse.approval_url);
+  } else {
+    info("");
+    info(dim("Open the URL above in any browser to continue."));
+  }
+  let callback;
+  try {
+    callback = await loopback.awaitCallback(startResponse.expires_in_secs * 1e3);
+  } catch (err) {
+    loopback.close();
+    throw err;
+  }
+  if (callback.state !== state) {
+    throw new CliError(
+      CLI_ERROR_CODE.UNAUTHORIZED,
+      "OAuth state mismatch. Possible CSRF attempt \u2014 try again."
+    );
+  }
+  const token = await unauthClient.post(ENDPOINT_CLI_TOKEN, {
+    auth_code: callback.code,
+    code_verifier: pkce.codeVerifier,
+    redirect_uri: loopback.redirectUri
+  });
+  const meClient = ApiClient.withKey(token.access_token, baseUrl);
+  const me = await meClient.get(ENDPOINT_AUTH_ME);
+  await writeAuth({
+    apiKey: token.access_token,
+    apiBaseUrl: baseUrl,
+    accountId: me.id,
+    businessId: me.business_id,
+    email: me.email,
+    name: me.name,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  success(
+    `Logged in as ${me.email ?? me.name ?? me.id} (business ${me.business_id})`
+  );
+}
+
+export { run as default };

package/dist/cli/commands/logout.mjs

@@ -0,0 +1,54 @@
+import { promises } from 'fs';
+import os from 'os';
+import path from 'path';
+
+// src/cli/config.ts
+var AUTH_FILE_NAME = "auth.json";
+var ENV_XDG_CONFIG_HOME = "XDG_CONFIG_HOME";
+var APP_CONFIG_DIR_NAME = "cimplify";
+var HOME_CONFIG_DIR_NAME = ".config";
+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);
+}
+async function clearAuth() {
+  try {
+    await promises.unlink(authConfigPath());
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+
+// src/cli/output.ts
+var RESET = "\x1B[0m";
+var GREEN_OPEN = "\x1B[32m";
+var PREFIX_SUCCESS = "\u2713";
+function wrap(open, value) {
+  return `${open}${value}${RESET}`;
+}
+function green(value) {
+  return wrap(GREEN_OPEN, value);
+}
+function success(message) {
+  console.log(`${green(PREFIX_SUCCESS)} ${message}`);
+}
+function info(message) {
+  console.log(message);
+}
+
+// src/cli/commands/logout.ts
+async function run(_argv) {
+  const removed = await clearAuth();
+  if (removed) {
+    success("Logged out.");
+  } else {
+    info("Not logged in.");
+  }
+}
+
+export { run as default };