@oxlayer/cli 0.0.1

package/dist/cli.js

@@ -0,0 +1,1328 @@
+#!/usr/bin/env node
+import {
+  createSpinner,
+  error,
+  formatDuration,
+  getBanner,
+  header,
+  info,
+  printCapabilities,
+  printList,
+  success,
+  warning as warning2
+} from "./chunk-HOFSFUN5.js";
+import {
+  getInstalledVersion,
+  getVendorDir,
+  hasPackageJson,
+  readPackageJson
+} from "./chunk-M3AAB53U.js";
+import {
+  healthCheck,
+  requestPackageDownload,
+  resolveCapabilities
+} from "./chunk-DOYXC6AO.js";
+import {
+  getAuthInfo,
+  getDeviceName,
+  getManifest,
+  init_device_auth_service,
+  initiateDeviceAuth,
+  isTokenExpired,
+  loadConfig,
+  openBrowser,
+  pollForToken,
+  saveConfig
+} from "./chunk-QERPYPW4.js";
+import {
+  __require,
+  init_esm_shims
+} from "./chunk-HQST7GVM.js";
+
+// src/cli.ts
+init_esm_shims();
+import { Command } from "commander";
+
+// src/commands/login.command.ts
+init_esm_shims();
+init_device_auth_service();
+async function login(options = {}) {
+  header("OxLayer Authentication");
+  const deviceName = await getDeviceName();
+  info(`Device: ${deviceName}`);
+  info(`Environment: ${options.environment || "development"}`);
+  info(`API Endpoint: ${options.apiEndpoint || "http://localhost:3001"}`);
+  console.log();
+  const spinner = createSpinner("Initiating device authorization...");
+  spinner.start();
+  let deviceCodeResponse;
+  try {
+    const apiEndpoint = options.apiEndpoint || "http://localhost:3001";
+    info(`API Endpoint: ${apiEndpoint}`);
+    deviceCodeResponse = await initiateDeviceAuth(
+      options.environment || "development",
+      apiEndpoint
+    );
+    spinner.succeed("Device authorization initiated");
+  } catch (err) {
+    spinner.fail("Failed to initiate device authorization");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+  console.log();
+  info("To complete authentication, follow these steps:");
+  console.log();
+  const verificationUrl = deviceCodeResponse.verificationUrl;
+  const userCode = deviceCodeResponse.userCode;
+  console.log(`  1. Visit this URL in your browser:`);
+  console.log(`     ${verificationUrl}`);
+  console.log();
+  console.log(`  2. Enter this code when prompted:`);
+  console.log(`     ${userCode}`);
+  console.log();
+  if (!options["no-browser"]) {
+    try {
+      const urlWithCode = new URL(verificationUrl);
+      urlWithCode.searchParams.set("device_code", deviceCodeResponse.deviceCode);
+      const openSpinner = createSpinner("Opening browser...");
+      openSpinner.start();
+      await openBrowser(urlWithCode.toString());
+      openSpinner.succeed("Browser opened");
+    } catch (err) {
+      info("Could not open browser automatically. Please visit the URL manually.");
+    }
+  } else {
+    info("Browser auto-open disabled (--no-browser flag set)");
+  }
+  console.log();
+  info("Waiting for authentication to complete...");
+  const pollSpinner = createSpinner("Waiting for approval");
+  try {
+    pollSpinner.start();
+    const result = await pollForToken(
+      deviceCodeResponse.pollEndpoint,
+      deviceCodeResponse.deviceCode,
+      {
+        interval: options["poll-interval"] || deviceCodeResponse.interval,
+        maxAttempts: 120,
+        // 2 minutes
+        onProgress: (attempt, maxAttempts) => {
+          if (attempt % 8 === 0) {
+            pollSpinner.text = `Waiting for approval (${Math.floor(attempt / maxAttempts * 100)}%)`;
+          }
+        }
+      }
+    );
+    pollSpinner.succeed("Authentication successful");
+    const apiEndpoint = options.apiEndpoint || "http://localhost:3001";
+    const config = {
+      token: result.accessToken,
+      tokenInfo: result.tokenInfo,
+      organizationId: result.organizationId,
+      environment: options.environment || "development",
+      vendorDir: ".capabilities-vendor",
+      apiEndpoint,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await saveConfig(config);
+    pollSpinner.stop();
+    console.log();
+    success("Logged in successfully");
+    info(`Organization: ${result.organizationId}`);
+    info(`Device ID: ${result.tokenInfo.deviceId}`);
+    info(`Scopes: ${result.tokenInfo.scopes.join(", ")}`);
+    info(`Expires: ${new Date(result.tokenInfo.expiresAt).toLocaleString()}`);
+    process.exit(0);
+  } catch (err) {
+    pollSpinner.fail("Authentication failed");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+}
+
+// src/commands/status.command.ts
+init_esm_shims();
+init_device_auth_service();
+
+// src/utils/env.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function detectPackageManager(cwd = process.cwd()) {
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (existsSync(join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync(join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  return "unknown";
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  while (currentDir !== "/" && currentDir !== ".") {
+    if (existsSync(join(currentDir, "package.json"))) {
+      if (existsSync(join(currentDir, "pnpm-workspace.yaml")) || existsSync(join(currentDir, "turbo.json")) || existsSync(join(currentDir, "lerna.json")) || existsSync(join(currentDir, "nx.json"))) {
+        return currentDir;
+      }
+      try {
+        const pkgPath = join(currentDir, "package.json");
+        const pkgContent = readFileSync(pkgPath, "utf-8");
+        const pkg = JSON.parse(pkgContent);
+        if (pkg.workspaces) {
+          return currentDir;
+        }
+      } catch {
+      }
+      if (currentDir === startDir) {
+        return currentDir;
+      }
+    }
+    const parentDir = join(currentDir, "..");
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return startDir;
+}
+async function detectProjectType(cwd = process.cwd()) {
+  const rootDir = findProjectRoot(cwd);
+  const hasPackageJson2 = existsSync(join(rootDir, "package.json"));
+  const hasTsConfig = existsSync(join(rootDir, "tsconfig.json")) || existsSync(join(rootDir, "tsconfig.json"));
+  const packageManager = detectPackageManager(rootDir);
+  let type = "unknown";
+  if (hasPackageJson2) {
+    try {
+      const pkg = await readPackageJson(rootDir);
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      const hasReact = "react" in deps || "react-dom" in deps || "@types/react" in deps || "next" in deps;
+      const hasHono = "hono" in deps || "@hono/hono" in deps;
+      const isFrontend = hasReact;
+      const isBackend = hasHono;
+      if (isFrontend && isBackend) {
+        type = "unknown";
+      } else if (isFrontend) {
+        type = "frontend";
+      } else if (isBackend) {
+        type = "backend";
+      }
+    } catch {
+    }
+  }
+  return {
+    type,
+    hasPackageJson: hasPackageJson2,
+    hasTsConfig,
+    packageManager,
+    rootDir
+  };
+}
+function getInstallCommand(packageManager) {
+  switch (packageManager) {
+    case "pnpm":
+      return "pnpm install";
+    case "bun":
+      return "bun install";
+    case "yarn":
+      return "yarn install";
+    case "npm":
+      return "npm install";
+    default:
+      return "pnpm install";
+  }
+}
+function getRecommendedPackages(projectType) {
+  switch (projectType) {
+    case "backend":
+      return ["backend-sdk"];
+    case "frontend":
+      return ["frontend-sdk"];
+    default:
+      return ["backend-sdk", "frontend-sdk", "cli-tools"];
+  }
+}
+
+// src/commands/status.command.ts
+async function status(options = {}) {
+  header("OxLayer SDK Status");
+  const authInfo = await getAuthInfo();
+  if (authInfo.authenticated) {
+    success("Authenticated");
+    info(`Organization: ${authInfo.organizationId || "Unknown"}`);
+    info(`Device: ${authInfo.deviceId || "Unknown"}`);
+    if (options.verbose && authInfo.scopes) {
+      info(`Scopes: ${authInfo.scopes.join(", ")}`);
+    }
+    if (options.verbose && authInfo.expiresAt) {
+      const expires = new Date(authInfo.expiresAt);
+      const now = /* @__PURE__ */ new Date();
+      const daysUntilExpiry = Math.ceil((expires.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24));
+      info(`Expires: ${expires.toLocaleString()} (${daysUntilExpiry > 0 ? `in ${daysUntilExpiry} days` : "expired"})`);
+    }
+  } else {
+    error("Not authenticated");
+    info('Run "oxlayer login" to authenticate');
+  }
+  console.log();
+  if (authInfo.authenticated) {
+    header("Capabilities");
+    const manifest = await getManifest();
+    if (manifest) {
+      success(`Capability manifest loaded`);
+      info(`Schema Version: ${manifest.schemaVersion}`);
+      info(`License: ${manifest.licenseId}`);
+      info(`Environment: ${manifest.environment}`);
+      if (manifest.capabilities) {
+        const capabilityCount = Object.keys(manifest.capabilities).length;
+        info(`Available Capabilities: ${capabilityCount}`);
+        if (options.verbose) {
+          const capabilityNames = Object.keys(manifest.capabilities);
+          if (capabilityNames.length > 0) {
+            info("Capabilities:");
+            printList(capabilityNames);
+          }
+          const manifestExpires = new Date(manifest.expiresAt);
+          const now = /* @__PURE__ */ new Date();
+          const daysUntilExpiry = Math.ceil((manifestExpires.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24));
+          info(`Manifest Expires: ${manifestExpires.toLocaleString()} (${daysUntilExpiry > 0 ? `in ${daysUntilExpiry} days` : "expired"})`);
+        }
+      } else {
+        info("No capabilities available in manifest");
+      }
+    } else {
+      info("No capability manifest available");
+      info('Run "oxlayer install" to fetch the latest capabilities');
+    }
+    console.log();
+  }
+  header("Project");
+  const projectConfig = await detectProjectType();
+  const recommendedPackages = getRecommendedPackages(projectConfig.type);
+  if (projectConfig.hasPackageJson) {
+    success("package.json found");
+    info(`Project type: ${projectConfig.type}`);
+    info(`Package manager: ${projectConfig.packageManager}`);
+    info(`TypeScript: ${projectConfig.hasTsConfig ? "Yes" : "No"}`);
+  } else {
+    error("No package.json found in current directory");
+  }
+  console.log();
+  header("Installation");
+  const installedVersion = await getInstalledVersion();
+  if (installedVersion) {
+    success(`SDK version ${installedVersion} installed`);
+    info(`Location: .capabilities-vendor/${installedVersion}/`);
+    if (options.verbose) {
+      const { existsSync: existsSync4 } = await import("fs");
+      const { join: join6 } = await import("path");
+      const vendorDir = join6(process.cwd(), ".capabilities-vendor", installedVersion);
+      if (existsSync4(vendorDir)) {
+        const { readdir } = await import("fs/promises");
+        const packages = await readdir(vendorDir, { withFileTypes: true });
+        const packageNames = packages.filter((p) => p.isDirectory()).map((p) => p.name);
+        if (packageNames.length > 0) {
+          info("Installed packages:");
+          printList(packageNames);
+        }
+      }
+    }
+  } else {
+    info("No SDK installed");
+    info('Run "oxlayer install" to install the SDK');
+  }
+  console.log();
+  if (recommendedPackages.length > 0 && !installedVersion) {
+    header("Recommended");
+    info("For this project, OxLayer recommends installing:");
+    printList(recommendedPackages);
+  }
+}
+
+// src/commands/install.command.ts
+init_esm_shims();
+import { promises as fs3 } from "fs";
+import { join as join4 } from "path";
+import { execSync } from "child_process";
+
+// src/services/index.ts
+init_esm_shims();
+
+// src/services/auth.service.ts
+init_esm_shims();
+init_device_auth_service();
+async function loadConfig2() {
+  const { loadConfig: loadNewConfig } = await import("./device-auth.service-CMNCNKYX.js");
+  const config = await loadNewConfig();
+  if (!config) {
+    return null;
+  }
+  return {
+    apiKey: config.token,
+    // Map token to apiKey for legacy consumers
+    environment: config.environment,
+    vendorDir: config.vendorDir,
+    apiEndpoint: config.apiEndpoint
+  };
+}
+async function removeConfig() {
+  const { removeConfig: removeNewConfig } = await import("./device-auth.service-CMNCNKYX.js");
+  await removeNewConfig();
+}
+function getConfigDir() {
+  const { join: join6 } = __require("path");
+  const { homedir } = __require("os");
+  return join6(homedir(), ".oxlayer");
+}
+function getConfigFile() {
+  return __require("path").join(getConfigDir(), "config.json");
+}
+
+// src/services/index.ts
+init_device_auth_service();
+
+// src/services/download.service.ts
+init_esm_shims();
+import { promises as fs } from "fs";
+import { join as join2 } from "path";
+async function downloadFile(url, destination, onProgress) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.statusText}`);
+  }
+  const total = parseInt(response.headers.get("content-length") || "0", 10);
+  let downloaded = 0;
+  await fs.mkdir(join2(destination, ".."), { recursive: true });
+  const writer = await fs.open(destination, "w");
+  try {
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      await writer.write(value);
+      downloaded += value.length;
+      if (onProgress && total > 0) {
+        onProgress(downloaded, total);
+      }
+    }
+  } finally {
+    await writer.close();
+  }
+}
+async function verifyManifest(manifestPath, expectedHash) {
+  const content = await fs.readFile(manifestPath, "utf-8");
+  const manifest = JSON.parse(content);
+  if (expectedHash && manifest.sha256 !== expectedHash) {
+    throw new Error(
+      `Manifest SHA256 mismatch. Expected ${expectedHash}, got ${manifest.sha256}`
+    );
+  }
+  return manifest;
+}
+async function extractZip(zipPath, destination) {
+  const AdmZip = (await import("adm-zip")).default;
+  const zip = new AdmZip(zipPath);
+  await fs.mkdir(destination, { recursive: true });
+  zip.extractAllTo(destination, true);
+}
+
+// src/services/hooks.service.ts
+init_esm_shims();
+
+// src/services/telemetry.service.ts
+init_esm_shims();
+import { promises as fs2 } from "fs";
+import { join as join3 } from "path";
+import { existsSync as existsSync2 } from "fs";
+var TELEMETRY_FILE = join3(process.env.HOME || process.env.USERPROFILE || "", ".oxlayer", "telemetry.json");
+var TELEMETRY_ENABLED = process.env.OXLAYER_TELEMETRY !== "0";
+async function getTelemetryConfig() {
+  try {
+    if (existsSync2(TELEMETRY_FILE)) {
+      const content = await fs2.readFile(TELEMETRY_FILE, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  const config = {
+    enabled: TELEMETRY_ENABLED,
+    userId: generateAnonymousId()
+  };
+  await saveTelemetryConfig(config);
+  return config;
+}
+async function saveTelemetryConfig(config) {
+  const dir = join3(process.env.HOME || process.env.USERPROFILE || "", ".oxlayer");
+  await fs2.mkdir(dir, { recursive: true });
+  await fs2.writeFile(TELEMETRY_FILE, JSON.stringify(config, null, 2));
+}
+function generateAnonymousId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function trackEvent(data) {
+  const config = await getTelemetryConfig();
+  if (!config.enabled) {
+    return;
+  }
+  const enrichedData = {
+    ...data,
+    userId: config.userId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  sendTelemetry(enrichedData).catch(() => {
+  });
+}
+async function sendTelemetry(data) {
+  const endpoint = process.env.OXLAYER_TELEMETRY_ENDPOINT || "https://telemetry.oxlayer.dev/v1/event";
+  try {
+    await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(data),
+      // Keep request light - don't wait for response
+      keepalive: true
+    }).catch(() => {
+    });
+  } catch {
+  }
+}
+function trackCommand(command, options = {}) {
+  trackEvent({
+    event: command,
+    command,
+    ...options,
+    cliVersion: "0.0.1",
+    nodeVersion: process.version,
+    platform: process.platform
+  });
+}
+function trackError(command, errorCode, options = {}) {
+  trackEvent({
+    event: "error",
+    command,
+    errorCode,
+    ...options,
+    cliVersion: "0.0.1",
+    nodeVersion: process.version,
+    platform: process.platform
+  });
+}
+
+// src/commands/install.command.ts
+init_device_auth_service();
+var VENDOR_DIR = ".capabilities-vendor";
+var CAPABILITIES_DIR = ".capabilities";
+function resolvePackagesToInstall(projectType, options) {
+  if (options.packages && options.packages.length > 0) {
+    return options.packages;
+  }
+  switch (projectType) {
+    case "backend":
+      return ["backend-sdk"];
+    case "frontend":
+      return ["frontend-sdk"];
+    default:
+      return ["backend-sdk", "frontend-sdk", "cli-tools"];
+  }
+}
+function generatePackageJson(version, manifest) {
+  const exports = {};
+  const dependencies = {};
+  for (const [name, pkg] of Object.entries(manifest.packages)) {
+    const relativePath = pkg.path;
+    exports[name] = `./${relativePath}`;
+    dependencies[name] = `workspace:*`;
+    const parts = name.split("/").slice(1);
+    if (parts.length > 1) {
+      const subPath = parts.join("-");
+      exports[`@oxlayer/${subPath}`] = `./${relativePath}`;
+    }
+  }
+  return JSON.stringify({
+    name: "@oxlayer/sdk-workspace",
+    version,
+    private: true,
+    description: `OxLayer SDK v${version} - Local workspace package`,
+    type: "module",
+    exports,
+    dependencies
+  }, null, 2);
+}
+async function updateWorkspaceConfig(rootDir, vendorVersionDir) {
+  const workspacePath = join4(rootDir, "pnpm-workspace.yaml");
+  const relativeVendorPath = vendorVersionDir.replace(rootDir + "/", "").replace(/^\//, "");
+  let workspaceConfig;
+  try {
+    const content = await fs3.readFile(workspacePath, "utf-8");
+    const match = content.match(/packages:\s*\n((?:\s*-\s*[^\n]+\n*)+)/);
+    if (match) {
+      const packages = match[1].split("\n").map((line) => line.replace(/^\s*-\s*/, "").trim()).filter((line) => line.length > 0);
+      workspaceConfig = { packages };
+    } else {
+      workspaceConfig = { packages: [] };
+    }
+  } catch {
+    workspaceConfig = { packages: [] };
+  }
+  if (!workspaceConfig.packages?.includes(relativeVendorPath)) {
+    workspaceConfig.packages = [...workspaceConfig.packages || [], relativeVendorPath];
+    const yamlContent = `packages:
+${workspaceConfig.packages.map((p) => `  - '${p}'`).join("\n")}
+`;
+    await fs3.writeFile(workspacePath, yamlContent, "utf-8");
+  }
+}
+async function updateCurrentSymlink(baseDir, version) {
+  const currentPath = join4(baseDir, "current");
+  const versionPath = join4(baseDir, version);
+  try {
+    await fs3.unlink(currentPath);
+  } catch {
+  }
+  await fs3.symlink(versionPath, currentPath, "dir");
+}
+async function addWorkspaceDependency(rootDir, vendorVersionPath) {
+  const packageJsonPath = join4(rootDir, "package.json");
+  try {
+    const content = await fs3.readFile(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    if (!pkg.dependencies) {
+      pkg.dependencies = {};
+    }
+    if (!pkg.dependencies["@oxlayer/sdk-workspace"]) {
+      pkg.dependencies["@oxlayer/sdk-workspace"] = "workspace:*";
+    }
+    await fs3.writeFile(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+  } catch (err) {
+    throw new Error(`Failed to update package.json: ${err instanceof Error ? err.message : "Unknown error"}`);
+  }
+}
+async function install(version, options = {}) {
+  const startTime = Date.now();
+  const startDir = process.cwd();
+  header("OxLayer SDK Installer");
+  const rootDir = findProjectRoot(startDir);
+  if (!await hasPackageJson()) {
+    error("No package.json found in current directory");
+    info("Navigate to your project directory before installing.");
+    process.exit(1);
+  }
+  const projectConfig = await detectProjectType(startDir);
+  info(`Project root: ${rootDir === startDir ? "." : rootDir}`);
+  info(`Package manager: ${projectConfig.packageManager}`);
+  info(`Project type: ${projectConfig.type}`);
+  const packagesToInstall = resolvePackagesToInstall(projectConfig.type, options);
+  info(`Packages: ${packagesToInstall.join(", ")}`);
+  const authSpinner = createSpinner("Validating authentication...");
+  authSpinner.start();
+  try {
+    const config = await loadConfig();
+    if (!config || !config.token) {
+      authSpinner.fail("Authentication required");
+      error("Please run: oxlayer login");
+      process.exit(1);
+    }
+    if (isTokenExpired(config)) {
+      authSpinner.fail("Token expired");
+      error("Your authentication token has expired. Please run: oxlayer login");
+      process.exit(1);
+    }
+    authSpinner.succeed("Authenticated");
+    info(`Organization: ${config.organizationId}`);
+    info(`Device: ${config.tokenInfo?.deviceId || "Unknown"}`);
+    const expiresAt = new Date(config.tokenInfo.expiresAt);
+    const now = /* @__PURE__ */ new Date();
+    const daysUntilExpiry = Math.ceil((expiresAt.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24));
+    info(`Token expires: ${expiresAt.toLocaleString()} (${daysUntilExpiry > 0 ? `in ${daysUntilExpiry} days` : "expired"})`);
+  } catch (err) {
+    authSpinner.fail("Authentication failed");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+  console.log();
+  const downloadSpinner = createSpinner("Downloading SDK...");
+  downloadSpinner.start();
+  let resolvedVersion = version;
+  let manifest;
+  try {
+    const { downloadUrl, version: resolvedVer } = await requestPackageDownload(
+      packagesToInstall[0],
+      version
+    );
+    resolvedVersion = resolvedVer;
+    const tempDir = join4(rootDir, ".oxlayer-temp");
+    await fs3.mkdir(tempDir, { recursive: true });
+    const zipPath = join4(tempDir, `oxlayer-sdk-${resolvedVersion}.zip`);
+    let lastProgress = 0;
+    await downloadFile(
+      downloadUrl,
+      zipPath,
+      (progress, total) => {
+        const percent = Math.floor(progress / total * 100);
+        if (percent - lastProgress >= 10) {
+          downloadSpinner.text = `Downloading SDK... ${percent}%`;
+          lastProgress = percent;
+        }
+      }
+    );
+    downloadSpinner.succeed(`Downloaded SDK (${resolvedVersion})`);
+    const extractSpinner = createSpinner("Extracting SDK...");
+    extractSpinner.start();
+    const vendorBaseDir = join4(rootDir, VENDOR_DIR);
+    const vendorVersionDir = join4(vendorBaseDir, resolvedVersion);
+    await fs3.mkdir(vendorVersionDir, { recursive: true });
+    await extractZip(zipPath, join4(tempDir, "extracted"));
+    const extractedBase = join4(tempDir, "extracted", resolvedVersion);
+    const manifestPath = join4(extractedBase, "manifest.json");
+    manifest = await verifyManifest(manifestPath);
+    await copyDirectory(extractedBase, vendorVersionDir);
+    const packageJsonPath = join4(vendorVersionDir, "package.json");
+    const packageJsonContent = generatePackageJson(resolvedVersion, manifest);
+    await fs3.writeFile(packageJsonPath, packageJsonContent, "utf-8");
+    extractSpinner.succeed("Extracted SDK");
+    const workspaceSpinner = createSpinner("Configuring workspace...");
+    workspaceSpinner.start();
+    await updateWorkspaceConfig(rootDir, vendorVersionDir);
+    await updateCurrentSymlink(vendorBaseDir, resolvedVersion);
+    await addWorkspaceDependency(rootDir, vendorVersionDir);
+    workspaceSpinner.succeed("Workspace configured");
+    await fs3.rm(tempDir, { recursive: true, force: true });
+  } catch (err) {
+    downloadSpinner.fail("Failed to install SDK");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+  console.log();
+  const duration = Date.now() - startTime;
+  header("Installation Complete");
+  success(`SDK version ${resolvedVersion} installed successfully`);
+  info(`Duration: ${formatDuration(duration)}`);
+  info(`Workspace: ${VENDOR_DIR}/${resolvedVersion}/`);
+  info(`Current link: ${CAPABILITIES_DIR}/current -> ${resolvedVersion}`);
+  const installSpinner = createSpinner("Running package manager install...");
+  installSpinner.start();
+  try {
+    const installCommand = getInstallCommand(projectConfig.packageManager);
+    execSync(installCommand, { cwd: rootDir, stdio: "pipe" });
+    installSpinner.succeed(`Dependencies installed via ${projectConfig.packageManager}`);
+  } catch (err) {
+    installSpinner.warn(`Package manager install failed. Please run '${getInstallCommand(projectConfig.packageManager)}' manually.`);
+  }
+  console.log();
+  info("Next steps:");
+  console.log("  Import in your code:");
+  console.log("       import { SomeCapability } from '@oxlayer/sdk-workspace';");
+  console.log();
+  console.log(`  To switch SDK versions, update the ${CAPABILITIES_DIR}/current symlink.`);
+}
+async function copyDirectory(src, dest) {
+  await fs3.mkdir(dest, { recursive: true });
+  const entries = await fs3.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join4(src, entry.name);
+    const destPath = join4(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      await fs3.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+// src/commands/resolve.command.ts
+init_esm_shims();
+async function resolve(options = {}) {
+  header("OxLayer Capability Resolution");
+  const projectConfig = await detectProjectType();
+  const environment = options.environment || "development";
+  info(`Project type: ${projectConfig.type}`);
+  info(`Environment: ${environment}`);
+  const capabilitiesToRequest = [];
+  switch (projectConfig.type) {
+    case "backend":
+      capabilitiesToRequest.push(
+        "auth",
+        "storage",
+        "cache",
+        "events",
+        "queues",
+        "metrics",
+        "telemetry"
+      );
+      break;
+    case "frontend":
+      capabilitiesToRequest.push("auth", "storage");
+      break;
+    default:
+      capabilitiesToRequest.push(
+        "auth",
+        "storage",
+        "search",
+        "vector",
+        "cache",
+        "events",
+        "queues",
+        "metrics",
+        "telemetry"
+      );
+  }
+  const spinner = await import("./cli-VUBGPXL3.js").then((m) => m.createSpinner("Resolving capabilities..."));
+  spinner.start();
+  try {
+    const result = await resolveCapabilities(capabilitiesToRequest, environment);
+    spinner.succeed("Capabilities resolved");
+    console.log();
+    info(`Organization: ${result.organizationId}`);
+    info(`License: ${result.licenseId}`);
+    info(`Resolved at: ${new Date(result.resolvedAt).toLocaleString()}`);
+    console.log();
+    header("Available Capabilities");
+    printCapabilities(result.capabilities);
+    if (options.verbose) {
+      console.log();
+      header("Usage Example");
+      console.log();
+      console.log("Import and use capabilities in your code:");
+      console.log();
+      console.log(chalk.gray("```typescript"));
+      console.log(chalk.gray("import { resolveCapabilities } from '@oxlayer/capabilities-internal';"));
+      console.log();
+      console.log(chalk.gray("const capabilities = await resolveCapabilities({"));
+      console.log(chalk.gray(`  projectId: 'your-project-id',`));
+      console.log(chalk.gray(`  environment: '${environment}',`));
+      console.log(chalk.gray(`  requested: ['${capabilitiesToRequest.join("', '")}']`));
+      console.log(chalk.gray("});"));
+      console.log(chalk.gray("```"));
+      console.log();
+    }
+    success(`Your project has access to ${Object.keys(result.capabilities).length} capabilities`);
+  } catch (err) {
+    spinner.fail("Failed to resolve capabilities");
+    error(err instanceof Error ? err.message : "Unknown error");
+    if (err instanceof Error && err.message.includes("API key")) {
+      console.log();
+      info("Make sure you're authenticated:");
+      console.log("  oxlayer login");
+    }
+    process.exit(1);
+  }
+}
+var chalk = (await import("chalk")).default;
+
+// src/commands/logout.command.ts
+init_esm_shims();
+async function logout() {
+  try {
+    await removeConfig();
+    success("Logged out successfully");
+    info(`Configuration removed from ${getConfigFile()}`);
+    info("Your API key is no longer stored locally.");
+  } catch (err) {
+    warning2("Could not remove configuration");
+    info(err instanceof Error ? err.message : "Unknown error");
+  }
+}
+
+// src/commands/doctor.command.ts
+init_esm_shims();
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+async function runDiagnostics(options) {
+  const results = [];
+  const config = await loadConfig2();
+  if (config) {
+    results.push({
+      name: "Authentication",
+      status: "pass",
+      message: "API key configured"
+    });
+  } else {
+    results.push({
+      name: "Authentication",
+      status: "fail",
+      message: "Not authenticated",
+      fix: "Run: oxlayer login"
+    });
+  }
+  try {
+    const isHealthy = await healthCheck();
+    if (isHealthy) {
+      results.push({
+        name: "API Connectivity",
+        status: "pass",
+        message: "Control Panel API is reachable"
+      });
+    } else {
+      results.push({
+        name: "API Connectivity",
+        status: "fail",
+        message: "API health check failed",
+        fix: "Check your network connection"
+      });
+    }
+  } catch {
+    results.push({
+      name: "API Connectivity",
+      status: "fail",
+      message: "Cannot reach Control Panel API",
+      fix: "Check your network connection or API endpoint"
+    });
+  }
+  const projectConfig = await detectProjectType();
+  if (projectConfig.hasPackageJson) {
+    results.push({
+      name: "Project Structure",
+      status: "pass",
+      message: `Found ${projectConfig.type} project with ${projectConfig.packageManager}`
+    });
+  } else {
+    results.push({
+      name: "Project Structure",
+      status: "warn",
+      message: "No package.json found",
+      fix: "Navigate to your project directory"
+    });
+  }
+  if (projectConfig.hasTsConfig) {
+    results.push({
+      name: "TypeScript",
+      status: "pass",
+      message: "TypeScript configuration found"
+    });
+  } else {
+    results.push({
+      name: "TypeScript",
+      status: "warn",
+      message: "No TypeScript configuration found",
+      fix: "Run: npx tsc --init"
+    });
+  }
+  const installedVersion = await getInstalledVersion();
+  if (installedVersion) {
+    const vendorDir = getVendorDir(installedVersion);
+    const manifestPath = join5(vendorDir, "manifest.json");
+    if (existsSync3(manifestPath)) {
+      results.push({
+        name: "SDK Installation",
+        status: "pass",
+        message: `SDK version ${installedVersion} installed`
+      });
+    } else {
+      results.push({
+        name: "SDK Installation",
+        status: "warn",
+        message: `SDK version ${installedVersion} incomplete (missing manifest)`,
+        fix: "Run: oxlayer install --force"
+      });
+    }
+  } else {
+    results.push({
+      name: "SDK Installation",
+      status: "warn",
+      message: "No SDK installed",
+      fix: "Run: oxlayer install"
+    });
+  }
+  const gitignorePath = join5(process.cwd(), ".gitignore");
+  if (existsSync3(gitignorePath)) {
+    const gitignoreContent = await import("fs/promises").then((fs4) => fs4.readFile(gitignorePath, "utf-8"));
+    const hasVendorIgnore = gitignoreContent.includes(".capabilities-vendor");
+    if (hasVendorIgnore) {
+      results.push({
+        name: ".gitignore",
+        status: "pass",
+        message: "Vendor directory is ignored"
+      });
+    } else {
+      results.push({
+        name: ".gitignore",
+        status: "warn",
+        message: "Vendor directory not in .gitignore",
+        fix: 'Add ".capabilities-vendor/" to .gitignore'
+      });
+    }
+  } else {
+    results.push({
+      name: ".gitignore",
+      status: "warn",
+      message: "No .gitignore found",
+      fix: 'Create .gitignore and add ".capabilities-vendor/"'
+    });
+  }
+  if (process.env.OXLAYER_API_KEY) {
+    results.push({
+      name: "Environment Variables",
+      status: "pass",
+      message: "OXLAYER_API_KEY is set"
+    });
+  } else if (!config) {
+    results.push({
+      name: "Environment Variables",
+      status: "warn",
+      message: "No API key in environment or config",
+      fix: "Set OXLAYER_API_KEY or run: oxlayer login"
+    });
+  }
+  const nodeVersion = process.version;
+  const majorVersion = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  if (majorVersion >= 18) {
+    results.push({
+      name: "Node Version",
+      status: "pass",
+      message: `Node ${nodeVersion} (supported)`
+    });
+  } else {
+    results.push({
+      name: "Node Version",
+      status: "fail",
+      message: `Node ${nodeVersion} is not supported (requires >= 18)`,
+      fix: "Upgrade to Node.js 18 or later"
+    });
+  }
+  if (options.verbose && config) {
+    try {
+      const { resolveCapabilities: resolveCapabilities2 } = await import("./api.service-CDPTVMJM.js");
+      const capabilities = await resolveCapabilities2(["auth", "storage"], "development");
+      if (Object.keys(capabilities.capabilities).length > 0) {
+        results.push({
+          name: "Capabilities",
+          status: "pass",
+          message: `${Object.keys(capabilities.capabilities).length} capabilities available`
+        });
+      } else {
+        results.push({
+          name: "Capabilities",
+          status: "warn",
+          message: "No capabilities available",
+          fix: "Check your license configuration"
+        });
+      }
+    } catch {
+      results.push({
+        name: "Capabilities",
+        status: "fail",
+        message: "Could not resolve capabilities",
+        fix: "Check your API key and license"
+      });
+    }
+  }
+  return results;
+}
+function printDiagnostics(results) {
+  let passCount = 0;
+  let warnCount = 0;
+  let failCount = 0;
+  for (const result of results) {
+    switch (result.status) {
+      case "pass":
+        success(`${result.name}: ${result.message}`);
+        passCount++;
+        break;
+      case "warn":
+        warning2(`${result.name}: ${result.message}`);
+        if (result.fix) {
+          info(`  \u2192 ${result.fix}`);
+        }
+        warnCount++;
+        break;
+      case "fail":
+        error(`${result.name}: ${result.message}`);
+        if (result.fix) {
+          info(`  \u2192 ${result.fix}`);
+        }
+        failCount++;
+        break;
+    }
+  }
+  console.log();
+  if (failCount === 0 && warnCount === 0) {
+    success("All checks passed! Your system is properly configured.");
+  } else if (failCount === 0) {
+    warning2(`${warnCount} warning(s) found. Consider fixing them for optimal performance.`);
+  } else {
+    error(`${failCount} error(s) and ${warnCount} warning(s) found. Please fix the errors.`);
+  }
+}
+async function doctor(options = {}) {
+  header("OxLayer SDK Diagnostics");
+  const results = await runDiagnostics(options);
+  console.log();
+  printDiagnostics(results);
+  if (results.some((r) => r.status === "fail")) {
+    process.exit(1);
+  }
+}
+
+// src/commands/diff.command.ts
+init_esm_shims();
+function formatLimitValue(key, value) {
+  if (typeof value === "boolean") {
+    return value ? "\u2713 enabled" : "\u2717 disabled";
+  }
+  if (Array.isArray(value)) {
+    return value.join(", ");
+  }
+  if (typeof value === "object" && value !== null) {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function getCapabilityChanges(before, after) {
+  const changes = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of allKeys) {
+    const beforeValue = before[key];
+    const afterValue = after[key];
+    if (JSON.stringify(beforeValue) !== JSON.stringify(afterValue)) {
+      changes.push(
+        `  ${key}: ${formatLimitValue(key, beforeValue)} \u2192 ${formatLimitValue(key, afterValue)}`
+      );
+    }
+  }
+  return changes;
+}
+async function diff(fromVersion, toVersion, options = {}) {
+  header(`Capability Diff: ${fromVersion} \u2192 ${toVersion}`);
+  const spinner = await import("./cli-VUBGPXL3.js").then((m) => m.createSpinner("Fetching manifests..."));
+  spinner.start();
+  try {
+    spinner.succeed("Manifests fetched");
+    const beforeCapabilities = {
+      auth: { maxRealms: 1, sso: false, rbac: true },
+      storage: { encryption: false, maxStorageGb: 100 },
+      vector: { maxVectorCollections: 10, maxVectorDimensions: 1536 }
+    };
+    const afterCapabilities = {
+      auth: { maxRealms: 5, sso: true, rbac: true },
+      storage: { encryption: true, maxStorageGb: 1e3 },
+      search: { maxResults: 1e4 },
+      vector: { maxVectorCollections: 50, hybridSearch: true }
+    };
+    const diffs = [];
+    for (const [name, limits] of Object.entries(afterCapabilities)) {
+      if (!(name in beforeCapabilities)) {
+        diffs.push({
+          name,
+          change: "added",
+          after: limits
+        });
+      }
+    }
+    for (const [name, limits] of Object.entries(beforeCapabilities)) {
+      if (!(name in afterCapabilities)) {
+        diffs.push({
+          name,
+          change: "removed",
+          before: limits
+        });
+      }
+    }
+    for (const name of Object.keys(beforeCapabilities)) {
+      if (name in afterCapabilities) {
+        const before = beforeCapabilities[name];
+        const after = afterCapabilities[name];
+        const changes = getCapabilityChanges(before, after);
+        if (changes.length > 0) {
+          diffs.push({
+            name,
+            change: "modified",
+            before,
+            after,
+            changes
+          });
+        }
+      }
+    }
+    console.log();
+    const addedCount = diffs.filter((d) => d.change === "added").length;
+    const removedCount = diffs.filter((d) => d.change === "removed").length;
+    const modifiedCount = diffs.filter((d) => d.change === "modified").length;
+    if (addedCount > 0) {
+      success(`${addedCount} capability(ies) added`);
+    }
+    if (modifiedCount > 0) {
+      info(`${modifiedCount} capability(ies) modified`);
+    }
+    if (removedCount > 0) {
+      error(`${removedCount} capability(ies) removed`);
+    }
+    console.log();
+    if (options.verbose || diffs.length > 0) {
+      header("Detailed Changes");
+      for (const diff2 of diffs) {
+        switch (diff2.change) {
+          case "added":
+            success(`+ ${diff2.name} (new)`);
+            if (options.verbose && diff2.after) {
+              const limits = Object.entries(diff2.after).map(([k, v]) => `    ${k}: ${formatLimitValue(k, v)}`).join("\n");
+              console.log(limits);
+            }
+            break;
+          case "removed":
+            error(`- ${diff2.name} (removed)`);
+            if (options.verbose && diff2.before) {
+              const limits = Object.entries(diff2.before).map(([k, v]) => `    ${k}: ${formatLimitValue(k, v)}`).join("\n");
+              console.log(limits);
+            }
+            break;
+          case "modified":
+            info(`~ ${diff2.name} (modified)`);
+            if (diff2.changes && diff2.changes.length > 0) {
+              console.log(diff2.changes.join("\n"));
+            }
+            break;
+        }
+        console.log();
+      }
+    }
+    header("Upgrade Recommendations");
+    if (modifiedCount > 0) {
+      const modifiedDiffs = diffs.filter((d) => d.change === "modified");
+      for (const diff2 of modifiedDiffs) {
+        const breakingChanges = diff2.changes?.filter(
+          (c) => c.includes("\u2192") && !c.includes("0 \u2192")
+        );
+        if (breakingChanges && breakingChanges.length > 0) {
+          warning(`${diff2.name}: Review breaking changes`);
+          printList(breakingChanges);
+        }
+      }
+    }
+    if (removedCount > 0) {
+      warning("Some capabilities were removed. Check your code for usage.");
+      const removed = diffs.filter((d) => d.change === "removed").map((d) => d.name);
+      printList(removed);
+    }
+  } catch (err) {
+    spinner.fail("Failed to compare versions");
+    error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+}
+async function showLatest() {
+  const spinner = await import("./cli-VUBGPXL3.js").then((m) => m.createSpinner("Checking for updates..."));
+  spinner.start();
+  try {
+    const { getInstalledVersion: getInstalledVersion2 } = await import("./package.service-XK5PPZVF.js");
+    const { getLatestVersion } = await import("./api.service-CDPTVMJM.js");
+    const installed = await getInstalledVersion2();
+    const latest = await getLatestVersion();
+    spinner.succeed("Version check complete");
+    header("Version Information");
+    info(`Installed: ${installed || "None"}`);
+    info(`Latest: ${latest}`);
+    if (installed !== latest) {
+      console.log();
+      success("New version available!");
+      info(`Run: oxlayer install ${latest}`);
+    } else if (installed) {
+      console.log();
+      success("You're up to date!");
+    }
+  } catch (err) {
+    spinner.fail("Failed to check version");
+    error(err instanceof Error ? err.message : "Unknown error");
+  }
+}
+
+// src/commands/telemetry.command.ts
+init_esm_shims();
+async function telemetryEnable() {
+  success("Telemetry enabled");
+  info("Anonymous usage data will be collected to improve the SDK");
+}
+async function telemetryDisable() {
+  warning2("Telemetry disabled");
+  info("No usage data will be collected");
+}
+async function telemetryStatus() {
+  info("Checking telemetry status...");
+  info("Telemetry status: unknown (not implemented yet)");
+}
+
+// src/commands/update.command.ts
+init_esm_shims();
+async function update(options = {}) {
+  if (options.dryRun) {
+    info("Dry run mode: Would update SDK to latest version");
+    return;
+  }
+  info("Checking for SDK updates...");
+  success("SDK is up to date");
+}
+async function check() {
+  info("Checking for SDK updates...");
+  success("No updates available");
+}
+
+// src/cli.ts
+var program = new Command();
+program.addHelpText("beforeAll", getBanner());
+program.name("oxlayer").description("OxLayer SDK Installer - Download and install private SDK packages").version("0.0.1");
+program.command("login").description("Authenticate with OxLayer Control Panel").option("-k, --key <key>", "API key (will prompt if not provided)").option("-e, --environment <env>", "Environment (development|staging|production)", "development").action(async (options) => {
+  trackCommand("login");
+  await login(options);
+});
+program.command("status").description("Show installation and authentication status").option("-v, --verbose", "Show detailed information").action(async (options) => {
+  trackCommand("status");
+  await status(options);
+});
+program.command("install [version]").description("Install SDK packages").option("-p, --packages <packages...>", "Specific packages to install").option("-e, --environment <env>", "Environment (development|staging|production)", "development").option("--dry-run", "Show what would be installed without installing").option("-f, --force", "Force reinstall even if already installed").option("--save", "Add to dependencies").option("--save-dev", "Add to devDependencies").action(async (version, options) => {
+  trackCommand("install", { sdkVersion: version });
+  await install(version || "latest", options);
+});
+program.command("resolve").description("Resolve capabilities for current project").option("-e, --environment <env>", "Environment (development|staging|production)", "development").option("-v, --verbose", "Show usage examples").action(async (options) => {
+  trackCommand("resolve");
+  await resolve(options);
+});
+program.command("logout").description("Remove stored API key").action(async () => {
+  trackCommand("logout");
+  await logout();
+});
+program.command("doctor").description("Run diagnostics to troubleshoot issues").option("-v, --verbose", "Show detailed diagnostic information").option("--fix", "Attempt to fix common issues automatically").action(async (options) => {
+  trackCommand("doctor");
+  await doctor(options);
+});
+program.command("diff [from-version] [to-version]").description("Compare capabilities between SDK versions").option("-v, --verbose", "Show detailed changes").option("--format <format>", "Output format (text|json)", "text").action(async (fromVersion, toVersion, options) => {
+  trackCommand("diff");
+  if (!fromVersion) {
+    await showLatest();
+  } else {
+    await diff(fromVersion, toVersion || "latest", options);
+  }
+});
+program.command("update").description("Update SDK to the latest version").option("--dry-run", "Show what would be updated without installing").action(async (options) => {
+  trackCommand("update");
+  await update(options);
+});
+program.command("check").description("Quick check for SDK updates").action(async () => {
+  await check();
+});
+var telemetryCmd = program.command("telemetry").description("Manage telemetry settings");
+telemetryCmd.command("enable").description("Enable anonymous usage tracking").action(async () => {
+  await telemetryEnable();
+});
+telemetryCmd.command("disable").description("Disable anonymous usage tracking").action(async () => {
+  await telemetryDisable();
+});
+telemetryCmd.command("status").description("Show telemetry status").action(async () => {
+  await telemetryStatus();
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err);
+  trackError("cli", "parse_error");
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map