taskify-nostr 0.1.0

package/dist/shared/agentSecurity.js

@@ -0,0 +1,161 @@
+// CLI-adapted version of agentSecurity.ts (browser storage removed)
+export const AGENT_SECURITY_STORAGE_KEY = "taskify.agent.security.v1";
+function nowISO() {
+    return new Date().toISOString();
+}
+export function defaultAgentSecurityConfig() {
+    return {
+        enabled: true,
+        mode: "moderate",
+        trustedNpubs: [],
+        updatedISO: nowISO(),
+    };
+}
+function normalizeMode(value) {
+    return value === "strict" || value === "off" ? value : "moderate";
+}
+function normalizeTrustedNpub(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed)
+        return null;
+    return trimmed;
+}
+export function isLooselyValidTrustedNpub(value) {
+    return typeof value === "string" && value.trim().toLowerCase().startsWith("npub1") && value.trim().length > 10;
+}
+function normalizeTrustedNpubList(value) {
+    if (!Array.isArray(value))
+        return [];
+    const deduped = new Map();
+    for (const entry of value) {
+        const normalized = normalizeTrustedNpub(entry);
+        if (!normalized)
+            continue;
+        deduped.set(normalized, normalized);
+    }
+    return Array.from(deduped.values()).sort();
+}
+export function normalizeAgentSecurityConfig(raw) {
+    const fallback = defaultAgentSecurityConfig();
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return fallback;
+    const candidate = raw;
+    const updatedISO = typeof candidate.updatedISO === "string" && !Number.isNaN(Date.parse(candidate.updatedISO))
+        ? new Date(candidate.updatedISO).toISOString()
+        : fallback.updatedISO;
+    return {
+        enabled: candidate.enabled === true,
+        mode: normalizeMode(candidate.mode),
+        trustedNpubs: normalizeTrustedNpubList(candidate.trustedNpubs),
+        updatedISO,
+    };
+}
+// In-memory store for CLI use (config.ts provides persistence)
+const inMemoryStore = { config: null };
+const defaultStore = {
+    get() {
+        return inMemoryStore.config ?? defaultAgentSecurityConfig();
+    },
+    set(config) {
+        const normalized = normalizeAgentSecurityConfig(config);
+        inMemoryStore.config = normalized;
+        return normalized;
+    },
+};
+let currentAgentSecurityStore = defaultStore;
+export function getAgentSecurityStore() {
+    return currentAgentSecurityStore;
+}
+export function setAgentSecurityStore(store) {
+    currentAgentSecurityStore = store ?? defaultStore;
+}
+export function loadAgentSecurityConfig() {
+    return currentAgentSecurityStore.get();
+}
+export function saveAgentSecurityConfig(config) {
+    return currentAgentSecurityStore.set(config);
+}
+export function updateAgentSecurityConfig(updates) {
+    const current = loadAgentSecurityConfig();
+    return saveAgentSecurityConfig({
+        enabled: typeof updates.enabled === "boolean" ? updates.enabled : current.enabled,
+        mode: updates.mode ? normalizeMode(updates.mode) : current.mode,
+        trustedNpubs: updates.trustedNpubs !== undefined
+            ? normalizeTrustedNpubList(updates.trustedNpubs)
+            : current.trustedNpubs,
+        updatedISO: nowISO(),
+    });
+}
+export function addTrustedNpub(config, npub) {
+    const normalized = normalizeTrustedNpub(npub);
+    if (!normalized)
+        return normalizeAgentSecurityConfig(config);
+    return normalizeAgentSecurityConfig({
+        ...config,
+        trustedNpubs: Array.from(new Set([...config.trustedNpubs.map((entry) => entry.toLowerCase()), normalized])),
+        updatedISO: nowISO(),
+    });
+}
+export function removeTrustedNpub(config, npub) {
+    const normalized = normalizeTrustedNpub(npub);
+    return normalizeAgentSecurityConfig({
+        ...config,
+        trustedNpubs: config.trustedNpubs.filter((entry) => entry.toLowerCase() !== normalized),
+        updatedISO: nowISO(),
+    });
+}
+export function clearTrustedNpubs(config) {
+    return normalizeAgentSecurityConfig({
+        ...config,
+        trustedNpubs: [],
+        updatedISO: nowISO(),
+    });
+}
+export function getEffectiveAgentSecurityMode(config) {
+    if (!config.enabled)
+        return "off";
+    return normalizeMode(config.mode);
+}
+function classifyProvenance(createdByNpub, lastEditedByNpub, config) {
+    const trustedNpubs = new Set(config.trustedNpubs.map((entry) => entry.toLowerCase()));
+    const normalizedLastEditedBy = normalizeTrustedNpub(lastEditedByNpub);
+    const normalizedCreatedBy = normalizeTrustedNpub(createdByNpub);
+    if (normalizedLastEditedBy && trustedNpubs.has(normalizedLastEditedBy)) {
+        return "trusted";
+    }
+    if (!normalizedLastEditedBy && !normalizedCreatedBy) {
+        return "unknown";
+    }
+    return "untrusted";
+}
+export function annotateTrust(item, config) {
+    const createdByNpub = normalizeTrustedNpub(item.createdByNpub) ?? null;
+    const lastEditedByNpub = normalizeTrustedNpub(item.lastEditedByNpub) ?? null;
+    const provenance = classifyProvenance(createdByNpub, lastEditedByNpub, config);
+    const trusted = provenance === "trusted";
+    return {
+        ...item,
+        createdByNpub,
+        lastEditedByNpub,
+        provenance,
+        trusted,
+        agentSafe: trusted,
+    };
+}
+export function applyTrustFilter(items, config) {
+    const annotated = items.map((item) => annotateTrust(item, config));
+    if (getEffectiveAgentSecurityMode(config) === "strict") {
+        return annotated.filter((item) => item.trusted);
+    }
+    return annotated;
+}
+export function summarizeTrustCounts(allItems, returnedCount) {
+    return {
+        trusted: allItems.filter((item) => item.provenance === "trusted").length,
+        untrusted: allItems.filter((item) => item.provenance === "untrusted").length,
+        unknown: allItems.filter((item) => item.provenance === "unknown").length,
+        returned: returnedCount,
+    };
+}

package/dist/shared/boardUtils.js

@@ -0,0 +1,441 @@
+import { isoDatePart, parseDateKey, startOfDay, isoTimePart, formatDateKeyFromParts, isoFromDateTime, normalizeTimeZone, } from "./dateUtils.js";
+const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+export function parseCompoundChildInput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return { boardId: "", relays: [] };
+    let boardId = trimmed;
+    let relaySegment = "";
+    const atIndex = trimmed.indexOf("@");
+    if (atIndex >= 0) {
+        boardId = trimmed.slice(0, atIndex).trim();
+        relaySegment = trimmed.slice(atIndex + 1).trim();
+    }
+    else {
+        const spaceIndex = trimmed.search(/\s/);
+        if (spaceIndex >= 0) {
+            boardId = trimmed.slice(0, spaceIndex).trim();
+            relaySegment = trimmed.slice(spaceIndex + 1).trim();
+        }
+    }
+    const relays = relaySegment
+        ? relaySegment.split(/[\s,]+/).map((relay) => relay.trim()).filter(Boolean)
+        : [];
+    return { boardId, relays };
+}
+export function boardScopeIds(board, boards) {
+    const ids = new Set();
+    const addId = (value) => {
+        if (typeof value === "string" && value)
+            ids.add(value);
+    };
+    const addBoard = (target) => {
+        if (!target)
+            return;
+        addId(target.id);
+        addId(target.nostr?.boardId);
+    };
+    addBoard(board);
+    if (board.kind === "compound") {
+        board.children.forEach((childId) => {
+            addId(childId);
+            addBoard(findBoardByCompoundChildId(boards, childId));
+        });
+    }
+    return Array.from(ids);
+}
+export function findBoardByCompoundChildId(boards, childId) {
+    return boards.find((board) => {
+        if (board.id === childId)
+            return true;
+        return !!board.nostr?.boardId && board.nostr.boardId === childId;
+    });
+}
+export function compoundChildMatchesBoard(childId, board) {
+    return childId === board.id || (!!board.nostr?.boardId && childId === board.nostr.boardId);
+}
+export function normalizeCompoundChildId(boards, childId) {
+    const match = findBoardByCompoundChildId(boards, childId);
+    return match ? match.id : childId;
+}
+// ---- Board migration ----
+export function migrateBoards(stored) {
+    try {
+        const arr = stored;
+        if (!Array.isArray(arr))
+            return null;
+        return arr.map((b) => {
+            const archived = typeof b?.archived === "boolean"
+                ? b.archived
+                : typeof b?.hidden === "boolean"
+                    ? b.hidden
+                    : false;
+            const hidden = typeof b?.hidden === "boolean" && typeof b?.archived === "boolean"
+                ? b.hidden
+                : false;
+            const clearCompletedDisabled = typeof b?.clearCompletedDisabled === "boolean" ? b.clearCompletedDisabled : false;
+            const indexCardEnabled = typeof b?.indexCardEnabled === "boolean" ? Boolean(b.indexCardEnabled) : false;
+            const hideChildBoardNames = typeof b?.hideChildBoardNames === "boolean"
+                ? Boolean(b.hideChildBoardNames)
+                : false;
+            if (b?.kind === "week") {
+                return {
+                    id: b.id,
+                    name: b.name,
+                    kind: "week",
+                    nostr: b.nostr,
+                    archived,
+                    hidden,
+                    clearCompletedDisabled,
+                };
+            }
+            if (b?.kind === "lists" && Array.isArray(b.columns)) {
+                return {
+                    id: b.id,
+                    name: b.name,
+                    kind: "lists",
+                    columns: b.columns,
+                    nostr: b.nostr,
+                    archived,
+                    hidden,
+                    clearCompletedDisabled,
+                    indexCardEnabled,
+                };
+            }
+            if (b?.kind === "compound") {
+                const rawChildren = Array.isArray(b?.children) ? b.children : [];
+                const children = rawChildren
+                    .filter((child) => typeof child === "string" && child && child !== b.id);
+                return {
+                    id: b.id,
+                    name: b.name,
+                    kind: "compound",
+                    children,
+                    nostr: b.nostr,
+                    archived,
+                    hidden,
+                    clearCompletedDisabled,
+                    indexCardEnabled,
+                    hideChildBoardNames,
+                };
+            }
+            if (b?.kind === "bible") {
+                const name = typeof b?.name === "string" && b.name.trim() ? b.name : "Bible";
+                return {
+                    id: b.id,
+                    name,
+                    kind: "bible",
+                    archived,
+                    hidden,
+                    clearCompletedDisabled,
+                };
+            }
+            if (b?.kind === "list") {
+                const colId = crypto.randomUUID();
+                return {
+                    id: b.id,
+                    name: b.name,
+                    kind: "lists",
+                    columns: [{ id: colId, name: "Items" }],
+                    nostr: b?.nostr,
+                    archived,
+                    hidden,
+                    clearCompletedDisabled,
+                    indexCardEnabled,
+                };
+            }
+            const colId = crypto.randomUUID();
+            return {
+                id: b?.id || crypto.randomUUID(),
+                name: b?.name || "Board",
+                kind: "lists",
+                columns: [{ id: colId, name: "Items" }],
+                nostr: b?.nostr,
+                archived,
+                hidden,
+                clearCompletedDisabled,
+                indexCardEnabled,
+            };
+        });
+    }
+    catch {
+        return null;
+    }
+}
+// ---- Startup board selection ----
+export function pickStartupBoard(boards, overrides) {
+    const visible = boards.filter(b => !b.archived && !b.hidden);
+    const today = new Date().getDay();
+    const overrideId = overrides?.[today];
+    if (overrideId) {
+        const match = visible.find(b => b.id === overrideId) || boards.find(b => !b.archived && b.id === overrideId);
+        if (match)
+            return match.id;
+    }
+    if (visible.length)
+        return visible[0].id;
+    const firstUnarchived = boards.find(b => !b.archived);
+    if (firstUnarchived)
+        return firstUnarchived.id;
+    return boards[0]?.id || "";
+}
+// ---- Week helpers ----
+export function startOfWeek(d, weekStart) {
+    const sd = startOfDay(d);
+    const current = sd.getDay();
+    const ws = (weekStart === 1 || weekStart === 6) ? weekStart : 0;
+    let diff = current - ws;
+    if (diff < 0)
+        diff += 7;
+    return new Date(sd.getTime() - diff * 86400000);
+}
+// ---- Recurrence helpers ----
+export function nextOccurrence(currentISO, rule, keepTime = false, timeZone) {
+    const safeZone = normalizeTimeZone(timeZone);
+    if (safeZone) {
+        const dateKey = isoDatePart(currentISO, safeZone);
+        const dateParts = parseDateKey(dateKey);
+        if (dateParts) {
+            const baseTime = keepTime ? isoTimePart(currentISO, safeZone) : "";
+            const applyDate = (parts) => {
+                const nextDateKey = formatDateKeyFromParts(parts.year, parts.month, parts.day);
+                return isoFromDateTime(nextDateKey, baseTime || undefined, safeZone);
+            };
+            const addDays = (d) => {
+                const base = new Date(Date.UTC(dateParts.year, dateParts.month - 1, dateParts.day));
+                base.setUTCDate(base.getUTCDate() + d);
+                return {
+                    year: base.getUTCFullYear(),
+                    month: base.getUTCMonth() + 1,
+                    day: base.getUTCDate(),
+                };
+            };
+            const weekdayForParts = (parts) => new Date(Date.UTC(parts.year, parts.month - 1, parts.day)).getUTCDay();
+            let next = null;
+            switch (rule.type) {
+                case "none":
+                    next = null;
+                    break;
+                case "daily":
+                    next = applyDate(addDays(1));
+                    break;
+                case "weekly": {
+                    if (!rule.days.length)
+                        return null;
+                    for (let i = 1; i <= 28; i++) {
+                        const cand = addDays(i);
+                        const wd = weekdayForParts(cand);
+                        if (rule.days.includes(wd)) {
+                            next = applyDate(cand);
+                            break;
+                        }
+                    }
+                    break;
+                }
+                case "every": {
+                    if (rule.unit === "hour") {
+                        const current = new Date(currentISO);
+                        const n = new Date(current.getTime() + rule.n * 3600000);
+                        next = n.toISOString();
+                    }
+                    else {
+                        const daysToAdd = rule.unit === "day" ? rule.n : rule.n * 7;
+                        next = applyDate(addDays(daysToAdd));
+                    }
+                    break;
+                }
+                case "monthlyDay": {
+                    const interval = Math.max(1, rule.interval ?? 1);
+                    const base = new Date(Date.UTC(dateParts.year, dateParts.month - 1 + interval, 1));
+                    const n = {
+                        year: base.getUTCFullYear(),
+                        month: base.getUTCMonth() + 1,
+                        day: Math.min(rule.day, 28),
+                    };
+                    next = applyDate(n);
+                    break;
+                }
+            }
+            if (next && rule.untilISO) {
+                const limitKey = isoDatePart(rule.untilISO, safeZone);
+                const nextKey = isoDatePart(next, safeZone);
+                if (nextKey > limitKey)
+                    return null;
+            }
+            return next;
+        }
+    }
+    const currentDate = new Date(currentISO);
+    const curDay = startOfDay(currentDate);
+    const timeOffset = currentDate.getTime() - curDay.getTime();
+    const baseTime = keepTime ? isoTimePart(currentISO) : "";
+    const applyTime = (day) => {
+        if (keepTime && baseTime) {
+            const datePart = isoDatePart(day.toISOString());
+            return isoFromDateTime(datePart, baseTime);
+        }
+        return new Date(day.getTime() + timeOffset).toISOString();
+    };
+    const addDays = (d) => {
+        const nextDay = startOfDay(new Date(curDay.getTime() + d * 86400000));
+        return applyTime(nextDay);
+    };
+    let next = null;
+    switch (rule.type) {
+        case "none":
+            next = null;
+            break;
+        case "daily":
+            next = addDays(1);
+            break;
+        case "weekly": {
+            if (!rule.days.length)
+                return null;
+            for (let i = 1; i <= 28; i++) {
+                const cand = addDays(i);
+                const wd = new Date(cand).getDay();
+                if (rule.days.includes(wd)) {
+                    next = cand;
+                    break;
+                }
+            }
+            break;
+        }
+        case "every": {
+            if (rule.unit === "hour") {
+                const current = new Date(currentISO);
+                const n = new Date(current.getTime() + rule.n * 3600000);
+                next = n.toISOString();
+            }
+            else {
+                const daysToAdd = rule.unit === "day" ? rule.n : rule.n * 7;
+                next = addDays(daysToAdd);
+            }
+            break;
+        }
+        case "monthlyDay": {
+            const y = curDay.getFullYear(), m = curDay.getMonth();
+            const interval = Math.max(1, rule.interval ?? 1);
+            const n = startOfDay(new Date(y, m + interval, Math.min(rule.day, 28)));
+            next = applyTime(n);
+            break;
+        }
+    }
+    if (next && rule.untilISO) {
+        const limit = startOfDay(new Date(rule.untilISO)).getTime();
+        const n = startOfDay(new Date(next)).getTime();
+        if (n > limit)
+            return null;
+    }
+    return next;
+}
+// ---- Visibility helpers ----
+export function revealsOnDueDate(rule) {
+    if (isFrequentRecurrence(rule))
+        return true;
+    return false;
+}
+export function isFrequentRecurrence(rule) {
+    if (!rule)
+        return false;
+    if (rule.type === "daily" || rule.type === "weekly")
+        return true;
+    if (rule.type === "every") {
+        return rule.unit === "day" || rule.unit === "week";
+    }
+    return false;
+}
+export function isVisibleNow(t, now = new Date()) {
+    if (!t.hiddenUntilISO)
+        return true;
+    const today = startOfDay(now).getTime();
+    if (t.recurrence && revealsOnDueDate(t.recurrence)) {
+        const dueReveal = startOfDay(new Date(t.dueISO)).getTime();
+        if (!Number.isNaN(dueReveal))
+            return today >= dueReveal;
+    }
+    const reveal = startOfDay(new Date(t.hiddenUntilISO)).getTime();
+    return today >= reveal;
+}
+export function hiddenUntilForNext(nextISO, rule, weekStart) {
+    const nextMidnight = startOfDay(new Date(nextISO));
+    if (revealsOnDueDate(rule)) {
+        return nextMidnight.toISOString();
+    }
+    const sow = startOfWeek(nextMidnight, weekStart);
+    return sow.toISOString();
+}
+export function hiddenUntilForBoard(dueISO, boardKind, weekStart) {
+    const dueDate = startOfDay(new Date(dueISO));
+    if (Number.isNaN(dueDate.getTime()))
+        return undefined;
+    const today = startOfDay(new Date());
+    if (boardKind === "lists" || boardKind === "compound") {
+        return dueDate.getTime() > today.getTime() ? dueDate.toISOString() : undefined;
+    }
+    const nowSow = startOfWeek(new Date(), weekStart);
+    const dueSow = startOfWeek(dueDate, weekStart);
+    return dueSow.getTime() > nowSow.getTime() ? dueSow.toISOString() : undefined;
+}
+export function applyHiddenForFuture(task, weekStart, boardKind) {
+    if (task.dueDateEnabled === false) {
+        task.hiddenUntilISO = undefined;
+        return;
+    }
+    task.hiddenUntilISO = hiddenUntilForBoard(task.dueISO, boardKind, weekStart);
+}
+// ---- Calendar event visibility helpers ----
+function calendarEventDateKey(event) {
+    if (event.kind === "date") {
+        return ISO_DATE_PATTERN.test(event.startDate) ? event.startDate : null;
+    }
+    const key = isoDatePart(event.startISO, event.startTzid);
+    return ISO_DATE_PATTERN.test(key) ? key : null;
+}
+function hiddenUntilForCalendarEvent(event, boardKind, weekStart) {
+    if (boardKind !== "lists" && boardKind !== "compound")
+        return undefined;
+    const dateKey = calendarEventDateKey(event);
+    if (!dateKey)
+        return undefined;
+    const parsed = parseDateKey(dateKey);
+    if (!parsed)
+        return undefined;
+    const eventDate = new Date(parsed.year, parsed.month - 1, parsed.day);
+    if (Number.isNaN(eventDate.getTime()))
+        return undefined;
+    const eventWeekStart = startOfWeek(eventDate, weekStart);
+    const currentWeekStart = startOfWeek(new Date(), weekStart);
+    if (eventWeekStart.getTime() > currentWeekStart.getTime()) {
+        return eventWeekStart.toISOString();
+    }
+    return undefined;
+}
+export function applyHiddenForCalendarEvent(event, weekStart, boardKind) {
+    const hiddenUntilISO = hiddenUntilForCalendarEvent(event, boardKind, weekStart);
+    if (hiddenUntilISO) {
+        if (event.hiddenUntilISO === hiddenUntilISO)
+            return event;
+        return { ...event, hiddenUntilISO };
+    }
+    if (!event.hiddenUntilISO)
+        return event;
+    return { ...event, hiddenUntilISO: undefined };
+}
+// ---- Order helpers ----
+export function nextOrderForBoard(boardId, tasks, newTaskPosition) {
+    const boardTasks = tasks.filter(task => task.boardId === boardId);
+    if (newTaskPosition === "top") {
+        const minOrder = boardTasks.reduce((min, task) => Math.min(min, task.order ?? 0), 0);
+        return minOrder - 1;
+    }
+    return boardTasks.reduce((max, task) => Math.max(max, task.order ?? -1), -1) + 1;
+}
+export function nextOrderForCalendarBoard(boardId, events, newItemPosition) {
+    const boardEvents = events.filter((event) => event.boardId === boardId && !event.external);
+    if (newItemPosition === "top") {
+        const minOrder = boardEvents.reduce((min, event) => Math.min(min, event.order ?? 0), 0);
+        return minOrder - 1;
+    }
+    return boardEvents.reduce((max, event) => Math.max(max, event.order ?? -1), -1) + 1;
+}