notoken-core 1.5.0 → 1.5.1

package/dist/index.d.ts

@@ -47,6 +47,7 @@ export { createBackup, rollback, listBackups, cleanExpiredBackups, formatBackupL
 export { checkForUpdate, checkForUpdateSync, runUpdate, formatUpdateBanner, type UpdateInfo } from "./utils/updater.js";
 export { detectProviders, formatStatus, goOffline, goOnline, disableLLM, enableLLM, isOfflineMode, isLLMDisabled, recordOfflineCommand, getTokensSaved, formatTokensSaved, formatTokensSavedBrief, saveOnExit, getSessionId, type LLMProvider, type LLMState, } from "./utils/llmManager.js";
 export { getRecentSessions, getSessionsForFolder, formatSessionSummary, formatSessionList, type SessionSummary, } from "./utils/sessionSummary.js";
+export { isSessionOpen, toggleSession, hideSession, unhideSession, getHiddenSessions, getLastViewedSession, createFullBackup, restoreFromBackup, listFullBackups, formatBackupsList, type BackupInfo, } from "./utils/sessionBackup.js";
 export { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
 export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";
 export { recordHistory, loadHistory, getRecentHistory, searchHistory } from "./context/history.js";

package/dist/index.js

@@ -62,6 +62,8 @@ export { checkForUpdate, checkForUpdateSync, runUpdate, formatUpdateBanner } fro
 export { detectProviders, formatStatus, goOffline, goOnline, disableLLM, enableLLM, isOfflineMode, isLLMDisabled, recordOfflineCommand, getTokensSaved, formatTokensSaved, formatTokensSavedBrief, saveOnExit, getSessionId, } from "./utils/llmManager.js";
 // ── Session Summaries ──
 export { getRecentSessions, getSessionsForFolder, formatSessionSummary, formatSessionList, } from "./utils/sessionSummary.js";
+// ── Session Backup & Prefs ──
+export { isSessionOpen, toggleSession, hideSession, unhideSession, getHiddenSessions, getLastViewedSession, createFullBackup, restoreFromBackup, listFullBackups, formatBackupsList, } from "./utils/sessionBackup.js";
 // ── Logging ──
 export { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
 export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";

package/dist/utils/sessionBackup.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Session backup and restore.
+ *
+ * Backup: tars ~/.notoken/ into a timestamped archive
+ * Restore: extracts an archive back to ~/.notoken/
+ * Manages open/closed state per session for the dashboard
+ */
+export declare function isSessionOpen(sessionId: string): boolean;
+export declare function toggleSession(sessionId: string): boolean;
+export declare function hideSession(sessionId: string): void;
+export declare function unhideSession(sessionId: string): void;
+export declare function getHiddenSessions(): string[];
+export declare function getLastViewedSession(): string | undefined;
+export interface BackupInfo {
+    path: string;
+    filename: string;
+    size: string;
+    createdAt: string;
+}
+/**
+ * Create a full backup of ~/.notoken/ as a tar.gz archive.
+ * Saves to ~/.notoken/backups/ by default, or a custom path.
+ */
+export declare function createFullBackup(outputDir?: string): BackupInfo;
+/**
+ * Restore from a backup archive.
+ * Creates a safety backup of current state first.
+ */
+export declare function restoreFromBackup(archivePath: string): {
+    success: boolean;
+    message: string;
+};
+/**
+ * List available backups.
+ */
+export declare function listFullBackups(): BackupInfo[];
+/**
+ * Format backup list for display.
+ */
+export declare function formatBackupsList(backups: BackupInfo[]): string;

package/dist/utils/sessionBackup.js

@@ -0,0 +1,181 @@
+/**
+ * Session backup and restore.
+ *
+ * Backup: tars ~/.notoken/ into a timestamped archive
+ * Restore: extracts an archive back to ~/.notoken/
+ * Manages open/closed state per session for the dashboard
+ */
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import { USER_HOME } from "./paths.js";
+const PREFS_FILE = resolve(USER_HOME, "session-prefs.json");
+const BACKUP_DIR = resolve(USER_HOME, "backups");
+function loadPrefs() {
+    try {
+        if (existsSync(PREFS_FILE))
+            return JSON.parse(readFileSync(PREFS_FILE, "utf-8"));
+    }
+    catch { }
+    return { openSessions: [], hiddenSessions: [] };
+}
+function savePrefs(prefs) {
+    try {
+        mkdirSync(USER_HOME, { recursive: true });
+        writeFileSync(PREFS_FILE, JSON.stringify(prefs, null, 2));
+    }
+    catch { }
+}
+export function isSessionOpen(sessionId) {
+    return loadPrefs().openSessions.includes(sessionId);
+}
+export function toggleSession(sessionId) {
+    const prefs = loadPrefs();
+    const idx = prefs.openSessions.indexOf(sessionId);
+    if (idx >= 0) {
+        prefs.openSessions.splice(idx, 1);
+        savePrefs(prefs);
+        return false;
+    }
+    else {
+        prefs.openSessions.push(sessionId);
+        prefs.lastViewed = sessionId;
+        savePrefs(prefs);
+        return true;
+    }
+}
+export function hideSession(sessionId) {
+    const prefs = loadPrefs();
+    if (!prefs.hiddenSessions.includes(sessionId)) {
+        prefs.hiddenSessions.push(sessionId);
+    }
+    prefs.openSessions = prefs.openSessions.filter(s => s !== sessionId);
+    savePrefs(prefs);
+}
+export function unhideSession(sessionId) {
+    const prefs = loadPrefs();
+    prefs.hiddenSessions = prefs.hiddenSessions.filter(s => s !== sessionId);
+    savePrefs(prefs);
+}
+export function getHiddenSessions() {
+    return loadPrefs().hiddenSessions;
+}
+export function getLastViewedSession() {
+    return loadPrefs().lastViewed;
+}
+/**
+ * Create a full backup of ~/.notoken/ as a tar.gz archive.
+ * Saves to ~/.notoken/backups/ by default, or a custom path.
+ */
+export function createFullBackup(outputDir) {
+    const dir = outputDir ?? BACKUP_DIR;
+    mkdirSync(dir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const filename = `notoken-backup-${ts}.tar.gz`;
+    const fullPath = resolve(dir, filename);
+    // Tar everything except the backups directory itself
+    execSync(`tar -czf "${fullPath}" -C "${resolve(USER_HOME, "..")}" --exclude="backups" "${basename(USER_HOME)}"`, { timeout: 60_000, stdio: "pipe" });
+    const size = tryExec(`ls -lh "${fullPath}" | awk '{print $5}'`) ?? "unknown";
+    return {
+        path: fullPath,
+        filename,
+        size,
+        createdAt: new Date().toISOString(),
+    };
+}
+/**
+ * Restore from a backup archive.
+ * Creates a safety backup of current state first.
+ */
+export function restoreFromBackup(archivePath) {
+    if (!existsSync(archivePath)) {
+        return { success: false, message: `Backup not found: ${archivePath}` };
+    }
+    // Safety backup of current state
+    try {
+        const safety = createFullBackup();
+        console.error(`\x1b[2m[backup] Safety backup created: ${safety.path}\x1b[0m`);
+    }
+    catch { }
+    // Extract
+    try {
+        execSync(`tar -xzf "${archivePath}" -C "${resolve(USER_HOME, "..")}"`, { timeout: 60_000, stdio: "pipe" });
+        return { success: true, message: `Restored from ${basename(archivePath)}` };
+    }
+    catch (err) {
+        return { success: false, message: `Restore failed: ${err.message}` };
+    }
+}
+/**
+ * List available backups.
+ */
+export function listFullBackups() {
+    if (!existsSync(BACKUP_DIR))
+        return [];
+    try {
+        const { readdirSync, statSync } = require("node:fs");
+        return readdirSync(BACKUP_DIR)
+            .filter((f) => f.startsWith("notoken-backup-") && f.endsWith(".tar.gz"))
+            .map((f) => {
+            const full = resolve(BACKUP_DIR, f);
+            const stat = statSync(full);
+            return {
+                path: full,
+                filename: f,
+                size: formatSize(stat.size),
+                createdAt: stat.mtime.toISOString(),
+            };
+        })
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Format backup list for display.
+ */
+export function formatBackupsList(backups) {
+    const c = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", cyan: "\x1b[36m", green: "\x1b[32m" };
+    if (backups.length === 0)
+        return `${c.dim}No backups found.${c.reset}`;
+    const lines = [`${c.bold}Backups:${c.reset}\n`];
+    for (const b of backups) {
+        const ago = timeAgo(b.createdAt);
+        lines.push(`  ${c.cyan}${b.filename}${c.reset} — ${b.size} — ${ago}`);
+    }
+    lines.push(`\n  ${c.dim}Backup dir: ${BACKUP_DIR}${c.reset}`);
+    lines.push(`  ${c.dim}Restore: notoken restore <filename>${c.reset}`);
+    return lines.join("\n");
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1048576)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1073741824)
+        return `${(bytes / 1048576).toFixed(1)} MB`;
+    return `${(bytes / 1073741824).toFixed(1)} GB`;
+}
+function timeAgo(dateStr) {
+    const ms = Date.now() - new Date(dateStr).getTime();
+    const mins = Math.floor(ms / 60000);
+    if (mins < 1)
+        return "just now";
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+function tryExec(cmd) {
+    try {
+        return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 10_000 }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "notoken-core",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Shared engine for notoken — NLP parsing, execution, detection, analysis",
   "type": "module",
   "license": "MIT",