everything-dev 0.0.1

package/src/config.ts

@@ -0,0 +1,214 @@
+import { dirname, join } from "path";
+
+export type SourceMode = "local" | "remote";
+
+export interface AppConfig {
+  host: SourceMode;
+  ui: SourceMode;
+  api: SourceMode;
+  proxy?: boolean;
+}
+
+export const DEFAULT_DEV_CONFIG: AppConfig = {
+  host: "local",
+  ui: "local",
+  api: "local",
+};
+
+export interface HostConfig {
+  title: string;
+  description?: string;
+  development: string;
+  production: string;
+  secrets?: string[];
+}
+
+export interface RemoteConfig {
+  name: string;
+  development: string;
+  production: string;
+  ssr?: string;
+  exposes?: Record<string, string>;
+  variables?: Record<string, string>;
+  secrets?: string[];
+}
+
+export interface GatewayConfig {
+  development: string;
+  production: string;
+}
+
+export interface BosConfig {
+  account: string;
+  gateway: GatewayConfig;
+  templates?: Record<string, string>;
+  create?: Record<string, string>;
+  cli?: {
+    remote?: string;
+    local?: string;
+  };
+  app: {
+    host: HostConfig;
+    [remoteName: string]: HostConfig | RemoteConfig;
+  };
+}
+
+let cachedConfig: BosConfig | null = null;
+let configDir: string | null = null;
+
+export function findConfigPath(startDir: string): string | null {
+  let dir = startDir;
+  while (dir !== "/") {
+    const configPath = join(dir, "bos.config.json");
+    if (Bun.file(configPath).size > 0) {
+      try {
+        Bun.file(configPath).text();
+        return configPath;
+      } catch {
+        // File doesn't exist or can't be read
+      }
+    }
+    dir = dirname(dir);
+  }
+  return null;
+}
+
+function findConfigPathSync(startDir: string): string | null {
+  let dir = startDir;
+  while (dir !== "/") {
+    const configPath = join(dir, "bos.config.json");
+    const file = Bun.file(configPath);
+    if (file.size > 0) {
+      return configPath;
+    }
+    dir = dirname(dir);
+  }
+  return null;
+}
+
+export function loadConfig(cwd?: string): BosConfig {
+  if (cachedConfig) return cachedConfig;
+
+  const startDir = cwd ?? process.cwd();
+  const configPath = findConfigPathSync(startDir);
+
+  if (!configPath) {
+    throw new Error("Could not find bos.config.json in current directory or parents");
+  }
+
+  configDir = dirname(configPath);
+  const file = Bun.file(configPath);
+  const content = require(configPath);
+  cachedConfig = content as BosConfig;
+  return cachedConfig;
+}
+
+export function getConfigDir(): string {
+  if (!configDir) {
+    loadConfig();
+  }
+  return configDir!;
+}
+
+export function getRemotes(): string[] {
+  const config = loadConfig();
+  return Object.keys(config.app).filter((k) => k !== "host");
+}
+
+export function getPackages(): string[] {
+  const config = loadConfig();
+  return Object.keys(config.app);
+}
+
+export function getRemote(name: string): RemoteConfig | undefined {
+  const config = loadConfig();
+  const remote = config.app[name];
+  if (remote && "name" in remote) {
+    return remote as RemoteConfig;
+  }
+  return undefined;
+}
+
+export function getHost(): HostConfig {
+  const config = loadConfig();
+  return config.app.host;
+}
+
+export function getUrl(
+  packageName: string,
+  env: "development" | "production" = "development"
+): string | undefined {
+  const config = loadConfig();
+  const pkg = config.app[packageName];
+  if (!pkg) return undefined;
+  return pkg[env];
+}
+
+export function getAccount(): string {
+  const config = loadConfig();
+  return config.account;
+}
+
+export function getTitle(): string {
+  const config = loadConfig();
+  return config.app.host.title;
+}
+
+export function getComponentUrl(
+  component: "host" | "ui" | "api",
+  source: SourceMode
+): string {
+  const config = loadConfig();
+
+  if (component === "host") {
+    return source === "remote" ? config.app.host.production : config.app.host.development;
+  }
+
+  const componentConfig = config.app[component];
+  if (!componentConfig || !("name" in componentConfig)) {
+    throw new Error(`Component ${component} not found in bos.config.json`);
+  }
+
+  return source === "remote" ? componentConfig.production : componentConfig.development;
+}
+
+export function parsePort(url: string): number {
+  try {
+    const parsed = new URL(url);
+    return parsed.port ? parseInt(parsed.port, 10) : (parsed.protocol === "https:" ? 443 : 80);
+  } catch {
+    return 3000;
+  }
+}
+
+export interface PortConfig {
+  host: number;
+  ui: number;
+  api: number;
+}
+
+export function getPortsFromConfig(): PortConfig {
+  const config = loadConfig();
+  return {
+    host: parsePort(config.app.host.development),
+    ui: config.app.ui ? parsePort((config.app.ui as RemoteConfig).development) : 3002,
+    api: config.app.api ? parsePort((config.app.api as RemoteConfig).development) : 3014,
+  };
+}
+
+export function getConfigPath(): string {
+  if (!configDir) {
+    loadConfig();
+  }
+  return `${configDir}/bos.config.json`;
+}
+
+export function getHostRemoteUrl(): string | undefined {
+  const config = loadConfig();
+  return config.app.host.production || undefined;
+}
+
+export function getGatewayUrl(env: "development" | "production" = "development"): string {
+  const config = loadConfig();
+  return config.gateway[env];
+}

package/src/contract.ts

@@ -0,0 +1,364 @@
+import { oc } from "every-plugin/orpc";
+import { z } from "every-plugin/zod";
+
+const SourceModeSchema = z.enum(["local", "remote"]);
+
+const DevOptionsSchema = z.object({
+  host: SourceModeSchema.default("local"),
+  ui: SourceModeSchema.default("local"),
+  api: SourceModeSchema.default("local"),
+  proxy: z.boolean().default(false),
+  port: z.number().optional(),
+  interactive: z.boolean().optional(),
+});
+
+const DevResultSchema = z.object({
+  status: z.enum(["started", "error"]),
+  description: z.string(),
+  processes: z.array(z.string()),
+});
+
+const StartOptionsSchema = z.object({
+  port: z.number().optional(),
+  interactive: z.boolean().optional(),
+  account: z.string().optional(),
+  domain: z.string().optional(),
+});
+
+const StartResultSchema = z.object({
+  status: z.enum(["running", "error"]),
+  url: z.string(),
+});
+
+const ServeOptionsSchema = z.object({
+  port: z.number().default(4000),
+});
+
+const ServeResultSchema = z.object({
+  status: z.enum(["serving", "error"]),
+  url: z.string(),
+  endpoints: z.object({
+    rpc: z.string(),
+    docs: z.string(),
+  }),
+});
+
+const BuildOptionsSchema = z.object({
+  package: z.string().default("all"),
+  force: z.boolean().default(false),
+  deploy: z.boolean().default(true),
+});
+
+const BuildResultSchema = z.object({
+  status: z.enum(["success", "error"]),
+  built: z.array(z.string()),
+  deployed: z.boolean().optional(),
+});
+
+const SigningMethodSchema = z.enum([
+  "keychain",
+  "ledger",
+  "seed-phrase",
+  "access-key-file",
+  "private-key",
+]);
+
+const PublishOptionsSchema = z.object({
+  signWith: SigningMethodSchema.optional(),
+  network: z.enum(["mainnet", "testnet"]).default("mainnet"),
+  path: z.string().default("bos.config.json"),
+  dryRun: z.boolean().default(false),
+});
+
+const PublishResultSchema = z.object({
+  status: z.enum(["published", "error", "dry-run"]),
+  txHash: z.string(),
+  registryUrl: z.string(),
+  error: z.string().optional(),
+});
+
+const CreateOptionsSchema = z.object({
+  type: z.enum(["project", "ui", "api", "host", "cli", "gateway"]),
+  name: z.string().optional(),
+  template: z.string().optional(),
+});
+
+const CreateResultSchema = z.object({
+  status: z.enum(["created", "error"]),
+  path: z.string(),
+});
+
+const RemoteConfigSchema = z.object({
+  name: z.string(),
+  development: z.string(),
+  production: z.string(),
+  ssr: z.string().optional(),
+  exposes: z.record(z.string(), z.string()).optional(),
+  variables: z.record(z.string(), z.string()).optional(),
+  secrets: z.array(z.string()).optional(),
+});
+
+const HostConfigSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  development: z.string(),
+  production: z.string(),
+  secrets: z.array(z.string()).optional(),
+});
+
+const BosConfigSchema = z.object({
+  account: z.string(),
+  cli: z.object({
+    remote: z.string().optional(),
+    local: z.string().optional(),
+  }).optional(),
+  create: z.record(z.string(), z.string()).optional(),
+  app: z.object({
+    host: HostConfigSchema,
+  }).catchall(z.union([HostConfigSchema, RemoteConfigSchema])),
+});
+
+const InfoResultSchema = z.object({
+  config: BosConfigSchema,
+  packages: z.array(z.string()),
+  remotes: z.array(z.string()),
+});
+
+const EndpointStatusSchema = z.object({
+  name: z.string(),
+  url: z.string(),
+  type: z.enum(["host", "remote", "ssr"]),
+  healthy: z.boolean(),
+  latency: z.number().optional(),
+});
+
+const StatusOptionsSchema = z.object({
+  env: z.enum(["development", "production"]).default("development"),
+});
+
+const StatusResultSchema = z.object({
+  endpoints: z.array(EndpointStatusSchema),
+});
+
+const CleanResultSchema = z.object({
+  status: z.enum(["cleaned", "error"]),
+  removed: z.array(z.string()),
+});
+
+const RegisterOptionsSchema = z.object({
+  name: z.string(),
+  network: z.enum(["mainnet", "testnet"]).default("mainnet"),
+});
+
+const RegisterResultSchema = z.object({
+  status: z.enum(["registered", "error"]),
+  account: z.string(),
+  novaGroup: z.string().optional(),
+  error: z.string().optional(),
+});
+
+const SecretsSyncOptionsSchema = z.object({
+  envPath: z.string(),
+});
+
+const SecretsSyncResultSchema = z.object({
+  status: z.enum(["synced", "error"]),
+  count: z.number(),
+  cid: z.string().optional(),
+  error: z.string().optional(),
+});
+
+const SecretsSetOptionsSchema = z.object({
+  key: z.string(),
+  value: z.string(),
+});
+
+const SecretsSetResultSchema = z.object({
+  status: z.enum(["set", "error"]),
+  cid: z.string().optional(),
+  error: z.string().optional(),
+});
+
+const SecretsListResultSchema = z.object({
+  status: z.enum(["listed", "error"]),
+  keys: z.array(z.string()),
+  error: z.string().optional(),
+});
+
+const SecretsDeleteOptionsSchema = z.object({
+  key: z.string(),
+});
+
+const SecretsDeleteResultSchema = z.object({
+  status: z.enum(["deleted", "error"]),
+  cid: z.string().optional(),
+  error: z.string().optional(),
+});
+
+const LoginOptionsSchema = z.object({
+  token: z.string().optional(),
+  accountId: z.string().optional(),
+});
+
+const LoginResultSchema = z.object({
+  status: z.enum(["logged-in", "error"]),
+  accountId: z.string().optional(),
+  error: z.string().optional(),
+});
+
+const LogoutResultSchema = z.object({
+  status: z.enum(["logged-out", "error"]),
+  error: z.string().optional(),
+});
+
+const GatewayDevOptionsSchema = z.object({});
+
+const GatewayDevResultSchema = z.object({
+  status: z.enum(["started", "error"]),
+  url: z.string(),
+  error: z.string().optional(),
+});
+
+const GatewayDeployOptionsSchema = z.object({
+  env: z.enum(["production", "staging"]).optional(),
+});
+
+const GatewayDeployResultSchema = z.object({
+  status: z.enum(["deployed", "error"]),
+  url: z.string(),
+  error: z.string().optional(),
+});
+
+const GatewaySyncOptionsSchema = z.object({});
+
+const GatewaySyncResultSchema = z.object({
+  status: z.enum(["synced", "error"]),
+  gatewayDomain: z.string().optional(),
+  gatewayAccount: z.string().optional(),
+  error: z.string().optional(),
+});
+
+export const bosContract = oc.router({
+  dev: oc
+    .route({ method: "POST", path: "/dev" })
+    .input(DevOptionsSchema)
+    .output(DevResultSchema),
+
+  start: oc
+    .route({ method: "POST", path: "/start" })
+    .input(StartOptionsSchema)
+    .output(StartResultSchema),
+
+  serve: oc
+    .route({ method: "POST", path: "/serve" })
+    .input(ServeOptionsSchema)
+    .output(ServeResultSchema),
+
+  build: oc
+    .route({ method: "POST", path: "/build" })
+    .input(BuildOptionsSchema)
+    .output(BuildResultSchema),
+
+  publish: oc
+    .route({ method: "POST", path: "/publish" })
+    .input(PublishOptionsSchema)
+    .output(PublishResultSchema),
+
+  create: oc
+    .route({ method: "POST", path: "/create" })
+    .input(CreateOptionsSchema)
+    .output(CreateResultSchema),
+
+  info: oc
+    .route({ method: "GET", path: "/info" })
+    .output(InfoResultSchema),
+
+  status: oc
+    .route({ method: "GET", path: "/status" })
+    .input(StatusOptionsSchema)
+    .output(StatusResultSchema),
+
+  clean: oc
+    .route({ method: "POST", path: "/clean" })
+    .output(CleanResultSchema),
+
+  register: oc
+    .route({ method: "POST", path: "/register" })
+    .input(RegisterOptionsSchema)
+    .output(RegisterResultSchema),
+
+  secretsSync: oc
+    .route({ method: "POST", path: "/secrets/sync" })
+    .input(SecretsSyncOptionsSchema)
+    .output(SecretsSyncResultSchema),
+
+  secretsSet: oc
+    .route({ method: "POST", path: "/secrets/set" })
+    .input(SecretsSetOptionsSchema)
+    .output(SecretsSetResultSchema),
+
+  secretsList: oc
+    .route({ method: "GET", path: "/secrets/list" })
+    .output(SecretsListResultSchema),
+
+  secretsDelete: oc
+    .route({ method: "POST", path: "/secrets/delete" })
+    .input(SecretsDeleteOptionsSchema)
+    .output(SecretsDeleteResultSchema),
+
+  login: oc
+    .route({ method: "POST", path: "/login" })
+    .input(LoginOptionsSchema)
+    .output(LoginResultSchema),
+
+  logout: oc
+    .route({ method: "POST", path: "/logout" })
+    .output(LogoutResultSchema),
+
+  gatewayDev: oc
+    .route({ method: "POST", path: "/gateway/dev" })
+    .input(GatewayDevOptionsSchema)
+    .output(GatewayDevResultSchema),
+
+  gatewayDeploy: oc
+    .route({ method: "POST", path: "/gateway/deploy" })
+    .input(GatewayDeployOptionsSchema)
+    .output(GatewayDeployResultSchema),
+
+  gatewaySync: oc
+    .route({ method: "POST", path: "/gateway/sync" })
+    .input(GatewaySyncOptionsSchema)
+    .output(GatewaySyncResultSchema),
+});
+
+export type BosContract = typeof bosContract;
+export type DevOptions = z.infer<typeof DevOptionsSchema>;
+export type DevResult = z.infer<typeof DevResultSchema>;
+export type StartOptions = z.infer<typeof StartOptionsSchema>;
+export type StartResult = z.infer<typeof StartResultSchema>;
+export type ServeOptions = z.infer<typeof ServeOptionsSchema>;
+export type ServeResult = z.infer<typeof ServeResultSchema>;
+export type BuildOptions = z.infer<typeof BuildOptionsSchema>;
+export type BuildResult = z.infer<typeof BuildResultSchema>;
+export type SigningMethod = z.infer<typeof SigningMethodSchema>;
+export type PublishOptions = z.infer<typeof PublishOptionsSchema>;
+export type PublishResult = z.infer<typeof PublishResultSchema>;
+export type CreateOptions = z.infer<typeof CreateOptionsSchema>;
+export type CreateResult = z.infer<typeof CreateResultSchema>;
+export type BosConfig = z.infer<typeof BosConfigSchema>;
+export type InfoResult = z.infer<typeof InfoResultSchema>;
+export type StatusOptions = z.infer<typeof StatusOptionsSchema>;
+export type StatusResult = z.infer<typeof StatusResultSchema>;
+export type CleanResult = z.infer<typeof CleanResultSchema>;
+export type RegisterOptions = z.infer<typeof RegisterOptionsSchema>;
+export type RegisterResult = z.infer<typeof RegisterResultSchema>;
+export type SecretsSyncOptions = z.infer<typeof SecretsSyncOptionsSchema>;
+export type SecretsSyncResult = z.infer<typeof SecretsSyncResultSchema>;
+export type SecretsSetOptions = z.infer<typeof SecretsSetOptionsSchema>;
+export type SecretsSetResult = z.infer<typeof SecretsSetResultSchema>;
+export type SecretsListResult = z.infer<typeof SecretsListResultSchema>;
+export type SecretsDeleteOptions = z.infer<typeof SecretsDeleteOptionsSchema>;
+export type SecretsDeleteResult = z.infer<typeof SecretsDeleteResultSchema>;
+export type LoginOptions = z.infer<typeof LoginOptionsSchema>;
+export type LoginResult = z.infer<typeof LoginResultSchema>;
+export type LogoutResult = z.infer<typeof LogoutResultSchema>;

package/src/index.ts

@@ -0,0 +1,3 @@
+export { default } from "./plugin";
+export { bosContract } from "./contract";
+export type * from "./contract";

package/src/lib/env.ts

@@ -0,0 +1,91 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { Effect } from "every-plugin/effect";
+import { getConfigDir } from "../config";
+
+export interface BosEnv {
+  ZE_SERVER_TOKEN?: string;
+  ZE_USER_EMAIL?: string;
+  NEAR_PRIVATE_KEY?: string;
+  GATEWAY_PRIVATE_KEY?: string;
+  NOVA_SECRETS_CID?: string;
+}
+
+function parseEnvFile(content: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  const lines = content.split("\n");
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+
+    if ((value.startsWith('"') && value.endsWith('"')) || 
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+
+    result[key] = value;
+  }
+
+  return result;
+}
+
+export const loadBosEnv = Effect.gen(function* () {
+  const configDir = getConfigDir();
+  const envBosPath = path.join(configDir, ".env.bos");
+  const envPath = path.join(configDir, ".env");
+
+  let envVars: BosEnv = {};
+
+  const envFilePath = existsSync(envBosPath) ? envBosPath : existsSync(envPath) ? envPath : null;
+
+  if (envFilePath) {
+    const content = yield* Effect.tryPromise({
+      try: () => readFile(envFilePath, "utf-8"),
+      catch: () => new Error(`Failed to read ${envFilePath}`),
+    });
+
+    const parsed = parseEnvFile(content);
+    envVars = {
+      ZE_SERVER_TOKEN: parsed.ZE_SERVER_TOKEN,
+      ZE_USER_EMAIL: parsed.ZE_USER_EMAIL,
+      NEAR_PRIVATE_KEY: parsed.NEAR_PRIVATE_KEY,
+      GATEWAY_PRIVATE_KEY: parsed.GATEWAY_PRIVATE_KEY,
+      NOVA_SECRETS_CID: parsed.NOVA_SECRETS_CID,
+    };
+  }
+
+  envVars.ZE_SERVER_TOKEN = envVars.ZE_SERVER_TOKEN || process.env.ZE_SERVER_TOKEN;
+  envVars.ZE_USER_EMAIL = envVars.ZE_USER_EMAIL || process.env.ZE_USER_EMAIL;
+  envVars.NEAR_PRIVATE_KEY = envVars.NEAR_PRIVATE_KEY || process.env.NEAR_PRIVATE_KEY;
+  envVars.GATEWAY_PRIVATE_KEY = envVars.GATEWAY_PRIVATE_KEY || process.env.GATEWAY_PRIVATE_KEY;
+  envVars.NOVA_SECRETS_CID = envVars.NOVA_SECRETS_CID || process.env.NOVA_SECRETS_CID;
+
+  return envVars;
+});
+
+export const ZEPHYR_DOCS_URL = "https://docs.zephyr-cloud.io/features/ci-cd-server-token";
+
+export const getBuildEnv = (bosEnv: BosEnv): Record<string, string> => {
+  const env: Record<string, string> = { ...process.env as Record<string, string> };
+
+  if (bosEnv.ZE_SERVER_TOKEN) {
+    env.ZE_SERVER_TOKEN = bosEnv.ZE_SERVER_TOKEN;
+  }
+  if (bosEnv.ZE_USER_EMAIL) {
+    env.ZE_USER_EMAIL = bosEnv.ZE_USER_EMAIL;
+  }
+
+  return env;
+};
+
+export const hasZephyrConfig = (bosEnv: BosEnv): boolean => {
+  return !!(bosEnv.ZE_SERVER_TOKEN && bosEnv.ZE_USER_EMAIL);
+};