@barekey/cli 0.4.0 → 0.5.0

package/src/contracts/index.ts

@@ -0,0 +1,370 @@
+import { Schema } from "effect";
+
+export const DeclaredTypeSchema = Schema.Literal(
+  "string",
+  "boolean",
+  "int64",
+  "float",
+  "date",
+  "json",
+);
+export const VisibilitySchema = Schema.Literal("private", "public");
+export const RolloutFunctionSchema = Schema.Literal("linear", "step", "ease_in_out");
+export const RuntimeModeSchema = Schema.Literal("centralized", "standalone");
+export const TypegenModeSchema = Schema.Literal("semantic", "minimal");
+
+const TrimmedStringSchema = Schema.String;
+const NonEmptyStringSchema = Schema.String.pipe(Schema.minLength(1));
+
+export const RuntimeConfigSchema = Schema.Struct({
+  organization: Schema.optional(Schema.NullOr(TrimmedStringSchema)),
+  org: Schema.optional(Schema.NullOr(TrimmedStringSchema)),
+  project: Schema.optional(Schema.NullOr(TrimmedStringSchema)),
+  environment: Schema.optional(Schema.NullOr(TrimmedStringSchema)),
+  stage: Schema.optional(Schema.NullOr(TrimmedStringSchema)),
+  typegen: Schema.optional(Schema.NullOr(TypegenModeSchema)),
+  config: Schema.optional(
+    Schema.Struct({
+      typegen: Schema.optional(TypegenModeSchema),
+      mode: Schema.optional(RuntimeModeSchema),
+    }),
+  ),
+});
+
+export const CliConfigSchema = Schema.Union(
+  Schema.Struct({
+    baseUrl: NonEmptyStringSchema,
+    activeSessionId: NonEmptyStringSchema,
+  }),
+  Schema.Struct({
+    baseUrl: NonEmptyStringSchema,
+    activeAccountId: NonEmptyStringSchema,
+  }),
+);
+
+export const CliSessionSchema = Schema.Union(
+  Schema.Struct({
+    accessToken: NonEmptyStringSchema,
+    refreshToken: NonEmptyStringSchema,
+    accessTokenExpiresAtMs: Schema.Number.pipe(Schema.finite()),
+    refreshTokenExpiresAtMs: Schema.Number.pipe(Schema.finite()),
+    clerkUserId: NonEmptyStringSchema,
+    orgId: Schema.NullOr(NonEmptyStringSchema),
+    orgSlug: Schema.NullOr(NonEmptyStringSchema),
+    lastOrgId: Schema.optional(Schema.NullOr(NonEmptyStringSchema)),
+    lastOrgSlug: Schema.optional(Schema.NullOr(NonEmptyStringSchema)),
+  }),
+  Schema.Struct({
+    accessToken: NonEmptyStringSchema,
+    refreshToken: NonEmptyStringSchema,
+    accessTokenExpiresAtMs: Schema.Number.pipe(Schema.finite()),
+    refreshTokenExpiresAtMs: Schema.Number.pipe(Schema.finite()),
+    clerkUserId: NonEmptyStringSchema,
+    orgId: NonEmptyStringSchema,
+    orgSlug: NonEmptyStringSchema,
+  }),
+);
+
+export const ErrorEnvelopeSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.optional(Schema.String),
+    message: Schema.optional(Schema.String),
+    requestId: Schema.optional(Schema.NullOr(Schema.String)),
+  }),
+});
+
+export const CliSessionResponseSchema = Schema.Struct({
+  clerkUserId: Schema.String,
+  orgId: Schema.String,
+  orgSlug: Schema.String,
+  source: Schema.Literal("clerk", "cli"),
+  requestId: Schema.optional(Schema.String),
+});
+
+export const DeviceStartResponseSchema = Schema.Struct({
+  deviceCode: Schema.String,
+  userCode: Schema.String,
+  verificationUri: Schema.String,
+  intervalSec: Schema.Number.pipe(Schema.finite()),
+  expiresInSec: Schema.Number.pipe(Schema.finite()),
+  requestId: Schema.optional(Schema.String),
+});
+
+export const DevicePollPendingSchema = Schema.Struct({
+  status: Schema.Literal("pending"),
+  intervalSec: Schema.Number.pipe(Schema.finite()),
+  requestId: Schema.optional(Schema.String),
+});
+
+export const DevicePollApprovedSchema = Schema.Struct({
+  status: Schema.Literal("approved"),
+  intervalSec: Schema.Number.pipe(Schema.finite()),
+  accessToken: Schema.String,
+  refreshToken: Schema.String,
+  accessTokenExpiresAtMs: Schema.Number.pipe(Schema.finite()),
+  refreshTokenExpiresAtMs: Schema.Number.pipe(Schema.finite()),
+  orgId: Schema.String,
+  orgSlug: Schema.String,
+  clerkUserId: Schema.String,
+  requestId: Schema.optional(Schema.String),
+});
+
+export const DevicePollResponseSchema = Schema.Union(
+  DevicePollPendingSchema,
+  DevicePollApprovedSchema,
+);
+
+export const RefreshResponseSchema = Schema.Struct({
+  accessToken: Schema.String,
+  refreshToken: Schema.String,
+  accessTokenExpiresAtMs: Schema.Number.pipe(Schema.finite()),
+  refreshTokenExpiresAtMs: Schema.Number.pipe(Schema.finite()),
+  orgId: Schema.String,
+  orgSlug: Schema.String,
+  clerkUserId: Schema.String,
+  requestId: Schema.optional(Schema.String),
+});
+
+export const EnvDecisionSchema = Schema.Struct({
+  bucket: Schema.Number.pipe(Schema.finite()),
+  chance: Schema.Number.pipe(Schema.finite()),
+  seed: Schema.optional(Schema.String),
+  key: Schema.optional(Schema.String),
+  matchedRule: Schema.String,
+});
+
+export const EnvResolvedValueSchema = Schema.Struct({
+  name: Schema.String,
+  kind: Schema.Literal("secret", "ab_roll", "rollout"),
+  declaredType: DeclaredTypeSchema,
+  visibility: VisibilitySchema,
+  value: Schema.Unknown,
+  decision: Schema.optional(EnvDecisionSchema),
+});
+
+export const EnvEvaluateResponseSchema = Schema.Struct({
+  name: Schema.String,
+  kind: Schema.Literal("secret", "ab_roll", "rollout"),
+  declaredType: DeclaredTypeSchema,
+  visibility: VisibilitySchema,
+  value: Schema.Unknown,
+  decision: Schema.optional(EnvDecisionSchema),
+});
+
+export const EnvEvaluateBatchResponseSchema = Schema.Struct({
+  values: Schema.Array(EnvResolvedValueSchema),
+});
+
+export const RolloutMilestoneSchema = Schema.Struct({
+  at: Schema.String,
+  percentage: Schema.Number.pipe(Schema.finite()),
+});
+
+export const EnvVariableListItemSchema = Schema.Struct({
+  name: Schema.String,
+  visibility: VisibilitySchema,
+  kind: Schema.Literal("secret", "ab_roll", "rollout"),
+  declaredType: DeclaredTypeSchema,
+  createdAtMs: Schema.Number.pipe(Schema.finite()),
+  updatedAtMs: Schema.Number.pipe(Schema.finite()),
+  chance: Schema.NullOr(Schema.Number.pipe(Schema.finite())),
+  rolloutFunction: Schema.NullOr(RolloutFunctionSchema),
+  rolloutMilestones: Schema.NullOr(Schema.Array(RolloutMilestoneSchema)),
+});
+
+export const EnvListResponseSchema = Schema.Struct({
+  variables: Schema.Array(EnvVariableListItemSchema),
+});
+
+export const EnvWriteResponseSchema = Schema.Struct({
+  createdCount: Schema.Number.pipe(Schema.finite()),
+  updatedCount: Schema.Number.pipe(Schema.finite()),
+  deletedCount: Schema.Number.pipe(Schema.finite()),
+});
+
+export const EnvPullValueSchema = Schema.Struct({
+  name: Schema.String,
+  kind: Schema.Literal("secret", "ab_roll", "rollout"),
+  declaredType: DeclaredTypeSchema,
+  value: Schema.String,
+});
+
+export const EnvPullResponseSchema = Schema.Struct({
+  values: Schema.Array(EnvPullValueSchema),
+  byName: Schema.Record({ key: Schema.String, value: Schema.String }),
+});
+
+export const TypegenVariableSchema = Schema.Struct({
+  name: Schema.String,
+  visibility: VisibilitySchema,
+  kind: Schema.Literal("secret", "ab_roll", "rollout"),
+  declaredType: DeclaredTypeSchema,
+  required: Schema.Boolean,
+  updatedAtMs: Schema.Number.pipe(Schema.finite()),
+  typeScriptType: Schema.String,
+  valueATypeScriptType: Schema.NullOr(Schema.String),
+  valueBTypeScriptType: Schema.NullOr(Schema.String),
+  rolloutFunction: Schema.NullOr(RolloutFunctionSchema),
+  rolloutMilestones: Schema.NullOr(Schema.Array(RolloutMilestoneSchema)),
+});
+
+export const TypegenManifestSchema = Schema.Struct({
+  orgId: Schema.String,
+  orgSlug: Schema.String,
+  projectSlug: Schema.String,
+  stageSlug: Schema.String,
+  generatedAtMs: Schema.Number.pipe(Schema.finite()),
+  manifestVersion: Schema.String,
+  variables: Schema.Array(TypegenVariableSchema),
+});
+
+export const OrganizationSummarySchema = Schema.Struct({
+  id: Schema.String,
+  slug: Schema.String,
+  name: Schema.String,
+  role: Schema.String,
+  imageUrl: Schema.String,
+});
+
+export const OrganizationsResponseSchema = Schema.Struct({
+  organizations: Schema.Array(OrganizationSummarySchema),
+});
+
+export const ProjectSummarySchema = Schema.Struct({
+  id: Schema.String,
+  orgId: Schema.String,
+  orgSlug: Schema.String,
+  name: Schema.String,
+  slug: Schema.String,
+  slugBase: Schema.String,
+  createdByClerkUserId: Schema.String,
+  createdAtMs: Schema.Number.pipe(Schema.finite()),
+  updatedAtMs: Schema.Number.pipe(Schema.finite()),
+});
+
+export const ProjectListItemSchema = Schema.Struct({
+  id: Schema.String,
+  orgId: Schema.String,
+  orgSlug: Schema.String,
+  name: Schema.String,
+  slug: Schema.String,
+  slugBase: Schema.String,
+  createdByClerkUserId: Schema.String,
+  createdAtMs: Schema.Number.pipe(Schema.finite()),
+  updatedAtMs: Schema.Number.pipe(Schema.finite()),
+  secretCount: Schema.Number.pipe(Schema.finite()),
+});
+
+export const ProjectsListResponseSchema = Schema.Struct({
+  projects: Schema.Array(ProjectListItemSchema),
+});
+
+export const ProjectCreateResponseSchema = Schema.Struct({
+  project: ProjectSummarySchema,
+});
+
+export const ProjectDeleteResponseSchema = Schema.Struct({
+  deletedProjectId: Schema.String,
+  deletedProjectSlug: Schema.String,
+});
+
+export const StageSummarySchema = Schema.Struct({
+  id: Schema.String,
+  projectId: Schema.String,
+  orgId: Schema.String,
+  slug: Schema.String,
+  name: Schema.String,
+  isDefault: Schema.Boolean,
+  variableCount: Schema.Number.pipe(Schema.finite()),
+  createdAtMs: Schema.Number.pipe(Schema.finite()),
+  updatedAtMs: Schema.Number.pipe(Schema.finite()),
+});
+
+export const StagesListResponseSchema = Schema.Struct({
+  stages: Schema.Array(StageSummarySchema),
+});
+
+export const StageCreateResponseSchema = Schema.Struct({
+  stage: StageSummarySchema,
+});
+
+export const StageRenameResponseSchema = Schema.Struct({
+  stage: StageSummarySchema,
+});
+
+export const StageDeleteResponseSchema = Schema.Struct({
+  deletedStageSlug: Schema.String,
+});
+
+export const FeatureUsageSchema = Schema.Struct({
+  featureId: Schema.String,
+  allowed: Schema.Boolean,
+  usage: Schema.NullOr(Schema.Number.pipe(Schema.finite())),
+  includedUsage: Schema.NullOr(Schema.Number.pipe(Schema.finite())),
+  usageLimit: Schema.NullOr(Schema.Number.pipe(Schema.finite())),
+  overageAllowed: Schema.NullOr(Schema.Boolean),
+  nextResetAtMs: Schema.NullOr(Schema.Number.pipe(Schema.finite())),
+});
+
+export const BillingCatalogResponseSchema = Schema.Struct({
+  variants: Schema.Array(Schema.Unknown),
+  featureIds: Schema.Struct({
+    staticRequests: Schema.String,
+    dynamicRequests: Schema.String,
+    storageBytes: Schema.String,
+  }),
+});
+
+export const BillingStatusResponseSchema = Schema.Struct({
+  orgId: Schema.String,
+  orgRole: Schema.NullOr(Schema.String),
+  canManageBilling: Schema.Boolean,
+  currentProductId: Schema.NullOr(Schema.String),
+  currentTier: Schema.NullOr(Schema.String),
+  currentInterval: Schema.NullOr(Schema.String),
+  currentOverageMode: Schema.NullOr(Schema.String),
+  hasScheduledPlanChange: Schema.Boolean,
+  scheduledPlanChange: Schema.NullOr(Schema.Unknown),
+  usage: Schema.Struct({
+    staticRequests: FeatureUsageSchema,
+    dynamicRequests: FeatureUsageSchema,
+    storageBytes: FeatureUsageSchema,
+  }),
+  storageMirrorBytes: Schema.Number.pipe(Schema.finite()),
+  variants: Schema.Array(Schema.Unknown),
+});
+
+export const AuditEventSchema = Schema.Struct({
+  id: Schema.String,
+  orgId: Schema.String,
+  orgSlug: Schema.String,
+  projectId: Schema.NullOr(Schema.String),
+  projectSlug: Schema.NullOr(Schema.String),
+  stageSlug: Schema.NullOr(Schema.String),
+  eventType: Schema.String,
+  category: Schema.String,
+  occurredAtMs: Schema.Number.pipe(Schema.finite()),
+  actorSource: Schema.String,
+  actorClerkUserId: Schema.NullOr(Schema.String),
+  actorDisplayName: Schema.NullOr(Schema.String),
+  actorEmail: Schema.NullOr(Schema.String),
+  subjectType: Schema.String,
+  subjectId: Schema.NullOr(Schema.String),
+  subjectName: Schema.NullOr(Schema.String),
+  title: Schema.String,
+  description: Schema.String,
+  severity: Schema.String,
+  payloadJson: Schema.String,
+  retentionTier: Schema.String,
+  expiresAtMs: Schema.NullOr(Schema.Number.pipe(Schema.finite())),
+});
+
+export const AuditListResponseSchema = Schema.Struct({
+  items: Schema.Array(AuditEventSchema),
+  nextBeforeOccurredAtMs: Schema.NullOr(Schema.Number.pipe(Schema.finite())),
+  hasMore: Schema.Boolean,
+});
+
+export type CliConfigRecord = Schema.Schema.Type<typeof CliConfigSchema>;
+export type CliSessionRecord = Schema.Schema.Type<typeof CliSessionSchema>;
+export type TypegenManifest = Schema.Schema.Type<typeof TypegenManifestSchema>;

package/src/credentials-store.ts

@@ -2,13 +2,29 @@ import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import { Either, Schema } from "effect";
 
+import { CliConfigSchema, CliSessionSchema } from "./contracts/index.js";
 import type { CliConfig, CliCredentials } from "./types.js";
 
 const SERVICE_NAME = "barekey-cli";
-const CONFIG_DIR = path.join(homedir(), ".config", "barekey");
-const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
-const CREDENTIALS_DIR = path.join(CONFIG_DIR, "credentials");
+
+function resolveHomeDir(): string {
+  const configuredHome = process.env.HOME?.trim();
+  return configuredHome && configuredHome.length > 0 ? configuredHome : homedir();
+}
+
+function getConfigDirPath(): string {
+  return path.join(resolveHomeDir(), ".config", "barekey");
+}
+
+function getConfigPath(): string {
+  return path.join(getConfigDirPath(), "config.json");
+}
+
+function getCredentialsDirPath(): string {
+  return path.join(getConfigDirPath(), "credentials");
+}
 
 type CommandResult = {
   stdout: string;
@@ -48,7 +64,7 @@ function runCommand(command: string, args: Array<string>, input?: string): Promi
 }
 
 async function ensureConfigDir(): Promise<void> {
-  await mkdir(CONFIG_DIR, {
+  await mkdir(getConfigDirPath(), {
     recursive: true,
     mode: 0o700,
   });
@@ -56,7 +72,7 @@ async function ensureConfigDir(): Promise<void> {
 
 async function ensureCredentialsDir(): Promise<void> {
   await ensureConfigDir();
-  await mkdir(CREDENTIALS_DIR, {
+  await mkdir(getCredentialsDirPath(), {
     recursive: true,
     mode: 0o700,
   });
@@ -80,7 +96,7 @@ async function writeJsonFile(filePath: string, value: unknown): Promise<void> {
 }
 
 function credentialsPathForAccount(accountId: string): string {
-  return path.join(CREDENTIALS_DIR, `${encodeURIComponent(accountId)}.json`);
+  return path.join(getCredentialsDirPath(), `${encodeURIComponent(accountId)}.json`);
 }
 
 async function canUseLinuxSecretTool(): Promise<boolean> {
@@ -188,15 +204,37 @@ async function deleteFromKeychain(account: string): Promise<boolean> {
 }
 
 export async function saveConfig(config: CliConfig): Promise<void> {
-  await writeJsonFile(CONFIG_PATH, config);
+  await writeJsonFile(getConfigPath(), config);
 }
 
 export async function loadConfig(): Promise<CliConfig | null> {
-  return readJsonFile<CliConfig>(CONFIG_PATH);
+  const decoded = await readJsonFile<unknown>(getConfigPath());
+  if (decoded === null) {
+    return null;
+  }
+
+  const result = Schema.decodeUnknownEither(
+    CliConfigSchema as unknown as Schema.Schema<any, any, never>,
+  )(decoded);
+  if (Either.isLeft(result)) {
+    return null;
+  }
+
+  if ("activeSessionId" in result.right) {
+    return {
+      baseUrl: result.right.baseUrl,
+      activeSessionId: result.right.activeSessionId,
+    };
+  }
+
+  return {
+    baseUrl: result.right.baseUrl,
+    activeSessionId: result.right.activeAccountId,
+  };
 }
 
 export async function clearConfig(): Promise<void> {
-  await rm(CONFIG_PATH, {
+  await rm(getConfigPath(), {
     force: true,
   });
 }
@@ -225,14 +263,50 @@ export async function loadCredentials(accountId: string): Promise<CliCredentials
   const fromKeychain = await getFromKeychain(accountId);
   if (fromKeychain !== null) {
     try {
-      return JSON.parse(fromKeychain) as CliCredentials;
+      const decoded = Schema.decodeUnknownEither(
+        CliSessionSchema as unknown as Schema.Schema<any, any, never>,
+      )(JSON.parse(fromKeychain) as unknown);
+      if (Either.isRight(decoded)) {
+        return {
+          accessToken: decoded.right.accessToken,
+          refreshToken: decoded.right.refreshToken,
+          accessTokenExpiresAtMs: decoded.right.accessTokenExpiresAtMs,
+          refreshTokenExpiresAtMs: decoded.right.refreshTokenExpiresAtMs,
+          clerkUserId: decoded.right.clerkUserId,
+          orgId: decoded.right.orgId ?? null,
+          orgSlug: decoded.right.orgSlug ?? null,
+          lastOrgId: ("lastOrgId" in decoded.right ? decoded.right.lastOrgId : undefined) ?? decoded.right.orgId ?? null,
+          lastOrgSlug: ("lastOrgSlug" in decoded.right ? decoded.right.lastOrgSlug : undefined) ?? decoded.right.orgSlug ?? null,
+        };
+      }
     } catch {
       // Fall back to file credentials when keychain data is malformed.
     }
   }
 
-  const fromFile = await readJsonFile<CliCredentials>(credentialsPathForAccount(accountId));
-  return fromFile;
+  const fromFile = await readJsonFile<unknown>(credentialsPathForAccount(accountId));
+  if (fromFile === null) {
+    return null;
+  }
+
+  const decoded = Schema.decodeUnknownEither(
+    CliSessionSchema as unknown as Schema.Schema<any, any, never>,
+  )(fromFile);
+  if (Either.isLeft(decoded)) {
+    return null;
+  }
+
+  return {
+    accessToken: decoded.right.accessToken,
+    refreshToken: decoded.right.refreshToken,
+    accessTokenExpiresAtMs: decoded.right.accessTokenExpiresAtMs,
+    refreshTokenExpiresAtMs: decoded.right.refreshTokenExpiresAtMs,
+    clerkUserId: decoded.right.clerkUserId,
+    orgId: decoded.right.orgId ?? null,
+    orgSlug: decoded.right.orgSlug ?? null,
+    lastOrgId: ("lastOrgId" in decoded.right ? decoded.right.lastOrgId : undefined) ?? decoded.right.orgId ?? null,
+    lastOrgSlug: ("lastOrgSlug" in decoded.right ? decoded.right.lastOrgSlug : undefined) ?? decoded.right.orgSlug ?? null,
+  };
 }
 
 export async function deleteCredentials(accountId: string): Promise<void> {

package/src/http.ts

@@ -1,3 +1,5 @@
+import { Effect, Either, Schema } from "effect";
+
 export class CliHttpError extends Error {
   readonly code: string;
   readonly status: number;
@@ -20,11 +22,27 @@ async function parseJson(response: Response): Promise<unknown> {
   }
 }
 
+function decodeResponse<TResponse>(
+  schema: Schema.Schema<TResponse>,
+  payload: unknown,
+): TResponse {
+  const decoded = Schema.decodeUnknownEither(schema)(payload);
+  if (Either.isLeft(decoded)) {
+    throw new CliHttpError({
+      code: "INVALID_RESPONSE",
+      status: 500,
+      message: "Barekey returned an unexpected response payload.",
+    });
+  }
+  return decoded.right;
+}
+
 export async function postJson<TResponse>(input: {
   baseUrl: string;
   path: string;
   payload: unknown;
   accessToken?: string | null;
+  schema?: Schema.Schema<TResponse>;
 }): Promise<TResponse> {
   const response = await fetch(`${input.baseUrl.replace(/\/$/, "")}${input.path}`, {
     method: "POST",
@@ -52,13 +70,14 @@ export async function postJson<TResponse>(input: {
     });
   }
 
-  return parsed as TResponse;
+  return input.schema ? decodeResponse(input.schema, parsed) : (parsed as TResponse);
 }
 
 export async function getJson<TResponse>(input: {
   baseUrl: string;
   path: string;
   accessToken?: string | null;
+  schema?: Schema.Schema<TResponse>;
 }): Promise<TResponse> {
   const response = await fetch(`${input.baseUrl.replace(/\/$/, "")}${input.path}`, {
     method: "GET",
@@ -82,5 +101,62 @@ export async function getJson<TResponse>(input: {
     });
   }
 
-  return parsed as TResponse;
+  return input.schema ? decodeResponse(input.schema, parsed) : (parsed as TResponse);
+}
+
+/**
+ * Executes one typed HTTP POST request as an Effect program.
+ *
+ * @param input The request configuration and response schema.
+ * @returns An Effect that succeeds with the decoded JSON response.
+ * @remarks CLI command programs use this so schema decode failures and transport failures share one typed path.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function postJsonEffect<TResponse>(input: {
+  baseUrl: string;
+  path: string;
+  payload: unknown;
+  accessToken?: string | null;
+  schema: Schema.Schema<TResponse>;
+}) {
+  return Effect.tryPromise({
+    try: () => postJson(input),
+    catch: (error) =>
+      error instanceof CliHttpError
+        ? error
+        : new CliHttpError({
+            code: "HTTP_ERROR",
+            status: 500,
+            message: error instanceof Error ? error.message : "HTTP request failed.",
+          }),
+  });
+}
+
+/**
+ * Executes one typed HTTP GET request as an Effect program.
+ *
+ * @param input The request configuration and response schema.
+ * @returns An Effect that succeeds with the decoded JSON response.
+ * @remarks CLI command programs use this so schema decode failures and transport failures share one typed path.
+ * @lastModified 2026-03-19
+ * @author GPT-5.4
+ */
+export function getJsonEffect<TResponse>(input: {
+  baseUrl: string;
+  path: string;
+  accessToken?: string | null;
+  schema: Schema.Schema<TResponse>;
+}) {
+  return Effect.tryPromise({
+    try: () => getJson(input),
+    catch: (error) =>
+      error instanceof CliHttpError
+        ? error
+        : new CliHttpError({
+            code: "HTTP_ERROR",
+            status: 500,
+            message: error instanceof Error ? error.message : "HTTP request failed.",
+          }),
+  });
 }

package/src/index.ts

@@ -3,7 +3,13 @@ import { Command } from "commander";
 import pc from "picocolors";
 
 import { registerAuthCommands } from "./commands/auth.js";
+import { registerAuditCommands } from "./commands/audit.js";
+import { registerBillingCommands } from "./commands/billing.js";
 import { registerEnvCommands } from "./commands/env.js";
+import { registerInitCommand } from "./commands/init.js";
+import { registerOrgCommands } from "./commands/org.js";
+import { registerProjectCommands } from "./commands/project.js";
+import { registerStageCommands } from "./commands/stage.js";
 import { registerTypegenCommand } from "./commands/typegen.js";
 import { CLI_DESCRIPTION, CLI_NAME, CLI_VERSION } from "./constants.js";
 
@@ -11,6 +17,12 @@ const program = new Command();
 program.name(CLI_NAME).description(CLI_DESCRIPTION).version(CLI_VERSION);
 
 registerAuthCommands(program);
+registerAuditCommands(program);
+registerBillingCommands(program);
+registerInitCommand(program);
+registerOrgCommands(program);
+registerProjectCommands(program);
+registerStageCommands(program);
 registerEnvCommands(program);
 registerTypegenCommand(program);