zotero-plugin 5.0.39 → 6.0.0

package/bin/branches.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// bin/branches.ts
+import "dotenv/config";
+import * as path from "path";
+import { Octokit } from "@octokit/rest";
+
+// root.ts
+var root_default = process.cwd();
+
+// bin/branches.ts
+process.on("unhandledRejection", (up) => {
+  throw up;
+});
+var octokit = new Octokit({ auth: `token ${process.env.GITHUB_TOKEN}` });
+var pkg = __require(path.join(root_default, "package.json"));
+var [, owner, repo] = pkg.repository.url.match(/:\/\/github.com\/([^/]+)\/([^.]+)\.git$/);
+async function main() {
+  const branches = await octokit.repos.listBranches({ owner, repo });
+  for (const branch of branches.data) {
+    if (/^[0-9]+$/.exec(branch.name)) {
+      const issue = await octokit.issues.get({ owner, repo, issue_number: parseInt(branch.name) });
+      if (issue.data.state !== "open") console.log(branch.name, issue.data.state);
+    } else if (!["master", "main", "gh-pages"].includes(branch.name)) {
+      console.log(branch.name);
+    }
+  }
+}
+main().catch((err) => console.log(err));

package/bin/fetch-log.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+// bin/fetch-log.ts
+import { Command } from "commander";
+import crypto2 from "crypto";
+import fs from "fs";
+import fetch from "node-fetch";
+import StreamZip from "node-stream-zip";
+import path from "path";
+import { Entry as KeyRingEntry } from "@napi-rs/keyring";
+import prompts from "prompts";
+
+// package.json
+var version = "6.0.0";
+
+// bin/crypto.ts
+import crypto from "crypto";
+function decrypt({ ciphertext, iv, tag, salt, iterations, keyLength, algorithm }, passphrase) {
+  const key = crypto.pbkdf2Sync(passphrase, Buffer.from(salt, "base64"), iterations, keyLength, "sha256");
+  const decipher = crypto.createDecipheriv(algorithm, key, Buffer.from(iv, "base64"));
+  decipher.setAuthTag(Buffer.from(tag, "base64"));
+  let decrypted = decipher.update(ciphertext, "base64", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+
+// bin/fetch-log.ts
+async function getPassphrase(service, account) {
+  const entry = new KeyRingEntry(service, account);
+  let passphrase = entry.getPassword();
+  if (!passphrase) {
+    const response = await prompts({
+      type: "password",
+      name: "passphrase",
+      message: "Enter a passphrase to decrypt your private key for ${service} ${account}:"
+    });
+    entry.setPassword(passphrase = response.passphrase);
+  }
+  return passphrase;
+}
+var oops = (...args2) => {
+  console.error(...args2);
+  process.exit(1);
+};
+var program = new Command();
+program.description("A script to generate and store an RSA key pair in an encrypted file.").option("-p, --private <path>", "Path for the encrypted private key .pem.json file", "private.pem.json").argument("<debug log id>", "debug log ID to fetch").parse(process.argv);
+var options = program.opts();
+var args = program.args;
+if (!args.length) oops("No log ID");
+var m = args[0].match(/^(?<key>[a-z0-9]+)-(?<host>[^-]+)-(?<remote>[^.]+)(?<tags>.*)$/i);
+if (!m) oops(args[0], "is not a valid log ID");
+if (m.groups.host !== "0x0") oops("Unexpected debug log host", m.groups.host);
+options.encrypted = m.groups.tags.split(".").includes("enc");
+options.zip = path.join("logs", `${m.groups.key}.zip`);
+options.url = `https://0x0.st/${m.groups.remote}.zip`;
+if (options.encrypted) {
+  if (!options.private) oops("No private key provided");
+  if (!fs.existsSync(options.private)) oops("Private key", options.private, "does not exist");
+  if (!fs.existsSync("package.json")) oops("package.json does not exist in the current directory");
+}
+var logs = path.join("logs", m.groups.key);
+console.log(options.url, "=>", logs);
+if (!fs.existsSync(logs)) {
+  fs.mkdirSync(logs, { recursive: true });
+}
+async function main() {
+  try {
+    const response = await fetch(options.url, {
+      method: "GET",
+      headers: {
+        "User-Agent": `Zotero plugin log fetcher ${version}`,
+        Accept: "*/*"
+      }
+    });
+    if (!response.ok) oops(`Failed to download: ${response.statusText}`);
+    const download = fs.createWriteStream(options.zip);
+    response.body.pipe(download);
+    await new Promise((resolve, reject) => {
+      download.on("finish", () => resolve());
+      download.on("error", (err) => reject(err));
+    });
+    let privateKey;
+    if (options.encrypted) {
+      const pkg = JSON.parse(fs.readFileSync("package.json", "utf-8"));
+      const passphrase = await getPassphrase(`${pkg.name} Zotero plugin`, "debug-log");
+      privateKey = decrypt(JSON.parse(fs.readFileSync(options.private, "utf-8")), passphrase);
+    }
+    const zipfile = new StreamZip.async({ file: options.zip });
+    let decryptionKey;
+    const fileEntries = {};
+    for (const entry of Object.values(await zipfile.entries())) {
+      if (entry.isDirectory) continue;
+      const m2 = entry.name.match(/(?<filename>.+)\.(?<type>key|enc|iv)$/i);
+      let filename = m2?.groups.filename || entry.name;
+      const type = (m2?.groups.ext || "").toLowerCase();
+      if (type && !options.encrypted) oops("unexpected", type, "file in non-encrypted log");
+      if (type === "key") {
+        decryptionKey = crypto2.privateDecrypt({
+          key: privateKey,
+          padding: crypto2.constants.RSA_PKCS1_OAEP_PADDING,
+          oaepHash: "sha256"
+        }, await zipfile.entryData(entry.name));
+      } else {
+        const key = filename.toLowerCase();
+        const f = fileEntries[key] = fileEntries[key] || { filename };
+        f[type === "iv" ? "iv" : "contents"] = entry.name;
+        if (type) f.encrypted = true;
+      }
+    }
+    if (options.encrypted && !decryptionKey) oops("no key file found");
+    for (const entry of Object.values(fileEntries)) {
+      if (!entry.contents) oops("no contents for", entry.filename);
+      if (entry.encrypted && !entry.iv) oops("no iv for", entry.filename);
+      const data = await zipfile.entryData(entry.contents);
+      const target = path.join("logs", entry.filename);
+      if (entry.iv) {
+        const iv = await zipfile.entryData(entry.iv);
+        const tag = data.slice(-16);
+        const ciphertext = data.slice(0, -16);
+        const decipher = crypto2.createDecipheriv("aes-256-gcm", decryptionKey, iv);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+        fs.writeFileSync(target, decrypted);
+      } else {
+        fs.writeFileSync(target, data);
+      }
+    }
+  } finally {
+    if (fs.existsSync(options.zip)) fs.unlinkSync(options.zip);
+  }
+}
+main().catch((err) => {
+  oops(err.message);
+});

package/bin/keypair.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+// bin/keypair.ts
+import { Command } from "commander";
+import crypto2 from "crypto";
+import { stat, writeFile } from "fs/promises";
+import { resolve } from "path";
+import prompts from "prompts";
+
+// bin/crypto.ts
+import crypto from "crypto";
+function encrypt(plaintext, passphrase) {
+  const salt = crypto.randomBytes(16);
+  const iterations = 1e5;
+  const keyLength = 32;
+  const algorithm = "aes-256-gcm";
+  const key = crypto.pbkdf2Sync(passphrase, salt, iterations, keyLength, "sha256");
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv(algorithm, key, iv);
+  let ciphertext = cipher.update(plaintext, "utf8", "base64");
+  ciphertext += cipher.final("base64");
+  const tag = cipher.getAuthTag();
+  return {
+    ciphertext,
+    iv: iv.toString("base64"),
+    tag: tag.toString("base64"),
+    salt: salt.toString("base64"),
+    iterations,
+    keyLength,
+    algorithm
+  };
+}
+
+// bin/keypair.ts
+import { config as dotenvConfig } from "dotenv";
+dotenvConfig({ quiet: true, override: true });
+var program = new Command();
+program.description("A script to generate and store an RSA key pair in an encrypted file.").option("-p, --public <path>", "Path for the public key .pem file", "public.pem").option("--private <path>", "Path for the encrypted private key .pem.json file", "private.pem.json").option("-r, --replace", "Replace existing files", false).parse(process.argv);
+var options = program.opts();
+async function main() {
+  try {
+    const publicKeyPath = resolve(options.public);
+    const encryptedKeyPath = resolve(options.private);
+    if (!publicKeyPath.endsWith(".pem")) {
+      console.error("Public key file must have a .pem extension.");
+      process.exit(1);
+    }
+    if (!encryptedKeyPath.endsWith(".pem.json")) {
+      console.error("Encrypted key file must have a .pem.json extension.");
+      process.exit(1);
+    }
+    const fileExists = async (path) => {
+      try {
+        await stat(path);
+        return true;
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          return false;
+        }
+        throw e;
+      }
+    };
+    if (await fileExists(publicKeyPath) && !options.replace) {
+      console.error(`Will not overwrite existing public key file: ${publicKeyPath}`);
+      process.exit(1);
+    }
+    if (await fileExists(encryptedKeyPath) && !options.replace) {
+      console.error(`Will not overwrite existing encrypted key file: ${encryptedKeyPath}`);
+      process.exit(1);
+    }
+    const { privateKey, publicKey } = crypto2.generateKeyPairSync("rsa", {
+      modulusLength: 2048,
+      publicKeyEncoding: {
+        type: "spki",
+        format: "pem"
+      },
+      privateKeyEncoding: {
+        type: "pkcs8",
+        format: "pem"
+      }
+    });
+    const { passphrase } = await prompts({
+      type: "password",
+      name: "passphrase",
+      message: "Enter a passphrase to encrypt your private key:"
+    });
+    if (!passphrase) {
+      console.error("Passphrase is required for encryption.");
+      process.exit(1);
+    }
+    await writeFile(encryptedKeyPath, JSON.stringify(encrypt(privateKey, passphrase), null, 2));
+    console.log(`Encrypted private key saved to: ${encryptedKeyPath}`);
+    await writeFile(publicKeyPath, publicKey);
+    console.log(`Public key saved to: ${publicKeyPath}`);
+  } catch (error) {
+    throw error;
+  }
+}
+main();

package/bin/link.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// bin/link.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// root.ts
+var root_default = process.cwd();
+
+// bin/link.ts
+var pkg = { ...__require(path.join(root_default, "package.json")) };
+if (!pkg.id) pkg.id = `${pkg.name.replace(/^zotero-/, "")}@${pkg.author.email.replace(/.*@/, "")}`.toLowerCase();
+if (pkg.xpi) Object.assign(pkg, pkg.xpi);
+var build = path.join(root_default, "build");
+var zotero = process.argv[2];
+if (!zotero) {
+  console.log("No directory specified");
+  process.exit(1);
+}
+var extensions = path.join(zotero, "extensions");
+if (!fs.existsSync(extensions)) {
+  console.log(`${extensions} does not exist`);
+  process.exit(1);
+}
+var extension = path.join(extensions, pkg.id);
+fs.writeFileSync(extension, build);