zurik 1.0.0

package/bin/zurik.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+import encryptFiles from "../lib/encrypt.js";
+import decryptFiles from "../lib/decrypt.js";
+
+const args = process.argv.slice(2);
+
+function extractPassword() {
+  const pIndex = args.indexOf("-p");
+  if (pIndex !== -1 && args[pIndex + 1]) {
+    return args[pIndex + 1];
+  }
+  return process.env.ZURIK_PASSWORD || null;
+}
+
+
+async function run() {
+  const password = extractPassword();
+  if (!password) {
+    console.error("Missing password. Use -p <password> or set ZURIK_PASSWORD environment variable.");
+    process.exit(1);
+  }
+
+  if (args.includes("-e")) {
+    await encryptFiles(password);
+    return;
+  }
+
+  if (args.includes("-d")) {
+    await decryptFiles(password);
+    return;
+  }
+
+  console.log("Usage:");
+  console.log("  npx zurik -e [-p password]   Encrypt");
+  console.log("  npx zurik -d [-p password]   Decrypt");
+}
+
+run().catch(err => {
+  console.error(err.message);
+  process.exit(1);
+});

package/lib/crypto.js

@@ -0,0 +1,41 @@
+import crypto from "crypto";
+
+const ALGO = "aes-256-gcm";
+const IV_LENGTH = 16;
+
+function deriveKey(password) {
+  return new Promise((resolve, reject) => {
+    crypto.scrypt(password, "zurik_fixed_salt", 32, (err, key) => {
+      if (err) reject(err);
+      else resolve(key);
+    });
+  });
+}
+
+export async function encryptData(data, password) {
+  const key = await deriveKey(password);
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGO, key, iv);
+
+  const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+  const tag = cipher.getAuthTag();
+
+  return Buffer.concat([iv, tag, encrypted]).toString("base64");
+}
+
+export async function decryptData(base64, password) {
+  const buffer = Buffer.from(base64, "base64");
+
+  const iv = buffer.subarray(0, 16);
+  const tag = buffer.subarray(16, 32);
+  const ciphertext = buffer.subarray(32);
+
+  const key = await deriveKey(password);
+  const decipher = crypto.createDecipheriv(ALGO, key, iv);
+  decipher.setAuthTag(tag);
+
+  return Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]);
+}

package/lib/decrypt.js

@@ -0,0 +1,19 @@
+import fs from "fs";
+import path from "path";
+import { decryptData } from "./crypto.js";
+
+export default async function decryptFiles(password) {
+  if (!fs.existsSync(".zurik")) {
+    throw new Error(".zurik not found");
+  }
+
+  const blob = fs.readFileSync(".zurik", "utf8");
+  const jsonStr = await decryptData(blob, password);
+  const data = JSON.parse(jsonStr);
+
+  for (const [filePath, base64] of Object.entries(data.files)) {
+    const buffer = Buffer.from(base64, "base64");
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, buffer);
+  }
+}

package/lib/encrypt.js

@@ -0,0 +1,47 @@
+import fs from "fs";
+import path from "path";
+import { encryptData } from "./crypto.js";
+
+export default async function encryptFiles(password) {
+  const listFile = ".gitencrypt";
+
+  if (!fs.existsSync(listFile)) {
+    throw new Error(".gitencrypt not found");
+  }
+
+  const fileList = fs
+    .readFileSync(listFile, "utf8")
+    .split("\n")
+    .map(x => x.trim())
+    .filter(Boolean);
+
+  const bundle = { version: 1, files: {} };
+
+  for (const filePath of fileList) {
+    if (!fs.existsSync(filePath)) {
+      console.warn(`Skipping missing file: ${filePath}`);
+      continue;
+    }
+
+    const content = fs.readFileSync(filePath);
+    bundle.files[filePath] = content.toString("base64");
+  }
+
+  const encrypted = await encryptData(JSON.stringify(bundle), password);
+  fs.writeFileSync(".zurik", encrypted);
+
+  updateGitignore(fileList);
+}
+
+function updateGitignore(fileList) {
+  const gi = ".gitignore";
+  let text = fs.existsSync(gi) ? fs.readFileSync(gi, "utf8") : "";
+
+  for (const file of fileList) {
+    if (!text.includes(file)) {
+      text += `\n${file}`;
+    }
+  }
+
+  fs.writeFileSync(gi, text.trim() + "\n");
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "zurik",
+  "version": "1.0.0",
+  "description": "CLI tool for encrypting and decrypting sensitive project files into a single .zurik bundle.",
+  "type": "module",
+  "bin": {
+    "zurik": "./bin/zurik.js"
+  },
+  "keywords": [
+    "encryption",
+    "cli",
+    "security",
+    "aes",
+    "gcm",
+    "git",
+    "files"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {}
+}

package/readme.md

@@ -0,0 +1,25 @@
+# zurik
+
+A Node.js CLI tool for encrypting and decrypting sensitive project files.
+It collects file paths from `.gitencrypt`, bundles them into a single `.zurik` file, and decrypts them when needed.
+
+## Features
+
+- Encrypt multiple files into a **single** `.zurik` bundle
+- AES-256-GCM authenticated encryption
+- Automatically append sensitive files to `.gitignore` when encrypting.
+
+## Installation
+
+You can run it directly using `npx`:
+
+```sh
+export ZURIK_PASSWORD="your-secret"
+npx zurik -e
+
+# or install it globally
+npm install -g zurik
+
+# also you can pass the password as an argument
+npx zurik -e -p "your-password"
+```