ysk-server-core 1.0.0 → 1.1.9

package/dist/hosting/backup-cron.js

@@ -1,11 +1,12 @@
 /**
  * Real backup (tar) and cron job management under dataDir.
  */
-import { existsSync, mkdirSync, readdirSync, writeFileSync, readFileSync, statSync, unlinkSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, writeFileSync, readFileSync, renameSync, copyFileSync, statSync, unlinkSync } from 'node:fs';
 import { join, resolve, sep } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { ErrorCodes, YskError, tl } from 'ysk-server-shared';
 import { planCronJob } from './extras.js';
+import { publicFilesRoot } from '../files/manager.js';
 /** Constrain archive under dataDir/backups/<projectId>/ */
 export function resolveManagedBackupArchive(dataDir, projectId, archiveName) {
     const id = String(projectId ?? '')
@@ -36,6 +37,8 @@ export function listBackups(dataDir) {
         return [];
     const out = [];
     for (const projectId of readdirSync(root)) {
+        if (projectId === '.trash' || projectId.startsWith('.'))
+            continue;
         const dir = join(root, projectId);
         try {
             if (!statSync(dir).isDirectory())
@@ -61,10 +64,16 @@ export function listBackups(dataDir) {
 /** Notes that mean "not attempted" (skip) — Chinese or English */
 export function isBackupSkipNote(note) {
     const n = note.trim();
-    return (/^skip\b/i.test(n) ||
-        /^skipped\b/i.test(n) ||
-        n.startsWith(tl('notes.auto.n1252')) ||
-        n.startsWith(tl('notes.auto.n1461')));
+    if (!n)
+        return false;
+    if (/blocked|YSK_EXECUTE|YSK_FORBIDDEN|requires execute/i.test(n))
+        return false;
+    if (/^skip(?:ped)?\b/i.test(n))
+        return true;
+    const prefixes = [tl('notes.auto.n1252'), tl('notes.auto.n1461')]
+        .map((p) => p.trim())
+        .filter((p) => p.length >= 2);
+    return prefixes.some((p) => n.startsWith(p));
 }
 export function isBackupSkippedResult(r) {
     if (r.skipped === true)
@@ -149,16 +158,31 @@ export function localizeLastBackupRun(last) {
     const results = Array.isArray(last.results)
         ? last.results
         : [];
-    const asSkip = (r) => isBackupSkippedResult({ ok: r.ok, notes: r.notes ?? [], skipped: r.skipped });
-    const skipped = results.filter(asSkip);
-    const attempted = results.filter((r) => !asSkip(r));
+    const asSkip = (r) => r.skipped === true ||
+        isBackupSkippedResult({ ok: r.ok, notes: r.notes ?? [], skipped: r.skipped });
+    let skipped = results.filter(asSkip);
+    let attempted = results.filter((r) => !asSkip(r));
+    const singleProjectOk = String(last.source || '') === 'projects.backup' && Boolean(last.archivePath);
+    if (singleProjectOk && attempted.length === 0) {
+        attempted = [{ ok: true, notes: [] }];
+        skipped = [];
+    }
     const okCount = attempted.filter((r) => r.ok).length;
     const notes = [
         tl('notes.auto.t0326', { v0: okCount, v1: attempted.length }) +
             (skipped.length ? tl('notes.auto.t0327', { v0: skipped.length }) : ''),
     ];
-    if (last.ok === true) {
-        notes.push(attempted.length === 0 ? tl('notes.auto.n0590') : tl('notes.auto.n0589'));
+    const singleOk = last.ok === true || singleProjectOk;
+    if (singleOk) {
+        notes.push(attempted.length === 0 && String(last.source || '') !== 'projects.backup'
+            ? tl('notes.auto.n0590')
+            : tl('notes.auto.n0589'));
+    }
+    else if (last.ok === false) {
+        notes.push(tl('notes.auto.n1492'));
+    }
+    else if (attempted.length === 0 && results.length === 0 && last.archivePath) {
+        notes.push(tl('notes.auto.n0589'));
     }
     else {
         notes.push(tl('notes.auto.n1492'));
@@ -188,7 +212,19 @@ export async function backupProject(input) {
     const stamp = new Date().toISOString().replace(/[:.]/g, '-');
     const archivePath = join(destDir, `backup-${stamp}.tar.gz`);
     const sources = [input.homeDir, ...(input.extraSources ?? [])];
-    const excludeArgs = (input.excludes ?? []).flatMap((e) => ['--exclude', e]);
+    const defaultExcludes = [
+        '.env',
+        '.env.*',
+        '.db.env',
+        'app/.env',
+        'app/.db.env',
+        '**/.env',
+        '**/.db.env',
+    ];
+    const excludeArgs = [...defaultExcludes, ...(input.excludes ?? [])].flatMap((e) => [
+        '--exclude',
+        e,
+    ]);
     // tar from parent with relative paths when possible
     const tarTimeoutMs = 600_000; // large homes
     const r = await input.host.runCommand([
@@ -236,14 +272,92 @@ export async function backupProject(input) {
             /* ignore */
         }
     }
+    const notes = [
+        tl('notes.auto.t0330', { v0: archivePath }),
+        tl('notes.auto.n0556'),
+    ];
+    let includesDatabase = false;
+    const sidecar = await maybeDumpSqlSidecar({
+        host: input.host,
+        dataDir: input.dataDir,
+        homeDir: input.homeDir,
+        destDir,
+        stamp,
+    });
+    notes.push(...sidecar.notes);
+    includesDatabase = sidecar.ok;
+    if (!includesDatabase) {
+        notes.push('Home tar only — no SQL dump. .env / .db.env excluded.');
+    }
     return {
         ok: true,
         archivePath,
         bytes,
-        notes: [tl('notes.auto.t0330', { v0: (archivePath) }), tl('notes.auto.n0556')],
+        includesDatabase,
+        notes,
         commandResults: [{ argv: ['tar', '-czf', archivePath], exitCode: 0, stderr: '' }]
     };
 }
+export function parseDbEnvFile(text) {
+    const map = {};
+    for (const line of text.split('\n')) {
+        const raw = line.trim();
+        if (!raw || raw.startsWith('#'))
+            continue;
+        const i = raw.indexOf('=');
+        if (i < 0)
+            continue;
+        const k = raw.slice(0, i).trim().toUpperCase();
+        const v = raw.slice(i + 1).trim().replace(/^['"]|['"]$/g, '');
+        map[k] = v;
+    }
+    const engineRaw = (map.ENGINE || map.DB_ENGINE || map.DB_DRIVER || '').toLowerCase();
+    let engine = 'mariadb';
+    if (engineRaw.includes('postgres') || engineRaw.includes('pgsql'))
+        engine = 'postgres';
+    else if (engineRaw.includes('mysql') && !engineRaw.includes('maria'))
+        engine = 'mysql';
+    return {
+        engine,
+        dbName: map.DB || map.DB_NAME || map.MYSQL_DATABASE || map.POSTGRES_DB,
+        username: map.USER || map.DB_USER || map.MYSQL_USER || map.POSTGRES_USER,
+        password: map.PASSWORD || map.DB_PASSWORD || map.MYSQL_PASSWORD || map.POSTGRES_PASSWORD,
+    };
+}
+async function maybeDumpSqlSidecar(input) {
+    const candidates = [join(input.homeDir, '.db.env'), join(input.homeDir, 'app', '.db.env')];
+    let envPath = '';
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            envPath = p;
+            break;
+        }
+    }
+    if (!envPath)
+        return { ok: false, notes: [] };
+    let parsed;
+    try {
+        parsed = parseDbEnvFile(readFileSync(envPath, 'utf8'));
+    }
+    catch {
+        return { ok: false, notes: [tl('notes.backup.dbEnvUnreadable')] };
+    }
+    if (!parsed.dbName) {
+        return { ok: false, notes: [tl('notes.backup.dbEnvNoName')] };
+    }
+    const { dumpSqlDatabase } = await import('./db-dump.js');
+    const out = join(input.destDir, `backup-${input.stamp}.sql`);
+    const dump = await dumpSqlDatabase({
+        host: input.host,
+        dataDir: input.dataDir,
+        engine: parsed.engine,
+        dbName: parsed.dbName,
+        username: parsed.username,
+        password: parsed.password,
+        outputPath: out,
+    });
+    return { ok: Boolean(dump.ok), notes: dump.notes };
+}
 /**
  * Restore a managed backup archive into the project home.
  * Path must live under dataDir/backups/<projectId>/ — never accepts arbitrary paths.
@@ -262,15 +376,16 @@ export async function restoreProjectBackup(input) {
     const mode = input.mode ?? 'full';
     if (mode === 'dry-run') {
         const r = await input.host.runCommand(['tar', '-tzf', archivePath], { timeoutMs: 60_000 });
-        const listing = (r.stdout || '').split('\n').filter(Boolean).slice(0, 80);
+        const listing = (r.stdout || '').split('\n').filter(Boolean);
+        const shown = listing.slice(0, 12);
         return {
             ok: r.exitCode === 0,
             archivePath,
             notes: [
                 r.exitCode === 0
-                    ? tl('notes.auto.t0331', { v0: (listing.length), v1: (listing.length) })
+                    ? tl('notes.auto.t0331', { v0: listing.length, v1: shown.length })
                     : tl('notes.auto.t0332', { v0: (r.stderr) }),
-                ...listing.slice(0, 12).map((l) => `  ${l}`),
+                ...shown.map((l) => `  ${l}`),
             ],
             commandResults: [{ argv: ['tar', '-tzf', archivePath], exitCode: r.exitCode, stderr: r.stderr }]
         };
@@ -278,21 +393,23 @@ export async function restoreProjectBackup(input) {
     if (!existsSync(input.homeDir)) {
         mkdirSync(input.homeDir, { recursive: true });
     }
-    if (mode === 'web') {
-        // Extract only into project home (safer partial restore for web files)
-        const r2 = await input.host.runCommand(['tar', '-xzf', archivePath, '-C', input.homeDir], { timeoutMs: 180_000 });
+    const destHome = resolveRestoreTargetDir(input.homeDir, input.dataDir, input.targetDir);
+    if (!existsSync(destHome))
+        mkdirSync(destHome, { recursive: true });
+    if (mode === 'web' || input.targetDir) {
+        const r2 = await input.host.runCommand(['tar', '-xzf', archivePath, '-C', destHome], { timeoutMs: 180_000 });
         const notes = r2.exitCode === 0
-            ? [tl('notes.auto.t0333', { v0: (input.homeDir) })]
+            ? [tl('notes.auto.t0333', { v0: destHome })]
             : [tl('notes.auto.t0334', { v0: (r2.stderr) })];
         if (r2.exitCode === 0) {
-            notes.push(...(await chownAfterRestore(input)));
+            notes.push(...(await chownAfterRestore({ ...input, homeDir: destHome })));
         }
         return {
             ok: r2.exitCode === 0,
             archivePath,
             notes,
             commandResults: [
-                { argv: ['tar', '-xzf', archivePath, '-C', input.homeDir], exitCode: r2.exitCode, stderr: r2.stderr },
+                { argv: ['tar', '-xzf', archivePath, '-C', destHome], exitCode: r2.exitCode, stderr: r2.stderr },
             ]
         };
     }
@@ -301,7 +418,7 @@ export async function restoreProjectBackup(input) {
         timeoutMs: 180_000
     });
     if (r.exitCode !== 0) {
-        const r2 = await input.host.runCommand(['tar', '-xzf', archivePath, '-C', input.homeDir], { timeoutMs: 180_000 });
+        const r2 = await input.host.runCommand(['tar', '-xzf', archivePath, '-C', destHome], { timeoutMs: 180_000 });
         if (r2.exitCode !== 0) {
             return {
                 ok: false,
@@ -321,6 +438,22 @@ export async function restoreProjectBackup(input) {
         commandResults: [{ argv: ['tar', '-xzf', archivePath], exitCode: 0, stderr: '' }]
     };
 }
+function resolveRestoreTargetDir(homeDir, dataDir, targetDir) {
+    if (!targetDir?.trim())
+        return homeDir;
+    const abs = resolve(targetDir.trim());
+    const allow = [resolve(homeDir), resolve(publicFilesRoot(dataDir))];
+    const ok = allow.some((root) => {
+        const prefix = root.endsWith(sep) ? root : root + sep;
+        return abs === root || abs.startsWith(prefix);
+    });
+    if (!ok) {
+        throw new YskError(ErrorCodes.SANDBOX_VIOLATION, tl('notes.backup.targetOutside'), {
+            httpStatus: 403,
+        });
+    }
+    return abs;
+}
 async function chownAfterRestore(input) {
     const u = input.linuxUser?.trim();
     if (!u)
@@ -338,8 +471,144 @@ async function chownAfterRestore(input) {
         ? [tl('notes.auto.t0337', { v0: (u), v1: (g), v2: (input.homeDir) })]
         : [tl('notes.tpl.chownFailed', { detail: (r.stderr || r.stdout).slice(0, 120) })];
 }
-/** Delete one managed backup archive (path constrained). */
+export const BACKUP_TRASH_DAYS = 7;
+export const BACKUP_TRASH_RETENTION_MS = BACKUP_TRASH_DAYS * 24 * 60 * 60 * 1000;
+const TRASH_DIR = '.trash';
+function trashRoot(dataDir) {
+    return resolve(join(dataDir, 'backups', TRASH_DIR));
+}
+function resolveTrashArchive(dataDir, projectId, archiveName) {
+    const id = String(projectId ?? '')
+        .replace(/[^a-zA-Z0-9_-]/g, '')
+        .slice(0, 80);
+    if (!id)
+        return { ok: false, notes: [tl('notes.auto.n1115')] };
+    const safeName = String(archiveName ?? '')
+        .replace(/[/\\]/g, '')
+        .replace(/\0/g, '');
+    if (!safeName.endsWith('.tar.gz') || safeName.includes('..')) {
+        return { ok: false, notes: [tl('notes.auto.n1116')] };
+    }
+    const root = resolve(join(trashRoot(dataDir), id));
+    const archivePath = resolve(join(root, safeName));
+    const rootPrefix = root.endsWith(sep) ? root : root + sep;
+    if (archivePath !== root && !archivePath.startsWith(rootPrefix)) {
+        return { ok: false, notes: [tl('notes.auto.n1460')] };
+    }
+    return { ok: true, root, path: archivePath, name: safeName, metaPath: `${archivePath}.json` };
+}
+function moveFile(src, dest) {
+    try {
+        renameSync(src, dest);
+    }
+    catch {
+        copyFileSync(src, dest);
+        unlinkSync(src);
+    }
+}
+function writeTrashMeta(metaPath, meta) {
+    writeFileSync(metaPath, JSON.stringify(meta), 'utf8');
+}
+function readTrashMeta(metaPath, fallback) {
+    try {
+        const parsed = JSON.parse(readFileSync(metaPath, 'utf8'));
+        if (parsed.deletedAt && parsed.originalName) {
+            return {
+                deletedAt: String(parsed.deletedAt),
+                originalName: String(parsed.originalName),
+                bytes: Number(parsed.bytes) || fallback.bytes,
+                projectId: String(parsed.projectId || fallback.projectId),
+            };
+        }
+    }
+    catch {
+        /* use fallback */
+    }
+    return fallback;
+}
+export function purgeExpiredBackupTrash(dataDir, nowMs = Date.now()) {
+    const root = trashRoot(dataDir);
+    if (!existsSync(root))
+        return 0;
+    let n = 0;
+    for (const projectId of readdirSync(root)) {
+        const dir = join(root, projectId);
+        try {
+            if (!statSync(dir).isDirectory())
+                continue;
+            for (const name of readdirSync(dir).filter((f) => f.endsWith('.tar.gz'))) {
+                const path = join(dir, name);
+                const metaPath = `${path}.json`;
+                const st = statSync(path);
+                const meta = readTrashMeta(metaPath, {
+                    deletedAt: st.mtime.toISOString(),
+                    originalName: name,
+                    bytes: st.size,
+                    projectId,
+                });
+                const deletedMs = Date.parse(meta.deletedAt);
+                if (!Number.isFinite(deletedMs) || nowMs - deletedMs < BACKUP_TRASH_RETENTION_MS)
+                    continue;
+                try {
+                    unlinkSync(path);
+                    if (existsSync(metaPath))
+                        unlinkSync(metaPath);
+                    n += 1;
+                }
+                catch {
+                    /* keep */
+                }
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return n;
+}
+export function listBackupTrash(dataDir, nowMs = Date.now()) {
+    purgeExpiredBackupTrash(dataDir, nowMs);
+    const root = trashRoot(dataDir);
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    for (const projectId of readdirSync(root)) {
+        const dir = join(root, projectId);
+        try {
+            if (!statSync(dir).isDirectory())
+                continue;
+            for (const name of readdirSync(dir).filter((f) => f.endsWith('.tar.gz'))) {
+                const path = join(dir, name);
+                const st = statSync(path);
+                const meta = readTrashMeta(`${path}.json`, {
+                    deletedAt: st.mtime.toISOString(),
+                    originalName: name,
+                    bytes: st.size,
+                    projectId,
+                });
+                const deletedMs = Date.parse(meta.deletedAt);
+                const expiresAt = new Date((Number.isFinite(deletedMs) ? deletedMs : st.mtimeMs) + BACKUP_TRASH_RETENTION_MS).toISOString();
+                out.push({
+                    projectId,
+                    name: meta.originalName,
+                    trashName: name,
+                    path,
+                    bytes: st.size,
+                    mtime: st.mtime.toISOString(),
+                    deletedAt: meta.deletedAt,
+                    expiresAt,
+                });
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return out.sort((a, b) => (a.deletedAt < b.deletedAt ? 1 : -1));
+}
+/** Move one managed backup into the 7-day trash (path constrained). */
 export function deleteProjectBackup(dataDir, projectId, archiveName) {
+    purgeExpiredBackupTrash(dataDir);
     const resolved = resolveManagedBackupArchive(dataDir, projectId, archiveName);
     if (!resolved.ok)
         return { ok: false, notes: resolved.notes };
@@ -347,13 +616,103 @@ export function deleteProjectBackup(dataDir, projectId, archiveName) {
         return { ok: false, notes: [tl('notes.backup.fileNotFound')] };
     }
     try {
-        unlinkSync(resolved.path);
-        return { ok: true, notes: [tl('notes.tpl.deleted', { name: resolved.name })] };
+        const st = statSync(resolved.path);
+        let trashName = resolved.name;
+        let dest = resolveTrashArchive(dataDir, projectId, trashName);
+        if (!dest.ok)
+            return { ok: false, notes: dest.notes };
+        if (existsSync(dest.path)) {
+            const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+            trashName = resolved.name.replace(/\.tar\.gz$/i, `-${stamp}.tar.gz`);
+            dest = resolveTrashArchive(dataDir, projectId, trashName);
+            if (!dest.ok)
+                return { ok: false, notes: dest.notes };
+        }
+        mkdirSync(dest.root, { recursive: true });
+        moveFile(resolved.path, dest.path);
+        const deletedAt = new Date().toISOString();
+        writeTrashMeta(dest.metaPath, {
+            deletedAt,
+            originalName: resolved.name,
+            bytes: st.size,
+            projectId,
+        });
+        const expiresAt = new Date(Date.parse(deletedAt) + BACKUP_TRASH_RETENTION_MS).toISOString();
+        return {
+            ok: true,
+            trashed: true,
+            expiresAt,
+            notes: [tl('notes.backup.movedToTrash', { name: resolved.name, days: BACKUP_TRASH_DAYS })],
+        };
     }
     catch (e) {
         return { ok: false, notes: [e instanceof Error ? e.message : String(e)] };
     }
 }
+export function restoreBackupTrash(dataDir, projectId, trashName) {
+    const dest = resolveTrashArchive(dataDir, projectId, trashName);
+    if (!dest.ok)
+        return { ok: false, notes: dest.notes };
+    if (!existsSync(dest.path)) {
+        return { ok: false, notes: [tl('notes.backup.fileNotFound')] };
+    }
+    const meta = readTrashMeta(dest.metaPath, {
+        deletedAt: new Date().toISOString(),
+        originalName: dest.name,
+        bytes: 0,
+        projectId,
+    });
+    const live = resolveManagedBackupArchive(dataDir, projectId, meta.originalName);
+    if (!live.ok)
+        return { ok: false, notes: live.notes };
+    if (existsSync(live.path)) {
+        return { ok: false, notes: [tl('notes.backup.restoreNameExists', { name: meta.originalName })] };
+    }
+    try {
+        mkdirSync(live.root, { recursive: true });
+        moveFile(dest.path, live.path);
+        if (existsSync(dest.metaPath))
+            unlinkSync(dest.metaPath);
+        return { ok: true, notes: [tl('notes.backup.restoredFromTrash', { name: meta.originalName })] };
+    }
+    catch (e) {
+        return { ok: false, notes: [e instanceof Error ? e.message : String(e)] };
+    }
+}
+export function purgeBackupTrash(dataDir, projectId, trashName) {
+    const dest = resolveTrashArchive(dataDir, projectId, trashName);
+    if (!dest.ok)
+        return { ok: false, notes: dest.notes };
+    if (!existsSync(dest.path)) {
+        return { ok: false, notes: [tl('notes.backup.fileNotFound')] };
+    }
+    try {
+        unlinkSync(dest.path);
+        if (existsSync(dest.metaPath))
+            unlinkSync(dest.metaPath);
+        return { ok: true, notes: [tl('notes.tpl.deleted', { name: dest.name })] };
+    }
+    catch (e) {
+        return { ok: false, notes: [e instanceof Error ? e.message : String(e)] };
+    }
+}
+export function emptyBackupTrash(dataDir) {
+    const items = listBackupTrash(dataDir);
+    let purged = 0;
+    const notes = [];
+    for (const item of items) {
+        const r = purgeBackupTrash(dataDir, item.projectId, item.trashName);
+        if (r.ok)
+            purged += 1;
+        else
+            notes.push(...r.notes);
+    }
+    return {
+        ok: notes.length === 0,
+        purged,
+        notes: notes.length ? notes : [tl('notes.backup.trashEmptied', { n: purged })],
+    };
+}
 /** Resolve a managed backup path for download (path constrained). */
 export function resolveBackupDownloadPath(dataDir, projectId, archiveName) {
     const resolved = resolveManagedBackupArchive(dataDir, projectId, archiveName);
@@ -474,16 +833,17 @@ export async function restoreControlPlaneBackup(input) {
     }
     if (mode === 'dry-run') {
         const r = await input.host.runCommand(['tar', '-tzf', archivePath], { timeoutMs: 60_000 });
-        const listing = (r.stdout || '').split('\n').filter(Boolean).slice(0, 40);
+        const listing = (r.stdout || '').split('\n').filter(Boolean);
+        const shown = listing.slice(0, 12);
         return {
             ok: r.exitCode === 0,
             archivePath,
             notes: [
                 r.exitCode === 0
-                    ? tl('notes.auto.t0331', { v0: listing.length, v1: listing.length })
+                    ? tl('notes.auto.t0331', { v0: listing.length, v1: shown.length })
                     : tl('notes.auto.t0332', { v0: r.stderr }),
-                'dry-run only — pass mode=full + confirmPhrase=RESTORE-CONTROL-PLANE to write',
-                ...listing.slice(0, 12).map((l) => `  ${l}`),
+                tl('notes.backup.controlPlaneDryRun'),
+                ...shown.map((l) => `  ${l}`),
             ],
             commandResults: [{ argv: ['tar', '-tzf', archivePath], exitCode: r.exitCode, stderr: r.stderr }],
         };
@@ -493,8 +853,8 @@ export async function restoreControlPlaneBackup(input) {
             ok: false,
             archivePath,
             notes: [
-                'refused: full control-plane restore requires confirmPhrase=RESTORE-CONTROL-PLANE',
-                'restart API after a successful restore',
+                tl('notes.backup.controlPlaneNeedConfirm'),
+                tl('notes.backup.controlPlaneRestartAfter'),
             ],
             commandResults: [],
         };
@@ -694,6 +1054,30 @@ export class CronJobService {
         this.writeManagedCrontab();
         return { ...row };
     }
+    update(id, patch) {
+        const row = cronRows(this.db).find((j) => j.id === id);
+        if (!row)
+            return undefined;
+        if (typeof patch.schedule === 'string' && patch.schedule.trim()) {
+            row.schedule = patch.schedule.trim();
+        }
+        if (typeof patch.command === 'string' && patch.command.trim()) {
+            row.command = patch.command.trim();
+        }
+        if (typeof patch.user === 'string' && patch.user.trim()) {
+            row.user = patch.user.trim();
+        }
+        if (patch.projectId !== undefined) {
+            row.project_id = patch.projectId || undefined;
+        }
+        if (typeof patch.enabled === 'boolean') {
+            row.enabled = patch.enabled;
+        }
+        row.updated_at = new Date().toISOString();
+        this.db.persist();
+        this.writeManagedCrontab();
+        return { ...row };
+    }
     /**
      * Run job command once (test). Requires EXECUTE; fail-closed.
      */
@@ -808,6 +1192,8 @@ export class CronJobService {
                         return false;
                     if (t.startsWith('# Generated by YSK Server'))
                         return false;
+                    if (t.startsWith('# YSK Server crontab merge'))
+                        return false;
                     if (/#\s*ysk:/i.test(t))
                         return false;
                     if (/\bysk-server\b/.test(t) && /backup|cron/i.test(t))
@@ -848,8 +1234,10 @@ export class CronJobService {
         if (ok) {
             notes.push(tl('notes.cron.installReplacesYskOnly'));
         }
+        const at = new Date().toISOString();
+        this.db.snapshot.settings.last_cron_install = JSON.stringify({ ok, at, actor });
         for (const j of this.db.snapshot.cron_jobs) {
-            j.last_install = { ok, at: new Date().toISOString(), actor };
+            j.last_install = { ok, at, actor };
         }
         this.db.persist();
         return {
@@ -866,14 +1254,9 @@ export class CronJobService {
      * Non-root: only `crontab -l` for the control-plane process user (honest partial).
      */
     async listHostCrontabs(projects = []) {
-        const executeEnabled = this.host.executeEnabled();
         const isRoot = this.host.isRoot();
         const notes = [];
         let partial = false;
-        if (!executeEnabled) {
-            notes.push(tl('notes.auto.n1165'));
-            partial = true;
-        }
         const users = [];
         const lines = [];
         let slots;
@@ -950,7 +1333,7 @@ export class CronJobService {
             notes,
             partial,
             isRoot,
-            executeEnabled,
+            executeEnabled: this.host.executeEnabled(),
         };
     }
     /** Probe managed file vs host crontab (honest status). */
@@ -999,7 +1382,17 @@ export class CronJobService {
         catch {
             hostHasYskEntries = null;
         }
-        const last = all.map((j) => j.last_install).find((x) => x && typeof x === 'object');
+        let last = all.map((j) => j.last_install).find((x) => x && typeof x === 'object');
+        if (!last) {
+            try {
+                const raw = this.db.snapshot.settings?.last_cron_install;
+                if (raw)
+                    last = JSON.parse(raw);
+            }
+            catch {
+                /* ignore */
+            }
+        }
         return {
             managedPath: path,
             managedLines,