Resolved merge conflict

.claude/settings.local.json

···
     "ask": []
   },
   "enableAllProjectMcpServers": true,
-  "enabledMcpjsonServers": [
-    "git-mcp-server"
-  ]
+  "enabledMcpjsonServers": ["git-mcp-server"]
 }

src/rules/handles/constants.example.ts

···
-import type { Checks } from "../../types.js";
-
-/**
- * Example handle check configurations
- *
- * This file demonstrates how to configure handle-based moderation rules.
- * Copy this file to constants.ts and customize for your labeler's needs.
- *
- * Each check can match against handles, display names, and/or descriptions
- * based on the flags you set (description: true, displayName: true).
- */
-
-export const HANDLE_CHECKS: Checks[] = [
-  // Example 1: Simple pattern matching with whitelist
-  {
-    label: "spam-indicator",
-    comment: "Handle matches common spam patterns",
-    reportAcct: false,
-    commentAcct: false,
-    toLabel: true,
-    check: new RegExp(
-      "follow.*?back|gain.*?followers|crypto.*?giveaway|free.*?money",
-      "i",
-    ),
-    whitelist: new RegExp("legitimate.*?business", "i"),
-  },
-
-  // Example 2: Check specific domain patterns
-  {
-    label: "suspicious-domain",
-    comment: "Handle uses suspicious domain pattern",
-    reportAcct: false,
-    commentAcct: false,
-    toLabel: true,
-    check: new RegExp("(?:suspicious-site\\.example)", "i"),
-  },
-
-  // Example 3: Check with display name and description matching
-  {
-    label: "potential-impersonator",
-    comment: "Account may be impersonating verified entities",
-    description: true,
-    displayName: true,
-    reportAcct: false,
-    commentAcct: false,
-    toLabel: true,
-    check: new RegExp(
-      "official.*?support|customer.*?service.*?rep|verified.*?account",
-      "i",
-    ),
-    // Exclude accounts that are actually legitimate
-    ignoredDIDs: [
-      "did:plc:example123", // Real customer support account
-      "did:plc:example456", // Verified business account
-    ],
-  },
-
-  // Example 4: Pattern with specific character variations
-  {
-    label: "suspicious-pattern",
-    comment: "Handle contains suspicious character patterns",
-    reportAcct: false,
-    commentAcct: false,
-    toLabel: true,
-    check: new RegExp("[a-z]{2,}[0-9]{6,}|random.*?numbers.*?[0-9]{4,}", "i"),
-    whitelist: new RegExp("year[0-9]{4}", "i"),
-    ignoredDIDs: [
-      "did:plc:example789", // Legitimate account with number pattern
-    ],
-  },
-
-  // Example 5: Brand protection
-  {
-    label: "brand-impersonation",
-    comment: "Potential brand impersonation detected",
-    reportAcct: false,
-    commentAcct: false,
-    toLabel: true,
-    check: new RegExp("example-?brand|cool-?company|awesome-?corp", "i"),
-    whitelist: new RegExp(
-      "anti-example-brand|not-cool-company|parody.*awesome-corp",
-      "i",
-    ),
-    ignoredDIDs: [
-      "did:plc:exampleabc", // Official brand account
-      "did:plc:exampledef", // Authorized partner
-    ],
-  },
-];

src/rules/posts/constants.example.ts

···
-import type { Checks } from "../../types.js";
-
-export const LINK_SHORTENER = /bit\.ly|tinyurl\.com|ow\.ly/i;
-
-export const POST_CHECKS: Checks[] = [
-  // Example 1: Spam detection
-  {
-    label: "spam",
-    comment: "Post contains spam indicators",
-    reportPost: true,
-    reportAcct: false,
-    commentAcct: false,
-    toLabel: true,
-    check: new RegExp(
-      "click.*?here|limited.*?time.*?offer|act.*?now|100%.*?free",
-      "i",
-    ),
-    whitelist: new RegExp("legitimate.*?offer", "i"),
-  },
-
-  // Example 2: Promotional content
-  {
-    label: "promotional",
-    comment: "Promotional content detected",
-    reportPost: false,
-    reportAcct: false,
-    commentAcct: false,
-    toLabel: true,
-    check: new RegExp("buy.*?now|discount.*?code|promo.*?link", "i"),
-  },
-];

src/rules/profiles/constants.example.ts

···
-import type { Checks } from "../../types.js";
-
-/**
- * Example profile check configurations
- *
- * This file demonstrates how to configure profile moderation rules.
- * Copy this file to constants.ts and customize for your labeler's needs.
- *
- * Profile checks can match against display names and/or descriptions.
- */
-
-export const PROFILE_CHECKS: Checks[] = [
-  // Example 1: Suspicious bio patterns
-  {
-    label: "suspicious-bio",
-    comment: "Profile contains suspicious patterns",
-    description: true,
-    displayName: false,
-    reportAcct: false,
-    commentAcct: false,
-    toLabel: true,
-    check: new RegExp(
-      "dm.*?for.*?promo|follow.*?for.*?follow|gain.*?followers",
-      "i",
-    ),
-  },
-
-  // Example 2: Display name checks
-  {
-    label: "impersonation-risk",
-    comment: "Display name may indicate impersonation",
-    description: false,
-    displayName: true,
-    reportAcct: false,
-    commentAcct: false,
-    toLabel: true,
-    check: new RegExp("official|verified|admin|support", "i"),
-    whitelist: new RegExp("unofficial|parody|fan", "i"),
-    ignoredDIDs: [
-      "did:plc:example123", // Actual official account
-    ],
-  },
-
-  // Example 3: Both display name and description
-  {
-    label: "crypto-spam",
-    comment: "Profile suggests crypto spam activity",
-    description: true,
-    displayName: true,
-    reportAcct: false,
-    commentAcct: false,
-    toLabel: true,
-    check: new RegExp("crypto.*?giveaway|nft.*?drop|airdrop", "i"),
-  },
-];

src/tests/session.test.ts

···
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import {
+  existsSync,
+  mkdirSync,
+  rmSync,
+  writeFileSync,
+  readFileSync,
+  unlinkSync,
+  chmodSync,
+} from "node:fs";
+import { join } from "node:path";
+import type { SessionData } from "../session.js";
+
+const TEST_DIR = join(process.cwd(), ".test-session");
+const TEST_SESSION_PATH = join(TEST_DIR, ".session");
+
+// Helper functions that mimic session.ts but use TEST_SESSION_PATH
+function testLoadSession(): SessionData | null {
+  try {
+    if (!existsSync(TEST_SESSION_PATH)) {
+      return null;
+    }
+
+    const data = readFileSync(TEST_SESSION_PATH, "utf-8");
+    const session = JSON.parse(data) as SessionData;
+
+    if (!session.accessJwt || !session.refreshJwt || !session.did) {
+      return null;
+    }
+
+    return session;
+  } catch (error) {
+    return null;
+  }
+}
+
+function testSaveSession(session: SessionData): void {
+  try {
+    const data = JSON.stringify(session, null, 2);
+    writeFileSync(TEST_SESSION_PATH, data, "utf-8");
+    chmodSync(TEST_SESSION_PATH, 0o600);
+  } catch (error) {
+    // Ignore errors for test
+  }
+}
+
+function testClearSession(): void {
+  try {
+    if (existsSync(TEST_SESSION_PATH)) {
+      unlinkSync(TEST_SESSION_PATH);
+    }
+  } catch (error) {
+    // Ignore errors for test
+  }
+}
+
+describe("session", () => {
+  beforeEach(() => {
+    // Create test directory
+    if (!existsSync(TEST_DIR)) {
+      mkdirSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe("saveSession", () => {
+    it("should save session to file with proper permissions", () => {
+      const session: SessionData = {
+        accessJwt: "access-token",
+        refreshJwt: "refresh-token",
+        did: "did:plc:test123",
+        handle: "test.bsky.social",
+        active: true,
+      };
+
+      testSaveSession(session);
+
+      expect(existsSync(TEST_SESSION_PATH)).toBe(true);
+    });
+
+    it("should save all session fields correctly", () => {
+      const session: SessionData = {
+        accessJwt: "access-token",
+        refreshJwt: "refresh-token",
+        did: "did:plc:test123",
+        handle: "test.bsky.social",
+        email: "[e-mail]",
+        emailConfirmed: true,
+        emailAuthFactor: false,
+        active: true,
+        status: "active",
+      };
+
+      testSaveSession(session);
+
+      const loaded = testLoadSession();
+      expect(loaded).toEqual(session);
+    });
+  });
+
+  describe("loadSession", () => {
+    it("should return null if session file does not exist", () => {
+      const session = testLoadSession();
+      expect(session).toBeNull();
+    });
+
+    it("should load valid session from file", () => {
+      const session: SessionData = {
+        accessJwt: "access-token",
+        refreshJwt: "refresh-token",
+        did: "did:plc:test123",
+        handle: "test.bsky.social",
+        active: true,
+      };
+
+      testSaveSession(session);
+      const loaded = testLoadSession();
+
+      expect(loaded).toEqual(session);
+    });
+
+    it("should return null for corrupted session file", () => {
+      writeFileSync(TEST_SESSION_PATH, "{ invalid json", "utf-8");
+
+      const session = testLoadSession();
+      expect(session).toBeNull();
+    });
+
+    it("should return null for session missing required fields", () => {
+      writeFileSync(
+        TEST_SESSION_PATH,
+        JSON.stringify({ accessJwt: "token" }),
+        "utf-8"
+      );
+
+      const session = testLoadSession();
+      expect(session).toBeNull();
+    });
+
+    it("should return null for session missing did", () => {
+      writeFileSync(
+        TEST_SESSION_PATH,
+        JSON.stringify({
+          accessJwt: "access",
+          refreshJwt: "refresh",
+          handle: "test.bsky.social",
+        }),
+        "utf-8"
+      );
+
+      const session = testLoadSession();
+      expect(session).toBeNull();
+    });
+  });
+
+  describe("clearSession", () => {
+    it("should remove session file if it exists", () => {
+      const session: SessionData = {
+        accessJwt: "access-token",
+        refreshJwt: "refresh-token",
+        did: "did:plc:test123",
+        handle: "test.bsky.social",
+        active: true,
+      };
+
+      testSaveSession(session);
+      expect(existsSync(TEST_SESSION_PATH)).toBe(true);
+
+      testClearSession();
+      expect(existsSync(TEST_SESSION_PATH)).toBe(false);
+    });
+
+    it("should not throw if session file does not exist", () => {
+      expect(() => testClearSession()).not.toThrow();
+    });
+  });
+});