@etree/cli 2.0.1 → 2.0.2

package/src/lib/crypto.ts

@@ -1,173 +0,0 @@
-import { spawn, ChildProcessWithoutNullStreams } from "child_process";
-import * as path from "path";
-
-const CRYPTO_ENGINE_PATH = path.resolve(
-  __dirname,
-  "../../../../packages/crypto/engine.py",
-);
-
-let engineProcess: ChildProcessWithoutNullStreams | null = null;
-
-interface CryptoRequest {
-  action: string;
-  data?: Record<string, any>;
-}
-
-interface CryptoResponse {
-  status: string;
-  [key: string]: any;
-}
-
-/**
- * Get or spawn the crypto engine Python process.
- */
-function getEngine(): ChildProcessWithoutNullStreams {
-  if (engineProcess && !engineProcess.killed) {
-    return engineProcess;
-  }
-
-  // Try venv python first, fall back to system python
-  const venvDir = path.resolve(__dirname, "../../../../packages/crypto/.venv");
-  const isWindows = process.platform === "win32";
-
-  // Potential Venv Paths
-  const potentialVenvPaths = isWindows
-    ? [
-        path.join(venvDir, "Scripts", "python.exe"),
-        path.join(venvDir, "bin", "python.exe"),
-      ]
-    : [path.join(venvDir, "bin", "python")];
-
-  let pythonCmd = isWindows ? "python" : "python3";
-
-  for (const venvPath of potentialVenvPaths) {
-    if (require("fs").existsSync(venvPath)) {
-      pythonCmd = venvPath;
-      break;
-    }
-  }
-
-  // If we haven't found a venv python, verify the system command exists
-  if (pythonCmd === "python" || pythonCmd === "python3") {
-    try {
-      // Use system python if it exists and works
-      require("child_process").execSync(`${pythonCmd} --version`, {
-        stdio: "ignore",
-      });
-    } catch {
-      // If the preferred one fails, try the fallback
-      pythonCmd = pythonCmd === "python3" ? "python" : "python3";
-    }
-  }
-
-  engineProcess = spawn(pythonCmd, [CRYPTO_ENGINE_PATH], {
-    stdio: ["pipe", "pipe", "pipe"],
-    cwd: path.resolve(__dirname, "../../../../packages/crypto"),
-  });
-
-  engineProcess.on("exit", () => {
-    engineProcess = null;
-  });
-
-  return engineProcess;
-}
-
-/**
- * Send a command to the crypto engine and get the response.
- */
-function sendCommand(request: CryptoRequest): Promise<CryptoResponse> {
-  return new Promise((resolve, reject) => {
-    const engine = getEngine();
-
-    const onData = (data: Buffer) => {
-      try {
-        const response = JSON.parse(data.toString().trim());
-        engine.stdout.removeListener("data", onData);
-        engine.stderr.removeListener("data", onError);
-
-        if (response.status === "error") {
-          reject(new Error(response.message));
-        } else {
-          resolve(response);
-        }
-      } catch (e) {
-        // partial data, wait for more
-      }
-    };
-
-    const onError = (data: Buffer) => {
-      engine.stdout.removeListener("data", onData);
-      engine.stderr.removeListener("data", onError);
-      reject(new Error(`Crypto engine error: ${data.toString()}`));
-    };
-
-    engine.stdout.on("data", onData);
-    engine.stderr.on("data", onError);
-
-    engine.stdin.write(JSON.stringify(request) + "\n");
-  });
-}
-
-/**
- * Generate a new X25519 key pair.
- */
-export async function generateKeys(): Promise<{
-  private_key: string;
-  public_key: string;
-}> {
-  const result = await sendCommand({ action: "generate_keys" });
-  return {
-    private_key: result.private_key,
-    public_key: result.public_key,
-  };
-}
-
-/**
- * Derive the public key from an existing private key.
- */
-export async function derivePublicKey(privateKey: string): Promise<string> {
-  const result = await sendCommand({
-    action: "derive_public_key",
-    data: { private_key: privateKey },
-  });
-  return result.public_key;
-}
-
-/**
- * Encrypt a plaintext value using the recipient's public key (SealedBox).
- */
-export async function encrypt(
-  plaintext: string,
-  publicKey: string,
-): Promise<string> {
-  const result = await sendCommand({
-    action: "encrypt",
-    data: { plaintext, public_key: publicKey },
-  });
-  return result.ciphertext;
-}
-
-/**
- * Decrypt a ciphertext using the recipient's private key (SealedBox).
- */
-export async function decrypt(
-  ciphertext: string,
-  privateKey: string,
-): Promise<string> {
-  const result = await sendCommand({
-    action: "decrypt",
-    data: { ciphertext, private_key: privateKey },
-  });
-  return result.plaintext;
-}
-
-/**
- * Shut down the crypto engine process.
- */
-export function shutdown(): void {
-  if (engineProcess && !engineProcess.killed) {
-    engineProcess.stdin.end();
-    engineProcess.kill();
-    engineProcess = null;
-  }
-}

package/src/lib/env-manager.ts

@@ -1,60 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-
-/**
- * Updates a key=value pair in a .env file.
- * Creates the file if it doesn't exist.
- * If the key exists, it updates its value.
- * If the key doesn't exist, it appends to the end.
- */
-export function updateEnvFile(key: string, value: string): void {
-  const envPath = path.resolve(process.cwd(), ".env");
-  let content = "";
-
-  if (fs.existsSync(envPath)) {
-    content = fs.readFileSync(envPath, "utf-8");
-  }
-
-  const lines = content.split("\n");
-  const keyPattern = new RegExp(`^${key}=.*`);
-  let found = false;
-
-  const newLines = lines.map((line) => {
-    if (keyPattern.test(line.trim())) {
-      found = true;
-      return `${key}=${value}`;
-    }
-    return line;
-  });
-
-  if (!found) {
-    if (newLines.length > 0 && newLines[newLines.length - 1].trim() !== "") {
-      newLines.push("");
-    }
-    newLines.push(`${key}=${value}`);
-  }
-
-  fs.writeFileSync(envPath, newLines.join("\n"), "utf-8");
-}
-
-/**
- * Ensures that a .gitignore file exists and contains the specified entry.
- */
-export function ensureGitIgnore(entry: string = ".env"): void {
-  const gitIgnorePath = path.resolve(process.cwd(), ".gitignore");
-  let content = "";
-
-  if (fs.existsSync(gitIgnorePath)) {
-    content = fs.readFileSync(gitIgnorePath, "utf-8");
-  }
-
-  const lines = content.split("\n").map((l) => l.trim());
-
-  if (!lines.includes(entry)) {
-    if (content.length > 0 && !content.endsWith("\n")) {
-      content += "\n";
-    }
-    content += `${entry}\n`;
-    fs.writeFileSync(gitIgnorePath, content, "utf-8");
-  }
-}

package/src/lib/key-store.ts

@@ -1,51 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-
-const KEY_DIR = path.join(os.homedir(), ".envtree");
-const KEY_FILE = path.join(KEY_DIR, "private_key");
-
-function ensureKeyDir(): void {
-  if (!fs.existsSync(KEY_DIR)) {
-    fs.mkdirSync(KEY_DIR, { recursive: true, mode: 0o700 });
-  }
-}
-
-/**
- * Save the private key to ~/.envtree/private_key
- */
-export function savePrivateKey(privateKey: string): void {
-  ensureKeyDir();
-  fs.writeFileSync(KEY_FILE, privateKey, { mode: 0o600 });
-}
-
-/**
- * Read the private key from ~/.envtree/private_key
- */
-export function getPrivateKey(): string | null {
-  if (!fs.existsSync(KEY_FILE)) {
-    return null;
-  }
-  return fs.readFileSync(KEY_FILE, "utf-8").trim();
-}
-
-/**
- * Get private key or exit with error.
- */
-export function requirePrivateKey(): string {
-  const key = getPrivateKey();
-  if (!key) {
-    console.error(
-      "Private key not found. Run: envtree signup (or envtree login)",
-    );
-    process.exit(1);
-  }
-  return key;
-}
-
-/**
- * Check if a private key exists locally.
- */
-export function hasPrivateKey(): boolean {
-  return fs.existsSync(KEY_FILE);
-}

package/src/test-e2e.ts

@@ -1,106 +0,0 @@
-import { apiRequest } from "./lib/api";
-import { saveSession } from "./lib/config";
-import { generateKeys, encrypt, decrypt, shutdown } from "./lib/crypto";
-import { savePrivateKey } from "./lib/key-store";
-import * as fs from "fs";
-import * as path from "os";
-
-async function testE2E() {
-  const email = `test-${Date.now()}@example.com`;
-  const username = `user-${Date.now()}`;
-  const password = "password123";
-
-  console.log("--- Phase 1: Signup ---");
-  try {
-    const signupResult = await apiRequest(
-      "POST",
-      "/auth/signup",
-      {
-        email,
-        password,
-        username,
-      },
-      false,
-    );
-
-    console.log("Signup response:", JSON.stringify(signupResult, null, 2));
-
-    if (signupResult.session) {
-      saveSession({
-        access_token: signupResult.session.access_token,
-        refresh_token: signupResult.session.refresh_token,
-        user_id: signupResult.user.id,
-        email,
-        username,
-      });
-      console.log(" Signup successful");
-    } else {
-      console.log(
-        " User created but NO session returned (possibly email verification required)",
-      );
-    }
-
-    if (!signupResult.session) {
-      console.warn(
-        "⚠️ Ending test early: No session available to continue authenticated requests.",
-      );
-      return;
-    }
-
-    console.log("--- Phase 2: Key Generation ---");
-    const { private_key, public_key } = await generateKeys();
-    savePrivateKey(private_key);
-    await apiRequest("PUT", "/profile/public-key", { public_key });
-    console.log(" Keypair generated and public key uploaded");
-
-    console.log("--- Phase 3: Wallet Creation ---");
-    const walletName = `test-wallet-${Date.now()}`;
-    const walletResult = await apiRequest("POST", "/wallets", {
-      name: walletName,
-    });
-    const walletId = walletResult.wallet.id;
-    console.log(` Wallet "${walletName}" created with ID: ${walletId}`);
-
-    console.log("--- Phase 4: Secret Encryption & Storage ---");
-    const secretKey = "MY_API_KEY";
-    const secretValue = "super-secret-value-123";
-    const encryptedValue = await encrypt(secretValue, public_key);
-
-    await apiRequest("POST", `/wallets/${walletId}/secrets`, {
-      secrets: [
-        {
-          key_name: secretKey,
-          encrypted_value: encryptedValue,
-          encrypted_for: public_key,
-        },
-      ],
-    });
-    console.log(" Secret encrypted and uploaded");
-
-    console.log("--- Phase 5: Secret Retrieval & Decryption ---");
-    const getResult = await apiRequest("GET", `/wallets/${walletId}/secrets`);
-    const foundSecret = getResult.secrets.find(
-      (s: any) => s.key_name === secretKey,
-    );
-
-    if (!foundSecret) throw new Error("Secret not found in response");
-
-    const decryptedValue = await decrypt(
-      foundSecret.encrypted_value,
-      private_key,
-    );
-    console.log(` Secret retrieved and decrypted: ${decryptedValue}`);
-
-    if (decryptedValue === secretValue) {
-      console.log(" E2E TRANSACTION SUCCESSFUL");
-    } else {
-      throw new Error("Decrypted value mismatch");
-    }
-  } catch (error) {
-    console.error(" E2E TEST FAILED:", error);
-  } finally {
-    shutdown();
-  }
-}
-
-testE2E();

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "lib": ["ES2020"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}