salmon-loop 0.2.16 → 0.3.1

package/dist/core/protocols/acp/acp-checkpoint-probe.js

@@ -0,0 +1,113 @@
+import { text } from '../../../locales/index.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { hashRepoPath } from './acp-types.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function toCheckpointMeta(input) {
+    if (!input)
+        return null;
+    return {
+        id: input.id,
+        createdAt: input.createdAt ?? null,
+        strategy: input.strategy ?? null,
+        backend: input.backend ?? null,
+    };
+}
+function toResumeHint(probe) {
+    if (!probe || probe.valid)
+        return null;
+    switch (probe.reason) {
+        case 'not_found':
+            return {
+                code: 'CHECKPOINT_NOT_FOUND',
+                message: text.acp.checkpointNotFound,
+            };
+        case 'manifest_parse_error':
+            return {
+                code: 'CHECKPOINT_MANIFEST_PARSE_ERROR',
+                message: text.acp.checkpointManifestParseError,
+            };
+        case 'manifest_io_error':
+            return {
+                code: 'CHECKPOINT_MANIFEST_IO_ERROR',
+                message: text.acp.checkpointManifestIoError,
+            };
+        case 'manifest_lock_timeout':
+            return {
+                code: 'CHECKPOINT_MANIFEST_LOCK_TIMEOUT',
+                message: text.acp.checkpointManifestLockTimeout,
+            };
+        case 'manifest_unavailable':
+            return {
+                code: 'CHECKPOINT_MANIFEST_UNAVAILABLE',
+                message: text.acp.checkpointManifestUnavailable,
+            };
+        default:
+            return {
+                code: 'CHECKPOINT_RESUME_UNAVAILABLE',
+                message: text.acp.checkpointResumeUnavailable,
+            };
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export async function probeCheckpoint(reader, params) {
+    const startedAt = Date.now();
+    const checkpoints = await reader.listBySession({
+        repoPath: params.repoPath,
+        sessionId: params.sessionId,
+        limit: 1,
+    });
+    const latest = checkpoints.at(-1);
+    let resumeProbe = null;
+    if (latest?.id && reader.probeById) {
+        const probed = await reader.probeById({
+            repoPath: params.repoPath,
+            checkpointId: latest.id,
+        });
+        resumeProbe = {
+            checkpointId: latest.id,
+            valid: probed.valid,
+            reason: probed.reason,
+        };
+    }
+    else if (latest?.id && reader.getById) {
+        const found = await reader.getById({
+            repoPath: params.repoPath,
+            checkpointId: latest.id,
+        });
+        resumeProbe = {
+            checkpointId: latest.id,
+            valid: Boolean(found),
+            reason: found ? 'ok' : 'not_found',
+        };
+    }
+    const resumeReady = resumeProbe?.valid ?? Boolean(latest);
+    recordAuditEvent('acp.checkpoint.read', {
+        sessionId: params.sessionId,
+        repoPathHash: params.repoPathHash,
+        latestCheckpointId: latest?.id ?? null,
+        hit: Boolean(latest),
+        latencyMs: Date.now() - startedAt,
+        resumeProbe: resumeProbe ?? undefined,
+    }, { source: 'acp', severity: 'low', scope: 'session', phase: 'PREFLIGHT' });
+    const resumeHint = toResumeHint(resumeProbe);
+    return {
+        _meta: {
+            salmonloop: {
+                latestCheckpointId: latest?.id ?? null,
+                checkpoint: toCheckpointMeta(latest),
+                resumeReady,
+                resumeProbe,
+                resumeHint: resumeHint?.message ?? null,
+                resumeHintCode: resumeHint?.code ?? null,
+            },
+        },
+    };
+}
+export function probeCheckpointForNewSession(reader, params) {
+    return probeCheckpoint(reader, { ...params, repoPathHash: hashRepoPath(params.repoPath) });
+}
+//# sourceMappingURL=acp-checkpoint-probe.js.map

package/dist/core/protocols/acp/acp-session-persistence.js

@@ -0,0 +1,336 @@
+import { mkdir, open, readFile, rename, stat, unlink, writeFile, } from '../../adapters/fs/node-fs.js';
+import { defaultPathAdapter } from '../../adapters/path/path-adapter.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { hashRepoPath, isPermissionPolicyValue, parseTimestamp, } from './acp-types.js';
+export function createAcpSessionPersistence(options) {
+    const deletedSessionIds = new Map();
+    let sessionsHydrated = false;
+    let hydratePromise = null;
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+    function isPidAlive(pid) {
+        if (!Number.isInteger(pid) || pid <= 0)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            if (error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                error.code === 'EPERM') {
+                return true;
+            }
+            return false;
+        }
+    }
+    function isFileMissing(error) {
+        return Boolean(error &&
+            typeof error === 'object' &&
+            'code' in error &&
+            (error.code === 'ENOENT' ||
+                error.code === 'ENOTDIR'));
+    }
+    function pruneSessionRecords(records) {
+        const cutoff = Date.now() - options.storePolicy.maxAgeMs;
+        return [...records]
+            .filter((record) => parseTimestamp(record.updatedAt) >= cutoff)
+            .sort((a, b) => parseTimestamp(b.updatedAt) - parseTimestamp(a.updatedAt))
+            .slice(0, options.storePolicy.maxEntries);
+    }
+    function normalizeDeletedSessionRecords(input) {
+        if (!Array.isArray(input))
+            return [];
+        const byId = new Map();
+        for (const entry of input) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const record = entry;
+            if (typeof record.id !== 'string' || !record.id)
+                continue;
+            if (typeof record.deletedAt !== 'string' || !record.deletedAt)
+                continue;
+            const current = byId.get(record.id);
+            if (!current || parseTimestamp(record.deletedAt) > parseTimestamp(current.deletedAt)) {
+                byId.set(record.id, { id: record.id, deletedAt: record.deletedAt });
+            }
+        }
+        return Array.from(byId.values());
+    }
+    function pruneDeletedSessionRecords(records) {
+        const cutoff = Date.now() - options.storePolicy.maxAgeMs;
+        return normalizeDeletedSessionRecords(records)
+            .filter((record) => parseTimestamp(record.deletedAt) >= cutoff)
+            .sort((a, b) => parseTimestamp(b.deletedAt) - parseTimestamp(a.deletedAt));
+    }
+    function normalizePersistedSessionStore(input) {
+        if (!input || typeof input !== 'object') {
+            return { schemaVersion: 2, sessions: [] };
+        }
+        const raw = input;
+        if (!Array.isArray(raw.sessions))
+            return { schemaVersion: 2, sessions: [] };
+        if (raw.schemaVersion === 1) {
+            return {
+                schemaVersion: 2,
+                sessions: raw.sessions.map((entry) => ({
+                    id: entry.id,
+                    cwd: entry.cwd,
+                    mcpServers: entry.mcpServers,
+                    createdAt: entry.createdAt,
+                    updatedAt: entry.updatedAt,
+                    title: entry.title,
+                    taskId: undefined,
+                    history: [],
+                    permissionPolicy: isPermissionPolicyValue(String(options.defaultPermissionPolicy))
+                        ? options.defaultPermissionPolicy
+                        : 'ask',
+                    modeId: options.resolveExposedAcpModeId(options.defaultModeId),
+                })),
+                deletedSessions: [],
+            };
+        }
+        if (raw.schemaVersion === 2) {
+            return {
+                schemaVersion: 2,
+                sessions: raw.sessions,
+                deletedSessions: pruneDeletedSessionRecords(raw.deletedSessions),
+            };
+        }
+        return { schemaVersion: 2, sessions: [] };
+    }
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+    async function hydrate() {
+        if (sessionsHydrated)
+            return;
+        if (hydratePromise)
+            return hydratePromise;
+        hydratePromise = (async () => {
+            sessionsHydrated = true;
+            if (!options.path)
+                return;
+            try {
+                const raw = await readFile(options.path, 'utf8');
+                const parsed = normalizePersistedSessionStore(JSON.parse(raw));
+                const deletedIds = new Set(parsed.deletedSessions?.map((record) => record.id) ?? []);
+                for (const record of parsed.deletedSessions ?? []) {
+                    deletedSessionIds.set(record.id, record.deletedAt);
+                }
+                for (const stored of pruneSessionRecords(parsed.sessions)) {
+                    if (deletedIds.has(stored.id))
+                        continue;
+                    const runtimeState = {
+                        permissionPolicy: isPermissionPolicyValue(String(stored.permissionPolicy))
+                            ? stored.permissionPolicy
+                            : options.defaultPermissionPolicy,
+                        modeId: options.resolveExposedAcpModeId(stored.modeId, options.defaultModeId),
+                    };
+                    options.sessions.upsert({
+                        id: stored.id,
+                        cwd: stored.cwd,
+                        mcpServers: Array.isArray(stored.mcpServers) ? stored.mcpServers : [],
+                        createdAt: stored.createdAt,
+                        updatedAt: stored.updatedAt,
+                        title: stored.title,
+                        taskId: stored.taskId,
+                        permissionPolicy: runtimeState.permissionPolicy,
+                        modeId: runtimeState.modeId,
+                        history: Array.isArray(stored.history)
+                            ? stored.history.slice(-options.storePolicy.historyMaxEntries)
+                            : [],
+                        materialized: true,
+                        cancelRequested: false,
+                    });
+                    if (!options.sessionRuntime.has(stored.id)) {
+                        options.sessionRuntime.set(stored.id, runtimeState);
+                    }
+                }
+            }
+            catch (error) {
+                if (isFileMissing(error))
+                    return;
+                recordAuditEvent('acp.session.hydrate.failed', {
+                    errorName: error instanceof Error ? error.name : typeof error,
+                }, { source: 'acp', severity: 'low', scope: 'session', phase: 'PREFLIGHT' });
+            }
+        })();
+        return hydratePromise;
+    }
+    async function persist() {
+        if (!options.path)
+            return;
+        const dir = defaultPathAdapter.dirname(options.path);
+        const lockPath = `${options.path}.lock`;
+        const baseRecords = options.sessions
+            .list()
+            .filter(options.isPersistableSession)
+            .map((session) => {
+            const runtimeState = options.ensureSessionRuntimeState(session.id);
+            return {
+                id: session.id,
+                cwd: session.cwd,
+                mcpServers: session.mcpServers,
+                createdAt: session.createdAt,
+                updatedAt: session.updatedAt,
+                title: session.title,
+                taskId: session.taskId,
+                history: session.history.slice(-options.storePolicy.historyMaxEntries),
+                permissionPolicy: session.permissionPolicy ?? runtimeState.permissionPolicy,
+                modeId: session.modeId ?? runtimeState.modeId,
+            };
+        });
+        const prunedRecords = pruneSessionRecords(baseRecords);
+        const keepIds = new Set(prunedRecords.map((record) => record.id));
+        for (const record of options.sessions.list()) {
+            if (options.isPersistableSession(record) && !keepIds.has(record.id)) {
+                options.sessions.delete(record.id);
+            }
+        }
+        const payload = { schemaVersion: 2, sessions: prunedRecords };
+        const payloadDeletedSessions = pruneDeletedSessionRecords(Array.from(deletedSessionIds, ([id, deletedAt]) => ({ id, deletedAt })));
+        const primaryRepoPath = prunedRecords[0]?.cwd;
+        const lockAuditDetails = {
+            lockPath,
+            lockPathHash: hashRepoPath(lockPath),
+            repoPathHash: primaryRepoPath ? hashRepoPath(primaryRepoPath) : undefined,
+        };
+        const tryClearStaleLock = async () => {
+            try {
+                const raw = await readFile(lockPath, 'utf8');
+                const parsed = JSON.parse(raw);
+                const createdAtMs = typeof parsed.createdAtMs === 'number' && Number.isFinite(parsed.createdAtMs)
+                    ? parsed.createdAtMs
+                    : null;
+                if (createdAtMs === null)
+                    return;
+                if (Date.now() - createdAtMs <= options.storePolicy.lockStaleMs)
+                    return;
+                if (typeof parsed.pid === 'number' && isPidAlive(parsed.pid))
+                    return;
+                await unlink(lockPath);
+                recordAuditEvent('acp.session.lock.stale_reclaimed', lockAuditDetails, {
+                    source: 'acp',
+                    severity: 'low',
+                    scope: 'session',
+                    phase: 'PREFLIGHT',
+                });
+            }
+            catch {
+                try {
+                    const lockStat = await stat(lockPath);
+                    const ageMs = Date.now() - lockStat.mtimeMs;
+                    if (Number.isFinite(ageMs) && ageMs > options.storePolicy.lockStaleMs * 2) {
+                        await unlink(lockPath);
+                        recordAuditEvent('acp.session.lock.corrupted_reclaimed', {
+                            ...lockAuditDetails,
+                            ageMs: Math.max(0, Math.floor(ageMs)),
+                        }, { source: 'acp', severity: 'medium', scope: 'session', phase: 'PREFLIGHT' });
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        };
+        let lockHandle;
+        try {
+            await mkdir(dir, { recursive: true });
+            const acquireDeadlineMs = Date.now() + Math.max(250, options.storePolicy.lockAcquireTimeoutMs);
+            for (let attempt = 0; Date.now() < acquireDeadlineMs; attempt += 1) {
+                try {
+                    lockHandle = await open(lockPath, 'wx');
+                    await lockHandle.writeFile(JSON.stringify({ pid: process.pid, createdAtMs: Date.now() }), 'utf8');
+                    break;
+                }
+                catch {
+                    await tryClearStaleLock();
+                    const delayMs = Math.min(250, 20 * (attempt + 1));
+                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                }
+            }
+            if (!lockHandle) {
+                recordAuditEvent('acp.session.lock.acquire_timeout', lockAuditDetails, {
+                    source: 'acp',
+                    severity: 'medium',
+                    scope: 'session',
+                    phase: 'PREFLIGHT',
+                });
+                throw new Error('ACP_SESSION_PERSIST_LOCK_TIMEOUT');
+            }
+            const heartbeat = setInterval(() => {
+                void writeFile(lockPath, JSON.stringify({ pid: process.pid, createdAtMs: Date.now() }), 'utf8');
+            }, Math.max(1000, options.storePolicy.lockHeartbeatMs));
+            const tempPath = defaultPathAdapter.join(dir, `.sessions.v1.json.tmp-${process.pid}-${Date.now()}`);
+            try {
+                let existing = { schemaVersion: 2, sessions: [] };
+                try {
+                    const existingRaw = await readFile(options.path, 'utf8');
+                    existing = normalizePersistedSessionStore(JSON.parse(existingRaw));
+                }
+                catch {
+                    // ignore read failure; writing fresh payload is acceptable
+                }
+                const merged = new Map();
+                const mergedDeletedSessions = pruneDeletedSessionRecords([
+                    ...(existing.deletedSessions ?? []),
+                    ...payloadDeletedSessions,
+                ]);
+                const mergedDeletedIds = new Set(mergedDeletedSessions.map((record) => record.id));
+                for (const record of mergedDeletedSessions) {
+                    deletedSessionIds.set(record.id, record.deletedAt);
+                }
+                for (const entry of existing.sessions)
+                    merged.set(entry.id, entry);
+                for (const entry of payload.sessions)
+                    merged.set(entry.id, entry);
+                for (const id of mergedDeletedIds)
+                    merged.delete(id);
+                const mergedPayload = {
+                    schemaVersion: 2,
+                    sessions: pruneSessionRecords(Array.from(merged.values())),
+                    deletedSessions: mergedDeletedSessions,
+                };
+                await writeFile(tempPath, JSON.stringify(mergedPayload, null, 2), 'utf8');
+                await rename(tempPath, options.path);
+            }
+            finally {
+                clearInterval(heartbeat);
+            }
+        }
+        catch (error) {
+            recordAuditEvent('acp.session.persist.failed', {
+                errorName: error instanceof Error ? error.name : typeof error,
+            }, { source: 'acp', severity: 'low', scope: 'session', phase: 'PREFLIGHT' });
+        }
+        finally {
+            if (lockHandle) {
+                try {
+                    await lockHandle.close();
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    await unlink(lockPath);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    function markDeleted(id) {
+        deletedSessionIds.set(id, new Date().toISOString());
+    }
+    return {
+        hydrate,
+        persist,
+        markDeleted,
+        getDeletedSessionIds: () => deletedSessionIds,
+    };
+}
+//# sourceMappingURL=acp-session-persistence.js.map

package/dist/core/protocols/acp/acp-types.js

@@ -0,0 +1,17 @@
+import { createHash } from 'crypto';
+export const ACP_PERMISSION_POLICY_ASK = 'ask';
+export const ACP_PERMISSION_POLICY_DENY_ALL = 'deny_all';
+export const ACP_PERMISSION_POLICY_ALLOW_ALL = 'allow_all';
+export function isPermissionPolicyValue(value) {
+    return value === 'ask' || value === 'deny_all' || value === 'allow_all';
+}
+export function parseTimestamp(value) {
+    if (typeof value !== 'string' || value.length === 0)
+        return 0;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+export function hashRepoPath(repoPath) {
+    return createHash('sha256').update(repoPath).digest('hex').slice(0, 16);
+}
+//# sourceMappingURL=acp-types.js.map