@digitalpaws/starr 0.0.1

package/tests/logger-jsonl.test.ts

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createLogger } from "../src/logging/logger.js";
+
+function tmpLogPath(): string {
+  return path.join(
+    os.tmpdir(),
+    `starr-log-test-${Date.now()}-${Math.random().toString(36).slice(2)}.log`,
+  );
+}
+
+function readLines(
+  logPath: string,
+): Array<Record<string, unknown>> {
+  if (!fs.existsSync(logPath)) return [];
+  return fs
+    .readFileSync(logPath, "utf8")
+    .trim()
+    .split("\n")
+    .filter((line) => line.length > 0)
+    .map((line) => JSON.parse(line) as Record<string, unknown>);
+}
+
+describe("JSONL file logging", () => {
+  let logPath: string;
+  let originalEnv: Record<string, string | undefined>;
+
+  beforeEach(() => {
+    logPath = tmpLogPath();
+    originalEnv = {
+      STARR_LOG_FILE: process.env.STARR_LOG_FILE,
+      STARR_LOG_LEVEL: process.env.STARR_LOG_LEVEL,
+      STARR_LOG_FILE_LEVEL: process.env.STARR_LOG_FILE_LEVEL,
+    };
+    process.env.STARR_LOG_FILE = logPath;
+    process.env.STARR_LOG_LEVEL = "debug";
+    delete process.env.STARR_LOG_FILE_LEVEL;
+  });
+
+  afterEach(() => {
+    try {
+      fs.rmSync(logPath, { force: true });
+    } catch {
+      // ignore
+    }
+    process.env.STARR_LOG_FILE = originalEnv.STARR_LOG_FILE;
+    process.env.STARR_LOG_LEVEL = originalEnv.STARR_LOG_LEVEL;
+    process.env.STARR_LOG_FILE_LEVEL = originalEnv.STARR_LOG_FILE_LEVEL;
+  });
+
+  it("creates the log file and parent directory on first log", () => {
+    // Use a nested tmp subdirectory to safely test directory creation
+    const nestedDir = path.join(os.tmpdir(), `starr-log-dir-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    const nestedLogPath = path.join(nestedDir, "sub", "test.log");
+    process.env.STARR_LOG_FILE = nestedLogPath;
+    const logger = createLogger("core", "debug");
+    logger.info("hello");
+    expect(fs.existsSync(nestedLogPath)).toBe(true);
+    const lines = readLines(nestedLogPath);
+    expect(lines.length).toBe(1);
+    expect(lines[0].message).toBe("hello");
+    expect(lines[0].level).toBe("info");
+    expect(lines[0].tag).toBe("core");
+    // Clean up
+    fs.rmSync(nestedDir, { recursive: true, force: true });
+  });
+
+  it("appends multiple log lines", () => {
+    const logger = createLogger("core", "debug");
+    logger.info("first");
+    logger.info("second");
+    const lines = readLines(logPath);
+    expect(lines.length).toBe(2);
+    expect(lines[0].message).toBe("first");
+    expect(lines[1].message).toBe("second");
+  });
+
+  it("preserves log level filtering", () => {
+    process.env.STARR_LOG_LEVEL = "warn";
+    const logger = createLogger("core", "warn");
+    logger.debug("debug line");
+    logger.info("info line");
+    logger.warn("warn line");
+    const lines = readLines(logPath);
+    expect(lines.length).toBe(1);
+    expect(lines[0].message).toBe("warn line");
+  });
+
+  it("uses independent file log level", () => {
+    process.env.STARR_LOG_LEVEL = "error";
+    process.env.STARR_LOG_FILE_LEVEL = "info";
+    const logger = createLogger("core", "error");
+    logger.info("file only");
+    logger.error("both sinks");
+    const lines = readLines(logPath);
+    expect(lines.length).toBe(2);
+    expect(lines[0].message).toBe("file only");
+    expect(lines[1].message).toBe("both sinks");
+  });
+
+  it("preserves plugin-style tags", () => {
+    const logger = createLogger("starr-tmdb", "debug");
+    logger.info("plugin log");
+    const lines = readLines(logPath);
+    expect(lines[0].tag).toBe("starr-tmdb");
+    expect(lines[0].message).toBe("plugin log");
+  });
+
+  it("includes metadata fields", () => {
+    const logger = createLogger("core", "debug");
+    logger.info("with meta", { requestId: "req-1", count: 2 });
+    const lines = readLines(logPath);
+    expect(lines[0].requestId).toBe("req-1");
+    expect(lines[0].count).toBe(2);
+  });
+
+  it("does not write file when STARR_LOG_FILE is empty", () => {
+    process.env.STARR_LOG_FILE = "";
+    const logger = createLogger("core", "debug");
+    logger.info("disabled");
+    expect(fs.existsSync(logPath)).toBe(false);
+  });
+
+  it("uses the default path when STARR_LOG_FILE is not set", () => {
+    delete process.env.STARR_LOG_FILE;
+    const dataDir = path.join(os.tmpdir(), `starr-data-${Date.now()}`);
+    process.env.STARR_DATA_DIR = dataDir;
+    const expected = path.join(dataDir, "logs", "starr.log");
+    try {
+      const logger = createLogger("core", "debug");
+      logger.info("default path");
+      expect(fs.existsSync(expected)).toBe(true);
+      const lines = readLines(expected);
+      expect(lines[0].message).toBe("default path");
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+      delete process.env.STARR_DATA_DIR;
+    }
+  });
+
+  it("does not crash on invalid directory permissions", () => {
+    // Point to a directory that cannot be created (e.g., /proc/foo/bar.log)
+    process.env.STARR_LOG_FILE = "/proc/foo/bar.log";
+    const logger = createLogger("core", "debug");
+    logger.info("should not crash");
+    // Test passes if we reach this point without throwing
+    expect(true).toBe(true);
+  });
+});

package/tests/metadata-matcher.test.ts

@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, vi } from "vitest";
+import { deriveSearchTerms } from "../src/library/metadata-matcher.js";
+
+describe("deriveSearchTerms", () => {
+  it("extracts title and year from 'Dune (2021) [2160p]'", () => {
+    const result = deriveSearchTerms("Dune (2021) [2160p]");
+    expect(result.cleanTitle).toBe("Dune");
+    expect(result.year).toBe("2021");
+    expect(result.title).toBe("Dune");
+  });
+
+  it("extracts title and year from 'The.Matrix.1999.1080p'", () => {
+    const result = deriveSearchTerms("The.Matrix.1999.1080p");
+    expect(result.cleanTitle).toBe("The Matrix");
+    expect(result.year).toBe("1999");
+  });
+
+  it("handles scene-style naming with group tag", () => {
+    const result = deriveSearchTerms("A.Movie.Name.2020.REMASTERED.1080p.BluRay.x264-GROUP");
+    expect(result.cleanTitle).toBe("A Movie Name");
+    expect(result.year).toBe("2020");
+  });
+
+  it("handles folder name with no year", () => {
+    const result = deriveSearchTerms("Some Movie Title");
+    expect(result.cleanTitle).toBe("Some Movie Title");
+    expect(result.year).toBeUndefined();
+  });
+
+  it("strips various quality and format tags", () => {
+    const result = deriveSearchTerms("Movie (2015) [BluRay] [1080p] [x264]");
+    expect(result.cleanTitle).toBe("Movie");
+    expect(result.year).toBe("2015");
+  });
+
+  it("handles underscores instead of dots", () => {
+    const result = deriveSearchTerms("A_Good_Movie_2022_1080p");
+    expect(result.cleanTitle).toBe("A Good Movie");
+    expect(result.year).toBe("2022");
+  });
+
+  it("returns empty cleanTitle for empty input", () => {
+    const result = deriveSearchTerms("");
+    expect(result.cleanTitle).toBe("");
+    expect(result.year).toBeUndefined();
+  });
+
+  it("handles simple title with parentheses year", () => {
+    const result = deriveSearchTerms("Inception (2010)");
+    expect(result.cleanTitle).toBe("Inception");
+    expect(result.year).toBe("2010");
+  });
+
+  it("handles multiple dots and spaces", () => {
+    const result = deriveSearchTerms("The   Dark   Knight   2008   REMUX   1080p");
+    expect(result.cleanTitle).toBe("The Dark Knight");
+    expect(result.year).toBe("2008");
+  });
+
+  it("handles Director's Cut tag", () => {
+    const result = deriveSearchTerms("Blade Runner (1982) [Director's Cut] 1080p");
+    expect(result.cleanTitle).toBe("Blade Runner");
+    expect(result.year).toBe("1982");
+  });
+});
+
+describe("MetadataMatcher integration", () => {
+  it("findMatches returns empty array when no metadata plugins respond", async () => {
+    // Set up a metadata matcher with a very short timeout
+    const { MetadataMatcher } = await import("../src/library/metadata-matcher.js");
+    const { EventBusImpl } = await import("../src/events/event-bus.js");
+    const { ContentTypeRegistryImpl } = await import("../src/content-types/registry.js");
+    const { createLogger } = await import("../src/logging/logger.js");
+
+    const logger = createLogger("test", "silent");
+    const impl = new EventBusImpl(logger);
+    const coreBus = impl.coreBus();
+    const registry = new ContentTypeRegistryImpl();
+
+    const matcher = new MetadataMatcher(coreBus, registry, logger, 50); // 50ms timeout
+
+    const group = {
+      directory: "/media/movies/Dune (2021)",
+      folderName: "Dune (2021)",
+      files: ["/media/movies/Dune (2021)/Dune.mkv"],
+      subtitleFiles: [],
+      contentTypeId: "starr-video/movie@1",
+    };
+
+    // No metadata plugin will respond, so should return empty
+    const matches = await matcher.findMatches(group);
+    expect(Array.isArray(matches)).toBe(true);
+    expect(matches.length).toBe(0);
+  });
+
+  it("findMatches returns results when metadata plugins respond", async () => {
+    const { MetadataMatcher } = await import("../src/library/metadata-matcher.js");
+    const { EventBusImpl } = await import("../src/events/event-bus.js");
+    const { ContentTypeRegistryImpl } = await import("../src/content-types/registry.js");
+    const { createLogger } = await import("../src/logging/logger.js");
+
+    const logger = createLogger("test", "silent");
+    const impl = new EventBusImpl(logger);
+    const coreBus = impl.coreBus();
+    const registry = new ContentTypeRegistryImpl();
+    registry.register({
+      id: "starr-video/movie@1",
+      name: "Movie",
+      identity: ["tmdb"],
+      fields: [],
+    });
+
+    const matcher = new MetadataMatcher(coreBus, registry, logger, 200);
+
+    // Simulate a metadata plugin responding
+    coreBus.on("discovery.search", (event: any) => {
+      coreBus.emit("discovery.results", {
+        contentTypeId: "starr-video/movie@1",
+        items: [
+          {
+            contentTypeId: "starr-video/movie@1",
+            title: "Dune",
+            releaseDate: "2021-10-22",
+            externalIds: { tmdb: "438631" },
+            images: [],
+          },
+        ],
+      });
+    });
+
+    const group = {
+      directory: "/media/movies/Dune (2021)",
+      folderName: "Dune (2021)",
+      files: ["/media/movies/Dune (2021)/Dune.mkv"],
+      subtitleFiles: [],
+      contentTypeId: "starr-video/movie@1",
+    };
+
+    const matches = await matcher.findMatches(group);
+    expect(matches.length).toBeGreaterThanOrEqual(1);
+    expect(matches[0].item.title).toBe("Dune");
+    expect(matches[0].source).toBe("core");
+    expect(matches[0].confidence).toBeGreaterThan(0);
+  });
+
+  it("searchCustom returns results for arbitrary queries", async () => {
+    const { MetadataMatcher } = await import("../src/library/metadata-matcher.js");
+    const { EventBusImpl } = await import("../src/events/event-bus.js");
+    const { ContentTypeRegistryImpl } = await import("../src/content-types/registry.js");
+    const { createLogger } = await import("../src/logging/logger.js");
+
+    const logger = createLogger("test", "silent");
+    const impl = new EventBusImpl(logger);
+    const coreBus = impl.coreBus();
+    const registry = new ContentTypeRegistryImpl();
+
+    const matcher = new MetadataMatcher(coreBus, registry, logger, 100);
+
+    // Simulate a metadata plugin responding
+    coreBus.on("discovery.search", (event: any) => {
+      coreBus.emit("discovery.results", {
+        contentTypeId: "starr-video/movie@1",
+        items: [
+          {
+            contentTypeId: "starr-video/movie@1",
+            title: "Inception",
+            releaseDate: "2010-07-16",
+            externalIds: { tmdb: "27205" },
+            images: [],
+          },
+        ],
+      });
+    });
+
+    const matches = await matcher.searchCustom("Inception (2010)", "Inception 2010", "starr-video/movie@1");
+    expect(matches.length).toBeGreaterThanOrEqual(1);
+    expect(matches[0].item.title).toBe("Inception");
+  });
+
+  it("searchCustom returns empty array for empty query", async () => {
+    const { MetadataMatcher } = await import("../src/library/metadata-matcher.js");
+    const { EventBusImpl } = await import("../src/events/event-bus.js");
+    const { ContentTypeRegistryImpl } = await import("../src/content-types/registry.js");
+    const { createLogger } = await import("../src/logging/logger.js");
+
+    const logger = createLogger("test", "silent");
+    const impl = new EventBusImpl(logger);
+    const coreBus = impl.coreBus();
+    const registry = new ContentTypeRegistryImpl();
+
+    const matcher = new MetadataMatcher(coreBus, registry, logger, 50);
+    const matches = await matcher.searchCustom("folder", "", "starr-video/movie@1");
+    expect(matches).toEqual([]);
+  });
+});

package/tests/oidc.test.ts

@@ -0,0 +1,218 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, beforeEach } from "vitest";
+import Database from "better-sqlite3";
+import { OidcProviderService } from "../src/auth/oidc/oidc-provider-service.js";
+import { UserService } from "../src/auth/oidc/user-service.js";
+
+// Minimal encrypt/decrypt for testing (not real encryption)
+const testEncrypt = (s: string) => `ENC(${s})`;
+const testDecrypt = (s: string) => s.replace(/^ENC\(/, "").replace(/\)$/, "");
+
+describe("OidcProviderService", () => {
+  let db: Database.Database;
+  let service: OidcProviderService;
+
+  beforeEach(() => {
+    db = new Database(":memory:");
+    db.exec(`
+      CREATE TABLE oidc_providers (
+        id TEXT PRIMARY KEY, name TEXT, issuer_url TEXT, client_id TEXT,
+        client_secret TEXT, scopes TEXT, role_attribute TEXT,
+        default_role TEXT, enabled INTEGER,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+    `);
+    service = new OidcProviderService(db, testEncrypt, testDecrypt, console as any);
+  });
+
+  it("creates and retrieves a provider", () => {
+    const provider = service.create({
+      name: "Test Provider",
+      issuerUrl: "https://auth.example.com",
+      clientId: "test-client",
+      clientSecret: "super-secret",
+    });
+    expect(provider.name).toBe("Test Provider");
+    expect(provider.clientSecret).toBe("super-secret"); // decrypted
+    expect(provider.enabled).toBe(true);
+    expect(provider.id).toBeTruthy();
+  });
+
+  it("masks secret in database (encrypted at rest)", () => {
+    service.create({
+      name: "Test",
+      issuerUrl: "https://auth.example.com",
+      clientId: "cid",
+      clientSecret: "my-secret",
+    });
+    const row = db.prepare("SELECT client_secret FROM oidc_providers").get() as any;
+    expect(row.client_secret).toBe("ENC(my-secret)"); // encrypted
+  });
+
+  it("updates provider", () => {
+    const created = service.create({
+      name: "Original",
+      issuerUrl: "https://auth.example.com",
+      clientId: "cid",
+      clientSecret: "secret",
+    });
+    const updated = service.update(created.id, { name: "Updated" });
+    expect(updated!.name).toBe("Updated");
+    expect(updated!.clientSecret).toBe("secret"); // unchanged
+  });
+
+  it("updates secret when provided", () => {
+    const created = service.create({
+      name: "Test",
+      issuerUrl: "https://auth.example.com",
+      clientId: "cid",
+      clientSecret: "old-secret",
+    });
+    const updated = service.update(created.id, { clientSecret: "new-secret" });
+    expect(updated!.clientSecret).toBe("new-secret");
+  });
+
+  it("deletes provider", () => {
+    const created = service.create({
+      name: "Test",
+      issuerUrl: "https://auth.example.com",
+      clientId: "cid",
+      clientSecret: "secret",
+    });
+    const deleted = service.delete(created.id);
+    expect(deleted).toBe(true);
+    expect(service.get(created.id)).toBeNull();
+  });
+
+  it("lists only enabled providers for public", () => {
+    service.create({ name: "P1", issuerUrl: "https://a.com", clientId: "c1", clientSecret: "s1", enabled: true });
+    service.create({ name: "P2", issuerUrl: "https://b.com", clientId: "c2", clientSecret: "s2", enabled: false });
+    const enabled = service.listEnabled();
+    expect(enabled).toHaveLength(1);
+    expect(enabled[0].name).toBe("P1");
+  });
+});
+
+describe("UserService", () => {
+  let db: Database.Database;
+  let service: UserService;
+
+  beforeEach(() => {
+    db = new Database(":memory:");
+    db.exec(`
+      CREATE TABLE users (
+        id TEXT PRIMARY KEY, username TEXT UNIQUE, display_name TEXT,
+        avatar_url TEXT, role TEXT DEFAULT 'user', provider TEXT DEFAULT 'local',
+        oidc_sub TEXT, oidc_provider_id TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+    `);
+    service = new UserService(db, console as any);
+  });
+
+  it("creates and retrieves a user", () => {
+    const { user, created } = service.findOrCreateFromOidc(
+      { sub: "sub123", preferred_username: "jdoe", name: "John Doe" },
+      "provider-1",
+      "user",
+    );
+    expect(created).toBe(true);
+    expect(user.username).toBe("jdoe");
+    expect(user.displayName).toBe("John Doe");
+    expect(user.role).toBe("user");
+    expect(user.provider).toBe("oidc");
+  });
+
+  it("finds existing user by OIDC sub", () => {
+    const { user: u1 } = service.findOrCreateFromOidc(
+      { sub: "sub456", preferred_username: "alice" },
+      "provider-1",
+      "user",
+    );
+    const { user: u2, created } = service.findOrCreateFromOidc(
+      { sub: "sub456", preferred_username: "alice_new", name: "Alice Smith" },
+      "provider-1",
+      "user",
+    );
+    expect(created).toBe(false);
+    expect(u2.id).toBe(u1.id);
+    expect(u2.displayName).toBe("Alice Smith"); // updated
+  });
+
+  it("changes user role", () => {
+    const { user } = service.findOrCreateFromOidc(
+      { sub: "s1", preferred_username: "user1" },
+      "p1",
+      "user",
+    );
+    const updated = service.setRole(user.id, "admin");
+    expect(updated!.role).toBe("admin");
+  });
+
+  it("prevents duplicate usernames", () => {
+    service.findOrCreateFromOidc(
+      { sub: "s1", preferred_username: "sameuser" },
+      "p1",
+      "user",
+    );
+    const { user } = service.findOrCreateFromOidc(
+      { sub: "s2", preferred_username: "sameuser" },
+      "p2",
+      "user",
+    );
+    expect(user.username).toMatch(/^sameuser_\d+$/);
+  });
+
+  it("lists all users", () => {
+    service.findOrCreateFromOidc({ sub: "a", preferred_username: "A" }, "p1", "user");
+    service.findOrCreateFromOidc({ sub: "b", preferred_username: "B" }, "p1", "user");
+    expect(service.list()).toHaveLength(2);
+  });
+
+  it("resolves user by id or username", () => {
+    const { user } = service.findOrCreateFromOidc(
+      { sub: "s1", preferred_username: "resolve-me" },
+      "p1", "user",
+    );
+    expect(service.resolveUser(user.id)!.username).toBe("resolve-me");
+    expect(service.resolveUser("resolve-me")!.username).toBe("resolve-me");
+  });
+
+  it("counts admin users", () => {
+    // Insert a local admin
+    db.prepare(`INSERT INTO users (id, username, display_name, role, provider) VALUES ('admin', 'admin', 'Admin', 'admin', 'local')`).run();
+    expect(service.countAdmins()).toBe(1);
+
+    // Add an OIDC admin
+    const { user } = service.findOrCreateFromOidc(
+      { sub: "s1", preferred_username: "admin2" },
+      "p1", "admin",
+    );
+    expect(service.countAdmins()).toBe(2);
+  });
+
+  it("prevents demoting the last admin", () => {
+    // Insert a non-built-in admin user
+    db.prepare(`INSERT INTO users (id, username, display_name, role, provider) VALUES ('user-1', 'admin1', 'Admin One', 'admin', 'local')`).run();
+
+    expect(() => service.setRole("user-1", "user")).toThrow("last admin");
+
+    // Add a second admin, then demoting the first should now work
+    service.findOrCreateFromOidc({ sub: "s1", preferred_username: "admin2" }, "p1", "admin");
+    const updated = service.setRole("user-1", "user");
+    expect(updated!.role).toBe("user");
+  });
+
+  it("prevents demoting the built-in admin account", () => {
+    // The built-in admin has id="admin" — simulate this by inserting one
+    db.prepare(`INSERT INTO users (id, username, display_name, role, provider) VALUES ('admin', 'admin', 'Admin', 'admin', 'local')`).run();
+    // Add a second admin so we're not the last
+    service.findOrCreateFromOidc({ sub: "s2", preferred_username: "other" }, "p1", "admin");
+
+    expect(() => service.setRole("admin", "user")).toThrow("built-in admin");
+  });
+});