laneyard 0.1.0 → 0.3.0

package/dist/src/server/routes/users.js

@@ -0,0 +1,64 @@
+import { MIN_PASSWORD_LENGTH, VALID_NAME, refusalFor, removeUserFromConfig, upsertUserInConfig, } from "../../config/accounts.js";
+const ROLES = ["admin", "builder"];
+/**
+ * The accounts, as the interface sees them.
+ *
+ * Every route here is on the admin list in `permissions.ts`, so nothing below
+ * checks a role: the hook already refused anyone who has no business here, and
+ * a second check inside a handler is a permission nobody finds during an audit.
+ */
+export async function registerUserRoutes(app, ctx) {
+    const accounts = () => ctx.config.server()?.users ?? [];
+    // Name and role, and that is the whole shape. The hash is not truncated or
+    // masked on the way out — it is simply never put on the wire.
+    app.get("/api/users", async () => accounts().map((u) => ({ name: u.name, role: u.role })));
+    app.post("/api/users", async (req, reply) => {
+        const { name, role, password } = (req.body ?? {});
+        if (typeof name !== "string" || !VALID_NAME.test(name)) {
+            return reply.code(400).send({
+                error: "A name is letters, digits, dot, dash and underscore, starting with a letter or a digit.",
+            });
+        }
+        if (typeof role !== "string" || !ROLES.includes(role)) {
+            return reply.code(400).send({ error: `A role is ${ROLES.join(" or ")}.` });
+        }
+        if (typeof password !== "string" || password.length < MIN_PASSWORD_LENGTH) {
+            return reply
+                .code(400)
+                .send({ error: `A password is at least ${MIN_PASSWORD_LENGTH} characters.` });
+        }
+        const refusal = refusalFor(accounts(), name, role);
+        if (refusal)
+            return reply.code(409).send({ error: refusal });
+        const { created } = await upsertUserInConfig(ctx.config.configPath(), {
+            name,
+            role: role,
+            password,
+        });
+        // Replacing an account changes the password and possibly the role, and a
+        // session holds neither — it holds a snapshot taken at login. The sessions
+        // go, so that what was just written is what is true everywhere.
+        if (!created)
+            ctx.sessions.revokeAllFor(name);
+        // The file is watched, but on a debounce: reloading here is what makes the
+        // very next request — the listing this page is about to ask for — truthful,
+        // and what lets the new account log in immediately.
+        await ctx.config.load();
+        return reply.code(created ? 201 : 200).send({ name, role });
+    });
+    app.delete("/api/users/:name", async (req, reply) => {
+        const { name } = req.params;
+        if (!accounts().some((u) => u.name === name)) {
+            return reply.code(404).send({ error: "Unknown account" });
+        }
+        const refusal = refusalFor(accounts(), name, null);
+        if (refusal)
+            return reply.code(409).send({ error: refusal });
+        const removed = await removeUserFromConfig(ctx.config.configPath(), name);
+        if (!removed)
+            return reply.code(404).send({ error: "Unknown account" });
+        ctx.sessions.revokeAllFor(name);
+        await ctx.config.load();
+        return reply.code(204).send();
+    });
+}

package/dist/src/sidecar/bridge.js

@@ -1,10 +1,26 @@
 import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { FASTLANE_UNAVAILABLE, resolveRubyEnv } from "./ruby-env.js";
 const exec = promisify(execFile);
-const SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "ruby", "introspect.rb");
+/**
+ * Locates `ruby/introspect.rb` from wherever this module happens to live.
+ *
+ * Two layouts, and only trying one of them is how listing lanes came to be
+ * broken in every installed copy while working perfectly from the sources:
+ * `src/sidecar/` sits two levels under the package root, `dist/src/sidecar/`
+ * sits three. The package ships `ruby/` at its root in both cases.
+ */
+export function resolveSidecarScript(moduleDir) {
+    const candidates = [
+        join(moduleDir, "..", "..", "ruby", "introspect.rb"),
+        join(moduleDir, "..", "..", "..", "ruby", "introspect.rb"),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+const SCRIPT = resolveSidecarScript(dirname(fileURLToPath(import.meta.url)));
 /**
  * Runs the sidecar in the project's context.
  * In `bundle` mode, the invocation goes through `bundle exec` to see the

package/dist/src/sidecar/lanes.js

@@ -27,14 +27,14 @@ export class LaneReader {
     }
     async read(slug, workspacePath, fastlaneDir) {
         const hash = await hashFastlaneDir(workspacePath, fastlaneDir);
-        const cached = this.cache.get(slug, hash);
+        const cached = this.cache.get(slug, "lanes", hash);
         if (cached)
             return cached;
         const res = await this.invoke("lanes", workspacePath, fastlaneDir);
         if (!res.ok)
             throw new Error(res.error);
         const lanes = res["lanes"];
-        this.cache.put(slug, hash, lanes);
+        this.cache.put(slug, "lanes", hash, lanes);
         return lanes;
     }
 }

package/dist/src/sidecar/uses.js

@@ -0,0 +1,40 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Hash of the whole fastlane folder, not just the Fastfile:
+ * an Appfile, a Pluginfile, or an imported file change the lanes just as much.
+ */
+async function hashFastlaneDir(root, fastlaneDir) {
+    const dir = join(root, fastlaneDir);
+    const hash = createHash("sha256");
+    const entries = (await readdir(dir, { withFileTypes: true, recursive: true }))
+        .filter((e) => e.isFile())
+        .map((e) => join(e.parentPath, e.name))
+        .sort();
+    for (const file of entries) {
+        hash.update(file);
+        hash.update(await readFile(file));
+    }
+    return hash.digest("hex");
+}
+export class UsesReader {
+    cache;
+    invoke;
+    constructor(cache, invoke) {
+        this.cache = cache;
+        this.invoke = invoke;
+    }
+    async read(slug, workspacePath, fastlaneDir) {
+        const hash = await hashFastlaneDir(workspacePath, fastlaneDir);
+        const cached = this.cache.get(slug, "uses", hash);
+        if (cached)
+            return cached;
+        const res = await this.invoke("uses", workspacePath, fastlaneDir);
+        if (!res.ok)
+            throw new Error(res.error);
+        const lanes = res["lanes"];
+        this.cache.put(slug, "uses", hash, lanes);
+        return lanes;
+    }
+}