@intlpullhq/cli 0.1.0

package/dist/api-D35M5BOX.js

@@ -0,0 +1,29 @@
+import {
+  ApiClient,
+  ApiKeysApi,
+  BaseApiClient,
+  BillingApi,
+  DocumentsApi,
+  EmailsApi,
+  ImportExportApi,
+  PLAN_LIMITS,
+  ProjectsApi,
+  TranslationsApi,
+  WorkflowsApi,
+  createApiClient
+} from "./chunk-S3EWA4QD.js";
+import "./chunk-2T7ERBDS.js";
+export {
+  ApiClient,
+  ApiKeysApi,
+  BaseApiClient,
+  BillingApi,
+  DocumentsApi,
+  EmailsApi,
+  ImportExportApi,
+  PLAN_LIMITS,
+  ProjectsApi,
+  TranslationsApi,
+  WorkflowsApi,
+  createApiClient
+};

package/dist/chunk-2T7ERBDS.js

@@ -0,0 +1,394 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/lib/config.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, chmodSync, renameSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+function writeFileAtomic(filePath, content, options) {
+  const dir = dirname(filePath);
+  if (options?.createDir && !existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const tempPath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    writeFileSync(tempPath, content, { mode: options?.mode });
+    renameSync(tempPath, filePath);
+    if (options?.mode) {
+      try {
+        chmodSync(filePath, options.mode);
+      } catch {
+      }
+    }
+  } catch (error) {
+    try {
+      if (existsSync(tempPath)) {
+        unlinkSync(tempPath);
+      }
+    } catch {
+    }
+    throw error;
+  }
+}
+var CONFIG_DIR = join(homedir(), ".intlpull");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var AUTH_FILE = join(CONFIG_DIR, "auth.json");
+var ENV_API_KEY = "INTLPULL_API_KEY";
+var ENV_PROJECT_ID = "INTLPULL_PROJECT_ID";
+var customEnvFile = null;
+function setCustomEnvFile(filePath) {
+  customEnvFile = filePath;
+}
+function getCustomEnvFile() {
+  return customEnvFile;
+}
+function parseEnvFile(content) {
+  const env = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (match) {
+      const key = match[1];
+      let value = match[2].trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (match[2].trim().startsWith('"')) {
+        value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"');
+      }
+      env[key] = value;
+    }
+  }
+  return env;
+}
+function loadEnvFiles(projectDir = process.cwd()) {
+  const loaded = [];
+  const vars = {};
+  const envFiles = [
+    ".env",
+    ".env.development",
+    ".env.local"
+  ];
+  if (customEnvFile) {
+    envFiles.push(customEnvFile);
+  }
+  let currentDir = projectDir;
+  const root = process.platform === "win32" ? currentDir.split(":")[0] + ":\\" : "/";
+  const checkedDirs = [];
+  while (currentDir !== root && checkedDirs.length < 10) {
+    checkedDirs.push(currentDir);
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  for (const dir of checkedDirs.reverse()) {
+    for (const envFile of envFiles) {
+      const filePath = envFile.startsWith("/") || envFile.match(/^[A-Z]:\\/i) ? envFile : join(dir, envFile);
+      if (existsSync(filePath)) {
+        try {
+          const content = readFileSync(filePath, "utf-8");
+          const parsed = parseEnvFile(content);
+          for (const [key, value] of Object.entries(parsed)) {
+            if (process.env[key] === void 0) {
+              process.env[key] = value;
+              vars[key] = value;
+            }
+          }
+          if (Object.keys(parsed).length > 0 && !loaded.includes(filePath)) {
+            loaded.push(filePath);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return { loaded, vars };
+}
+function getEnvProjectId() {
+  return process.env[ENV_PROJECT_ID] || null;
+}
+function detectFramework(projectDir = process.cwd()) {
+  const indicators = [];
+  let framework = "unknown";
+  let library = "react-i18next";
+  let confidence = "low";
+  const nextConfigPaths = [
+    join(projectDir, "next.config.js"),
+    join(projectDir, "next.config.mjs"),
+    join(projectDir, "next.config.ts")
+  ];
+  const hasNextConfig = nextConfigPaths.some((p) => existsSync(p));
+  const packageJsonPath = join(projectDir, "package.json");
+  let packageJson = {};
+  if (existsSync(packageJsonPath)) {
+    try {
+      packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    } catch {
+    }
+  }
+  const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  if (hasNextConfig || deps["next"]) {
+    framework = "next";
+    indicators.push(hasNextConfig ? "next.config.* found" : "next in dependencies");
+    confidence = "high";
+    if (deps["next-intl"]) {
+      library = "next-intl";
+      indicators.push("next-intl detected");
+    } else if (deps["next-i18next"]) {
+      library = "next-i18next";
+      indicators.push("next-i18next detected");
+    } else if (deps["react-i18next"]) {
+      library = "react-i18next";
+      indicators.push("react-i18next detected");
+    }
+  } else if (deps["vue"] || existsSync(join(projectDir, "vue.config.js"))) {
+    framework = "vue";
+    library = deps["vue-i18n"] ? "vue-i18n" : "vue-i18n";
+    indicators.push("Vue.js detected");
+    confidence = "high";
+  } else if (deps["svelte"] || existsSync(join(projectDir, "svelte.config.js"))) {
+    framework = "svelte";
+    library = "svelte-i18n";
+    indicators.push("Svelte detected");
+    confidence = "high";
+  } else if (deps["astro"] || existsSync(join(projectDir, "astro.config.mjs"))) {
+    framework = "astro";
+    library = "astro-i18n";
+    indicators.push("Astro detected");
+    confidence = "high";
+  } else if (deps["react"]) {
+    framework = "react";
+    indicators.push("React detected");
+    confidence = "medium";
+    if (deps["react-i18next"]) {
+      library = "react-i18next";
+      indicators.push("react-i18next detected");
+    } else if (deps["react-intl"]) {
+      library = "react-intl";
+      indicators.push("react-intl detected");
+    }
+  }
+  const i18nConfigFiles = [
+    "next-i18next.config.js",
+    "i18n.config.js",
+    "i18n.config.ts",
+    "i18n.js",
+    "i18n.ts"
+  ];
+  for (const configFile of i18nConfigFiles) {
+    if (existsSync(join(projectDir, configFile))) {
+      indicators.push(`${configFile} found`);
+      if (confidence === "low") confidence = "medium";
+    }
+  }
+  return { framework, library, confidence, indicators };
+}
+function getProjectConfig() {
+  const configPath = join(process.cwd(), ".intlpull.json");
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveProjectConfig(config) {
+  const configPath = join(process.cwd(), ".intlpull.json");
+  writeFileAtomic(configPath, JSON.stringify(config, null, 2));
+}
+function getAuthConfig() {
+  if (!existsSync(AUTH_FILE)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(AUTH_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveAuthConfig(config) {
+  try {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+    }
+    writeFileAtomic(AUTH_FILE, JSON.stringify(config, null, 2), { mode: 384 });
+  } catch (err) {
+    throw new Error(`Failed to save auth config: ${err instanceof Error ? err.message : "Permission denied or disk full"}`);
+  }
+}
+function clearAuthConfig() {
+  try {
+    if (existsSync(AUTH_FILE)) {
+      unlinkSync(AUTH_FILE);
+    }
+  } catch (err) {
+    throw new Error(`Failed to clear auth config: ${err instanceof Error ? err.message : "Permission denied"}`);
+  }
+}
+var DEFAULT_API_URL = "https://api.intlpull.com";
+function getGlobalConfig() {
+  const defaults = {
+    apiUrl: DEFAULT_API_URL,
+    defaultFramework: "next"
+  };
+  if (!existsSync(CONFIG_FILE)) {
+    return defaults;
+  }
+  try {
+    const content = readFileSync(CONFIG_FILE, "utf-8");
+    const config = JSON.parse(content);
+    if (config.apiUrl && config.apiUrl.includes("localhost")) {
+      config.apiUrl = DEFAULT_API_URL;
+    }
+    return { ...defaults, ...config };
+  } catch {
+    return defaults;
+  }
+}
+function getEnvApiKey() {
+  return process.env[ENV_API_KEY] || null;
+}
+function getResolvedApiKey() {
+  const envKey = getEnvApiKey();
+  if (envKey) {
+    return { key: envKey, source: "env" };
+  }
+  const auth = getAuthConfig();
+  if (auth?.apiKey) {
+    return { key: auth.apiKey, source: "config" };
+  }
+  if (auth?.token && auth?.expiresAt) {
+    const expiryDate = new Date(auth.expiresAt);
+    if (!isNaN(expiryDate.getTime()) && expiryDate > /* @__PURE__ */ new Date()) {
+      return { key: auth.token, source: "config" };
+    }
+  }
+  return null;
+}
+function isAuthenticated() {
+  return getResolvedApiKey() !== null;
+}
+function getAuthErrorMessage() {
+  return `Not authenticated. To authenticate, you can:
+
+  1. Add to your .env file:
+     ${ENV_API_KEY}="your-api-key"
+     (Reads from .env, .env.local, or .env.development)
+
+  2. Set environment variable:
+     export ${ENV_API_KEY}="your-api-key"
+     (Useful for CI/CD pipelines)
+
+  3. Run: npx @intlpullhq/cli login
+     (Interactive login - saves token to ~/.intlpull/auth.json)
+
+  4. Use a custom env file:
+     npx @intlpullhq/cli --env-file .env.production <command>
+
+Get your API key from: Settings \u2192 API Keys in the IntlPull dashboard.`;
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  const root = process.platform === "win32" ? currentDir.split(":")[0] + ":\\" : "/";
+  while (currentDir !== root) {
+    const configPath = join(currentDir, ".intlpull.json");
+    if (existsSync(configPath)) {
+      return currentDir;
+    }
+    const parentDir = join(currentDir, "..");
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+}
+function getProjectConfigFromDir(dir) {
+  if (dir) {
+    const configPath2 = join(dir, ".intlpull.json");
+    if (existsSync(configPath2)) {
+      try {
+        const content = readFileSync(configPath2, "utf-8");
+        return { config: JSON.parse(content), projectRoot: dir };
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return null;
+  const configPath = join(projectRoot, ".intlpull.json");
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return { config: JSON.parse(content), projectRoot };
+  } catch {
+    return null;
+  }
+}
+function resolveOutputDir(outputDir, projectRoot) {
+  if (outputDir.startsWith("/") || outputDir.match(/^[A-Z]:\\/i)) {
+    return outputDir;
+  }
+  return join(projectRoot, outputDir);
+}
+function detectGitBranch(dir = process.cwd()) {
+  try {
+    let currentDir = dir;
+    const root = process.platform === "win32" ? currentDir.split(":")[0] + ":\\" : "/";
+    while (currentDir !== root) {
+      const gitHead = join(currentDir, ".git", "HEAD");
+      if (existsSync(gitHead)) {
+        const content = readFileSync(gitHead, "utf-8").trim();
+        if (content.startsWith("ref: refs/heads/")) {
+          return content.replace("ref: refs/heads/", "");
+        }
+        return null;
+      }
+      const parentDir = dirname(currentDir);
+      if (parentDir === currentDir) break;
+      currentDir = parentDir;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getEffectiveBranch(cliBranch, dir) {
+  if (cliBranch) return cliBranch;
+  const gitBranch = detectGitBranch(dir);
+  return gitBranch || "main";
+}
+
+export {
+  __require,
+  writeFileAtomic,
+  setCustomEnvFile,
+  getCustomEnvFile,
+  loadEnvFiles,
+  getEnvProjectId,
+  detectFramework,
+  getProjectConfig,
+  saveProjectConfig,
+  getAuthConfig,
+  saveAuthConfig,
+  clearAuthConfig,
+  getGlobalConfig,
+  getEnvApiKey,
+  getResolvedApiKey,
+  isAuthenticated,
+  getAuthErrorMessage,
+  findProjectRoot,
+  getProjectConfigFromDir,
+  resolveOutputDir,
+  detectGitBranch,
+  getEffectiveBranch
+};