@getpara/cli 2.15.0

package/dist/config/config-manager.js

@@ -0,0 +1,32 @@
+import { DEFAULT_ENVIRONMENT, parseEnvironment } from "../core/constants.js";
+import { readGlobalConfig } from "./config-store.js";
+import { readProjectConfig } from "./project-config.js";
+async function resolveConfig(opts, projectRoot) {
+  const globalConfig = await readGlobalConfig();
+  const projectConfig = projectRoot ? await readProjectConfig(projectRoot) : {};
+  const environment = resolveEnvironment(opts, projectConfig, globalConfig);
+  const organizationId = resolveOrgId(opts, projectConfig, globalConfig);
+  const projectId = resolveProjectId(opts, projectConfig, globalConfig);
+  return { environment, organizationId, projectId };
+}
+function resolveEnvironment(opts, projectConfig, globalConfig) {
+  if (opts.environment) return opts.environment;
+  const envVar = process.env["PARA_ENVIRONMENT"];
+  if (envVar) return parseEnvironment(envVar);
+  if (projectConfig.environment) {
+    return parseEnvironment(projectConfig.environment);
+  }
+  if (globalConfig.defaultEnvironment) {
+    return parseEnvironment(globalConfig.defaultEnvironment);
+  }
+  return DEFAULT_ENVIRONMENT;
+}
+function resolveOrgId(opts, projectConfig, globalConfig) {
+  return opts.org || process.env["PARA_ORG_ID"] || projectConfig.organizationId || globalConfig.defaultOrganizationId;
+}
+function resolveProjectId(opts, projectConfig, globalConfig) {
+  return opts.project || process.env["PARA_PROJECT_ID"] || projectConfig.projectId || globalConfig.defaultProjectId;
+}
+export {
+  resolveConfig
+};

package/dist/config/config-store.d.ts

@@ -0,0 +1,10 @@
+export interface GlobalConfig {
+    defaultOrganizationId?: string;
+    defaultProjectId?: string;
+    defaultEnvironment?: string;
+}
+export declare function readGlobalConfig(): Promise<GlobalConfig>;
+export declare function writeGlobalConfig(config: GlobalConfig): Promise<void>;
+export declare function updateGlobalConfig(updates: Partial<GlobalConfig>): Promise<GlobalConfig>;
+export declare function removeGlobalConfigKey(key: keyof GlobalConfig): Promise<void>;
+//# sourceMappingURL=config-store.d.ts.map

package/dist/config/config-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-store.d.ts","sourceRoot":"","sources":["../../src/config/config-store.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,YAAY;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAID,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,YAAY,CAAC,CAO9D;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAM3E;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAK9F;AAED,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAIlF"}

package/dist/config/config-store.js

@@ -0,0 +1,37 @@
+import { readFile, writeFile, mkdir, rename } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { getGlobalConfigPath } from "./paths.js";
+const DEFAULT_CONFIG = {};
+async function readGlobalConfig() {
+  try {
+    const raw = await readFile(getGlobalConfigPath(), "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+async function writeGlobalConfig(config) {
+  const configPath = getGlobalConfigPath();
+  await mkdir(dirname(configPath), { recursive: true, mode: 448 });
+  const tmpPath = join(dirname(configPath), `.config.${randomBytes(4).toString("hex")}.tmp`);
+  await writeFile(tmpPath, JSON.stringify(config, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  await rename(tmpPath, configPath);
+}
+async function updateGlobalConfig(updates) {
+  const config = await readGlobalConfig();
+  const merged = { ...config, ...updates };
+  await writeGlobalConfig(merged);
+  return merged;
+}
+async function removeGlobalConfigKey(key) {
+  const config = await readGlobalConfig();
+  delete config[key];
+  await writeGlobalConfig(config);
+}
+export {
+  readGlobalConfig,
+  removeGlobalConfigKey,
+  updateGlobalConfig,
+  writeGlobalConfig
+};

package/dist/config/credential-store.d.ts

@@ -0,0 +1,12 @@
+import { Environment } from '../core/constants.js';
+import type { SessionInfo } from '../core/types.js';
+interface CredentialsFile {
+    sessions: Partial<Record<string, SessionInfo>>;
+}
+export declare function readCredentials(): Promise<CredentialsFile>;
+export declare function getSession(environment: Environment): Promise<SessionInfo | null>;
+export declare function storeSession(environment: Environment, session: SessionInfo): Promise<void>;
+export declare function clearSession(environment: Environment): Promise<void>;
+export declare function clearAllSessions(): Promise<void>;
+export {};
+//# sourceMappingURL=credential-store.d.ts.map

package/dist/config/credential-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-store.d.ts","sourceRoot":"","sources":["../../src/config/credential-store.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,UAAU,eAAe;IACvB,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;CAChD;AA+CD,wBAAsB,eAAe,IAAI,OAAO,CAAC,eAAe,CAAC,CAUhE;AAsBD,wBAAsB,UAAU,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAYtF;AAED,wBAAsB,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhG;AAED,wBAAsB,YAAY,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1E;AAED,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEtD"}

package/dist/config/credential-store.js

@@ -0,0 +1,94 @@
+import { readFile, writeFile, mkdir, chmod, stat, rename } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { getCredentialsPath, getParaConfigDir } from "./paths.js";
+import { Environment } from "../core/constants.js";
+function sessionKey(environment) {
+  return environment === Environment.BETA ? Environment.PROD : environment;
+}
+const EMPTY_CREDENTIALS = { sessions: {} };
+async function ensureConfigDir() {
+  const dir = getParaConfigDir();
+  await mkdir(dir, { recursive: true, mode: 448 });
+  if (process.platform === "darwin") {
+    try {
+      await new Promise((resolve, reject) => {
+        execFile(
+          "xattr",
+          ["-w", "com.apple.metadata:com_apple_backup_excludeItem", "com.apple.backupd", dir],
+          (err) => err ? reject(err) : resolve()
+        );
+      });
+    } catch {
+    }
+  }
+}
+async function checkPermissions() {
+  if (process.platform === "win32") return;
+  const credPath = getCredentialsPath();
+  try {
+    const stats = await stat(credPath);
+    const mode = stats.mode & 511;
+    if (mode & 63) {
+      console.warn(
+        `Warning: ${credPath} has overly permissive permissions (${mode.toString(8)}). Run: chmod 600 ` + credPath
+      );
+    }
+  } catch {
+  }
+}
+async function readCredentials() {
+  await checkPermissions();
+  try {
+    const raw = await readFile(getCredentialsPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.sessions) return { sessions: {} };
+    return parsed;
+  } catch {
+    return { ...EMPTY_CREDENTIALS };
+  }
+}
+async function writeCredentialsAtomic(data) {
+  await ensureConfigDir();
+  const credPath = getCredentialsPath();
+  const tmpPath = join(dirname(credPath), `.credentials.${randomBytes(4).toString("hex")}.tmp`);
+  await writeFile(tmpPath, JSON.stringify(data, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+  if (process.platform !== "win32") {
+    await chmod(tmpPath, 384);
+  }
+  await rename(tmpPath, credPath);
+}
+async function getSession(environment) {
+  const creds = await readCredentials();
+  const session = creds.sessions[sessionKey(environment)];
+  if (!session) return null;
+  if (session.expiresAt && Date.now() > session.expiresAt) {
+    await clearSession(environment);
+    return null;
+  }
+  return session;
+}
+async function storeSession(environment, session) {
+  const creds = await readCredentials();
+  creds.sessions[sessionKey(environment)] = session;
+  await writeCredentialsAtomic(creds);
+}
+async function clearSession(environment) {
+  const creds = await readCredentials();
+  delete creds.sessions[sessionKey(environment)];
+  await writeCredentialsAtomic(creds);
+}
+async function clearAllSessions() {
+  await writeCredentialsAtomic(EMPTY_CREDENTIALS);
+}
+export {
+  clearAllSessions,
+  clearSession,
+  getSession,
+  readCredentials,
+  storeSession
+};

package/dist/config/paths.d.ts

@@ -0,0 +1,5 @@
+export declare function getParaConfigDir(): string;
+export declare function getGlobalConfigPath(): string;
+export declare function getCredentialsPath(): string;
+export declare function getProjectConfigPath(projectRoot: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/config/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/config/paths.ts"],"names":[],"mappings":"AAcA,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEhE"}

package/dist/config/paths.js

@@ -0,0 +1,29 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+function getConfigHome() {
+  if (process.env["XDG_CONFIG_HOME"]) {
+    return process.env["XDG_CONFIG_HOME"];
+  }
+  if (process.platform === "win32" && process.env["APPDATA"]) {
+    return process.env["APPDATA"];
+  }
+  return join(homedir(), ".config");
+}
+function getParaConfigDir() {
+  return join(getConfigHome(), "para");
+}
+function getGlobalConfigPath() {
+  return join(getParaConfigDir(), "config.json");
+}
+function getCredentialsPath() {
+  return join(getParaConfigDir(), "credentials.json");
+}
+function getProjectConfigPath(projectRoot) {
+  return join(projectRoot, ".pararc");
+}
+export {
+  getCredentialsPath,
+  getGlobalConfigPath,
+  getParaConfigDir,
+  getProjectConfigPath
+};

package/dist/config/project-config.d.ts

@@ -0,0 +1,8 @@
+export interface ProjectConfig {
+    organizationId?: string;
+    projectId?: string;
+    environment?: string;
+}
+export declare function readProjectConfig(projectRoot: string): Promise<ProjectConfig>;
+export declare function writeProjectConfig(projectRoot: string, config: ProjectConfig): Promise<void>;
+//# sourceMappingURL=project-config.d.ts.map

package/dist/config/project-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-config.d.ts","sourceRoot":"","sources":["../../src/config/project-config.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAkBD,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAYnF;AAED,wBAAsB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAMlG"}

package/dist/config/project-config.js

@@ -0,0 +1,41 @@
+import { readFile, writeFile, rename } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { getProjectConfigPath } from "./paths.js";
+const FORBIDDEN_KEYS = ["session", "token", "secret", "credential", "password", "apikey", "api_key"];
+function validateNoSecrets(config) {
+  for (const key of Object.keys(config)) {
+    const lower = key.toLowerCase();
+    for (const forbidden of FORBIDDEN_KEYS) {
+      if (lower.includes(forbidden)) {
+        throw new Error(
+          `.pararc must not contain secret values. Key "${key}" looks like a secret. Store secrets in environment variables or ~/.config/para/credentials.json instead.`
+        );
+      }
+    }
+  }
+}
+async function readProjectConfig(projectRoot) {
+  try {
+    const raw = await readFile(getProjectConfigPath(projectRoot), "utf-8");
+    const parsed = JSON.parse(raw);
+    validateNoSecrets(parsed);
+    return parsed;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {};
+    }
+    throw err;
+  }
+}
+async function writeProjectConfig(projectRoot, config) {
+  validateNoSecrets(config);
+  const configPath = getProjectConfigPath(projectRoot);
+  const tmpPath = join(dirname(configPath), `.pararc.${randomBytes(4).toString("hex")}.tmp`);
+  await writeFile(tmpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await rename(tmpPath, configPath);
+}
+export {
+  readProjectConfig,
+  writeProjectConfig
+};

package/dist/core/constants.d.ts

@@ -0,0 +1,27 @@
+export declare const CLI_VERSION: string;
+export declare const CLI_NAME = "para";
+export declare const USER_AGENT: string;
+export declare enum Environment {
+    DEV = "DEV",
+    SANDBOX = "SANDBOX",
+    BETA = "BETA",
+    PROD = "PROD"
+}
+export declare const DEFAULT_ENVIRONMENT = Environment.BETA;
+export declare const BASE_URLS: Record<Environment, string>;
+export declare const PORTAL_URLS: Record<Environment, string>;
+export declare function parseEnvironment(value: string): Environment;
+export declare const DEV_PORTAL_API_KEY = "d0b61c2c8865aaa2fb12886651627271";
+export declare enum ExitCode {
+    SUCCESS = 0,
+    GENERAL_ERROR = 1,
+    USAGE_ERROR = 2,
+    AUTH_REQUIRED = 3,
+    AUTH_EXPIRED = 4,
+    FORBIDDEN = 5,
+    NOT_FOUND = 6,
+    RATE_LIMITED = 7,
+    NETWORK_ERROR = 8,
+    INTERRUPTED = 130
+}
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/core/constants.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW,QAAc,CAAC;AACvC,eAAO,MAAM,QAAQ,SAAS,CAAC;AAC/B,eAAO,MAAM,UAAU,QAAgC,CAAC;AAExD,oBAAY,WAAW;IACrB,GAAG,QAAQ;IACX,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,IAAI,SAAS;CACd;AAED,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAKjD,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAKnD,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAO3D;AAGD,eAAO,MAAM,kBAAkB,qCAAqC,CAAC;AAErE,oBAAY,QAAQ;IAClB,OAAO,IAAI;IACX,aAAa,IAAI;IACjB,WAAW,IAAI;IACf,aAAa,IAAI;IACjB,YAAY,IAAI;IAChB,SAAS,IAAI;IACb,SAAS,IAAI;IACb,YAAY,IAAI;IAChB,aAAa,IAAI;IACjB,WAAW,MAAM;CAClB"}

package/dist/core/constants.js

@@ -0,0 +1,60 @@
+import { createRequire } from "node:module";
+const require2 = createRequire(import.meta.url);
+const pkg = require2("../../package.json");
+const CLI_VERSION = pkg.version;
+const CLI_NAME = "para";
+const USER_AGENT = `@getpara/cli/${CLI_VERSION}`;
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2["DEV"] = "DEV";
+  Environment2["SANDBOX"] = "SANDBOX";
+  Environment2["BETA"] = "BETA";
+  Environment2["PROD"] = "PROD";
+  return Environment2;
+})(Environment || {});
+const DEFAULT_ENVIRONMENT = "BETA" /* BETA */;
+const BASE_URLS = {
+  ["DEV" /* DEV */]: "http://localhost:8080",
+  ["SANDBOX" /* SANDBOX */]: "https://api.sandbox.getpara.com",
+  ["BETA" /* BETA */]: "https://api.beta.getpara.com",
+  ["PROD" /* PROD */]: "https://api.getpara.com"
+};
+const PORTAL_URLS = {
+  ["DEV" /* DEV */]: "http://localhost:5173",
+  ["SANDBOX" /* SANDBOX */]: "https://developer.sandbox.usecapsule.com",
+  ["BETA" /* BETA */]: "https://developer.getpara.com",
+  ["PROD" /* PROD */]: "https://developer.getpara.com"
+};
+function parseEnvironment(value) {
+  const upper = value.toUpperCase();
+  if (upper in Environment) {
+    return Environment[upper];
+  }
+  const valid = Object.keys(Environment).join(", ");
+  throw new Error(`Invalid environment "${value}". Valid values: ${valid}`);
+}
+const DEV_PORTAL_API_KEY = "d0b61c2c8865aaa2fb12886651627271";
+var ExitCode = /* @__PURE__ */ ((ExitCode2) => {
+  ExitCode2[ExitCode2["SUCCESS"] = 0] = "SUCCESS";
+  ExitCode2[ExitCode2["GENERAL_ERROR"] = 1] = "GENERAL_ERROR";
+  ExitCode2[ExitCode2["USAGE_ERROR"] = 2] = "USAGE_ERROR";
+  ExitCode2[ExitCode2["AUTH_REQUIRED"] = 3] = "AUTH_REQUIRED";
+  ExitCode2[ExitCode2["AUTH_EXPIRED"] = 4] = "AUTH_EXPIRED";
+  ExitCode2[ExitCode2["FORBIDDEN"] = 5] = "FORBIDDEN";
+  ExitCode2[ExitCode2["NOT_FOUND"] = 6] = "NOT_FOUND";
+  ExitCode2[ExitCode2["RATE_LIMITED"] = 7] = "RATE_LIMITED";
+  ExitCode2[ExitCode2["NETWORK_ERROR"] = 8] = "NETWORK_ERROR";
+  ExitCode2[ExitCode2["INTERRUPTED"] = 130] = "INTERRUPTED";
+  return ExitCode2;
+})(ExitCode || {});
+export {
+  BASE_URLS,
+  CLI_NAME,
+  CLI_VERSION,
+  DEFAULT_ENVIRONMENT,
+  DEV_PORTAL_API_KEY,
+  Environment,
+  ExitCode,
+  PORTAL_URLS,
+  USER_AGENT,
+  parseEnvironment
+};

package/dist/core/error-handler.d.ts

@@ -0,0 +1,24 @@
+import { ExitCode } from './constants.js';
+export declare function setJsonMode(enabled: boolean): void;
+export declare class CliError extends Error {
+    readonly exitCode: ExitCode;
+    constructor(message: string, exitCode?: ExitCode);
+}
+export declare class AuthError extends CliError {
+    constructor(message: string, expired?: boolean);
+}
+export declare class NetworkError extends CliError {
+    constructor(message: string);
+}
+export declare class RateLimitError extends CliError {
+    readonly retryAfter?: number | undefined;
+    constructor(message: string, retryAfter?: number | undefined);
+}
+export declare class ForbiddenError extends CliError {
+    constructor(message: string);
+}
+export declare class NotFoundError extends CliError {
+    constructor(message: string);
+}
+export declare function handleError(error: unknown): never;
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/core/error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../src/core/error-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI1C,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAElD;AAED,qBAAa,QAAS,SAAQ,KAAK;aAGf,QAAQ,EAAE,QAAQ;gBADlC,OAAO,EAAE,MAAM,EACC,QAAQ,GAAE,QAAiC;CAK9D;AAED,qBAAa,SAAU,SAAQ,QAAQ;gBACzB,OAAO,EAAE,MAAM,EAAE,OAAO,UAAQ;CAI7C;AAED,qBAAa,YAAa,SAAQ,QAAQ;gBAC5B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,cAAe,SAAQ,QAAQ;aAGxB,UAAU,CAAC,EAAE,MAAM;gBADnC,OAAO,EAAE,MAAM,EACC,UAAU,CAAC,EAAE,MAAM,YAAA;CAKtC;AAED,qBAAa,cAAe,SAAQ,QAAQ;gBAC9B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,aAAc,SAAQ,QAAQ;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAOD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CA+BjD"}

package/dist/core/error-handler.js

@@ -0,0 +1,83 @@
+import { ExitCode } from "./constants.js";
+let _jsonMode = false;
+function setJsonMode(enabled) {
+  _jsonMode = enabled;
+}
+class CliError extends Error {
+  constructor(message, exitCode = ExitCode.GENERAL_ERROR) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+}
+class AuthError extends CliError {
+  constructor(message, expired = false) {
+    super(message, expired ? ExitCode.AUTH_EXPIRED : ExitCode.AUTH_REQUIRED);
+    this.name = "AuthError";
+  }
+}
+class NetworkError extends CliError {
+  constructor(message) {
+    super(message, ExitCode.NETWORK_ERROR);
+    this.name = "NetworkError";
+  }
+}
+class RateLimitError extends CliError {
+  constructor(message, retryAfter) {
+    super(message, ExitCode.RATE_LIMITED);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+}
+class ForbiddenError extends CliError {
+  constructor(message) {
+    super(message, ExitCode.FORBIDDEN);
+    this.name = "ForbiddenError";
+  }
+}
+class NotFoundError extends CliError {
+  constructor(message) {
+    super(message, ExitCode.NOT_FOUND);
+    this.name = "NotFoundError";
+  }
+}
+function emitJsonError(type, code, message) {
+  if (!_jsonMode) return;
+  console.log(JSON.stringify({ error: { type, code, message } }));
+}
+function handleError(error) {
+  if (error instanceof CliError) {
+    emitJsonError(error.name, error.exitCode, error.message);
+    console.error(`Error: ${error.message}`);
+    if (error instanceof RateLimitError && error.retryAfter) {
+      console.error(`Rate limited. Retry after ${error.retryAfter} seconds.`);
+    }
+    process.exit(error.exitCode);
+  }
+  if (error instanceof Error && "exitCode" in error) {
+    const exitCode = error.exitCode;
+    if (exitCode === 0) {
+      process.exit(ExitCode.SUCCESS);
+    }
+    emitJsonError("UsageError", ExitCode.USAGE_ERROR, error.message);
+    console.error(error.message);
+    process.exit(ExitCode.USAGE_ERROR);
+  }
+  if (error instanceof Error && error.message.includes("cancelled")) {
+    process.exit(ExitCode.INTERRUPTED);
+  }
+  const message = error instanceof Error ? error.message : "An unexpected error occurred.";
+  emitJsonError("Error", ExitCode.GENERAL_ERROR, message);
+  console.error(`Error: ${message}`);
+  process.exit(ExitCode.GENERAL_ERROR);
+}
+export {
+  AuthError,
+  CliError,
+  ForbiddenError,
+  NetworkError,
+  NotFoundError,
+  RateLimitError,
+  handleError,
+  setJsonMode
+};

package/dist/core/types.d.ts

@@ -0,0 +1,21 @@
+import type { Environment } from './constants.js';
+export interface GlobalOptions {
+    json: boolean;
+    environment: Environment;
+    org?: string;
+    project?: string;
+    quiet: boolean;
+    noInput: boolean;
+}
+export interface ResolvedConfig {
+    environment: Environment;
+    organizationId?: string;
+    projectId?: string;
+}
+export interface SessionInfo {
+    sessionId: string;
+    userId: string;
+    email: string;
+    expiresAt: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,OAAO,CAAC;IACd,WAAW,EAAE,WAAW,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,WAAW,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/core/update-check.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Starts a non-blocking update check. Returns a function that, when called,
+ * prints the update notice if a newer version is available.
+ */
+export declare function startUpdateCheck(): () => Promise<void>;
+//# sourceMappingURL=update-check.d.ts.map

package/dist/core/update-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-check.d.ts","sourceRoot":"","sources":["../../src/core/update-check.ts"],"names":[],"mappings":"AAwDA;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,OAAO,CAAC,IAAI,CAAC,CAgBtD"}

package/dist/core/update-check.js

@@ -0,0 +1,78 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import pc from "picocolors";
+import { getParaConfigDir } from "../config/paths.js";
+import { CLI_VERSION } from "./constants.js";
+const PACKAGE_NAME = "@getpara/cli";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function getCachePath() {
+  return join(getParaConfigDir(), "update-check.json");
+}
+async function readCache() {
+  try {
+    const raw = await readFile(getCachePath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeCache(cache) {
+  const dir = getParaConfigDir();
+  await mkdir(dir, { recursive: true });
+  await writeFile(getCachePath(), JSON.stringify(cache), "utf-8");
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isNewer(latest, current) {
+  const parse = (v) => v.replace(/^v/, "").split(".").map(Number);
+  const [lMajor, lMinor, lPatch] = parse(latest);
+  const [cMajor, cMinor, cPatch] = parse(current);
+  if (lMajor !== cMajor) return lMajor > cMajor;
+  if (lMinor !== cMinor) return lMinor > cMinor;
+  return lPatch > cPatch;
+}
+function startUpdateCheck() {
+  const promise = checkForUpdate();
+  return async () => {
+    const result = await promise;
+    if (result) {
+      console.error("");
+      console.error(pc.yellow(`  Update available: ${pc.dim(CLI_VERSION)} \u2192 ${pc.green(result)}`));
+      console.error(
+        pc.yellow(
+          `  Update: ${pc.cyan(`npm i -g ${PACKAGE_NAME}`)} or ${pc.cyan(`yarn global add ${PACKAGE_NAME}`)} or ${pc.cyan(`pnpm add -g ${PACKAGE_NAME}`)}`
+        )
+      );
+      console.error("");
+    }
+  };
+}
+async function checkForUpdate() {
+  try {
+    const cache = await readCache();
+    if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
+      return isNewer(cache.latestVersion, CLI_VERSION) ? cache.latestVersion : null;
+    }
+    const latest = await fetchLatestVersion();
+    if (!latest) return null;
+    await writeCache({ lastCheck: Date.now(), latestVersion: latest }).catch(() => {
+    });
+    return isNewer(latest, CLI_VERSION) ? latest : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  startUpdateCheck
+};

package/dist/diagnostics/checks/chain-dependencies.d.ts

@@ -0,0 +1,2 @@
+export declare const chainDependenciesCheck: import("../types.js").Check;
+//# sourceMappingURL=chain-dependencies.d.ts.map

package/dist/diagnostics/checks/chain-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-dependencies.d.ts","sourceRoot":"","sources":["../../../src/diagnostics/checks/chain-dependencies.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,sBAAsB,6BA6BjC,CAAC"}