@nightkatana/kronosys-app 1.0.0-beta.0

package/server/payloadStore.test.ts

@@ -0,0 +1,78 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { resetSqliteConnection } from "@/server/db";
+import { readPayload, writePayload } from "@/server/payloadStore";
+
+describe("payloadStore (intégration SQLite)", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "kronosys-payload-"));
+    process.env.TRACE_DATA_DIR = tmpDir;
+    resetSqliteConnection();
+  });
+
+  afterEach(() => {
+    resetSqliteConnection();
+    delete process.env.TRACE_DATA_DIR;
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("readPayload retourne un payload initial valide sur base vierge", () => {
+    const p = readPayload();
+    expect(p.viewType).toBe("dashboard");
+    expect(Array.isArray(p.history)).toBe(true);
+    expect(p.cfg).toBeDefined();
+    expect(p.dashboardDataOrigin).toBe("local_next");
+  });
+
+  it("writePayload puis readPayload retourne les mêmes données", () => {
+    const initial = readPayload();
+    const modified = { ...initial, knownTags: ["dev", "design"] };
+    writePayload(modified);
+    const back = readPayload();
+    expect(back.knownTags).toEqual(["dev", "design"]);
+  });
+
+  it("writePayload est idempotent (INSERT OR REPLACE)", () => {
+    const p = readPayload();
+    writePayload(p);
+    writePayload(p);
+    const back = readPayload();
+    expect(back.viewType).toBe("dashboard");
+  });
+
+  it("readPayload retourne un payload initial si la valeur stockée est du JSON invalide", async () => {
+    // Écrire manuellement du JSON corrompu dans la DB
+    const { getSqlite } = await import("@/server/db");
+    const db = getSqlite();
+    db.exec(`CREATE TABLE IF NOT EXISTS kv_store (k TEXT PRIMARY KEY NOT NULL, v TEXT NOT NULL);`);
+    db.prepare("INSERT OR REPLACE INTO kv_store (k, v) VALUES (?, ?)").run(
+      "dashboard_payload_v1",
+      "{ invalide json [[["
+    );
+    const recovered = readPayload();
+    expect(recovered.viewType).toBe("dashboard");
+  });
+
+  it("readPayload fusionne les défauts cfg si une clé est manquante dans le payload stocké", () => {
+    const p = readPayload();
+    // Supprimer une clé du cfg et réécrire
+    const cfg = { ...p.cfg } as Record<string, unknown>;
+    delete cfg["taskDefaultTagBucketEnabled"];
+    writePayload({ ...p, cfg });
+    const back = readPayload();
+    // Le defaultCfg doit remettre la clé manquante
+    expect(back.cfg).toHaveProperty("taskDefaultTagBucketEnabled");
+  });
+
+  it("knownProjects et knownTags sont des tableaux après lecture initiale", () => {
+    const p = readPayload();
+    expect(Array.isArray(p.knownProjects)).toBe(true);
+    expect(Array.isArray(p.knownTags)).toBe(true);
+  });
+});

package/server/payloadStore.ts

@@ -0,0 +1,83 @@
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+import { readUseProductionDataInDevelopmentFromFile } from "@/lib/devDataPreferenceFile";
+import { migrateLegacyPayloadRecord } from "@/lib/legacyEditorPayloadKeys";
+
+import { defaultKronosysCfg } from "./defaultCfg";
+import { getSqlite } from "./db";
+import { hydrateKronoFocusInPayload } from "./kronoFocusHydrate";
+import { migrateLegacyKronoFocusPayload } from "./kronoFocusMigrate";
+import { materializeRunningMainTimersInPayload } from "./mainTimerHydrate";
+import { materializeSessionWallClockInPayload } from "./sessionWallHydrate";
+
+const PAYLOAD_KEY = "dashboard_payload_v1";
+
+function ensureTables(): void {
+  getSqlite().exec(`
+    CREATE TABLE IF NOT EXISTS kv_store (
+      k TEXT PRIMARY KEY NOT NULL,
+      v TEXT NOT NULL
+    );
+  `);
+}
+
+export function readPayload(): KronosysUpdatePayload {
+  ensureTables();
+  const row = getSqlite().prepare("SELECT v FROM kv_store WHERE k = ?").get(PAYLOAD_KEY) as { v: string } | undefined;
+  if (!row?.v) {
+    const initial = createInitialPayload();
+    writePayload(initial);
+    return initial;
+  }
+  try {
+    const parsed = JSON.parse(row.v) as KronosysUpdatePayload;
+    const cfg = { ...defaultKronosysCfg(), ...(typeof parsed.cfg === "object" && parsed.cfg ? parsed.cfg : {}) };
+    if (process.env.NODE_ENV === "development" && !process.env.TRACE_DATA_DIR?.trim()) {
+      (cfg as Record<string, unknown>).developmentUseProductionData =
+        readUseProductionDataInDevelopmentFromFile();
+    }
+    const merged = { ...parsed, cfg };
+    let legacyMigrated = migrateLegacyPayloadRecord(merged as Record<string, unknown>);
+    if (merged.cfg && typeof merged.cfg === "object") {
+      legacyMigrated = migrateLegacyPayloadRecord(merged.cfg as Record<string, unknown>) || legacyMigrated;
+    }
+    const migrated = migrateLegacyKronoFocusPayload(merged);
+    const hydrated = hydrateKronoFocusInPayload(merged);
+    const mainTimers = materializeRunningMainTimersInPayload(merged);
+    const sessionWall = materializeSessionWallClockInPayload(merged);
+    if (migrated || hydrated || mainTimers || sessionWall || legacyMigrated) {
+      writePayload(merged);
+    }
+    return merged;
+  } catch {
+    const initial = createInitialPayload();
+    writePayload(initial);
+    return initial;
+  }
+}
+
+export function writePayload(p: KronosysUpdatePayload): void {
+  ensureTables();
+  getSqlite().prepare("INSERT OR REPLACE INTO kv_store (k, v) VALUES (?, ?)").run(PAYLOAD_KEY, JSON.stringify(p));
+}
+
+function createInitialPayload(): KronosysUpdatePayload {
+  const cfg = { ...defaultKronosysCfg() } as Record<string, unknown>;
+  if (process.env.NODE_ENV === "development" && !process.env.TRACE_DATA_DIR?.trim()) {
+    cfg.developmentUseProductionData = readUseProductionDataInDevelopmentFromFile();
+  }
+  return {
+    viewType: "dashboard",
+    cfg,
+    history: [],
+    historyArchived: [] as unknown[],
+    inspectingSessionId: null,
+    knownTags: [],
+    knownProjects: [],
+    userKnownTags: [],
+    excludedSuggestionTags: [],
+    tagDescriptions: {},
+    projectDescriptions: {},
+    gitIdentity: {},
+    dashboardDataOrigin: "local_next",
+  };
+}

package/server/sessionWallHydrate.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+import { materializeSessionWallClockInPayload, SESSION_WALL_SEGMENT_STARTED_AT } from "./sessionWallHydrate";
+
+describe("materializeSessionWallClockInPayload", () => {
+  it("accumule la durée murale entre deux appels", () => {
+    const t0 = Date.UTC(2026, 2, 1, 8, 0, 0);
+    const cur = {
+      sessionId: "sid-1",
+      archived: false,
+      isPaused: false,
+      endAt: null,
+      sessionDurationMinutes: 0,
+      [SESSION_WALL_SEGMENT_STARTED_AT]: new Date(t0).toISOString(),
+    };
+    const p = {
+      viewType: "dashboard",
+      cfg: {},
+      current: cur,
+    } as unknown as KronosysUpdatePayload;
+
+    const t1 = t0 + 120_000;
+    const w1 = materializeSessionWallClockInPayload(p, t1);
+    expect(w1).toBe(true);
+    expect(cur.sessionDurationMinutes).toBeCloseTo(2, 5);
+
+    const t2 = t1 + 60_000;
+    const w2 = materializeSessionWallClockInPayload(p, t2);
+    expect(w2).toBe(true);
+    expect(cur.sessionDurationMinutes).toBeCloseTo(3, 5);
+  });
+
+  it("ne matérialise pas si la session est en pause", () => {
+    const cur = {
+      sessionId: "sid",
+      archived: false,
+      isPaused: true,
+      endAt: null,
+      sessionDurationMinutes: 1,
+      [SESSION_WALL_SEGMENT_STARTED_AT]: new Date().toISOString(),
+    };
+    const p = { viewType: "dashboard", cfg: {}, current: cur } as unknown as KronosysUpdatePayload;
+    expect(materializeSessionWallClockInPayload(p, Date.UTC(2026, 2, 1, 9, 0, 0))).toBe(false);
+    expect(cur.sessionDurationMinutes).toBe(1);
+  });
+});

package/server/sessionWallHydrate.ts

@@ -0,0 +1,88 @@
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+import { asRecord } from "./actionTaskSession";
+
+/** Horodatage ISO du segment de durée murale en cours (session live). */
+export const SESSION_WALL_SEGMENT_STARTED_AT = "sessionWallSegmentStartedAt";
+
+function liveSessionWallClockActive(cur: Record<string, unknown>): boolean {
+  const sid = typeof cur.sessionId === "string" ? cur.sessionId.trim() : "";
+  if (!sid) {
+    return false;
+  }
+  if (cur.archived === true) {
+    return false;
+  }
+  if (cur.isPaused === true) {
+    return false;
+  }
+  if (typeof cur.endAt === "string" && cur.endAt.trim() !== "") {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Consolide le segment de durée murale dans `sessionDurationMinutes` (minutes, valeur réelle)
+ * et retire l’horodatage de segment.
+ */
+export function flushSessionWallSegmentOnLive(cur: Record<string, unknown>): void {
+  const raw = cur[SESSION_WALL_SEGMENT_STARTED_AT];
+  if (typeof raw !== "string" || raw.trim() === "") {
+    return;
+  }
+  const startedMs = Date.parse(raw);
+  if (!Number.isFinite(startedMs)) {
+    delete cur[SESSION_WALL_SEGMENT_STARTED_AT];
+    return;
+  }
+  const elapsed = Math.max(0, Date.now() - startedMs);
+  const prevMin =
+    typeof cur.sessionDurationMinutes === "number" && Number.isFinite(cur.sessionDurationMinutes)
+      ? Number(cur.sessionDurationMinutes)
+      : 0;
+  cur.sessionDurationMinutes = prevMin + elapsed / 60000;
+  delete cur[SESSION_WALL_SEGMENT_STARTED_AT];
+}
+
+/** Démarre un segment de durée murale si la session est ouverte et non en pause. */
+export function ensureSessionWallSegmentOnLive(cur: Record<string, unknown>): void {
+  if (!liveSessionWallClockActive(cur)) {
+    return;
+  }
+  const raw = cur[SESSION_WALL_SEGMENT_STARTED_AT];
+  if (typeof raw === "string" && raw.trim() !== "") {
+    return;
+  }
+  cur[SESSION_WALL_SEGMENT_STARTED_AT] = new Date().toISOString();
+}
+
+/**
+ * Fait progresser `sessionDurationMinutes` à chaque lecture d’état (poll), même hors tableau de bord.
+ */
+export function materializeSessionWallClockInPayload(p: KronosysUpdatePayload, nowMs = Date.now()): boolean {
+  const cur = asRecord(p.current);
+  if (!cur || !liveSessionWallClockActive(cur)) {
+    return false;
+  }
+  const raw = cur[SESSION_WALL_SEGMENT_STARTED_AT];
+  if (typeof raw !== "string" || raw.trim() === "") {
+    cur[SESSION_WALL_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
+    return true;
+  }
+  const startedMs = Date.parse(raw);
+  if (!Number.isFinite(startedMs)) {
+    cur[SESSION_WALL_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
+    return true;
+  }
+  const elapsed = Math.max(0, nowMs - startedMs);
+  if (elapsed <= 0) {
+    return false;
+  }
+  const prevMin =
+    typeof cur.sessionDurationMinutes === "number" && Number.isFinite(cur.sessionDurationMinutes)
+      ? Number(cur.sessionDurationMinutes)
+      : 0;
+  cur.sessionDurationMinutes = prevMin + elapsed / 60000;
+  cur[SESSION_WALL_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
+  return true;
+}

package/tsconfig.json

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "ES2022"
+    ],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./*"
+      ]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}