@layr-labs/ecloud-cli 0.2.0-dev.1 → 0.2.0-dev.2

package/dist/commands/compute/build/submit.js

@@ -1,618 +0,0 @@
-#!/usr/bin/env node
-
-// src/commands/compute/build/submit.ts
-import { Command, Flags as Flags2 } from "@oclif/core";
-import chalk from "chalk";
-
-// src/flags.ts
-import { Flags } from "@oclif/core";
-import { getBuildType as getBuildType2 } from "@layr-labs/ecloud-sdk";
-
-// src/utils/prompts.ts
-import { input, select, password, confirm as inquirerConfirm } from "@inquirer/prompts";
-import fs3 from "fs";
-import path3 from "path";
-import os3 from "os";
-import { isAddress as isAddress2 } from "viem";
-import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
-import {
-  getEnvironmentConfig,
-  getAvailableEnvironments,
-  isEnvironmentAvailable,
-  getAllAppsByDeveloper as getAllAppsByDeveloper2,
-  getCategoryDescriptions,
-  fetchTemplateCatalog,
-  PRIMARY_LANGUAGES,
-  validateAppName,
-  validateImageReference,
-  validateFilePath,
-  validatePrivateKeyFormat,
-  extractAppNameFromImage,
-  UserApiClient as UserApiClient2
-} from "@layr-labs/ecloud-sdk";
-
-// src/utils/appResolver.ts
-import { isAddress } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
-import {
-  UserApiClient,
-  getAllAppsByDeveloper
-} from "@layr-labs/ecloud-sdk";
-
-// src/utils/globalConfig.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { load as loadYaml, dump as dumpYaml } from "js-yaml";
-import { getBuildType } from "@layr-labs/ecloud-sdk";
-import * as crypto from "crypto";
-var GLOBAL_CONFIG_FILE = "config.yaml";
-var PROFILE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-function getGlobalConfigDir() {
-  const configHome = process.env.XDG_CONFIG_HOME;
-  let baseDir;
-  if (configHome && path.isAbsolute(configHome)) {
-    baseDir = configHome;
-  } else {
-    baseDir = path.join(os.homedir(), ".config");
-  }
-  const buildType = getBuildType();
-  const buildSuffix = buildType === "dev" ? "-dev" : "";
-  const configDirName = `ecloud${buildSuffix}`;
-  return path.join(baseDir, configDirName);
-}
-function getGlobalConfigPath() {
-  return path.join(getGlobalConfigDir(), GLOBAL_CONFIG_FILE);
-}
-function loadGlobalConfig() {
-  const configPath = getGlobalConfigPath();
-  if (!fs.existsSync(configPath)) {
-    return {
-      first_run: true
-    };
-  }
-  try {
-    const content = fs.readFileSync(configPath, "utf-8");
-    const config = loadYaml(content);
-    return config || { first_run: true };
-  } catch {
-    return {
-      first_run: true
-    };
-  }
-}
-function saveGlobalConfig(config) {
-  const configPath = getGlobalConfigPath();
-  const configDir = path.dirname(configPath);
-  fs.mkdirSync(configDir, { recursive: true, mode: 493 });
-  const content = dumpYaml(config, { lineWidth: -1 });
-  fs.writeFileSync(configPath, content, { mode: 420 });
-}
-function getDefaultEnvironment() {
-  const config = loadGlobalConfig();
-  return config.default_environment;
-}
-function getGlobalTelemetryPreference() {
-  const config = loadGlobalConfig();
-  return config.telemetry_enabled;
-}
-function getOrCreateUserUUID() {
-  const config = loadGlobalConfig();
-  if (config.user_uuid) {
-    return config.user_uuid;
-  }
-  const uuid = generateUUID();
-  config.user_uuid = uuid;
-  config.first_run = false;
-  saveGlobalConfig(config);
-  return uuid;
-}
-function generateUUID() {
-  const bytes = crypto.randomBytes(16);
-  bytes[6] = bytes[6] & 15 | 64;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
-  return hex.slice(0, 4).join("") + hex.slice(4, 6).join("") + "-" + hex.slice(6, 8).join("") + "-" + hex.slice(8, 10).join("") + "-" + hex.slice(10, 12).join("") + "-" + hex.slice(12, 16).join("");
-}
-
-// src/utils/appNames.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
-import { load as loadYaml2, dump as dumpYaml2 } from "js-yaml";
-var CONFIG_DIR = path2.join(os2.homedir(), ".eigenx");
-var APPS_DIR = path2.join(CONFIG_DIR, "apps");
-
-// src/utils/version.ts
-function getCliVersion() {
-  return true ? "0.2.0-dev.1" : "0.0.0";
-}
-function getClientId() {
-  return `ecloud-cli/v${getCliVersion()}`;
-}
-
-// src/utils/prompts.ts
-async function promptVerifiableGitSourceInputs() {
-  const repoUrl = (await input({
-    message: "Enter public git repository URL:",
-    default: "",
-    validate: (value) => {
-      if (!value.trim()) return "Repository URL is required";
-      try {
-        const url = new URL(value.trim());
-        if (url.protocol !== "https:") return "Repository URL must start with https://";
-        if (url.hostname.toLowerCase() !== "github.com")
-          return "Repository URL must be a public GitHub HTTPS URL (github.com)";
-        const parts = url.pathname.replace(/\/+$/, "").split("/").filter(Boolean);
-        if (parts.length < 2) return "Repository URL must be https://github.com/<owner>/<repo>";
-        const [owner, repo] = parts;
-        if (!owner || !repo) return "Repository URL must be https://github.com/<owner>/<repo>";
-        if (repo.toLowerCase() === "settings") return "Repository URL looks invalid";
-        if (url.search || url.hash)
-          return "Repository URL must not include query params or fragments";
-      } catch {
-        return "Invalid URL format";
-      }
-      return true;
-    }
-  })).trim();
-  const gitRef = (await input({
-    message: "Enter git commit SHA (40 hex chars):",
-    default: "",
-    validate: (value) => {
-      const trimmed = value.trim();
-      if (!trimmed) return "Commit SHA is required";
-      if (!/^[0-9a-f]{40}$/i.test(trimmed))
-        return "Commit must be a 40-character hexadecimal SHA";
-      return true;
-    }
-  })).trim();
-  const buildContextPath = (await input({
-    message: "Enter build context path (relative to repo):",
-    default: ".",
-    validate: (value) => value.trim() ? true : "Build context path cannot be empty"
-  })).trim();
-  const dockerfilePath = (await input({
-    message: "Enter Dockerfile path (relative to build context):",
-    default: "Dockerfile",
-    validate: (value) => value.trim() ? true : "Dockerfile path cannot be empty"
-  })).trim();
-  const caddyfileRaw = (await input({
-    message: "Enter Caddyfile path (relative to build context, optional):",
-    default: "",
-    validate: (value) => {
-      const trimmed = value.trim();
-      if (!trimmed) return true;
-      if (trimmed.includes("..")) return "Caddyfile path must not contain '..'";
-      return true;
-    }
-  })).trim();
-  const depsRaw = (await input({
-    message: "Enter dependency digests (comma-separated sha256:..., optional):",
-    default: "",
-    validate: (value) => {
-      const trimmed = value.trim();
-      if (!trimmed) return true;
-      const parts = trimmed.split(",").map((p) => p.trim()).filter(Boolean);
-      for (const p of parts) {
-        if (!/^sha256:[0-9a-f]{64}$/i.test(p)) {
-          return `Invalid dependency digest: ${p} (expected sha256:<64 hex>)`;
-        }
-      }
-      return true;
-    }
-  })).trim();
-  const dependencies = depsRaw === "" ? [] : depsRaw.split(",").map((p) => p.trim()).filter(Boolean);
-  return {
-    repoUrl,
-    gitRef,
-    dockerfilePath,
-    caddyfilePath: caddyfileRaw === "" ? void 0 : caddyfileRaw,
-    buildContextPath,
-    dependencies
-  };
-}
-async function getPrivateKeyInteractive(privateKey) {
-  if (privateKey) {
-    if (!validatePrivateKeyFormat(privateKey)) {
-      throw new Error("Invalid private key format");
-    }
-    return privateKey;
-  }
-  const { getPrivateKeyWithSource: getPrivateKeyWithSource2 } = await import("@layr-labs/ecloud-sdk");
-  const result = await getPrivateKeyWithSource2({ privateKey: void 0 });
-  if (result) {
-    return result.key;
-  }
-  const key = await password({
-    message: "Enter private key:",
-    mask: true,
-    validate: (value) => {
-      if (!value.trim()) {
-        return "Private key is required";
-      }
-      if (!validatePrivateKeyFormat(value)) {
-        return "Invalid private key format (must be 64 hex characters, optionally prefixed with 0x)";
-      }
-      return true;
-    }
-  });
-  return key.trim();
-}
-async function getEnvironmentInteractive(environment) {
-  if (environment) {
-    try {
-      getEnvironmentConfig(environment);
-      if (!isEnvironmentAvailable(environment)) {
-        throw new Error(`Environment ${environment} is not available in this build`);
-      }
-      return environment;
-    } catch {
-    }
-  }
-  const availableEnvs = getAvailableEnvironments();
-  let defaultEnv;
-  const configDefaultEnv = getDefaultEnvironment();
-  if (configDefaultEnv && availableEnvs.includes(configDefaultEnv)) {
-    try {
-      getEnvironmentConfig(configDefaultEnv);
-      defaultEnv = configDefaultEnv;
-    } catch {
-    }
-  }
-  const choices = [];
-  if (availableEnvs.includes("sepolia")) {
-    choices.push({ name: "sepolia - Ethereum Sepolia testnet", value: "sepolia" });
-  }
-  if (availableEnvs.includes("sepolia-dev")) {
-    choices.push({ name: "sepolia-dev - Ethereum Sepolia testnet (dev)", value: "sepolia-dev" });
-  }
-  if (availableEnvs.includes("mainnet-alpha")) {
-    choices.push({
-      name: "mainnet-alpha - Ethereum mainnet (\u26A0\uFE0F  uses real funds)",
-      value: "mainnet-alpha"
-    });
-  }
-  if (choices.length === 0) {
-    throw new Error("No environments available in this build");
-  }
-  const env = await select({
-    message: "Select environment:",
-    choices,
-    default: defaultEnv
-  });
-  return env;
-}
-var MAX_IMAGE_SIZE = 4 * 1024 * 1024;
-
-// src/flags.ts
-var commonFlags = {
-  environment: Flags.string({
-    required: false,
-    description: "Deployment environment to use",
-    env: "ECLOUD_ENV",
-    default: async () => getDefaultEnvironment() || (getBuildType2() === "dev" ? "sepolia-dev" : "sepolia")
-  }),
-  "private-key": Flags.string({
-    required: false,
-    description: "Private key for signing transactions",
-    env: "ECLOUD_PRIVATE_KEY"
-  }),
-  "rpc-url": Flags.string({
-    required: false,
-    description: "RPC URL to connect to blockchain",
-    env: "ECLOUD_RPC_URL"
-  }),
-  verbose: Flags.boolean({
-    required: false,
-    description: "Enable verbose logging (default: false)",
-    default: false
-  })
-};
-async function validateCommonFlags(flags, options) {
-  flags["environment"] = await getEnvironmentInteractive(flags["environment"]);
-  if (options?.requirePrivateKey !== false) {
-    flags["private-key"] = await getPrivateKeyInteractive(flags["private-key"]);
-  }
-  return flags;
-}
-
-// src/client.ts
-import {
-  createComputeModule,
-  createBillingModule,
-  createBuildModule,
-  getEnvironmentConfig as getEnvironmentConfig2,
-  requirePrivateKey,
-  getPrivateKeyWithSource
-} from "@layr-labs/ecloud-sdk";
-async function createBuildClient(flags) {
-  flags = await validateCommonFlags(flags, { requirePrivateKey: false });
-  return createBuildModule({
-    verbose: flags.verbose,
-    privateKey: flags["private-key"],
-    environment: flags.environment,
-    clientId: getClientId(),
-    skipTelemetry: true
-    // CLI already has telemetry, skip SDK telemetry
-  });
-}
-
-// src/telemetry.ts
-import {
-  createTelemetryClient,
-  createAppEnvironment,
-  createMetricsContext,
-  addMetric,
-  addMetricWithDimensions,
-  emitMetrics,
-  getBuildType as getBuildType3
-} from "@layr-labs/ecloud-sdk";
-function createCLITelemetryClient() {
-  const userUUID = getOrCreateUserUUID();
-  const environment = createAppEnvironment(userUUID);
-  const telemetryEnabled = getGlobalTelemetryPreference();
-  return createTelemetryClient(environment, "ecloud-cli", {
-    telemetryEnabled: telemetryEnabled !== false
-    // Enabled by default, disabled only if explicitly set to false
-  });
-}
-async function withTelemetry(command, action) {
-  const client = createCLITelemetryClient();
-  const metrics = createMetricsContext();
-  metrics.properties["source"] = "ecloud-cli";
-  metrics.properties["command"] = command.id || command.constructor.name;
-  const environment = getDefaultEnvironment() || "sepolia";
-  metrics.properties["environment"] = environment;
-  const buildType = getBuildType3() || "prod";
-  metrics.properties["build_type"] = buildType;
-  const cliVersion = command.config.version;
-  if (cliVersion) {
-    metrics.properties["cli_version"] = cliVersion;
-  }
-  addMetric(metrics, "Count", 1);
-  let actionError;
-  let result;
-  try {
-    result = await action();
-    return result;
-  } catch (err) {
-    actionError = err instanceof Error ? err : new Error(String(err));
-    throw err;
-  } finally {
-    const resultValue = actionError ? "Failure" : "Success";
-    const dimensions = {};
-    if (actionError) {
-      dimensions["error"] = actionError.message;
-    }
-    addMetricWithDimensions(metrics, resultValue, 1, dimensions);
-    const duration = Date.now() - metrics.startTime.getTime();
-    addMetric(metrics, "DurationMilliseconds", duration);
-    try {
-      await emitMetrics(client, metrics);
-      await client.close();
-    } catch {
-    }
-  }
-}
-
-// src/commands/compute/build/submit.ts
-import { BUILD_STATUS as BUILD_STATUS2 } from "@layr-labs/ecloud-sdk";
-
-// src/utils/build.ts
-function formatSourceLink(repoUrl, gitRef) {
-  const normalizedRepo = repoUrl.replace(/\.git$/, "");
-  try {
-    const url = new URL(normalizedRepo);
-    const host = url.host.toLowerCase();
-    if (host === "github.com") {
-      const path4 = url.pathname.replace(/\/+$/, "");
-      if (path4.split("/").filter(Boolean).length >= 2) {
-        return `https://github.com${path4}/tree/${gitRef}`;
-      }
-    }
-  } catch {
-  }
-  return `${repoUrl}@${gitRef}`;
-}
-function extractRepoName(repoUrl) {
-  const normalized = repoUrl.replace(/\.git$/, "");
-  const match = normalized.match(/\/([^/]+?)$/);
-  return match?.[1];
-}
-function formatDependencyLines(dependencies) {
-  if (!dependencies || Object.keys(dependencies).length === 0) return [];
-  const lines = [];
-  lines.push("Dependencies (resolved builds):");
-  for (const [digest, dep] of Object.entries(dependencies)) {
-    const name = extractRepoName(dep.repoUrl);
-    const depSource = formatSourceLink(dep.repoUrl, dep.gitRef);
-    lines.push(`  - ${digest} \u2713${name ? ` ${name}` : ""}`);
-    lines.push(`    ${depSource}`);
-  }
-  return lines;
-}
-function formatVerifiableBuildSummary(options) {
-  const lines = [];
-  lines.push("Build completed successfully \u2713");
-  lines.push("");
-  lines.push(`Image:  ${options.imageUrl}`);
-  lines.push(`Digest: ${options.imageDigest}`);
-  lines.push(`Source: ${formatSourceLink(options.repoUrl, options.gitRef)}`);
-  const depLines = formatDependencyLines(options.dependencies);
-  if (depLines.length) {
-    lines.push("");
-    lines.push(...depLines);
-  }
-  lines.push("");
-  lines.push("Provenance signature verified \u2713");
-  lines.push(`provenance_signature: ${options.provenanceSignature}`);
-  if (options.buildId) {
-    lines.push("");
-    lines.push(`Build ID: ${options.buildId}`);
-  }
-  return lines;
-}
-
-// src/utils/verifiableBuild.ts
-import { BUILD_STATUS } from "@layr-labs/ecloud-sdk";
-function assertCommitSha40(commit) {
-  if (!/^[0-9a-f]{40}$/i.test(commit)) {
-    throw new Error("Commit must be a 40-character hexadecimal SHA");
-  }
-}
-async function runVerifiableBuildAndVerify(client, request, options = {}) {
-  const { buildId } = await client.submit(request);
-  const completed = await client.waitForBuild(buildId, { onLog: options.onLog });
-  if (completed.status !== BUILD_STATUS.SUCCESS) {
-    throw new Error(`Build did not complete successfully (status: ${completed.status})`);
-  }
-  const [build, verify] = await Promise.all([client.get(buildId), client.verify(buildId)]);
-  if (verify.status !== "verified") {
-    throw new Error(`Provenance verification failed: ${verify.error}`);
-  }
-  return { build, verified: verify };
-}
-
-// src/commands/compute/build/submit.ts
-var BuildSubmit = class _BuildSubmit extends Command {
-  static description = "Submit a new verifiable build";
-  static examples = [
-    `$ ecloud compute build submit --repo https://github.com/myorg/myapp --commit abc123...`,
-    `$ ecloud compute build submit --repo https://github.com/myorg/myapp --commit abc123... --dependencies sha256:def456...`,
-    `$ ecloud compute build submit --repo https://github.com/myorg/myapp --commit abc123... --build-caddyfile Caddyfile`,
-    `$ ecloud compute build submit --repo https://github.com/myorg/myapp --commit abc123... --no-follow`
-  ];
-  static flags = {
-    ...commonFlags,
-    repo: Flags2.string({
-      description: "Git repository URL",
-      required: false,
-      env: "ECLOUD_BUILD_REPO"
-    }),
-    commit: Flags2.string({
-      description: "Git commit SHA (40 hex characters)",
-      required: false,
-      env: "ECLOUD_BUILD_COMMIT"
-    }),
-    dockerfile: Flags2.string({
-      description: "Path to Dockerfile",
-      default: "Dockerfile",
-      env: "ECLOUD_BUILD_DOCKERFILE"
-    }),
-    "build-caddyfile": Flags2.string({
-      description: "Optional path to Caddyfile inside the repo (relative to build context). If omitted, no Caddyfile is copied into the image",
-      required: false,
-      env: "ECLOUD_BUILD_CADDYFILE"
-    }),
-    context: Flags2.string({
-      description: "Build context path",
-      default: ".",
-      env: "ECLOUD_BUILD_CONTEXT"
-    }),
-    dependencies: Flags2.string({
-      description: "Dependency image digests (sha256:...)",
-      multiple: true
-    }),
-    "no-follow": Flags2.boolean({
-      description: "Don't follow logs, exit after submission",
-      default: false
-    }),
-    json: Flags2.boolean({
-      description: "Output JSON instead of formatted text",
-      default: false
-    })
-  };
-  async run() {
-    return withTelemetry(this, async () => {
-      const { flags } = await this.parse(_BuildSubmit);
-      const validatedFlags = await validateCommonFlags(flags);
-      const interactiveInputs = flags.repo && flags.commit ? void 0 : await promptVerifiableGitSourceInputs();
-      const repoUrl = flags.repo ?? interactiveInputs.repoUrl;
-      const gitRef = flags.commit ?? interactiveInputs.gitRef;
-      const dockerfilePath = flags.dockerfile ?? interactiveInputs.dockerfilePath;
-      const buildContextPath = flags.context ?? interactiveInputs.buildContextPath;
-      const dependencies = flags.dependencies && flags.dependencies.length > 0 ? flags.dependencies : interactiveInputs?.dependencies;
-      const caddyfilePath = flags["build-caddyfile"] ?? interactiveInputs?.caddyfilePath;
-      try {
-        assertCommitSha40(gitRef);
-      } catch (e) {
-        this.error(e?.message || String(e));
-      }
-      const client = await createBuildClient(validatedFlags);
-      this.log(chalk.gray("Submitting build..."));
-      try {
-        if (flags["no-follow"]) {
-          const { buildId } = await client.submit({
-            repoUrl,
-            gitRef,
-            dockerfilePath,
-            caddyfilePath,
-            buildContextPath,
-            dependencies
-          });
-          this.log(chalk.green(`Build submitted: ${buildId}`));
-          if (flags.json) {
-            this.log(JSON.stringify({ buildId }, null, 2));
-          } else {
-            this.log(`
-Build ID: ${chalk.cyan(buildId)}`);
-            this.log(
-              `
-Use ${chalk.yellow(`ecloud compute build logs ${buildId} --follow`)} to watch progress`
-            );
-          }
-          return;
-        }
-        this.log("");
-        const { build, verified } = await runVerifiableBuildAndVerify(
-          client,
-          {
-            repoUrl,
-            gitRef,
-            dockerfilePath,
-            caddyfilePath,
-            buildContextPath,
-            dependencies
-          },
-          {
-            onLog: (chunk) => process.stdout.write(chunk)
-          }
-        );
-        this.log("");
-        await this.printBuildResult(build, flags.json, verified);
-      } catch (error) {
-        this.log(chalk.red("Build submission failed"));
-        if (error?.name === "BuildFailedError") {
-          this.error(`Build failed: ${error.message}`);
-        }
-        throw error;
-      }
-    });
-  }
-  async printBuildResult(build, json, verify) {
-    if (json) {
-      this.log(JSON.stringify(build, null, 2));
-      return;
-    }
-    if (build.status === BUILD_STATUS2.SUCCESS && verify?.status === "verified") {
-      for (const line of formatVerifiableBuildSummary({
-        buildId: build.buildId,
-        imageUrl: build.imageUrl || "",
-        imageDigest: build.imageDigest || "",
-        repoUrl: build.repoUrl,
-        gitRef: build.gitRef,
-        dependencies: build.dependencies,
-        provenanceSignature: verify.provenanceSignature
-      })) {
-        this.log(line);
-      }
-    } else {
-      this.log(chalk.red(`Build failed: ${build.errorMessage ?? "Unknown error"}`));
-    }
-  }
-};
-export {
-  BuildSubmit as default
-};
-//# sourceMappingURL=submit.js.map