relic 0.4.0 → 0.4.1

package/commands/whoami.ts

@@ -1,45 +0,0 @@
-import { validateSession } from "@repo/auth";
-import { trackEvent } from "@repo/logger";
-import ora from "ora";
-import pc from "picocolors";
-import { getApi } from "../lib/api";
-
-export default async function whoami() {
-  const spinner = ora("Fetching user info...").start();
-
-  try {
-    const sessionValidation = await validateSession();
-    if (!sessionValidation.isValid || sessionValidation.isExpired) {
-      spinner.stop();
-      console.log(pc.yellow("Not logged in"));
-      console.log(pc.dim("Run `relic login` to authenticate"));
-      return;
-    }
-
-    const api = getApi();
-    const user = await api.getCurrentUser();
-
-    trackEvent("cli_command_executed", { command: "whoami" });
-    spinner.stop();
-    console.log(pc.bold("Logged in as:"));
-    console.log();
-    console.log(`${pc.dim("Name:")}  ${user.name}`);
-    console.log(`${pc.dim("Email:")} ${user.email}`);
-    console.log(`${pc.dim("Plan:")}  ${user.hasPro ? pc.green("Pro") : "Free"}`);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Failed to fetch user";
-    // Handle auth-related errors more gracefully
-    if (
-      message.includes("Not authenticated") ||
-      message.includes("JWT") ||
-      message.includes("token")
-    ) {
-      spinner.stop();
-      console.log(pc.yellow("Not logged in"));
-      console.log(pc.dim("Run `relic login` to authenticate"));
-      return;
-    }
-    spinner.fail(pc.red(`Error: ${message}`));
-    process.exit(1);
-  }
-}

package/ffi/bridge.ts

@@ -1,36 +0,0 @@
-import type { Pointer } from "bun:ffi";
-import { getLibrary } from "./helper";
-
-type LibraryType = Awaited<ReturnType<typeof getLibrary>>;
-
-export class RunnerBridge {
-  private lib: LibraryType;
-  private static instance: RunnerBridge | null = null;
-  private static instancePromise: Promise<RunnerBridge> | null = null;
-
-  private constructor(lib: LibraryType) {
-    this.lib = lib;
-  }
-
-  static async getInstance(): Promise<RunnerBridge> {
-    if (RunnerBridge.instance) {
-      return RunnerBridge.instance;
-    }
-
-    if (RunnerBridge.instancePromise) {
-      return RunnerBridge.instancePromise;
-    }
-
-    RunnerBridge.instancePromise = (async () => {
-      const lib = await getLibrary();
-      RunnerBridge.instance = new RunnerBridge(lib);
-      return RunnerBridge.instance;
-    })();
-
-    return RunnerBridge.instancePromise;
-  }
-
-  runWithSecrets(command: Pointer, secrets: Pointer): number {
-    return this.lib.symbols.run_with_secrets(command, secrets);
-  }
-}

package/ffi/constants.ts

@@ -1,3 +0,0 @@
-export const REPO_URL = "https://github.com/heycupola/relic";
-export const ISSUES_URL = `${REPO_URL}/issues`;
-export const RELEASES_URL = `${REPO_URL}/releases`;

package/ffi/helper.ts

@@ -1,134 +0,0 @@
-import { dlopen, FFIType, suffix } from "bun:ffi";
-import { ISSUES_URL, RELEASES_URL } from "./constants";
-
-type Environment = "development" | "production";
-
-const PLATFORM_MAP: Record<string, string> = {
-  "darwin-arm64": "darwin-arm64",
-  "darwin-x64": "darwin-x64",
-  "linux-x64": "linux-x64",
-  "win32-x64": "win32-x64",
-};
-
-async function detectEnvironment(): Promise<Environment> {
-  if (process.env.DEV === "true") {
-    return "development";
-  }
-
-  const prebuildsPath = `${import.meta.dir}/../prebuilds`;
-  if (await Bun.file(prebuildsPath).exists()) {
-    return "production";
-  }
-
-  const turboJsonPath = `${import.meta.dir}/../../../turbo.json`;
-  if (await Bun.file(turboJsonPath).exists()) {
-    return "development";
-  }
-
-  return "production";
-}
-
-function getRunnerPath(): string {
-  return `${import.meta.dir}/../../../packages/runner`;
-}
-
-function getLibraryName(): string {
-  return process.platform === "win32" ? "relic_runner.dll" : `librelic_runner.${suffix}`;
-}
-
-function getProductionError(platform: string): Error {
-  return new Error(
-    `Rust library not found for ${platform}.\n\n` +
-      `This appears to be a packaging issue. Please try reinstalling:\n` +
-      `  - If installed via package manager: uninstall and reinstall relic\n` +
-      `  - If using binaries: re-download from ${RELEASES_URL}\n\n` +
-      `If the problem persists, report at: ${ISSUES_URL}`,
-  );
-}
-
-function getDevelopmentError(platform: string): Error {
-  return new Error(
-    `Rust library not found for ${platform}.\n\n` +
-      `Build the runner first:\n` +
-      `  cd packages/runner && cargo build --release`,
-  );
-}
-
-async function findLibraryInProduction(
-  targetPlatform: string,
-  libName: string,
-): Promise<string | null> {
-  const searchPaths = [
-    `${import.meta.dir}/${libName}`,
-    `${import.meta.dir}/../lib/${libName}`,
-    `${import.meta.dir}/../prebuilds/${targetPlatform}/${libName}`,
-  ];
-
-  for (const candidate of searchPaths) {
-    if (await Bun.file(candidate).exists()) {
-      return candidate;
-    }
-  }
-
-  return null;
-}
-
-async function findLibraryInDevelopment(
-  targetPlatform: string,
-  libName: string,
-): Promise<string | null> {
-  const runnerPath = getRunnerPath();
-
-  const paths = [
-    `${runnerPath}/target/release/${libName}`,
-    `${runnerPath}/target/debug/${libName}`,
-    `${runnerPath}/prebuilt/${targetPlatform}/${libName}`,
-  ];
-
-  for (const path of paths) {
-    if (await Bun.file(path).exists()) {
-      return path;
-    }
-  }
-
-  return null;
-}
-
-export async function getPlatformLibrary(): Promise<string> {
-  const platformKey = `${process.platform}-${process.arch}`;
-  const targetPlatform = PLATFORM_MAP[platformKey];
-
-  if (!targetPlatform) {
-    throw new Error(
-      `Unsupported platform: ${platformKey}. Supported platforms: ${Object.keys(PLATFORM_MAP).join(", ")}`,
-    );
-  }
-
-  const libName = getLibraryName();
-  const env = await detectEnvironment();
-
-  if (env === "production") {
-    const libraryPath = await findLibraryInProduction(targetPlatform, libName);
-    if (libraryPath) {
-      return libraryPath;
-    }
-    throw getProductionError(platformKey);
-  }
-
-  const libraryPath = await findLibraryInDevelopment(targetPlatform, libName);
-  if (libraryPath) {
-    return libraryPath;
-  }
-  throw getDevelopmentError(platformKey);
-}
-
-export async function getLibrary() {
-  const lib = dlopen(await getPlatformLibrary(), {
-    run_with_secrets: {
-      args: [FFIType.cstring, FFIType.cstring],
-      returns: FFIType.i32,
-    },
-  });
-
-  return lib;
-}

package/index.ts

@@ -1,116 +0,0 @@
-import { initLogger, isFirstRun, saveTelemetryPreference } from "@repo/logger";
-import { Command, CommanderError } from "commander";
-import type { SecretScope } from "lib/types";
-import pc from "picocolors";
-import init from "./commands/init";
-import login from "./commands/login";
-import logout from "./commands/logout";
-import projects from "./commands/projects";
-import run from "./commands/run";
-import { telemetryDisable, telemetryEnable, telemetryStatus } from "./commands/telemetry";
-import whoami from "./commands/whoami";
-import pkg from "./package.json";
-
-await initLogger();
-
-if (isFirstRun()) {
-  console.log(
-    pc.dim(
-      "Relic collects anonymous usage data to improve the product. Run `relic telemetry disable` to opt out.",
-    ),
-  );
-  saveTelemetryPreference(true);
-}
-
-function printAvailableCommands() {
-  console.error(pc.dim("  Available commands:\n"));
-  for (const cmd of program.commands) {
-    console.error(`    ${pc.cyan(cmd.name().padEnd(14))} ${pc.dim(cmd.description())}`);
-  }
-}
-
-function printHelpHint() {
-  console.error(`\n  ${pc.dim(`Run ${pc.white("relic --help")} for more information.`)}\n`);
-}
-
-const program = new Command()
-  .name("relic")
-  .description("Zero-knowledge secret layer for your projects")
-  .version(pkg.version)
-  .exitOverride()
-  .configureOutput({
-    outputError: () => {
-      /* suppressed */
-    },
-  })
-  .action(async () => {
-    process.env._RELIC_FROM_CLI = "true";
-    await import("@repo/tui");
-  });
-
-program.command("login").description("Authenticate with Relic").action(login);
-program.command("logout").description("Clear authentication").action(logout);
-program.command("whoami").description("Show current user").action(whoami);
-program.command("projects").description("List all projects").action(projects);
-program.command("init").description("Initialize Relic for the current project").action(init);
-
-const telemetryCmd = program
-  .command("telemetry")
-  .description("Manage anonymous usage data collection");
-telemetryCmd.command("status").description("Show telemetry status").action(telemetryStatus);
-telemetryCmd.command("enable").description("Enable telemetry").action(telemetryEnable);
-telemetryCmd.command("disable").description("Disable telemetry").action(telemetryDisable);
-
-program
-  .command("run")
-  .description("Run a command with secrets injected as environment variables")
-  .requiredOption("-e, --environment <name>", "Environment name (required)")
-  .option("-f, --folder <name>", "Folder name (optional)")
-  .option("-s, --scope <scope>", "Scope filter: client, server, or shared (optional)")
-  .option("-p, --project <id>", "Project ID (optional, defaults to relic.toml or RELIC_PROJECT_ID)")
-  .argument("<command...>", "Command to run")
-  .action(
-    (
-      command: string[],
-      options: { environment: string; folder?: string; scope?: SecretScope; project?: string },
-    ) => {
-      run(command, options);
-    },
-  );
-
-try {
-  program.parse();
-} catch (err) {
-  if (err instanceof CommanderError) {
-    if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
-      process.exit(0);
-    }
-
-    const cleanMessage = err.message.replace(/^error:\s*/i, "");
-    console.error();
-
-    if (err.code === "commander.unknownCommand" || err.code === "commander.excessArguments") {
-      const unknown =
-        err.message.match(/'(.+?)'/)?.[1] ??
-        process.argv.find(
-          (arg) => !arg.startsWith("-") && arg !== process.argv[0] && arg !== process.argv[1],
-        );
-      console.error(`  ${pc.red(pc.bold("Unknown command:"))} ${pc.white(unknown ?? "unknown")}`);
-      console.error();
-      printAvailableCommands();
-    } else if (err.code === "commander.missingArgument") {
-      console.error(`  ${pc.red(pc.bold("Missing argument:"))} ${pc.dim(cleanMessage)}`);
-    } else if (err.code === "commander.missingMandatoryOptionValue") {
-      console.error(`  ${pc.red(pc.bold("Missing required option:"))} ${pc.dim(cleanMessage)}`);
-    } else if (err.code === "commander.optionMissingArgument") {
-      console.error(`  ${pc.red(pc.bold("Option missing argument:"))} ${pc.dim(cleanMessage)}`);
-    } else {
-      console.error(`  ${pc.red(pc.bold("Error:"))} ${pc.dim(cleanMessage)}`);
-    }
-
-    printHelpHint();
-    process.exit(1);
-  }
-
-  throw err;
-}