@skrr-ai/cli 0.1.94 → 0.1.95

package/dist/lib/memory-sync.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MEMORY_SYNC_TOMBSTONES = exports.MEMORY_SYNC_CONFLICTS = exports.MEMORY_SYNC_BASIS = exports.MEMORY_SYNC_MANIFEST = void 0;
+exports.MEMORY_SYNC_TOMBSTONES = exports.MEMORY_SYNC_QUARANTINE = exports.MEMORY_SYNC_CONFLICTS = exports.MEMORY_SYNC_BASIS = exports.MEMORY_SYNC_MANIFEST = void 0;
 exports.fileForMemoryPath = fileForMemoryPath;
 exports.readMaterializationBinding = readMaterializationBinding;
 exports.assertMaterializationSpaceContext = assertMaterializationSpaceContext;
@@ -22,6 +22,7 @@ const node_path_1 = __importDefault(require("node:path"));
 exports.MEMORY_SYNC_MANIFEST = '.memory-sync';
 exports.MEMORY_SYNC_BASIS = '.memory-sync-basis';
 exports.MEMORY_SYNC_CONFLICTS = '.memory-conflicts';
+exports.MEMORY_SYNC_QUARANTINE = '.memory-quarantine';
 exports.MEMORY_SYNC_TOMBSTONES = '.memory-tombstones';
 function codedError(code, message) {
     const exitCode = code.includes('NOT_FOUND')
@@ -127,10 +128,12 @@ async function readJson(root, target) {
     catch (error) {
         if (error?.code === 'ENOENT')
             return null;
+        if (['MEMORY_SYNC_SYMLINK_DENIED', 'MEMORY_SYNC_PATH_ESCAPE'].includes(error?.code))
+            throw error;
         throw codedError('MEMORY_SYNC_METADATA_INVALID', `Invalid sync metadata: ${target}`);
     }
 }
-async function atomicWrite(root, target, content) {
+async function atomicWrite(root, target, content, { replace = true } = {}) {
     await assertSafeTarget(root, target, { createParents: true });
     const tmp = `${target}.tmp-${process.pid}-${(0, node_crypto_1.randomUUID)()}`;
     await assertSafeTarget(root, tmp);
@@ -139,7 +142,23 @@ async function atomicWrite(root, target, content) {
         // Recheck immediately before the atomic replace. Another process may have
         // swapped a parent after the first validation.
         await assertSafeTarget(root, target);
-        await promises_1.default.rename(tmp, target);
+        if (replace) {
+            await promises_1.default.rename(tmp, target);
+        }
+        else {
+            try {
+                // Publishing an untracked destination must never replace a file that
+                // appeared after preflight. link is atomic and refuses an existing name.
+                await promises_1.default.link(tmp, target);
+            }
+            catch (error) {
+                if (error?.code !== 'EEXIST')
+                    throw error;
+                if ((await localHash(root, target)) !== hash(content)) {
+                    throw codedError('MEMORY_SYNC_LOCAL_FILE_CONFLICT', `A local file now occupies ${node_path_1.default.relative(root, target)}; preserve it before pulling`);
+                }
+            }
+        }
     }
     finally {
         await promises_1.default.unlink(tmp).catch((error) => {
@@ -207,7 +226,104 @@ async function localHash(root, target) {
 async function writeConflict(root, conflict, dryRun) {
     if (dryRun)
         return;
-    await atomicJson(root, node_path_1.default.join(root, exports.MEMORY_SYNC_CONFLICTS, `${conflict.id}.json`), conflict);
+    const target = node_path_1.default.join(root, exports.MEMORY_SYNC_CONFLICTS, `${conflict.id}.json`);
+    const existing = await readJson(root, target);
+    if (typeof existing?.quarantineFile === 'string' &&
+        existing.quarantineFile !== conflict.quarantineFile &&
+        (await localHash(root, node_path_1.default.join(root, existing.quarantineFile))) !== null) {
+        throw codedError('MEMORY_SYNC_RECOVERY_CONFLICT', `Resolve the preserved edit for ${conflict.id} before recording another conflict`);
+    }
+    await atomicJson(root, target, conflict);
+}
+async function quarantineRemovedTopic(root, prior, dryRun, localFileHash, movedHead) {
+    const conflictPath = node_path_1.default.join(root, exports.MEMORY_SYNC_CONFLICTS, `${prior.memoryId}.json`);
+    const existing = await readJson(root, conflictPath);
+    const type = movedHead ? 'remote_move_local_edit' : 'remote_delete_local_edit';
+    const matchingIntent = existing?.type === type &&
+        existing.file === prior.file &&
+        existing.baseVersionId === prior.versionId &&
+        typeof existing.quarantineFile === 'string' &&
+        (!movedHead ||
+            (existing.recoveryFile === fileForMemoryPath(movedHead.path) &&
+                existing.remoteVersionId === movedHead.versionId &&
+                existing.remoteFileHash === hash(movedHead.document)));
+    if (!matchingIntent &&
+        typeof existing?.quarantineFile === 'string' &&
+        (await localHash(root, node_path_1.default.join(root, existing.quarantineFile))) !== null) {
+        throw codedError('MEMORY_SYNC_RECOVERY_CONFLICT', `Resolve the preserved edit for ${prior.memoryId} before applying another retirement or move`);
+    }
+    const relative = matchingIntent
+        ? existing.quarantineFile
+        : node_path_1.default.join(exports.MEMORY_SYNC_QUARANTINE, `${safeSegment(prior.memoryId)}-${(0, node_crypto_1.randomUUID)()}.md`);
+    if (matchingIntent && (await localHash(root, node_path_1.default.join(root, relative))) !== null) {
+        // A previous attempt already moved this exact edit. Its former active
+        // path may now hold another topic; preserve both and the original receipt.
+        return relative;
+    }
+    if (!dryRun) {
+        const source = node_path_1.default.join(root, prior.file);
+        const target = node_path_1.default.join(root, relative);
+        await assertSafeTarget(root, source);
+        await assertSafeTarget(root, target, { createParents: true });
+        // Persist the recovery intent BEFORE moving the edit. If the process
+        // crashes after rename, the preserved file still has an indexed receipt.
+        await writeConflict(root, {
+            id: prior.memoryId,
+            type,
+            memoryId: prior.memoryId,
+            file: prior.file,
+            baseVersionId: prior.versionId,
+            quarantineFile: relative,
+            localFileHash,
+            ...(movedHead
+                ? {
+                    recoveryFile: fileForMemoryPath(movedHead.path),
+                    remoteVersionId: movedHead.versionId,
+                    remoteFileHash: hash(movedHead.document),
+                }
+                : {}),
+            detectedAt: new Date().toISOString(),
+        }, false);
+        await promises_1.default.rename(source, target);
+    }
+    return relative;
+}
+async function assertRemoteTarget(root, remote, entries, retiringIds = new Set()) {
+    const relative = fileForMemoryPath(remote.path);
+    const owner = Object.values(entries).find((entry) => entry.file === relative);
+    if (owner && owner.memoryId !== remote.memoryId) {
+        if (retiringIds.has(owner.memoryId))
+            return;
+        throw codedError('MEMORY_SYNC_PATH_CONFLICT', `Remote topic ${remote.memoryId} targets a path owned by ${owner.memoryId}; reconcile these paths before pulling`);
+    }
+    if (entries[remote.memoryId]?.file === relative)
+        return;
+    const currentHash = await localHash(root, node_path_1.default.join(root, relative));
+    if (currentHash !== null && currentHash !== hash(remote.document)) {
+        throw codedError('MEMORY_SYNC_LOCAL_FILE_CONFLICT', `Remote topic ${remote.memoryId} would overwrite an untracked file at ${relative}; preserve or move that file before pulling`);
+    }
+}
+async function reconcileRemoteMove(root, prior, remote, dryRun) {
+    const existing = await readJson(root, node_path_1.default.join(root, exports.MEMORY_SYNC_CONFLICTS, `${prior.memoryId}.json`));
+    const alreadyQuarantined = existing?.type === 'remote_move_local_edit' &&
+        existing.file === prior.file &&
+        existing.baseVersionId === prior.versionId &&
+        typeof existing.quarantineFile === 'string' &&
+        (await localHash(root, node_path_1.default.join(root, existing.quarantineFile))) !== null;
+    const source = node_path_1.default.join(root, prior.file);
+    const currentHash = await localHash(root, source);
+    if (alreadyQuarantined || (currentHash !== null && currentHash !== prior.fileHash)) {
+        await quarantineRemovedTopic(root, prior, dryRun, currentHash || existing?.localFileHash || prior.fileHash, remote);
+        return true;
+    }
+    if (!dryRun) {
+        await assertSafeTarget(root, source);
+        await promises_1.default.unlink(source).catch((error) => {
+            if (error?.code !== 'ENOENT')
+                throw error;
+        });
+    }
+    return false;
 }
 async function pullSnapshot(rootInput, snapshot, { dryRun = false } = {}) {
     const root = await assertSafeRoot(rootInput, true);
@@ -215,15 +331,56 @@ async function pullSnapshot(rootInput, snapshot, { dryRun = false } = {}) {
     validateBinding(snapshot, manifest, basis);
     const nextEntries = { ...(basis?.entries || {}) };
     const remoteIds = new Set(snapshot.entries.map((entry) => entry.memoryId));
+    const retiringIds = new Set(Object.keys(nextEntries).filter((id) => !remoteIds.has(id)));
     let changed = 0;
     let conflicts = 0;
+    // Check all destinations before retiring any old path. A colliding local
+    // file must leave both the old materialization and the cursor intact.
+    for (const remote of snapshot.entries) {
+        await assertRemoteTarget(root, remote, nextEntries, retiringIds);
+    }
+    // Retire old identities before materializing replacements at the same path.
+    // This also reconciles a crash after quarantine rename but before basis save.
+    for (const [memoryId, prior] of Object.entries(nextEntries)) {
+        if (remoteIds.has(memoryId))
+            continue;
+        const target = node_path_1.default.join(root, prior.file);
+        const existing = await readJson(root, node_path_1.default.join(root, exports.MEMORY_SYNC_CONFLICTS, `${memoryId}.json`));
+        const alreadyQuarantined = existing?.type === 'remote_delete_local_edit' &&
+            existing.file === prior.file &&
+            existing.baseVersionId === prior.versionId &&
+            typeof existing.quarantineFile === 'string' &&
+            (await localHash(root, node_path_1.default.join(root, existing.quarantineFile))) !== null;
+        const currentHash = await localHash(root, target);
+        if (alreadyQuarantined || (currentHash !== null && currentHash !== prior.fileHash)) {
+            conflicts += 1;
+            await quarantineRemovedTopic(root, prior, dryRun, currentHash || existing?.localFileHash || prior.fileHash);
+        }
+        else if (!dryRun) {
+            await assertSafeTarget(root, target);
+            await promises_1.default.unlink(target).catch((error) => {
+                if (error?.code !== 'ENOENT')
+                    throw error;
+            });
+        }
+        changed += 1;
+        delete nextEntries[memoryId];
+    }
     for (const remote of snapshot.entries) {
         const relative = fileForMemoryPath(remote.path);
         const target = node_path_1.default.join(root, relative);
         const prior = nextEntries[remote.memoryId];
+        const virtuallyRetired = dryRun &&
+            Object.values(basis?.entries || {}).some((entry) => entry.file === relative && retiringIds.has(entry.memoryId));
+        if (!virtuallyRetired)
+            await assertRemoteTarget(root, remote, nextEntries);
+        const moved = Boolean(prior && prior.file !== relative);
+        if (prior && moved && (await reconcileRemoteMove(root, prior, remote, dryRun))) {
+            conflicts += 1;
+        }
         const currentHash = await localHash(root, target);
-        const localChanged = Boolean(prior && currentHash !== prior.fileHash);
-        const remoteChanged = !prior || prior.versionId !== remote.versionId;
+        const localChanged = Boolean(prior && !moved && currentHash !== prior.fileHash);
+        const remoteChanged = !prior || moved || prior.versionId !== remote.versionId;
         if (prior && localChanged && remoteChanged) {
             conflicts += 1;
             await writeConflict(root, {
@@ -241,7 +398,9 @@ async function pullSnapshot(rootInput, snapshot, { dryRun = false } = {}) {
         if (remoteChanged || currentHash === null) {
             changed += 1;
             if (!dryRun)
-                await atomicWrite(root, target, remote.document);
+                await atomicWrite(root, target, remote.document, {
+                    replace: Boolean(prior && !moved && currentHash !== null),
+                });
         }
         const nextHash = hash(remote.document);
         nextEntries[remote.memoryId] = {
@@ -253,33 +412,6 @@ async function pullSnapshot(rootInput, snapshot, { dryRun = false } = {}) {
             contentHash: remote.contentHash,
         };
     }
-    for (const [memoryId, prior] of Object.entries(nextEntries)) {
-        if (remoteIds.has(memoryId))
-            continue;
-        const target = node_path_1.default.join(root, prior.file);
-        const currentHash = await localHash(root, target);
-        if (currentHash !== null && currentHash !== prior.fileHash) {
-            conflicts += 1;
-            await writeConflict(root, {
-                id: memoryId,
-                type: 'remote_delete_local_edit',
-                memoryId,
-                file: prior.file,
-                baseVersionId: prior.versionId,
-                detectedAt: new Date().toISOString(),
-            }, dryRun);
-            continue;
-        }
-        changed += 1;
-        if (!dryRun) {
-            await assertSafeTarget(root, target);
-            await promises_1.default.unlink(target).catch((error) => {
-                if (error?.code !== 'ENOENT')
-                    throw error;
-            });
-        }
-        delete nextEntries[memoryId];
-    }
     if (!dryRun) {
         await atomicWrite(root, node_path_1.default.join(root, 'MEMORY.md'), snapshot.index);
         await atomicJson(root, node_path_1.default.join(root, exports.MEMORY_SYNC_MANIFEST), {
@@ -333,8 +465,13 @@ async function pullChanges(rootInput, delta, { dryRun = false } = {}) {
             }
             const relative = fileForMemoryPath(item.head.path);
             const target = node_path_1.default.join(root, relative);
+            await assertRemoteTarget(root, item.head, nextEntries);
+            const moved = Boolean(prior && prior.file !== relative);
+            if (prior && moved && (await reconcileRemoteMove(root, prior, item.head, dryRun))) {
+                conflicts += 1;
+            }
             const currentHash = await localHash(root, target);
-            if (prior && currentHash !== prior.fileHash) {
+            if (prior && !moved && currentHash !== prior.fileHash) {
                 conflicts += 1;
                 await writeConflict(root, {
                     id: memoryId,
@@ -350,7 +487,9 @@ async function pullChanges(rootInput, delta, { dryRun = false } = {}) {
             }
             changed += 1;
             if (!dryRun)
-                await atomicWrite(root, target, item.head.document);
+                await atomicWrite(root, target, item.head.document, {
+                    replace: Boolean(prior && !moved && currentHash !== null),
+                });
             nextEntries[memoryId] = {
                 memoryId,
                 path: item.head.path,
@@ -371,17 +510,18 @@ async function pullChanges(rootInput, delta, { dryRun = false } = {}) {
         if (!prior)
             continue;
         const target = node_path_1.default.join(root, prior.file);
+        const existing = await readJson(root, node_path_1.default.join(root, exports.MEMORY_SYNC_CONFLICTS, `${memoryId}.json`));
+        const alreadyQuarantined = existing?.type === 'remote_delete_local_edit' &&
+            existing.file === prior.file &&
+            existing.baseVersionId === prior.versionId &&
+            typeof existing.quarantineFile === 'string' &&
+            (await localHash(root, node_path_1.default.join(root, existing.quarantineFile))) !== null;
         const currentHash = await localHash(root, target);
-        if (currentHash !== null && currentHash !== prior.fileHash) {
+        if (alreadyQuarantined || (currentHash !== null && currentHash !== prior.fileHash)) {
             conflicts += 1;
-            await writeConflict(root, {
-                id: memoryId,
-                type: 'remote_delete_local_edit',
-                memoryId,
-                file: prior.file,
-                baseVersionId: prior.versionId,
-                detectedAt: new Date().toISOString(),
-            }, dryRun);
+            await quarantineRemovedTopic(root, prior, dryRun, currentHash || existing?.localFileHash || prior.fileHash);
+            changed += 1;
+            delete nextEntries[memoryId];
             continue;
         }
         changed += 1;
@@ -609,14 +749,80 @@ async function resolveConflict(rootInput, conflictId, strategy, manualContent) {
     if (!conflict)
         throw codedError('MEMORY_SYNC_CONFLICT_NOT_FOUND', `Conflict not found: ${conflictId}`);
     const target = node_path_1.default.join(root, conflict.file);
+    const quarantined = conflict.quarantineFile ? node_path_1.default.join(root, conflict.quarantineFile) : null;
+    if (quarantined)
+        await assertSafeTarget(root, quarantined);
+    const quarantineExists = quarantined ? (await localHash(root, quarantined)) !== null : false;
+    const basisEntry = binding.basis.entries[conflict.memoryId];
+    const exactBasis = basisEntry?.file === conflict.file && basisEntry?.versionId === conflict.baseVersionId;
+    if (conflict.type === 'remote_move_local_edit') {
+        if (!['keep-local', 'keep-remote', 'manual'].includes(strategy)) {
+            throw codedError('MEMORY_SYNC_STRATEGY_INVALID', `Unsupported conflict strategy: ${strategy}`);
+        }
+        const currentRemoteBasis = typeof conflict.recoveryFile === 'string' &&
+            basisEntry?.file === conflict.recoveryFile &&
+            basisEntry?.versionId === conflict.remoteVersionId &&
+            basisEntry?.fileHash === conflict.remoteFileHash;
+        if (!quarantineExists || !quarantined) {
+            throw codedError('MEMORY_SYNC_RECOVERY_CONFLICT', 'The move has not completed its quarantine; retry the pull before resolving it');
+        }
+        if (strategy !== 'keep-remote') {
+            if (!currentRemoteBasis) {
+                throw codedError('MEMORY_SYNC_RECOVERY_CONFLICT', 'The moved Memory head changed; keep the remote head or preserve the quarantined edit separately');
+            }
+            const recoveryTarget = node_path_1.default.join(root, conflict.recoveryFile);
+            if ((await localHash(root, recoveryTarget)) !== conflict.remoteFileHash) {
+                throw codedError('MEMORY_SYNC_RECOVERY_CONFLICT', 'The moved topic has newer local edits; preserve them before recovering the quarantined edit');
+            }
+            if (strategy === 'manual' && !manualContent?.trim()) {
+                throw codedError('MEMORY_SYNC_MANUAL_CONTENT_REQUIRED', 'Manual content is required');
+            }
+            await atomicWrite(root, recoveryTarget, strategy === 'manual' ? manualContent : await promises_1.default.readFile(quarantined, 'utf8'));
+            // Keep the current remote version/hash as the CAS basis. The recovered
+            // body is an explicit local edit of that head, never a new old-path topic.
+        }
+        await promises_1.default.unlink(quarantined);
+        await assertSafeTarget(root, conflictFile);
+        await promises_1.default.unlink(conflictFile);
+        return { resolved: true, strategy };
+    }
+    if (quarantined && strategy !== 'keep-remote' && basisEntry && !exactBasis) {
+        throw codedError('MEMORY_SYNC_RECOVERY_CONFLICT', 'Memory changed after this recovery was recorded');
+    }
+    if (quarantined &&
+        strategy !== 'keep-remote' &&
+        Object.values(binding.basis.entries).some((entry) => entry.file === conflict.file && entry.memoryId !== conflict.memoryId)) {
+        throw codedError('MEMORY_SYNC_RECOVERY_CONFLICT', 'The old topic path now belongs to another Memory');
+    }
+    if (strategy === 'keep-local' && quarantineExists && quarantined) {
+        await assertSafeTarget(root, target, { createParents: true });
+        // Recovery is an explicit user action. Do not overwrite a new local file
+        // created after quarantine, and never send a remote write from this step.
+        await promises_1.default.writeFile(target, await promises_1.default.readFile(quarantined), { mode: 0o600, flag: 'wx' });
+    }
+    if (strategy === 'keep-local' && quarantined && !quarantineExists) {
+        if (!exactBasis || (await localHash(root, target)) !== conflict.localFileHash) {
+            throw codedError('MEMORY_SYNC_RECOVERY_CONFLICT', 'Pending quarantine no longer matches its local edit');
+        }
+    }
     if (strategy === 'keep-remote') {
         if (conflict.type === 'remote_delete_local_edit') {
-            await assertSafeTarget(root, target);
-            await promises_1.default.unlink(target).catch((error) => {
-                if (error?.code !== 'ENOENT')
-                    throw error;
-            });
-            delete binding.basis.entries[conflict.memoryId];
+            // A completed quarantine owns only its recovery file. The active path
+            // may now hold a different remote topic; never delete by the old path.
+            if (!quarantined ||
+                (!quarantineExists &&
+                    exactBasis &&
+                    (await localHash(root, target)) === conflict.localFileHash)) {
+                if (exactBasis) {
+                    await assertSafeTarget(root, target);
+                    await promises_1.default.unlink(target).catch((error) => {
+                        if (error?.code !== 'ENOENT')
+                            throw error;
+                    });
+                }
+            }
+            if (exactBasis)
+                delete binding.basis.entries[conflict.memoryId];
         }
         else {
             if (!conflict.remoteDocument)
@@ -640,7 +846,8 @@ async function resolveConflict(rootInput, conflictId, strategy, manualContent) {
     if (strategy !== 'keep-remote') {
         const basisEntry = binding.basis.entries[conflict.memoryId];
         if (conflict.type === 'remote_delete_local_edit') {
-            delete binding.basis.entries[conflict.memoryId];
+            if (exactBasis)
+                delete binding.basis.entries[conflict.memoryId];
         }
         else if (basisEntry && conflict.remoteVersionId) {
             // The local body stays dirty, but its CAS basis advances to the remote
@@ -649,6 +856,8 @@ async function resolveConflict(rootInput, conflictId, strategy, manualContent) {
         }
     }
     await atomicJson(root, node_path_1.default.join(root, exports.MEMORY_SYNC_BASIS), binding.basis);
+    if (quarantineExists && quarantined)
+        await promises_1.default.unlink(quarantined);
     await assertSafeTarget(root, conflictFile);
     await promises_1.default.unlink(conflictFile);
     return { resolved: true, strategy };
@@ -681,24 +890,26 @@ async function revokeMaterialization(rootInput, generation) {
         if (error?.code !== 'ENOENT')
             throw error;
     });
-    const conflictsDirectory = node_path_1.default.join(root, exports.MEMORY_SYNC_CONFLICTS);
-    const conflictEntries = await promises_1.default.readdir(conflictsDirectory).catch((error) => {
-        if (error?.code === 'ENOENT')
-            return [];
-        throw error;
-    });
-    for (const entry of conflictEntries) {
-        const conflictFile = node_path_1.default.join(conflictsDirectory, entry);
-        await assertSafeTarget(root, conflictFile);
-        const stat = await promises_1.default.lstat(conflictFile);
-        if (!stat.isFile()) {
-            throw codedError('MEMORY_SYNC_METADATA_INVALID', `Unexpected conflict entry during revocation: ${entry}`);
+    for (const directory of [exports.MEMORY_SYNC_CONFLICTS, exports.MEMORY_SYNC_QUARANTINE]) {
+        const protectedDirectory = node_path_1.default.join(root, directory);
+        const protectedEntries = await promises_1.default.readdir(protectedDirectory).catch((error) => {
+            if (error?.code === 'ENOENT')
+                return [];
+            throw error;
+        });
+        for (const entry of protectedEntries) {
+            const protectedFile = node_path_1.default.join(protectedDirectory, entry);
+            await assertSafeTarget(root, protectedFile);
+            const stat = await promises_1.default.lstat(protectedFile);
+            if (!stat.isFile()) {
+                throw codedError('MEMORY_SYNC_METADATA_INVALID', `Unexpected protected entry during revocation: ${entry}`);
+            }
+            await promises_1.default.unlink(protectedFile);
+            removed += 1;
         }
-        await promises_1.default.unlink(conflictFile);
-        removed += 1;
+        if (protectedEntries.length)
+            await promises_1.default.rmdir(protectedDirectory);
     }
-    if (conflictEntries.length)
-        await promises_1.default.rmdir(conflictsDirectory);
     if (manifest) {
         await atomicJson(root, node_path_1.default.join(root, exports.MEMORY_SYNC_MANIFEST), {
             ...manifest,

package/dist/lib/platform-update-local.d.ts

@@ -0,0 +1,2 @@
+import type { PlatformUpdateDependencies } from './platform-update';
+export declare const localPlatformUpdateDependencies: PlatformUpdateDependencies;

package/dist/lib/platform-update-local.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localPlatformUpdateDependencies = void 0;
+const update_check_1 = require("./update-check");
+const first_party_harness_update_1 = require("./first-party-harness-update");
+const exec_runtime_binary_1 = require("./exec-runtime-binary");
+function parseDaemonStatus(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout.trim());
+    }
+    catch {
+        return null;
+    }
+    if (!parsed ||
+        typeof parsed !== 'object' ||
+        Array.isArray(parsed) ||
+        typeof parsed.state !== 'string') {
+        return null;
+    }
+    return parsed;
+}
+async function daemonStatus(check) {
+    const result = await (0, exec_runtime_binary_1.execRuntimeBinaryCapture)(['update', check ? '--check' : '--status', '--json'], { timeoutMs: 8000 });
+    const status = parseDaemonStatus(result.stdout);
+    if (!status) {
+        // Older daemons already own a signed updater, but do not know this JSON
+        // schema. Keep that recovery path reachable without guessing from logs.
+        const legacy = check
+            ? await (0, exec_runtime_binary_1.execRuntimeBinaryCapture)(['update', '--check'], { timeoutMs: 8000 })
+            : null;
+        const version = await (0, exec_runtime_binary_1.execRuntimeBinaryCapture)(['--version'], { timeoutMs: 2500 });
+        const installedVersion = version.stdout
+            .trim()
+            .match(/^v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/)?.[1] ?? null;
+        return {
+            state: legacy && legacy.code !== 0 ? 'check-failed' : 'legacy-runtime',
+            owner: 'legacy-runtime',
+            installedVersion,
+            runningVersion: null,
+            offeredVersion: null,
+            commands: ['skrr daemon update'],
+            detail: legacy
+                ? legacy.stdout.trim() || legacy.stderr.trim()
+                : 'This daemon predates unified update status. Its existing updater remains available; detailed status appears after upgrading.',
+        };
+    }
+    return result.code === 0
+        ? status
+        : { ...status, state: 'check-failed', detail: status.detail ?? result.stderr.trim() };
+}
+async function updateDaemon(mode, options) {
+    if (!(0, exec_runtime_binary_1.findRuntimeBinary)())
+        return {
+            state: 'not-installed',
+            owner: 'none',
+            commands: ['skrr daemon install'],
+            detail: 'The daemon is not installed on this computer.',
+        };
+    if (mode !== 'apply')
+        return daemonStatus(mode === 'check');
+    const before = await daemonStatus(false);
+    // Source, desktop, image and retired npm installs have a different owner.
+    // Their next command is already present in the daemon's own status response.
+    if (!['self', 'homebrew', 'direct', 'brew', 'legacy-runtime'].includes(String(before.owner ?? before.installMethod)))
+        return before;
+    const args = ['update', ...(options.restart ? ['--restart'] : [])];
+    const result = await (0, exec_runtime_binary_1.execRuntimeBinaryCapture)(args, { timeoutMs: 15 * 60 * 1000 });
+    let after = before;
+    try {
+        after = await daemonStatus(false);
+    }
+    catch {
+        /* An apply failure must retain its original result if a restart prevents probing. */
+    }
+    return {
+        ...after,
+        ...(result.code !== 0 ? { state: 'failed' } : {}),
+        detail: result.code !== 0
+            ? result.stderr.trim() || result.stdout.trim() || `Daemon updater exited ${result.code}.`
+            : after.detail,
+        apply: {
+            exitCode: result.code,
+            output: result.stdout.trim(),
+            diagnostics: result.stderr.trim(),
+        },
+    };
+}
+exports.localPlatformUpdateDependencies = {
+    async cli(mode, options) {
+        const args = {
+            currentVersion: options.currentVersion,
+            baseURL: options.baseURL,
+            env: options.env,
+        };
+        if (mode === 'status')
+            return (0, update_check_1.readCliUpdateStatus)(args);
+        if (mode === 'check')
+            return (0, update_check_1.checkCliUpdate)({ ...args, force: true });
+        return (0, update_check_1.performCliUpdate)(args);
+    },
+    async code(mode, options) {
+        if (mode === 'status')
+            return (0, first_party_harness_update_1.getLocalCodeUpdateStatus)(options.env);
+        if (mode === 'check')
+            return (0, first_party_harness_update_1.checkLocalCodeUpdate)({ env: options.env, force: true });
+        const current = (0, first_party_harness_update_1.getLocalCodeUpdateStatus)(options.env);
+        if (current.owner !== 'managed' || !current.activePath)
+            return current;
+        return (0, first_party_harness_update_1.updateLocalCode)({ env: options.env });
+    },
+    daemon: updateDaemon,
+};

package/dist/lib/platform-update.d.ts

@@ -0,0 +1,39 @@
+/** One local update surface; each installation owner still applies its own bytes. */
+export declare const UPDATE_COMPONENTS: readonly ["cli", "code", "daemon"];
+export type UpdateComponent = (typeof UPDATE_COMPONENTS)[number];
+export type UpdateMode = 'check' | 'status' | 'apply';
+export interface ComponentUpdateStatus {
+    component: UpdateComponent;
+    state: string;
+    runningVersion: string | null;
+    installedVersion: string | null;
+    offeredVersion: string | null;
+    owner: string;
+    commands: string[];
+    autoUpdateEnabled: boolean | null;
+    lastAttempt: unknown | null;
+    detail: string | null;
+    /** The component's full status is retained for machine-readable diagnostics. */
+    status: Record<string, unknown>;
+}
+export interface PlatformUpdateOptions {
+    mode: UpdateMode;
+    component?: UpdateComponent | 'all';
+    currentVersion: string;
+    baseURL: string;
+    restart?: boolean;
+    env?: NodeJS.ProcessEnv;
+}
+export interface PlatformUpdateDependencies {
+    cli(mode: UpdateMode, options: PlatformUpdateOptions): Promise<unknown>;
+    code(mode: UpdateMode, options: PlatformUpdateOptions): Promise<unknown>;
+    daemon(mode: UpdateMode, options: PlatformUpdateOptions): Promise<unknown>;
+}
+export declare function normalizeComponentUpdateStatus(component: UpdateComponent, value: unknown): ComponentUpdateStatus;
+export declare function runPlatformUpdate(options: PlatformUpdateOptions, dependencies: PlatformUpdateDependencies): Promise<{
+    schemaVersion: 1;
+    mode: UpdateMode;
+    components: ComponentUpdateStatus[];
+    ok: boolean;
+}>;
+export declare function describeComponentUpdate(status: ComponentUpdateStatus): string;