@kodelyth/nostr 2026.5.42 → 2026.6.2

package/src/nostr-state-store.test.ts

@@ -1,237 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { describe, expect, it } from "vitest";
-import type { PluginRuntime } from "../runtime-api.js";
-import {
-  readNostrBusState,
-  readNostrProfileState,
-  writeNostrBusState,
-  writeNostrProfileState,
-  computeSinceTimestamp,
-} from "./nostr-state-store.js";
-import { setNostrRuntime } from "./runtime.js";
-
-async function withTempStateDir<T>(fn: (dir: string) => Promise<T>) {
-  const previous = process.env.KLAW_STATE_DIR;
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "klaw-nostr-"));
-  process.env.KLAW_STATE_DIR = dir;
-  setNostrRuntime({
-    state: {
-      resolveStateDir: (env, homedir) => {
-        const stateEnv = env ?? process.env;
-        const override = stateEnv.KLAW_STATE_DIR?.trim();
-        if (override) {
-          return override;
-        }
-        const resolveHome = homedir ?? os.homedir;
-        return path.join(resolveHome(), ".klaw");
-      },
-    },
-  } as PluginRuntime);
-  try {
-    return await fn(dir);
-  } finally {
-    if (previous === undefined) {
-      delete process.env.KLAW_STATE_DIR;
-    } else {
-      process.env.KLAW_STATE_DIR = previous;
-    }
-    await fs.rm(dir, { recursive: true, force: true });
-  }
-}
-
-describe("nostr bus state store", () => {
-  it("persists and reloads state across restarts", async () => {
-    await withTempStateDir(async () => {
-      // Fresh start - no state
-      expect(await readNostrBusState({ accountId: "test-bot" })).toBeNull();
-
-      // Write state
-      await writeNostrBusState({
-        accountId: "test-bot",
-        lastProcessedAt: 1700000000,
-        gatewayStartedAt: 1700000100,
-      });
-
-      // Read it back
-      const state = await readNostrBusState({ accountId: "test-bot" });
-      expect(state).toEqual({
-        version: 2,
-        lastProcessedAt: 1700000000,
-        gatewayStartedAt: 1700000100,
-        recentEventIds: [],
-      });
-    });
-  });
-
-  it("isolates state by accountId", async () => {
-    await withTempStateDir(async () => {
-      await writeNostrBusState({
-        accountId: "bot-a",
-        lastProcessedAt: 1000,
-        gatewayStartedAt: 1000,
-      });
-      await writeNostrBusState({
-        accountId: "bot-b",
-        lastProcessedAt: 2000,
-        gatewayStartedAt: 2000,
-      });
-
-      const stateA = await readNostrBusState({ accountId: "bot-a" });
-      const stateB = await readNostrBusState({ accountId: "bot-b" });
-
-      expect(stateA?.lastProcessedAt).toBe(1000);
-      expect(stateB?.lastProcessedAt).toBe(2000);
-    });
-  });
-
-  it("upgrades v1 bus state files on read", async () => {
-    await withTempStateDir(async (dir) => {
-      const filePath = path.join(dir, "nostr", "bus-state-test-bot.json");
-      await fs.mkdir(path.dirname(filePath), { recursive: true });
-      await fs.writeFile(
-        filePath,
-        JSON.stringify({
-          version: 1,
-          lastProcessedAt: 1700000000,
-          gatewayStartedAt: 1700000100,
-        }),
-        "utf-8",
-      );
-
-      const state = await readNostrBusState({ accountId: "test-bot" });
-      expect(state).toEqual({
-        version: 2,
-        lastProcessedAt: 1700000000,
-        gatewayStartedAt: 1700000100,
-        recentEventIds: [],
-      });
-    });
-  });
-
-  it("drops malformed recent event ids while keeping the state", async () => {
-    await withTempStateDir(async (dir) => {
-      const filePath = path.join(dir, "nostr", "bus-state-test-bot.json");
-      await fs.mkdir(path.dirname(filePath), { recursive: true });
-      await fs.writeFile(
-        filePath,
-        JSON.stringify({
-          version: 2,
-          lastProcessedAt: 1700000000,
-          gatewayStartedAt: 1700000100,
-          recentEventIds: ["evt-1", 2, null],
-        }),
-        "utf-8",
-      );
-
-      const state = await readNostrBusState({ accountId: "test-bot" });
-      expect(state).toEqual({
-        version: 2,
-        lastProcessedAt: 1700000000,
-        gatewayStartedAt: 1700000100,
-        recentEventIds: ["evt-1"],
-      });
-    });
-  });
-});
-
-describe("nostr profile state store", () => {
-  it("persists and reloads profile publish state", async () => {
-    await withTempStateDir(async () => {
-      await writeNostrProfileState({
-        accountId: "test-bot",
-        lastPublishedAt: 1700000000,
-        lastPublishedEventId: "evt-1",
-        lastPublishResults: {
-          "wss://relay.example": "ok",
-        },
-      });
-
-      const state = await readNostrProfileState({ accountId: "test-bot" });
-      expect(state).toEqual({
-        version: 1,
-        lastPublishedAt: 1700000000,
-        lastPublishedEventId: "evt-1",
-        lastPublishResults: {
-          "wss://relay.example": "ok",
-        },
-      });
-    });
-  });
-
-  it("drops malformed relay results while keeping valid state fields", async () => {
-    await withTempStateDir(async (dir) => {
-      const filePath = path.join(dir, "nostr", "profile-state-test-bot.json");
-      await fs.mkdir(path.dirname(filePath), { recursive: true });
-      await fs.writeFile(
-        filePath,
-        JSON.stringify({
-          version: 1,
-          lastPublishedAt: 1700000000,
-          lastPublishedEventId: "evt-1",
-          lastPublishResults: {
-            "wss://relay.example": "ok",
-            "wss://relay.bad": "unknown",
-          },
-        }),
-        "utf-8",
-      );
-
-      const state = await readNostrProfileState({ accountId: "test-bot" });
-      expect(state).toEqual({
-        version: 1,
-        lastPublishedAt: 1700000000,
-        lastPublishedEventId: "evt-1",
-        lastPublishResults: null,
-      });
-    });
-  });
-});
-
-describe("computeSinceTimestamp", () => {
-  it("returns now for null state (fresh start)", () => {
-    const now = 1700000000;
-    expect(computeSinceTimestamp(null, now)).toBe(now);
-  });
-
-  it("uses lastProcessedAt when available", () => {
-    const state: Parameters<typeof computeSinceTimestamp>[0] = {
-      version: 2,
-      lastProcessedAt: 1699999000,
-      gatewayStartedAt: null,
-      recentEventIds: [],
-    };
-    expect(computeSinceTimestamp(state, 1700000000)).toBe(1699999000);
-  });
-
-  it("uses gatewayStartedAt when lastProcessedAt is null", () => {
-    const state: Parameters<typeof computeSinceTimestamp>[0] = {
-      version: 2,
-      lastProcessedAt: null,
-      gatewayStartedAt: 1699998000,
-      recentEventIds: [],
-    };
-    expect(computeSinceTimestamp(state, 1700000000)).toBe(1699998000);
-  });
-
-  it("uses the max of both timestamps", () => {
-    const state: Parameters<typeof computeSinceTimestamp>[0] = {
-      version: 2,
-      lastProcessedAt: 1699999000,
-      gatewayStartedAt: 1699998000,
-      recentEventIds: [],
-    };
-    expect(computeSinceTimestamp(state, 1700000000)).toBe(1699999000);
-  });
-
-  it("falls back to now if both are null", () => {
-    const state: Parameters<typeof computeSinceTimestamp>[0] = {
-      version: 2,
-      lastProcessedAt: null,
-      gatewayStartedAt: null,
-      recentEventIds: [],
-    };
-    expect(computeSinceTimestamp(state, 1700000000)).toBe(1700000000);
-  });
-});

package/src/nostr-state-store.ts

@@ -1,206 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { safeParseJsonWithSchema } from "klaw/plugin-sdk/extension-shared";
-import { privateFileStore } from "klaw/plugin-sdk/security-runtime";
-import { z } from "zod";
-import { getNostrRuntime } from "./runtime.js";
-
-const STORE_VERSION = 2;
-const PROFILE_STATE_VERSION = 1;
-
-type NostrBusState = {
-  version: 2;
-  /** Unix timestamp (seconds) of the last processed event */
-  lastProcessedAt: number | null;
-  /** Gateway startup timestamp (seconds) - events before this are old */
-  gatewayStartedAt: number | null;
-  /** Recent processed event IDs for overlap dedupe across restarts */
-  recentEventIds: string[];
-};
-
-/** Profile publish state (separate from bus state) */
-type NostrProfileState = {
-  version: 1;
-  /** Unix timestamp (seconds) of last successful profile publish */
-  lastPublishedAt: number | null;
-  /** Event ID of the last published profile */
-  lastPublishedEventId: string | null;
-  /** Per-relay publish results from last attempt */
-  lastPublishResults: Record<string, "ok" | "failed" | "timeout"> | null;
-};
-
-const NullableFiniteNumberSchema = z.number().finite().nullable().catch(null);
-const NostrBusStateV1Schema = z.object({
-  version: z.literal(1),
-  lastProcessedAt: NullableFiniteNumberSchema,
-  gatewayStartedAt: NullableFiniteNumberSchema,
-});
-
-const NostrBusStateSchema = z.object({
-  version: z.literal(2),
-  lastProcessedAt: NullableFiniteNumberSchema,
-  gatewayStartedAt: NullableFiniteNumberSchema,
-  recentEventIds: z
-    .array(z.unknown())
-    .catch([])
-    .transform((ids) => ids.filter((id): id is string => typeof id === "string")),
-});
-
-const NostrProfileStateSchema = z.object({
-  version: z.literal(1),
-  lastPublishedAt: NullableFiniteNumberSchema,
-  lastPublishedEventId: z.string().nullable().catch(null),
-  lastPublishResults: z
-    .record(z.string(), z.enum(["ok", "failed", "timeout"]))
-    .nullable()
-    .catch(null),
-});
-
-function normalizeAccountId(accountId?: string): string {
-  const trimmed = accountId?.trim();
-  if (!trimmed) {
-    return "default";
-  }
-  return trimmed.replace(/[^a-z0-9._-]+/gi, "_");
-}
-
-function resolveNostrStatePath(accountId?: string, env: NodeJS.ProcessEnv = process.env): string {
-  const stateDir = getNostrRuntime().state.resolveStateDir(env, os.homedir);
-  const normalized = normalizeAccountId(accountId);
-  return path.join(stateDir, "nostr", `bus-state-${normalized}.json`);
-}
-
-function resolveNostrProfileStatePath(
-  accountId?: string,
-  env: NodeJS.ProcessEnv = process.env,
-): string {
-  const stateDir = getNostrRuntime().state.resolveStateDir(env, os.homedir);
-  const normalized = normalizeAccountId(accountId);
-  return path.join(stateDir, "nostr", `profile-state-${normalized}.json`);
-}
-
-function safeParseState(raw: string): NostrBusState | null {
-  const parsedV2 = safeParseJsonWithSchema(NostrBusStateSchema, raw);
-  if (parsedV2) {
-    return parsedV2;
-  }
-
-  const parsedV1 = safeParseJsonWithSchema(NostrBusStateV1Schema, raw);
-  if (!parsedV1) {
-    return null;
-  }
-
-  // Back-compat: v1 state files
-  return {
-    version: 2,
-    lastProcessedAt: parsedV1.lastProcessedAt,
-    gatewayStartedAt: parsedV1.gatewayStartedAt,
-    recentEventIds: [],
-  };
-}
-
-export async function readNostrBusState(params: {
-  accountId?: string;
-  env?: NodeJS.ProcessEnv;
-}): Promise<NostrBusState | null> {
-  const filePath = resolveNostrStatePath(params.accountId, params.env);
-  try {
-    const raw = await privateFileStore(path.dirname(filePath)).readTextIfExists(
-      path.basename(filePath),
-    );
-    if (raw === null) {
-      return null;
-    }
-    return safeParseState(raw);
-  } catch {
-    return null;
-  }
-}
-
-export async function writeNostrBusState(params: {
-  accountId?: string;
-  lastProcessedAt: number;
-  gatewayStartedAt: number;
-  recentEventIds?: string[];
-  env?: NodeJS.ProcessEnv;
-}): Promise<void> {
-  const filePath = resolveNostrStatePath(params.accountId, params.env);
-  const payload: NostrBusState = {
-    version: STORE_VERSION,
-    lastProcessedAt: params.lastProcessedAt,
-    gatewayStartedAt: params.gatewayStartedAt,
-    recentEventIds: (params.recentEventIds ?? []).filter((x): x is string => typeof x === "string"),
-  };
-  await privateFileStore(path.dirname(filePath)).writeJson(path.basename(filePath), payload, {
-    trailingNewline: true,
-  });
-}
-
-/**
- * Determine the `since` timestamp for subscription.
- * Returns the later of: lastProcessedAt or gatewayStartedAt (both from disk),
- * falling back to `now` for fresh starts.
- */
-export function computeSinceTimestamp(
-  state: NostrBusState | null,
-  nowSec: number = Math.floor(Date.now() / 1000),
-): number {
-  if (!state) {
-    return nowSec;
-  }
-
-  // Use the most recent timestamp we have
-  const candidates = [state.lastProcessedAt, state.gatewayStartedAt].filter(
-    (t): t is number => t !== null && t > 0,
-  );
-
-  if (candidates.length === 0) {
-    return nowSec;
-  }
-  return Math.max(...candidates);
-}
-
-// ============================================================================
-// Profile State Management
-// ============================================================================
-
-function safeParseProfileState(raw: string): NostrProfileState | null {
-  return safeParseJsonWithSchema(NostrProfileStateSchema, raw);
-}
-
-export async function readNostrProfileState(params: {
-  accountId?: string;
-  env?: NodeJS.ProcessEnv;
-}): Promise<NostrProfileState | null> {
-  const filePath = resolveNostrProfileStatePath(params.accountId, params.env);
-  try {
-    const raw = await privateFileStore(path.dirname(filePath)).readTextIfExists(
-      path.basename(filePath),
-    );
-    if (raw === null) {
-      return null;
-    }
-    return safeParseProfileState(raw);
-  } catch {
-    return null;
-  }
-}
-
-export async function writeNostrProfileState(params: {
-  accountId?: string;
-  lastPublishedAt: number;
-  lastPublishedEventId: string;
-  lastPublishResults: Record<string, "ok" | "failed" | "timeout">;
-  env?: NodeJS.ProcessEnv;
-}): Promise<void> {
-  const filePath = resolveNostrProfileStatePath(params.accountId, params.env);
-  const payload: NostrProfileState = {
-    version: PROFILE_STATE_VERSION,
-    lastPublishedAt: params.lastPublishedAt,
-    lastPublishedEventId: params.lastPublishedEventId,
-    lastPublishResults: params.lastPublishResults,
-  };
-  await privateFileStore(path.dirname(filePath)).writeJson(path.basename(filePath), payload, {
-    trailingNewline: true,
-  });
-}

package/src/runtime.ts

@@ -1,9 +0,0 @@
-import type { PluginRuntime } from "klaw/plugin-sdk/core";
-import { createPluginRuntimeStore } from "klaw/plugin-sdk/runtime-store";
-
-const { setRuntime: setNostrRuntime, getRuntime: getNostrRuntime } =
-  createPluginRuntimeStore<PluginRuntime>({
-    pluginId: "nostr",
-    errorMessage: "Nostr runtime not initialized",
-  });
-export { getNostrRuntime, setNostrRuntime };