everything-dev 0.0.1

package/src/lib/near-cli.ts

@@ -0,0 +1,289 @@
+import { spawn } from "node:child_process";
+import { confirm } from "@inquirer/prompts";
+import { Effect } from "every-plugin/effect";
+import { colors, icons } from "../utils/theme";
+
+export interface TransactionConfig {
+  account: string;
+  contract: string;
+  method: string;
+  argsBase64: string;
+  network?: "mainnet" | "testnet";
+  privateKey?: string;
+  gas?: string;
+  deposit?: string;
+}
+
+export interface TransactionResult {
+  success: boolean;
+  txHash?: string;
+  error?: string;
+}
+
+const NEAR_CLI_VERSION = "0.23.5";
+const INSTALLER_URL = `https://github.com/near/near-cli-rs/releases/download/v${NEAR_CLI_VERSION}/near-cli-rs-installer.sh`;
+
+export class NearCliNotFoundError extends Error {
+  readonly _tag = "NearCliNotFoundError";
+  constructor() {
+    super("NEAR CLI not found");
+  }
+}
+
+export class NearCliInstallError extends Error {
+  readonly _tag = "NearCliInstallError";
+  constructor(message: string) {
+    super(`Failed to install NEAR CLI: ${message}`);
+  }
+}
+
+export class TransactionError extends Error {
+  readonly _tag = "TransactionError";
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+const checkNearCliInstalled = Effect.gen(function* () {
+  const result = yield* Effect.tryPromise({
+    try: async () => {
+      return new Promise<boolean>((resolve) => {
+        const proc = spawn("near", ["--version"], { shell: true, stdio: "pipe" });
+        proc.on("close", (code) => resolve(code === 0));
+        proc.on("error", () => resolve(false));
+      });
+    },
+    catch: () => new Error("Failed to check NEAR CLI"),
+  });
+  return result;
+});
+
+const installNearCli = Effect.gen(function* () {
+  console.log();
+  console.log(`  ${icons.pkg} Installing NEAR CLI v${NEAR_CLI_VERSION}...`);
+  console.log(colors.dim(`  Using official installer from GitHub`));
+  console.log();
+
+  yield* Effect.tryPromise({
+    try: async () => {
+      return new Promise<void>((resolve, reject) => {
+        const proc = spawn("sh", ["-c", `curl --proto '=https' --tlsv1.2 -LsSf ${INSTALLER_URL} | sh`], {
+          stdio: "inherit",
+          shell: true,
+        });
+        proc.on("close", (code) => {
+          if (code === 0) resolve();
+          else reject(new NearCliInstallError(`Installer exited with code ${code}`));
+        });
+        proc.on("error", (err) => reject(new NearCliInstallError(err.message)));
+      });
+    },
+    catch: (e) => e as Error,
+  });
+
+  console.log();
+  console.log(colors.green(`  ${icons.ok} NEAR CLI installed successfully`));
+});
+
+export const ensureNearCli = Effect.gen(function* () {
+  const isInstalled = yield* checkNearCliInstalled;
+
+  if (isInstalled) {
+    return;
+  }
+
+  console.log();
+  console.log(colors.error(`  ${icons.err} NEAR CLI not found`));
+
+  const shouldInstall = yield* Effect.tryPromise({
+    try: () => confirm({
+      message: "Install NEAR CLI? (required for publishing)",
+      default: true,
+    }),
+    catch: () => new Error("Prompt cancelled"),
+  });
+
+  if (!shouldInstall) {
+    console.log();
+    console.log(colors.dim("  To install manually:"));
+    console.log(colors.dim(`  curl --proto '=https' --tlsv1.2 -LsSf ${INSTALLER_URL} | sh`));
+    console.log();
+    yield* Effect.fail(new NearCliNotFoundError());
+  }
+
+  yield* installNearCli;
+});
+
+export interface CreateSubaccountConfig {
+  newAccount: string;
+  parentAccount: string;
+  initialBalance?: string;
+  network: "mainnet" | "testnet";
+  privateKey?: string;
+}
+
+export interface CreateSubaccountResult {
+  success: boolean;
+  account: string;
+  error?: string;
+}
+
+export const createSubaccount = (config: CreateSubaccountConfig): Effect.Effect<CreateSubaccountResult, Error> =>
+  Effect.gen(function* () {
+    const balance = config.initialBalance || "0.1NEAR";
+    const network = config.network;
+
+    const args = [
+      "account",
+      "create-account",
+      "fund-myself",
+      config.newAccount,
+      balance,
+      "autogenerate-new-keypair",
+      "save-to-keychain",
+      "sign-as",
+      config.parentAccount,
+      "network-config",
+      network,
+    ];
+
+    if (config.privateKey) {
+      args.push("sign-with-plaintext-private-key", "--private-key", config.privateKey, "send");
+    }
+
+    console.log();
+    console.log(`  ${icons.run} Creating subaccount...`);
+    console.log(colors.dim(`  Account: ${config.newAccount}`));
+    console.log(colors.dim(`  Parent: ${config.parentAccount}`));
+    console.log(colors.dim(`  Balance: ${balance}`));
+    console.log();
+
+    const output = yield* Effect.tryPromise({
+      try: async () => {
+        return new Promise<string>((resolve, reject) => {
+          const proc = spawn("near", args, {
+            shell: true,
+            stdio: ["inherit", "pipe", "pipe"],
+          });
+
+          let stdout = "";
+          let stderr = "";
+
+          proc.stdout?.on("data", (data) => {
+            const text = data.toString();
+            stdout += text;
+            process.stdout.write(text);
+          });
+
+          proc.stderr?.on("data", (data) => {
+            const text = data.toString();
+            stderr += text;
+            process.stderr.write(text);
+          });
+
+          proc.on("close", (code) => {
+            if (code === 0) {
+              resolve(stdout);
+            } else {
+              reject(new Error(stderr || `Subaccount creation failed with code ${code}`));
+            }
+          });
+
+          proc.on("error", (err) => {
+            reject(new Error(err.message));
+          });
+        });
+      },
+      catch: (e) => e as Error,
+    });
+
+    return {
+      success: true,
+      account: config.newAccount,
+    };
+  });
+
+export const executeTransaction = (config: TransactionConfig): Effect.Effect<TransactionResult, Error> =>
+  Effect.gen(function* () {
+    const gas = (config.gas || "300Tgas").replace(/\s+/g, "");
+    const deposit = (config.deposit || "0NEAR").replace(/\s+/g, "");
+    const network = config.network || (config.account.endsWith(".testnet") ? "testnet" : "mainnet");
+
+    const args = [
+      "contract",
+      "call-function",
+      "as-transaction",
+      config.contract,
+      config.method,
+      "base64-args",
+      config.argsBase64,
+      "prepaid-gas",
+      gas,
+      "attached-deposit",
+      deposit,
+      "sign-as",
+      config.account,
+      "network-config",
+      network,
+    ];
+
+    if (config.privateKey) {
+      args.push("sign-with-plaintext-private-key", config.privateKey, "send");
+    }
+
+    console.log();
+    console.log(`  ${icons.run} Executing transaction...`);
+    console.log(colors.dim(`  Contract: ${config.contract}`));
+    console.log(colors.dim(`  Method: ${config.method}`));
+    console.log(colors.dim(`  Signer: ${config.account}`));
+    console.log();
+
+    const output = yield* Effect.tryPromise({
+      try: async () => {
+        return new Promise<string>((resolve, reject) => {
+          const proc = spawn("near", args, {
+            shell: true,
+            stdio: ["inherit", "pipe", "pipe"],
+          });
+
+          let stdout = "";
+          let stderr = "";
+
+          proc.stdout?.on("data", (data) => {
+            const text = data.toString();
+            stdout += text;
+            process.stdout.write(text);
+          });
+
+          proc.stderr?.on("data", (data) => {
+            const text = data.toString();
+            stderr += text;
+            process.stderr.write(text);
+          });
+
+          proc.on("close", (code) => {
+            if (code === 0) {
+              resolve(stdout);
+            } else {
+              reject(new TransactionError(stderr || `Transaction failed with code ${code}`));
+            }
+          });
+
+          proc.on("error", (err) => {
+            reject(new TransactionError(err.message));
+          });
+        });
+      },
+      catch: (e) => e as Error,
+    });
+
+    const txHashMatch = output.match(/Transaction ID:\s*([A-Za-z0-9]+)/i) ||
+      output.match(/([A-HJ-NP-Za-km-z1-9]{43,44})/);
+
+    const txHash = txHashMatch?.[1] || "unknown";
+
+    return {
+      success: true,
+      txHash,
+    };
+  });

package/src/lib/nova.ts

@@ -0,0 +1,254 @@
+import { NovaSdk } from "nova-sdk-js";
+import { Effect } from "every-plugin/effect";
+import { getConfigDir } from "../config";
+
+export interface NovaConfig {
+  accountId: string;
+  sessionToken: string;
+}
+
+export interface SecretsData {
+  secrets: Record<string, string>;
+  updatedAt: string;
+}
+
+export interface UploadResult {
+  cid: string;
+  groupId: string;
+  txHash?: string;
+}
+
+export const getNovaConfig = Effect.gen(function* () {
+  const accountId = process.env.NOVA_ACCOUNT_ID;
+  const sessionToken = process.env.NOVA_SESSION_TOKEN;
+
+  if (!accountId || !sessionToken) {
+    return yield* Effect.fail(
+      new Error(
+        "NOVA credentials not configured. Run 'bos login' to authenticate with NOVA."
+      )
+    );
+  }
+
+  return { accountId, sessionToken } satisfies NovaConfig;
+});
+
+export function createNovaClient(config: NovaConfig): NovaSdk {
+  return new NovaSdk(config.accountId, {
+    sessionToken: config.sessionToken,
+  });
+}
+
+export function getSecretsGroupId(nearAccount: string): string {
+  return `${nearAccount}-secrets`;
+}
+
+export const registerSecretsGroup = (
+  nova: NovaSdk,
+  nearAccount: string,
+  gatewayAccount: string
+) =>
+  Effect.gen(function* () {
+    const groupId = getSecretsGroupId(nearAccount);
+
+    yield* Effect.tryPromise({
+      try: () => nova.registerGroup(groupId),
+      catch: (e) => new Error(`Failed to register NOVA group: ${e}`),
+    });
+
+    yield* Effect.tryPromise({
+      try: () => nova.addGroupMember(groupId, gatewayAccount),
+      catch: (e) => new Error(`Failed to add gateway to NOVA group: ${e}`),
+    });
+
+    return groupId;
+  });
+
+export const uploadSecrets = (
+  nova: NovaSdk,
+  groupId: string,
+  secrets: Record<string, string>
+) =>
+  Effect.gen(function* () {
+    const secretsData: SecretsData = {
+      secrets,
+      updatedAt: new Date().toISOString(),
+    };
+
+    const buffer = Buffer.from(JSON.stringify(secretsData, null, 2));
+
+    const result = yield* Effect.tryPromise({
+      try: () => nova.upload(groupId, buffer, "secrets.json"),
+      catch: (e) => new Error(`Failed to upload secrets to NOVA: ${e}`),
+    });
+
+    return {
+      cid: result.cid,
+      groupId,
+      txHash: result.trans_id,
+    } satisfies UploadResult;
+  });
+
+export const retrieveSecrets = (nova: NovaSdk, groupId: string, cid: string) =>
+  Effect.gen(function* () {
+    const result = yield* Effect.tryPromise({
+      try: () => nova.retrieve(groupId, cid),
+      catch: (e) => new Error(`Failed to retrieve secrets from NOVA: ${e}`),
+    });
+
+    const secretsData = JSON.parse(result.data.toString()) as SecretsData;
+    return secretsData;
+  });
+
+export function parseEnvFile(content: string): Record<string, string> {
+  const secrets: 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);
+    }
+
+    if (key) {
+      secrets[key] = value;
+    }
+  }
+
+  return secrets;
+}
+
+export function filterSecretsToRequired(
+  allSecrets: Record<string, string>,
+  requiredKeys: string[]
+): Record<string, string> {
+  const filtered: Record<string, string> = {};
+
+  for (const key of requiredKeys) {
+    if (key in allSecrets) {
+      filtered[key] = allSecrets[key];
+    }
+  }
+
+  return filtered;
+}
+
+export function hasNovaCredentials(): boolean {
+  return !!(process.env.NOVA_ACCOUNT_ID && process.env.NOVA_SESSION_TOKEN);
+}
+
+function getBosEnvPath(): string {
+  return `${getConfigDir()}/.env.bos`;
+}
+
+export const saveNovaCredentials = (accountId: string, sessionToken: string) =>
+  Effect.gen(function* () {
+    const envPath = getBosEnvPath();
+    let content = "";
+
+    const file = Bun.file(envPath);
+    const exists = yield* Effect.promise(() => file.exists());
+
+    if (exists) {
+      content = yield* Effect.tryPromise({
+        try: () => file.text(),
+        catch: () => new Error("File read failed"),
+      }).pipe(Effect.orElseSucceed(() => ""));
+    }
+
+    const lines = content.split("\n");
+    const newLines: string[] = [];
+    let foundAccountId = false;
+    let foundSessionToken = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("NOVA_ACCOUNT_ID=")) {
+        newLines.push(`NOVA_ACCOUNT_ID=${accountId}`);
+        foundAccountId = true;
+      } else if (trimmed.startsWith("NOVA_SESSION_TOKEN=")) {
+        newLines.push(`NOVA_SESSION_TOKEN=${sessionToken}`);
+        foundSessionToken = true;
+      } else {
+        newLines.push(line);
+      }
+    }
+
+    if (!foundAccountId) {
+      if (newLines.length > 0 && newLines[newLines.length - 1] !== "") {
+        newLines.push("");
+      }
+      newLines.push(`NOVA_ACCOUNT_ID=${accountId}`);
+    }
+
+    if (!foundSessionToken) {
+      newLines.push(`NOVA_SESSION_TOKEN=${sessionToken}`);
+    }
+
+    yield* Effect.tryPromise({
+      try: () => Bun.write(envPath, newLines.join("\n")),
+      catch: (e) => new Error(`Failed to save credentials: ${e}`),
+    });
+
+    process.env.NOVA_ACCOUNT_ID = accountId;
+    process.env.NOVA_SESSION_TOKEN = sessionToken;
+  });
+
+export const removeNovaCredentials = Effect.gen(function* () {
+  const envPath = getBosEnvPath();
+  let content = "";
+
+  try {
+    content = yield* Effect.tryPromise({
+      try: () => Bun.file(envPath).text(),
+      catch: () => "",
+    });
+  } catch {
+    return;
+  }
+
+  const lines = content.split("\n");
+  const newLines = lines.filter((line) => {
+    const trimmed = line.trim();
+    return !trimmed.startsWith("NOVA_ACCOUNT_ID=") && !trimmed.startsWith("NOVA_SESSION_TOKEN=");
+  });
+
+  yield* Effect.tryPromise({
+    try: () => Bun.write(envPath, newLines.join("\n")),
+    catch: (e) => new Error(`Failed to remove credentials: ${e}`),
+  });
+
+  delete process.env.NOVA_ACCOUNT_ID;
+  delete process.env.NOVA_SESSION_TOKEN;
+});
+
+export const verifyNovaCredentials = (accountId: string, sessionToken: string) =>
+  Effect.gen(function* () {
+    const nova = new NovaSdk(accountId, { sessionToken });
+
+    yield* Effect.tryPromise({
+      try: () => nova.getBalance(),
+      catch: (e) => {
+        const message = e instanceof Error ? e.message : String(e);
+        return new Error(`NOVA verification failed: ${message}`);
+      },
+    });
+
+    return true;
+  });