Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

feat: add password reset utility

yoma0bd3ec920f56
diff --git a/package.json b/package.json
index 8c1b1355..93ca23fd 100644
--- a/package.json
+++ b/package.json
@@ -29,6 +29,7 @@
"db:migrate:local": "bun scripts/run-wrangler.mjs d1 migrations apply DB --local",
"db:migrate:remote": "bun scripts/run-wrangler.mjs d1 migrations apply DB --remote",
"auth:hash": "bun scripts/hash-password.mjs",
+ "auth:reset-password": "bun scripts/reset-password.mjs",
"cli": "bun scripts/edgeever.mjs",
"import:evernote": "bun scripts/import-evernote-enex-via-mcp.mjs",
"mcp:stdio": "bun scripts/edgeever-mcp-stdio.mjs",
diff --git a/scripts/hash-password.mjs b/scripts/hash-password.mjs
index 626c85ad..ee3510b3 100644
--- a/scripts/hash-password.mjs
+++ b/scripts/hash-password.mjs
@@ -1,9 +1,4 @@
-import { pbkdf2Sync, randomBytes } from "node:crypto";
-
-const PASSWORD_HASH_ALGORITHM = "pbkdf2-sha256";
-const PASSWORD_HASH_ITERATIONS = 100_000;
-const PASSWORD_HASH_BYTES = 32;
-const PASSWORD_SALT_BYTES = 16;
+import { createPasswordHash } from "./password-hash.mjs";
const password = process.argv.slice(2).join(" ") || process.env.EDGE_EVER_PASSWORD;
@@ -13,12 +8,4 @@ if (!password) {
process.exit(1);
}
-const base64UrlEncode = (buffer) =>
- buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
-
-const salt = randomBytes(PASSWORD_SALT_BYTES);
-const hash = pbkdf2Sync(password, salt, PASSWORD_HASH_ITERATIONS, PASSWORD_HASH_BYTES, "sha256");
-
-console.log(
- [PASSWORD_HASH_ALGORITHM, PASSWORD_HASH_ITERATIONS, base64UrlEncode(salt), base64UrlEncode(hash)].join("$")
-);
+console.log(createPasswordHash(password));
diff --git a/scripts/password-hash.mjs b/scripts/password-hash.mjs
new file mode 100644
index 00000000..a1740827
--- /dev/null
+++ b/scripts/password-hash.mjs
@@ -0,0 +1,20 @@
+import { pbkdf2Sync, randomBytes } from "node:crypto";
+
+export const PASSWORD_HASH_ALGORITHM = "pbkdf2-sha256";
+export const PASSWORD_HASH_ITERATIONS = 100_000;
+export const PASSWORD_HASH_BYTES = 32;
+export const PASSWORD_SALT_BYTES = 16;
+
+const base64UrlEncode = (buffer) =>
+ buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+
+export const createPasswordHash = (password, salt = randomBytes(PASSWORD_SALT_BYTES)) => {
+ const hash = pbkdf2Sync(password, salt, PASSWORD_HASH_ITERATIONS, PASSWORD_HASH_BYTES, "sha256");
+
+ return [
+ PASSWORD_HASH_ALGORITHM,
+ PASSWORD_HASH_ITERATIONS,
+ base64UrlEncode(salt),
+ base64UrlEncode(hash),
+ ].join("$");
+};
diff --git a/scripts/reset-password.mjs b/scripts/reset-password.mjs
new file mode 100644
index 00000000..b7355c5a
--- /dev/null
+++ b/scripts/reset-password.mjs
@@ -0,0 +1,160 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { createPasswordHash } from "./password-hash.mjs";
+
+const usage = `Usage:
+ EDGE_EVER_PASSWORD='<new-password>' bun run auth:reset-password -- --remote --username <username>
+ EDGE_EVER_PASSWORD='<new-password>' bun run auth:reset-password -- --local --username <username>
+
+For a scoped instance, also set EDGE_EVER_INSTANCE, for example EDGE_EVER_INSTANCE=demo.`;
+
+export const parseResetPasswordArgs = (args) => {
+ let target;
+ let username;
+
+ for (let index = 0; index < args.length; index += 1) {
+ const arg = args[index];
+ if (arg === "--remote" || arg === "--local") {
+ const nextTarget = arg.slice(2);
+ if (target && target !== nextTarget) {
+ throw new Error("Choose exactly one of --remote or --local.");
+ }
+ target = nextTarget;
+ continue;
+ }
+
+ if (arg === "--username") {
+ username = args[index + 1];
+ index += 1;
+ continue;
+ }
+
+ throw new Error(`Unknown argument: ${arg}`);
+ }
+
+ if (!target) {
+ throw new Error("Choose --remote or --local.");
+ }
+
+ if (!username?.trim()) {
+ throw new Error("Provide --username <username>.");
+ }
+
+ return { target, username: username.trim() };
+};
+
+const sqlString = (value) => `'${value.replaceAll("'", "''")}'`;
+
+export const buildUserLookupSql = (username) =>
+ `SELECT id FROM users WHERE username = ${sqlString(username)} AND is_disabled = 0 LIMIT 1`;
+
+export const buildPasswordResetSql = (username, passwordHash) => {
+ const escapedUsername = sqlString(username);
+ const escapedHash = sqlString(passwordHash);
+
+ return `UPDATE users
+SET password_hash = ${escapedHash}, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE username = ${escapedUsername} AND is_disabled = 0;
+SELECT changes() AS updated_users;
+UPDATE sessions
+SET revoked_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE user_id IN (
+ SELECT id FROM users WHERE username = ${escapedUsername} AND is_disabled = 0
+) AND revoked_at IS NULL;
+SELECT changes() AS revoked_sessions;
+`;
+};
+
+export const parseD1Rows = (output) => {
+ const parsed = JSON.parse(output);
+ const results = Array.isArray(parsed) ? parsed : [parsed];
+ return results.flatMap((result) => result?.results ?? []);
+};
+
+const runWrangler = (args) => {
+ const result = spawnSync(
+ process.execPath,
+ [resolve("scripts/run-wrangler.mjs"), ...args],
+ { encoding: "utf8", env: process.env },
+ );
+
+ if (result.status !== 0) {
+ if (result.stdout) process.stdout.write(result.stdout);
+ if (result.stderr) process.stderr.write(result.stderr);
+ throw new Error(`Wrangler exited with status ${result.status ?? 1}.`);
+ }
+
+ return result.stdout;
+};
+
+const main = () => {
+ let options;
+ try {
+ options = parseResetPasswordArgs(process.argv.slice(2));
+ } catch (error) {
+ console.error(error.message);
+ console.error(usage);
+ process.exit(1);
+ }
+
+ const password = process.env.EDGE_EVER_PASSWORD;
+ if (!password || password.length < 8 || password.length > 512) {
+ console.error("EDGE_EVER_PASSWORD must contain 8-512 characters.");
+ console.error(usage);
+ process.exit(1);
+ }
+
+ const targetFlag = `--${options.target}`;
+ const lookupOutput = runWrangler([
+ "d1",
+ "execute",
+ "DB",
+ targetFlag,
+ "--command",
+ buildUserLookupSql(options.username),
+ "--json",
+ ]);
+
+ if (parseD1Rows(lookupOutput).length === 0) {
+ throw new Error(`Enabled user not found: ${options.username}`);
+ }
+
+ const temporaryDirectory = mkdtempSync(join(tmpdir(), "edgeever-password-reset-"));
+ const sqlPath = join(temporaryDirectory, "reset-password.sql");
+
+ try {
+ writeFileSync(sqlPath, buildPasswordResetSql(options.username, createPasswordHash(password)), {
+ mode: 0o600,
+ });
+ const resetOutput = runWrangler([
+ "d1",
+ "execute",
+ "DB",
+ targetFlag,
+ "--file",
+ sqlPath,
+ "--yes",
+ "--json",
+ ]);
+ const resetRows = parseD1Rows(resetOutput);
+ const updateResult = resetRows.find((row) => "updated_users" in row);
+ if (Number(updateResult?.updated_users) !== 1) {
+ throw new Error(`Password reset did not update exactly one user: ${options.username}`);
+ }
+ } finally {
+ rmSync(temporaryDirectory, { recursive: true, force: true });
+ }
+
+ console.log(`Password reset for ${options.username} (${options.target}); existing sessions revoked.`);
+};
+
+if (import.meta.main) {
+ try {
+ main();
+ } catch (error) {
+ console.error(error instanceof Error ? error.message : String(error));
+ process.exit(1);
+ }
+}
diff --git a/tests/reset-password.test.ts b/tests/reset-password.test.ts
new file mode 100644
index 00000000..98874d32
--- /dev/null
+++ b/tests/reset-password.test.ts
@@ -0,0 +1,58 @@
+import { describe, expect, test } from "bun:test";
+import { pbkdf2Sync } from "node:crypto";
+import {
+ PASSWORD_HASH_BYTES,
+ PASSWORD_HASH_ITERATIONS,
+ createPasswordHash,
+} from "../scripts/password-hash.mjs";
+import {
+ buildPasswordResetSql,
+ buildUserLookupSql,
+ parseD1Rows,
+ parseResetPasswordArgs,
+} from "../scripts/reset-password.mjs";
+
+const decodeBase64Url = (value: string) => Buffer.from(value, "base64url");
+
+describe("password reset script", () => {
+ test("creates hashes compatible with EdgeEver authentication", () => {
+ const password = "demo-password";
+ const salt = Buffer.alloc(16, 7);
+ const encoded = createPasswordHash(password, salt);
+ const [algorithm, iterations, encodedSalt, encodedHash] = encoded.split("$");
+
+ expect(algorithm).toBe("pbkdf2-sha256");
+ expect(Number(iterations)).toBe(PASSWORD_HASH_ITERATIONS);
+ expect(decodeBase64Url(encodedSalt)).toEqual(salt);
+ expect(decodeBase64Url(encodedHash)).toEqual(
+ pbkdf2Sync(password, salt, PASSWORD_HASH_ITERATIONS, PASSWORD_HASH_BYTES, "sha256"),
+ );
+ });
+
+ test("requires an explicit target and username", () => {
+ expect(parseResetPasswordArgs(["--remote", "--username", "ee-demo"])).toEqual({
+ target: "remote",
+ username: "ee-demo",
+ });
+ expect(() => parseResetPasswordArgs(["--username", "ee-demo"])).toThrow("Choose --remote or --local");
+ expect(() => parseResetPasswordArgs(["--remote"])).toThrow("Provide --username");
+ });
+
+ test("escapes usernames and revokes existing sessions", () => {
+ expect(buildUserLookupSql("demo'user")).toContain("username = 'demo''user'");
+
+ const sql = buildPasswordResetSql("demo'user", "pbkdf2$hash");
+ expect(sql).toContain("password_hash = 'pbkdf2$hash'");
+ expect(sql).toContain("username = 'demo''user'");
+ expect(sql).toContain("UPDATE sessions");
+ expect(sql).toContain("revoked_at IS NULL");
+ expect(sql).toContain("SELECT changes() AS updated_users");
+ expect(sql).not.toContain("BEGIN TRANSACTION");
+ });
+
+ test("reads rows from Wrangler JSON output", () => {
+ expect(parseD1Rows(JSON.stringify([{ results: [{ id: "usr_demo" }], success: true }]))).toEqual([
+ { id: "usr_demo" },
+ ]);
+ });
+});