@nightkatana/kronosys-app 1.0.0-beta.2 → 1.0.0-beta.21

package/server/mainTimerHydrate.ts

@@ -2,8 +2,11 @@ import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
 import {
   asRecord,
   ensureTaskParentDurationCoversSubtasksMs,
+  finishTaskInSession,
   forEachTaskRecordInSession,
   MAIN_TIMER_SEGMENT_STARTED_AT,
+  TASK_CURRENT_LAP_STARTED_AT,
+  TASK_SCHEDULED_END_AT,
 } from "./actionTaskSession";
 
 /**
@@ -16,6 +19,28 @@ export function materializeRunningMainTimersInPayload(p: KronosysUpdatePayload,
     return false;
   }
   let needWrite = false;
+
+  const scheduledFinishes: Array<{ taskId: string; endMs: number }> = [];
+  forEachTaskRecordInSession(cur, (task, taskId) => {
+    if (task.isDone === true) {
+      return;
+    }
+    const scheduledRaw =
+      typeof task[TASK_SCHEDULED_END_AT] === "string" ? String(task[TASK_SCHEDULED_END_AT]).trim() : "";
+    if (!scheduledRaw) {
+      return;
+    }
+    const scheduledMs = Date.parse(scheduledRaw);
+    if (Number.isFinite(scheduledMs) && scheduledMs <= nowMs) {
+      scheduledFinishes.push({ taskId, endMs: scheduledMs });
+    }
+  });
+  for (const { taskId, endMs } of scheduledFinishes) {
+    if (finishTaskInSession(cur, taskId, false, undefined, { completionInstantMs: endMs })) {
+      needWrite = true;
+    }
+  }
+
   forEachTaskRecordInSession(cur, (task) => {
     if (task.isDone === true) {
       return;
@@ -28,13 +53,21 @@ export function materializeRunningMainTimersInPayload(p: KronosysUpdatePayload,
     }
     const raw = task[MAIN_TIMER_SEGMENT_STARTED_AT];
     if (typeof raw !== "string" || raw.trim() === "") {
-      task[MAIN_TIMER_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
+      const nowIso = new Date(nowMs).toISOString();
+      task[MAIN_TIMER_SEGMENT_STARTED_AT] = nowIso;
+      if (typeof task[TASK_CURRENT_LAP_STARTED_AT] !== "string" || String(task[TASK_CURRENT_LAP_STARTED_AT]).trim() === "") {
+        task[TASK_CURRENT_LAP_STARTED_AT] = nowIso;
+      }
       needWrite = true;
       return;
     }
     const startedMs = Date.parse(raw);
     if (!Number.isFinite(startedMs)) {
-      task[MAIN_TIMER_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
+      const nowIso = new Date(nowMs).toISOString();
+      task[MAIN_TIMER_SEGMENT_STARTED_AT] = nowIso;
+      if (typeof task[TASK_CURRENT_LAP_STARTED_AT] !== "string" || String(task[TASK_CURRENT_LAP_STARTED_AT]).trim() === "") {
+        task[TASK_CURRENT_LAP_STARTED_AT] = nowIso;
+      }
       needWrite = true;
       return;
     }
@@ -46,6 +79,9 @@ export function materializeRunningMainTimersInPayload(p: KronosysUpdatePayload,
       typeof task.durationMs === "number" && Number.isFinite(task.durationMs) ? Number(task.durationMs) : 0;
     task.durationMs = Math.floor(parentPrev + elapsed);
     task[MAIN_TIMER_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
+    if (typeof task[TASK_CURRENT_LAP_STARTED_AT] !== "string" || String(task[TASK_CURRENT_LAP_STARTED_AT]).trim() === "") {
+      task[TASK_CURRENT_LAP_STARTED_AT] = new Date(nowMs - elapsed).toISOString();
+    }
     ensureTaskParentDurationCoversSubtasksMs(task);
     needWrite = true;
   });

package/server/payloadStore.ts

@@ -11,17 +11,7 @@ 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();
@@ -56,10 +46,41 @@ export function readPayload(): KronosysUpdatePayload {
 }
 
 export function writePayload(p: KronosysUpdatePayload): void {
-  ensureTables();
   getSqlite().prepare("INSERT OR REPLACE INTO kv_store (k, v) VALUES (?, ?)").run(PAYLOAD_KEY, JSON.stringify(p));
 }
 
+export function withPayloadWrite<T>(mutate: (payload: KronosysUpdatePayload) => T): T {
+  const db = getSqlite();
+  db.exec("BEGIN IMMEDIATE TRANSACTION;");
+  try {
+    const payload = readPayload();
+    const out = mutate(payload);
+    writePayload(payload);
+    db.exec("COMMIT;");
+    return out;
+  } catch (error) {
+    db.exec("ROLLBACK;");
+    throw error;
+  }
+}
+
+export async function withPayloadWriteAsync<T>(
+  mutate: (payload: KronosysUpdatePayload) => Promise<T>,
+): Promise<T> {
+  const db = getSqlite();
+  db.exec("BEGIN IMMEDIATE TRANSACTION;");
+  try {
+    const payload = readPayload();
+    const out = await mutate(payload);
+    writePayload(payload);
+    db.exec("COMMIT;");
+    return out;
+  } catch (error) {
+    db.exec("ROLLBACK;");
+    throw error;
+  }
+}
+
 function createInitialPayload(): KronosysUpdatePayload {
   const cfg = { ...defaultKronosysCfg() } as Record<string, unknown>;
   if (process.env.NODE_ENV === "development" && !process.env.TRACE_DATA_DIR?.trim()) {
@@ -73,6 +94,7 @@ function createInitialPayload(): KronosysUpdatePayload {
     inspectingSessionId: null,
     knownTags: [],
     knownProjects: [],
+    knownPersonalProjects: [],
     userKnownTags: [],
     excludedSuggestionTags: [],
     tagDescriptions: {},

package/server/sessionWallHydrate.ts

@@ -1,5 +1,11 @@
 import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
-import { asRecord } from "./actionTaskSession";
+import {
+  asRecord,
+  flushMainTimerSegmentOnTask,
+  flushSubtaskTimerOnTask,
+  forEachTaskRecordInSession,
+} from "./actionTaskSession";
+import { syncLiveIntoHistory } from "./liveHistorySync";
 
 /** Horodatage ISO du segment de durée murale en cours (session live). */
 export const SESSION_WALL_SEGMENT_STARTED_AT = "sessionWallSegmentStartedAt";
@@ -25,7 +31,10 @@ function liveSessionWallClockActive(cur: Record<string, unknown>): boolean {
  * 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 {
+export function flushSessionWallSegmentOnLive(
+  cur: Record<string, unknown>,
+  wallClockEndMs: number = Date.now(),
+): void {
   const raw = cur[SESSION_WALL_SEGMENT_STARTED_AT];
   if (typeof raw !== "string" || raw.trim() === "") {
     return;
@@ -35,7 +44,7 @@ export function flushSessionWallSegmentOnLive(cur: Record<string, unknown>): voi
     delete cur[SESSION_WALL_SEGMENT_STARTED_AT];
     return;
   }
-  const elapsed = Math.max(0, Date.now() - startedMs);
+  const elapsed = Math.max(0, wallClockEndMs - startedMs);
   const prevMin =
     typeof cur.sessionDurationMinutes === "number" && Number.isFinite(cur.sessionDurationMinutes)
       ? Number(cur.sessionDurationMinutes)
@@ -44,6 +53,52 @@ export function flushSessionWallSegmentOnLive(cur: Record<string, unknown>): voi
   delete cur[SESSION_WALL_SEGMENT_STARTED_AT];
 }
 
+/**
+ * Termine la session live à l’instant donné (mur consolidé jusqu’à ce moment, tâches ouvertes figées
+ * comme avec « fin de session » en mode conserver), archive l’instantané puis vide `current`.
+ */
+export function finalizeLiveSessionClosedAt(
+  p: KronosysUpdatePayload,
+  wallClockEndMs: number,
+): void {
+  const cur = asRecord(p.current);
+  if (!cur) {
+    return;
+  }
+  const sid = typeof cur.sessionId === "string" ? cur.sessionId.trim() : "";
+  if (!sid) {
+    return;
+  }
+  forEachTaskRecordInSession(cur, (task) => {
+    if (task.isDone === true) {
+      return;
+    }
+    flushSubtaskTimerOnTask(task);
+    flushMainTimerSegmentOnTask(task);
+    task.manualTaskTimerPaused = true;
+  });
+  flushSessionWallSegmentOnLive(cur, wallClockEndMs);
+  cur.endAt = new Date(wallClockEndMs).toISOString();
+  delete cur.scheduledEndAt;
+  delete cur.sessionEndReasonKind;
+  delete cur.sessionEndReasonNote;
+  syncLiveIntoHistory(p);
+  p.current = undefined;
+}
+
+/**
+ * Si la session live est en pause collecte (`isPaused`), reprend le suivi mural
+ * (utilisé quand l’utilisateur reprend une tâche ou démarre du travail).
+ */
+export function resumeLiveSessionWallIfPaused(cur: Record<string, unknown>): boolean {
+  if (cur.isPaused !== true) {
+    return false;
+  }
+  cur.isPaused = false;
+  ensureSessionWallSegmentOnLive(cur);
+  return true;
+}
+
 /** 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)) {
@@ -64,6 +119,14 @@ export function materializeSessionWallClockInPayload(p: KronosysUpdatePayload, n
   if (!cur || !liveSessionWallClockActive(cur)) {
     return false;
   }
+  const scheduledRaw = typeof cur.scheduledEndAt === "string" ? cur.scheduledEndAt.trim() : "";
+  if (scheduledRaw) {
+    const scheduledMs = Date.parse(scheduledRaw);
+    if (Number.isFinite(scheduledMs) && scheduledMs <= nowMs) {
+      finalizeLiveSessionClosedAt(p, scheduledMs);
+      return true;
+    }
+  }
   const raw = cur[SESSION_WALL_SEGMENT_STARTED_AT];
   if (typeof raw !== "string" || raw.trim() === "") {
     cur[SESSION_WALL_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();

package/server/userActionLog.ts

@@ -0,0 +1,126 @@
+import { getSqlite } from "./db";
+
+export type UserActionLogContext = {
+  sourceIp?: string | null;
+  userAgent?: string | null;
+};
+
+export type UserActionLogEntry = {
+  id: number;
+  createdAt: string;
+  actionType: string;
+  ok: boolean;
+  sourceIp: string | null;
+  userAgent: string | null;
+  sessionId: string | null;
+  payloadJson: string | null;
+};
+
+type LogUserActionInput = {
+  actionType: string;
+  ok: boolean;
+  body: Record<string, unknown>;
+  context?: UserActionLogContext;
+};
+
+function safeTrimmedString(v: unknown): string | null {
+  if (typeof v !== "string") {
+    return null;
+  }
+  const out = v.trim();
+  return out.length > 0 ? out : null;
+}
+
+function extractSessionId(body: Record<string, unknown>): string | null {
+  return safeTrimmedString(body.sessionId);
+}
+
+function sanitizePayload(body: Record<string, unknown>): string | null {
+  const clone: Record<string, unknown> = { ...body };
+  const sensitiveKeys = ["token", "password", "uri"];
+  for (const key of sensitiveKeys) {
+    if (key in clone && typeof clone[key] === "string" && String(clone[key]).trim().length > 0) {
+      clone[key] = "[REDACTED]";
+    }
+  }
+  try {
+    const raw = JSON.stringify(clone);
+    if (!raw) {
+      return null;
+    }
+    return raw.length > 4000 ? `${raw.slice(0, 4000)}…` : raw;
+  } catch {
+    return null;
+  }
+}
+
+export function logUserAction(input: LogUserActionInput): void {
+  const createdAt = new Date().toISOString();
+  const actionType = safeTrimmedString(input.actionType) ?? "unknown";
+  const sourceIp = safeTrimmedString(input.context?.sourceIp);
+  const userAgent = safeTrimmedString(input.context?.userAgent);
+  const sessionId = extractSessionId(input.body);
+  const payloadJson = sanitizePayload(input.body);
+  getSqlite()
+    .prepare(
+      `
+      INSERT INTO user_action_logs (
+        created_at,
+        action_type,
+        ok,
+        source_ip,
+        user_agent,
+        session_id,
+        payload_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `
+    )
+    .run(createdAt, actionType, input.ok ? 1 : 0, sourceIp, userAgent, sessionId, payloadJson);
+}
+
+export function readUserActionLogs(limit = 100, offset = 0): UserActionLogEntry[] {
+  const safeLimit = Math.min(500, Math.max(1, Math.floor(limit)));
+  const safeOffset = Math.max(0, Math.floor(offset));
+  const rows = getSqlite()
+    .prepare(
+      `
+      SELECT
+        id,
+        created_at,
+        action_type,
+        ok,
+        source_ip,
+        user_agent,
+        session_id,
+        payload_json
+      FROM user_action_logs
+      ORDER BY id DESC
+      LIMIT ? OFFSET ?
+      `
+    )
+    .all(safeLimit, safeOffset) as Array<{
+    id: number;
+    created_at: string;
+    action_type: string;
+    ok: number;
+    source_ip: string | null;
+    user_agent: string | null;
+    session_id: string | null;
+    payload_json: string | null;
+  }>;
+
+  return rows.map((row) => ({
+    id: row.id,
+    createdAt: row.created_at,
+    actionType: row.action_type,
+    ok: row.ok === 1,
+    sourceIp: row.source_ip,
+    userAgent: row.user_agent,
+    sessionId: row.session_id,
+    payloadJson: row.payload_json,
+  }));
+}
+
+export function clearUserActionLogs(): void {
+  getSqlite().prepare("DELETE FROM user_action_logs").run();
+}

package/sonar-project.properties

@@ -0,0 +1,11 @@
+sonar.projectKey=nightkatana_project-kronosys
+sonar.projectName=Kronosys
+sonar.sourceEncoding=UTF-8
+
+sonar.sources=app,components,lib,server
+sonar.tests=app,components,lib,server,test,e2e
+sonar.test.inclusions=**/*.test.ts,**/*.test.tsx,**/*.spec.ts,**/*.spec.tsx,test/**/*.ts,e2e/**/*.ts
+
+sonar.exclusions=.next/**,coverage/**,node_modules/**,playwright-report/**,test-results/**,public/**,**/*.config.*,**/*.test.ts,**/*.test.tsx,**/*.spec.ts,**/*.spec.tsx,next-env.d.ts
+sonar.coverage.exclusions=**/*.test.ts,**/*.test.tsx,**/*.spec.ts,**/*.spec.tsx,test/**,e2e/**,next-env.d.ts
+sonar.javascript.lcov.reportPaths=coverage/lcov.info

package/tsconfig.json

@@ -17,6 +17,7 @@
     "isolatedModules": true,
     "jsx": "react-jsx",
     "incremental": true,
+    "baseUrl": ".",
     "plugins": [
       {
         "name": "next"
@@ -38,4 +39,4 @@
   "exclude": [
     "node_modules"
   ]
-}
+}

package/components/dashboard/IssuePickerModal.tsx

@@ -1,168 +0,0 @@
-"use client";
-
-import { useCallback, useEffect, useRef, useState } from "react";
-import { Loader2, X } from "lucide-react";
-import type { DashboardStrings } from "@/lib/dashboardCopy";
-
-export type RemoteIssue = { title?: string; number: number | string; source?: string };
-
-const SEARCH_DEBOUNCE_MS = 350;
-const SEARCH_MIN_CHARS = 2;
-
-/** IID seul : le serveur utilise `iids[]` ; un seul chiffre suffit (ex. « 5 » ou « #12 »). */
-function issueSearchMinChars(trimmed: string): number {
-  const compact = trimmed.replace(/\s+/g, "");
-  return /^#?\d{1,10}$/.test(compact) ? 1 : SEARCH_MIN_CHARS;
-}
-
-export function IssuePickerModal({
-  t,
-  onClose,
-  onSelect,
-  fetchIssues,
-}: {
-  t: DashboardStrings;
-  onClose: () => void;
-  onSelect: (issue: RemoteIssue) => void;
-  fetchIssues: (query: string) => Promise<{ issues: RemoteIssue[]; error?: string }>;
-}) {
-  const [search, setSearch] = useState("");
-  const [results, setResults] = useState<RemoteIssue[]>([]);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<string | undefined>();
-  const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-  const requestSeq = useRef(0);
-
-  const runFetch = useCallback(
-    async (q: string) => {
-      const seq = ++requestSeq.current;
-      setError(undefined);
-      try {
-        const out = await fetchIssues(q);
-        if (seq !== requestSeq.current) {
-          return;
-        }
-        setResults(out.issues);
-        setError(out.error);
-      } catch (e) {
-        if (seq !== requestSeq.current) {
-          return;
-        }
-        setResults([]);
-        setError(e instanceof Error ? e.message : String(e));
-      } finally {
-        if (seq === requestSeq.current) {
-          setLoading(false);
-        }
-      }
-    },
-    [fetchIssues],
-  );
-
-  useEffect(() => {
-    if (debounceRef.current) {
-      clearTimeout(debounceRef.current);
-      debounceRef.current = null;
-    }
-    const q = search.trim();
-    if (q.length < issueSearchMinChars(q)) {
-      requestSeq.current += 1;
-      setResults([]);
-      setLoading(false);
-      setError(undefined);
-      return;
-    }
-    setLoading(true);
-    setError(undefined);
-    debounceRef.current = setTimeout(() => {
-      debounceRef.current = null;
-      void runFetch(q);
-    }, SEARCH_DEBOUNCE_MS);
-    return () => {
-      if (debounceRef.current) {
-        clearTimeout(debounceRef.current);
-        debounceRef.current = null;
-      }
-    };
-  }, [search, runFetch]);
-
-  const q = search.trim();
-  const ready = q.length >= issueSearchMinChars(q);
-
-  return (
-    <div
-      className="fixed inset-0 z-50 flex items-center justify-center bg-black/70 p-4"
-      role="dialog"
-      aria-modal="true"
-      aria-labelledby="issue-picker-title"
-      onClick={onClose}
-    >
-      <div
-        className="flex max-h-[80vh] w-full max-w-md flex-col overflow-hidden rounded-xl border border-zinc-200 bg-white shadow-xl dark:border-zinc-700 dark:bg-zinc-900"
-        onClick={(e) => e.stopPropagation()}
-      >
-        <div className="flex shrink-0 items-center justify-between border-b border-zinc-200 px-4 py-3 dark:border-zinc-800">
-          <h3 id="issue-picker-title" className="font-semibold text-zinc-900 dark:text-zinc-100">
-            {t.selectIssue}
-          </h3>
-          <button
-            type="button"
-            className="rounded p-1 text-zinc-500 hover:bg-zinc-200 hover:text-zinc-900 dark:text-zinc-400 dark:hover:bg-zinc-800 dark:hover:text-zinc-200"
-            aria-label={t.issuePickerCloseAria}
-            onClick={onClose}
-          >
-            <X size={20} aria-hidden />
-          </button>
-        </div>
-        <div className="shrink-0 border-b border-zinc-200 dark:border-zinc-800">
-          <input
-            className="w-full bg-white px-4 py-2.5 text-sm text-zinc-900 outline-none placeholder:text-zinc-400 focus:ring-2 focus:ring-violet-500/40 dark:bg-zinc-950 dark:text-zinc-100 dark:placeholder:text-zinc-500"
-            placeholder={t.issuePickerSearchPlaceholder}
-            value={search}
-            onChange={(e) => setSearch(e.target.value)}
-            autoFocus
-            aria-label={t.issuePickerSearchPlaceholder}
-          />
-        </div>
-        <div className="min-h-0 flex-1 overflow-y-auto">
-          {loading ? (
-            <div className="flex items-center justify-center gap-2 px-4 py-10 text-sm text-zinc-600 dark:text-zinc-400">
-              <Loader2 className="h-4 w-4 shrink-0 animate-spin" aria-hidden />
-              <span>{t.issuePickerLoading}</span>
-            </div>
-          ) : error ? (
-            <div className="px-4 py-6 text-center text-sm text-red-600 dark:text-red-400">{error}</div>
-          ) : !ready ? (
-            <div className="px-4 py-6 text-center text-sm text-zinc-600 dark:text-zinc-500">
-              {t.issuePickerSearchMinHint}
-            </div>
-          ) : results.length === 0 ? (
-            <div className="px-4 py-6 text-center text-sm text-zinc-600 dark:text-zinc-500">
-              {t.issuePickerNoResults}
-            </div>
-          ) : (
-            <ul className="divide-y divide-zinc-200 dark:divide-zinc-800">
-              {results.map((issue, idx) => (
-                <li key={`${String(issue.source)}-${String(issue.number)}-${idx}`}>
-                  <button
-                    type="button"
-                    className="w-full px-4 py-3 text-left text-sm hover:bg-zinc-100/90 dark:hover:bg-zinc-800/60"
-                    onClick={() => onSelect(issue)}
-                  >
-                    <div className="font-medium text-zinc-900 dark:text-zinc-200">{issue.title}</div>
-                    <div className="mt-1 flex flex-wrap gap-2 text-xs text-zinc-600 dark:text-zinc-500">
-                      {issue.source ? (
-                        <span className="rounded bg-zinc-200 px-1.5 py-0.5 dark:bg-zinc-800">{issue.source}</span>
-                      ) : null}
-                      <span>#{issue.number}</span>
-                    </div>
-                  </button>
-                </li>
-              ))}
-            </ul>
-          )}
-        </div>
-      </div>
-    </div>
-  );
-}

package/components/dashboard/ThemeToggle.test.tsx

@@ -1,26 +0,0 @@
-import { render, screen, waitFor } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { describe, expect, it } from "vitest";
-import { ThemeProvider } from "@/components/ThemeProvider";
-import { ThemeToggle } from "@/components/dashboard/ThemeToggle";
-
-describe("ThemeToggle", () => {
-  it("bascule le thème au clic", async () => {
-    const user = userEvent.setup();
-    render(
-      <ThemeProvider>
-        <ThemeToggle lang="fr" />
-      </ThemeProvider>
-    );
-    const btn = screen.getByRole("button");
-    await waitFor(() => {
-      expect((btn as HTMLButtonElement).disabled).toBe(false);
-    });
-    const before = btn.getAttribute("aria-label");
-    await user.click(btn);
-    const after = btn.getAttribute("aria-label");
-    expect(before).toBeTruthy();
-    expect(after).toBeTruthy();
-    expect(before).not.toBe(after);
-  });
-});