@tarout/cli 0.2.0 → 0.2.1

package/dist/chunk-FKX4CRPL.js

@@ -0,0 +1,669 @@
+import {
+  ExitCode,
+  error,
+  exit,
+  isJsonMode,
+  jsonError,
+  outputJson
+} from "./chunk-FS74WWHV.js";
+
+// src/lib/api.ts
+import { createTRPCProxyClient, httpBatchLink } from "@trpc/client";
+import superjson from "superjson";
+
+// src/lib/config.ts
+import Conf from "conf";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+var config = new Conf({
+  projectName: "tarout",
+  configFileMode: 384,
+  defaults: {
+    currentProfile: "default",
+    profiles: {}
+  }
+});
+function getConfig() {
+  return config.store;
+}
+function getCurrentProfile() {
+  const cfg = getConfig();
+  return cfg.profiles[cfg.currentProfile] || null;
+}
+function setProfile(name, profile) {
+  config.set(`profiles.${name}`, profile);
+}
+function setCurrentProfile(name) {
+  config.set("currentProfile", name);
+}
+function clearConfig() {
+  config.clear();
+}
+function isLoggedIn() {
+  const profile = getCurrentProfile();
+  return profile !== null && !!profile.token || !!process.env.TAROUT_TOKEN;
+}
+function getToken() {
+  const profile = getCurrentProfile();
+  return profile?.token || process.env.TAROUT_TOKEN || null;
+}
+function getApiUrl() {
+  const profile = getCurrentProfile();
+  return profile?.apiUrl || "https://tarout.sa";
+}
+function updateProfile(updates) {
+  const cfg = getConfig();
+  const currentProfileName = cfg.currentProfile;
+  const currentProfile = cfg.profiles[currentProfileName];
+  if (currentProfile) {
+    config.set(`profiles.${currentProfileName}`, {
+      ...currentProfile,
+      ...updates
+    });
+  }
+}
+var PROJECT_CONFIG_DIR = ".tarout";
+var PROJECT_CONFIG_FILE = "project.json";
+function chmodIfSupported(path, mode) {
+  try {
+    chmodSync(path, mode);
+  } catch {
+  }
+}
+function getProjectConfigDir(basePath) {
+  const base = basePath || process.cwd();
+  return join(base, PROJECT_CONFIG_DIR);
+}
+function getProjectConfigPath(basePath) {
+  return join(getProjectConfigDir(basePath), PROJECT_CONFIG_FILE);
+}
+function isProjectLinked(basePath) {
+  return existsSync(getProjectConfigPath(basePath));
+}
+function getProjectConfig(basePath) {
+  const configPath = getProjectConfigPath(basePath);
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function setProjectConfig(config2, basePath) {
+  const configDir = getProjectConfigDir(basePath);
+  const configPath = getProjectConfigPath(basePath);
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true, mode: 448 });
+  }
+  chmodIfSupported(configDir, 448);
+  writeFileSync(configPath, JSON.stringify(config2, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+  chmodIfSupported(configPath, 384);
+  const gitignorePath = join(configDir, ".gitignore");
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(
+      gitignorePath,
+      "# Ignore local tarout config\n*\n!.gitignore\n",
+      { encoding: "utf-8", mode: 384 }
+    );
+    chmodIfSupported(gitignorePath, 384);
+  }
+}
+function removeProjectConfig(basePath) {
+  const configDir = getProjectConfigDir(basePath);
+  if (!existsSync(configDir)) {
+    return false;
+  }
+  try {
+    rmSync(configDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/errors.ts
+var CliError = class extends Error {
+  constructor(message, code = ExitCode.GENERAL_ERROR, suggestions) {
+    super(message);
+    this.code = code;
+    this.suggestions = suggestions;
+    this.name = "CliError";
+  }
+  code;
+  suggestions;
+};
+var AuthError = class extends CliError {
+  constructor(message = "Not logged in. Run 'tarout login' first.") {
+    super(message, ExitCode.AUTH_ERROR);
+  }
+};
+var NotFoundError = class extends CliError {
+  constructor(resource, id, suggestions) {
+    super(`${resource} "${id}" not found`, ExitCode.NOT_FOUND, suggestions);
+  }
+};
+var InvalidArgumentError = class extends CliError {
+  constructor(message) {
+    super(message, ExitCode.INVALID_ARGUMENTS);
+  }
+};
+var DeploymentFailedError = class extends CliError {
+  constructor(message, deploymentId, errorAnalysis) {
+    super(message, ExitCode.DEPLOYMENT_FAILED);
+    this.deploymentId = deploymentId;
+    this.errorAnalysis = errorAnalysis;
+  }
+  deploymentId;
+  errorAnalysis;
+};
+var DeploymentTimeoutError = class extends CliError {
+  constructor(message = "Deployment timed out", deploymentId) {
+    super(message, ExitCode.DEPLOYMENT_TIMEOUT);
+    this.deploymentId = deploymentId;
+  }
+  deploymentId;
+};
+var BuildFailedError = class extends CliError {
+  constructor(message, deploymentId, errorAnalysis) {
+    super(message, ExitCode.BUILD_FAILED);
+    this.deploymentId = deploymentId;
+    this.errorAnalysis = errorAnalysis;
+  }
+  deploymentId;
+  errorAnalysis;
+};
+function handleError(err) {
+  if (err instanceof CliError) {
+    if (isJsonMode()) {
+      outputJson(
+        jsonError(getErrorCode(err.code), err.message, err.suggestions)
+      );
+    } else {
+      error(err.message, err.suggestions);
+    }
+    exit(err.code);
+  }
+  if (err && typeof err === "object") {
+    const e = err;
+    const code = e.code ?? e.data?.code;
+    if (code) {
+      const exitCode = mapTrpcErrorCode(code);
+      const message2 = e.message ?? "Request failed";
+      if (isJsonMode()) {
+        outputJson(jsonError(code, message2));
+      } else {
+        error(message2);
+      }
+      exit(exitCode);
+    }
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  if (isJsonMode()) {
+    outputJson(jsonError("UNKNOWN_ERROR", message));
+  } else {
+    error(message);
+  }
+  exit(ExitCode.GENERAL_ERROR);
+}
+function getErrorCode(exitCode) {
+  const codes = {
+    [ExitCode.SUCCESS]: "SUCCESS",
+    [ExitCode.GENERAL_ERROR]: "ERROR",
+    [ExitCode.INVALID_ARGUMENTS]: "INVALID_ARGUMENTS",
+    [ExitCode.AUTH_ERROR]: "AUTH_ERROR",
+    [ExitCode.NOT_FOUND]: "NOT_FOUND",
+    [ExitCode.PERMISSION_DENIED]: "PERMISSION_DENIED",
+    [ExitCode.DEPLOYMENT_FAILED]: "DEPLOYMENT_FAILED",
+    [ExitCode.DEPLOYMENT_TIMEOUT]: "DEPLOYMENT_TIMEOUT",
+    [ExitCode.BUILD_FAILED]: "BUILD_FAILED"
+  };
+  return codes[exitCode] || "ERROR";
+}
+function mapTrpcErrorCode(code) {
+  const mapping = {
+    UNAUTHORIZED: ExitCode.AUTH_ERROR,
+    FORBIDDEN: ExitCode.PERMISSION_DENIED,
+    NOT_FOUND: ExitCode.NOT_FOUND,
+    BAD_REQUEST: ExitCode.INVALID_ARGUMENTS,
+    PARSE_ERROR: ExitCode.INVALID_ARGUMENTS
+  };
+  return mapping[code] || ExitCode.GENERAL_ERROR;
+}
+function findSimilar(target, candidates, maxResults = 3) {
+  const targetLower = target.toLowerCase();
+  return candidates.map((candidate) => ({
+    candidate,
+    score: similarity(targetLower, candidate.toLowerCase())
+  })).filter(({ score }) => score > 0.3).sort((a, b) => b.score - a.score).slice(0, maxResults).map(({ candidate }) => candidate);
+}
+function similarity(s1, s2) {
+  if (s1 === s2) return 1;
+  if (s1.length < 2 || s2.length < 2) return 0;
+  const bigrams1 = /* @__PURE__ */ new Set();
+  for (let i = 0; i < s1.length - 1; i++) {
+    bigrams1.add(s1.slice(i, i + 2));
+  }
+  let intersection = 0;
+  for (let i = 0; i < s2.length - 1; i++) {
+    if (bigrams1.has(s2.slice(i, i + 2))) {
+      intersection++;
+    }
+  }
+  return 2 * intersection / (s1.length - 1 + s2.length - 1);
+}
+var ERROR_PATTERNS = [
+  {
+    patterns: [
+      /npm ERR!/i,
+      /npm error/i,
+      /ERESOLVE/i,
+      /Could not resolve dependency/i,
+      /peer dep missing/i
+    ],
+    category: "npm_install",
+    type: "build_error",
+    possibleCauses: [
+      "Package version conflicts",
+      "Missing peer dependencies",
+      "Invalid package.json",
+      "Network issues during npm install",
+      "Private package without authentication"
+    ],
+    suggestedFixes: [
+      "Run `npm install` locally to reproduce the issue",
+      "Check for conflicting package versions in package.json",
+      "Try deleting package-lock.json and node_modules, then reinstall",
+      "Add missing peer dependencies explicitly",
+      "Check if private packages are properly authenticated"
+    ]
+  },
+  {
+    patterns: [
+      /yarn error/i,
+      /YN\d{4}/i,
+      /error An unexpected error occurred/i
+    ],
+    category: "yarn_install",
+    type: "build_error",
+    possibleCauses: [
+      "Package version conflicts",
+      "Corrupted yarn.lock file",
+      "Network issues during install",
+      "Incompatible yarn version"
+    ],
+    suggestedFixes: [
+      "Run `yarn install` locally to reproduce the issue",
+      "Delete yarn.lock and node_modules, then reinstall",
+      "Check for conflicting resolutions in package.json",
+      "Ensure yarn version matches the project requirements"
+    ]
+  },
+  {
+    patterns: [/pnpm ERR/i, /ERR_PNPM/i],
+    category: "pnpm_install",
+    type: "build_error",
+    possibleCauses: [
+      "Package version conflicts",
+      "Incompatible pnpm version",
+      "Corrupted pnpm-lock.yaml"
+    ],
+    suggestedFixes: [
+      "Run `pnpm install` locally to reproduce the issue",
+      "Delete pnpm-lock.yaml and node_modules, then reinstall",
+      "Check pnpm version compatibility"
+    ]
+  },
+  {
+    patterns: [/bun install/i, /error: .* failed to resolve/i],
+    category: "bun_install",
+    type: "build_error",
+    possibleCauses: [
+      "Package resolution failure",
+      "Incompatible bun version",
+      "Missing dependencies"
+    ],
+    suggestedFixes: [
+      "Run `bun install` locally to reproduce the issue",
+      "Delete bun.lockb and node_modules, then reinstall",
+      "Check bun version compatibility"
+    ]
+  },
+  {
+    patterns: [
+      /error TS\d+/i,
+      /TypeScript error/i,
+      /tsc.*error/i,
+      /Type .* is not assignable to/i,
+      /Cannot find module/i,
+      /Property .* does not exist/i
+    ],
+    category: "typescript",
+    type: "build_error",
+    possibleCauses: [
+      "TypeScript compilation errors in source code",
+      "Missing type definitions",
+      "Incompatible TypeScript version",
+      "Strict mode type errors"
+    ],
+    suggestedFixes: [
+      "Run `npx tsc --noEmit` locally to see all type errors",
+      "Fix the TypeScript errors in the indicated files",
+      "Install missing @types/* packages",
+      "Check tsconfig.json for strict mode settings"
+    ]
+  },
+  {
+    patterns: [
+      /COPY failed/i,
+      /RUN.*failed/i,
+      /failed to build/i,
+      /Error building image/i,
+      /Dockerfile/i
+    ],
+    category: "docker_build",
+    type: "build_error",
+    possibleCauses: [
+      "Invalid Dockerfile syntax",
+      "Missing files in build context",
+      "Failed RUN commands",
+      "Base image not found"
+    ],
+    suggestedFixes: [
+      "Test Docker build locally with `docker build .`",
+      "Check that all required files are in the build context",
+      "Verify Dockerfile syntax and commands",
+      "Ensure base image exists and is accessible"
+    ]
+  },
+  {
+    patterns: [
+      /build.*failed/i,
+      /Build failed/i,
+      /exit code 1/i,
+      /Command failed/i,
+      /Script.*failed/i
+    ],
+    category: "build_script",
+    type: "build_error",
+    possibleCauses: [
+      "Build script error in package.json",
+      "Missing build dependencies",
+      "Environment variable issues",
+      "Build command not found"
+    ],
+    suggestedFixes: [
+      "Run `npm run build` locally to reproduce the error",
+      "Check package.json build script for errors",
+      "Ensure all required environment variables are set",
+      "Verify build dependencies are installed"
+    ]
+  },
+  {
+    patterns: [
+      /out of memory/i,
+      /JavaScript heap out of memory/i,
+      /FATAL ERROR: .* allocation failed/i,
+      /OOMKilled/i
+    ],
+    category: "memory_limit",
+    type: "build_error",
+    possibleCauses: [
+      "Build process requires more memory than allocated",
+      "Memory leak in build process",
+      "Large dependency tree"
+    ],
+    suggestedFixes: [
+      "Increase memory allocation for the build",
+      "Optimize build process to use less memory",
+      "Consider splitting large bundles",
+      "Add NODE_OPTIONS=--max_old_space_size=4096"
+    ]
+  },
+  {
+    patterns: [/timed? ?out/i, /deadline exceeded/i, /timeout/i],
+    category: "timeout",
+    type: "build_error",
+    possibleCauses: [
+      "Build process took too long",
+      "Network timeout during dependency install",
+      "Slow external service calls"
+    ],
+    suggestedFixes: [
+      "Optimize build process for faster execution",
+      "Check for slow network requests during build",
+      "Consider caching dependencies",
+      "Increase build timeout if possible"
+    ]
+  },
+  {
+    patterns: [/permission denied/i, /EACCES/i, /EPERM/i],
+    category: "permission",
+    type: "build_error",
+    possibleCauses: [
+      "File permission issues",
+      "Attempting to write to read-only locations",
+      "Docker user permission mismatch"
+    ],
+    suggestedFixes: [
+      "Check file permissions in the project",
+      "Ensure Dockerfile uses correct user",
+      "Avoid writing to restricted directories"
+    ]
+  },
+  {
+    patterns: [
+      /ENOTFOUND/i,
+      /ECONNREFUSED/i,
+      /network error/i,
+      /fetch failed/i,
+      /getaddrinfo/i
+    ],
+    category: "network",
+    type: "build_error",
+    possibleCauses: [
+      "Network connectivity issues",
+      "DNS resolution failure",
+      "Registry unavailable",
+      "Firewall blocking connections"
+    ],
+    suggestedFixes: [
+      "Check if the package registry is accessible",
+      "Verify network configuration",
+      "Try again later if registry is temporarily down",
+      "Check for any proxy configuration issues"
+    ]
+  }
+];
+function analyzeDeploymentError(logs, errorMessage) {
+  const relevantLogLines = [];
+  let matchedPattern = null;
+  let maxMatches = 0;
+  const allLines = errorMessage ? [...logs, errorMessage] : logs;
+  for (const pattern of ERROR_PATTERNS) {
+    let matches = 0;
+    const matchedLines = [];
+    for (const line of allLines) {
+      for (const regex of pattern.patterns) {
+        if (regex.test(line)) {
+          matches++;
+          if (!matchedLines.includes(line)) {
+            matchedLines.push(line);
+          }
+          break;
+        }
+      }
+    }
+    if (matches > maxMatches) {
+      maxMatches = matches;
+      matchedPattern = pattern;
+      relevantLogLines.length = 0;
+      relevantLogLines.push(...matchedLines.slice(0, 10));
+    }
+  }
+  const errorIndicators = [/error/i, /failed/i, /fatal/i, /exception/i];
+  for (const line of allLines) {
+    if (relevantLogLines.length < 15 && !relevantLogLines.includes(line) && errorIndicators.some((indicator) => indicator.test(line))) {
+      relevantLogLines.push(line);
+    }
+  }
+  if (matchedPattern) {
+    return {
+      type: matchedPattern.type,
+      category: matchedPattern.category,
+      possibleCauses: matchedPattern.possibleCauses,
+      suggestedFixes: matchedPattern.suggestedFixes,
+      relevantLogLines
+    };
+  }
+  return {
+    type: "unknown",
+    category: "unknown",
+    possibleCauses: [
+      "Unable to automatically determine the cause",
+      "Check the log output for specific error messages"
+    ],
+    suggestedFixes: [
+      "Review the deployment logs for error messages",
+      "Try running the build locally to reproduce the issue",
+      "Check environment variables and configuration",
+      "Contact support if the issue persists"
+    ],
+    relevantLogLines
+  };
+}
+
+// src/lib/password-gate.ts
+var gateCookies = /* @__PURE__ */ new Map();
+function requestUrl(input) {
+  if (input instanceof URL) return input;
+  if (typeof input === "string") return new URL(input);
+  return new URL(input.url);
+}
+function requestHeaders(input, init) {
+  const headers = new Headers(
+    input instanceof Request ? input.headers : void 0
+  );
+  if (init?.headers) {
+    new Headers(init.headers).forEach((value, key) => {
+      headers.set(key, value);
+    });
+  }
+  return headers;
+}
+function isPasswordGateResponse(body) {
+  return /site is password-protected/i.test(body);
+}
+function sitePassword() {
+  return process.env.TAROUT_SITE_PASSWORD || process.env.SITE_PASSWORD;
+}
+async function unlockPasswordGate(origin) {
+  const password = sitePassword();
+  if (!password) {
+    throw new AuthError(
+      "Tarout is currently password-protected. Set TAROUT_SITE_PASSWORD and try again."
+    );
+  }
+  const response = await fetch(`${origin}/api/password-gate`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ password })
+  });
+  if (!response.ok) {
+    throw new AuthError(
+      "Tarout site password was rejected. Check TAROUT_SITE_PASSWORD and try again."
+    );
+  }
+  const setCookie = response.headers.get("set-cookie");
+  const cookie = setCookie?.split(",").find((part) => part.trim().startsWith("__tarout_site_gate="))?.trim().split(";")[0];
+  if (!cookie) {
+    throw new AuthError("Tarout did not return a site-gate session cookie.");
+  }
+  gateCookies.set(origin, cookie);
+  return cookie;
+}
+async function platformFetch(input, init) {
+  const url = requestUrl(input);
+  const headers = requestHeaders(input, init);
+  const existingCookie = gateCookies.get(url.origin);
+  if (existingCookie && !headers.has("cookie")) {
+    headers.set("cookie", existingCookie);
+  }
+  const response = await fetch(input, { ...init, headers });
+  if (response.status !== 401) return response;
+  const body = await response.clone().text().catch(() => "");
+  if (!isPasswordGateResponse(body)) return response;
+  const cookie = await unlockPasswordGate(url.origin);
+  headers.set("cookie", cookie);
+  return fetch(input, { ...init, headers });
+}
+
+// src/lib/api.ts
+var client = null;
+function createApiClient() {
+  if (!isLoggedIn()) {
+    throw new AuthError();
+  }
+  const token = getToken();
+  const apiUrl = getApiUrl();
+  return createTRPCProxyClient({
+    transformer: superjson,
+    links: [
+      httpBatchLink({
+        url: `${apiUrl}/api/trpc`,
+        headers: () => token ? { "x-api-key": token } : {},
+        fetch: platformFetch
+      })
+    ]
+  });
+}
+function getApiClient() {
+  if (!client) {
+    client = createApiClient();
+  }
+  return client;
+}
+function resetApiClient() {
+  client = null;
+}
+
+export {
+  getCurrentProfile,
+  setProfile,
+  setCurrentProfile,
+  clearConfig,
+  isLoggedIn,
+  getToken,
+  getApiUrl,
+  updateProfile,
+  isProjectLinked,
+  getProjectConfig,
+  setProjectConfig,
+  removeProjectConfig,
+  CliError,
+  AuthError,
+  NotFoundError,
+  InvalidArgumentError,
+  DeploymentFailedError,
+  DeploymentTimeoutError,
+  BuildFailedError,
+  handleError,
+  findSimilar,
+  analyzeDeploymentError,
+  platformFetch,
+  createApiClient,
+  getApiClient,
+  resetApiClient
+};