@pasko70/pibo 1.13.0 → 1.14.0

package/dist/plugins/context-files.js

@@ -1,8 +1,9 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { dirname, extname, isAbsolute, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { readFallbackPidFile, readPidFile } from "../gateway/pidfile.js";
 import { PiboWebHttpError, readJsonBody, responseHtml, responseJson } from "../web/http.js";
 import { definePiboPlugin } from "./registry.js";
 import { buildContextFileDiff, ContextFileMetadataStore, hashContextFileContent, } from "./context-files-store.js";
@@ -33,6 +34,18 @@ function resolveContextFilesPaths(options) {
         agentWorkspaceRoot: resolve(options.agentWorkspaceRoot ?? join(getPiboHome(), "agent-workspaces")),
     };
 }
+function assertContextFilesStorageOwnership(paths) {
+    const piboHome = resolve(getPiboHome());
+    const metadataPath = resolve(paths.metadataPath);
+    if (metadataPath !== piboHome && !metadataPath.startsWith(`${piboHome}${sep}`))
+        return;
+    const ownerPid = [readPidFile(), readFallbackPidFile()]
+        .find((pid) => pid !== undefined && pid !== process.pid);
+    if (ownerPid === undefined)
+        return;
+    throw new Error(`Context Files storage is owned by the active gateway process ${ownerPid}. ` +
+        "Use an isolated PIBO_HOME for candidate validation, or stop and activate the gateway package before migrating this storage.");
+}
 function normalizeLabel(value) {
     if (typeof value !== "string")
         throw new PiboWebHttpError("label must be a string", 400);
@@ -96,6 +109,16 @@ function normalizeRevisionId(value) {
         throw new PiboWebHttpError("revisionId is required", 400);
     return value.trim();
 }
+function normalizeRevisionName(value) {
+    if (typeof value !== "string")
+        throw new PiboWebHttpError("name must be a string", 400);
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new PiboWebHttpError("name is required", 400);
+    if (trimmed.length > 120)
+        throw new PiboWebHttpError("name must be at most 120 characters", 400);
+    return trimmed;
+}
 function normalizeDiffSide(value, fallback) {
     if (!value)
         return fallback;
@@ -196,8 +219,7 @@ function sameSnapshot(left, right) {
         && left?.updatedAt === right.updatedAt
         && left?.bytes === right.bytes
         && left?.linkState === right.linkState
-        && left?.sourceHash === right.sourceHash
-        && left?.activeRevisionId === right.activeRevisionId;
+        && left?.sourceHash === right.sourceHash;
 }
 function contentType(pathname) {
     const ext = extname(pathname);
@@ -272,7 +294,6 @@ function contextFilePayload(file) {
         ...(file.agentProfileName ? { agentProfileName: file.agentProfileName } : {}),
         ...(file.sourceRef ? { sourceRef: file.sourceRef } : {}),
         ...(file.sourceHash ? { sourceHash: file.sourceHash } : {}),
-        ...(file.activeRevisionId ? { activeRevisionId: file.activeRevisionId } : {}),
         exists: file.exists,
         ...(file.bytes !== undefined ? { bytes: file.bytes } : {}),
         ...(file.updatedAt ? { updatedAt: file.updatedAt } : {}),
@@ -317,6 +338,7 @@ class ContextFileService {
     managed = new Map();
     snapshots = new Map();
     pollTimer;
+    pollFailureReported = false;
     constructor(paths, api) {
         this.paths = paths;
         this.api = api;
@@ -335,17 +357,16 @@ class ContextFileService {
         this.discoverGlobalManagedFiles(context, false);
         const managed = this.managed.get(key);
         if (managed) {
-            const file = this.resolveManagedInfo(context, managed);
-            const activeRevision = file.activeRevisionId ? this.store.getRevision(file.activeRevisionId) : undefined;
+            const record = this.ensureManagedRecordSynced(managed);
+            const file = this.resolveManagedInfo(context, record);
             const snapshot = await fileSnapshot(file.absolutePath);
-            const markdown = snapshot.exists ? (snapshot.content ?? "") : (activeRevision?.content ?? "");
             return {
                 ...file,
                 bytes: snapshot.bytes ?? file.bytes,
                 updatedAt: snapshot.updatedAt ?? file.updatedAt,
                 version: snapshot.version ?? file.version,
                 exists: snapshot.exists,
-                markdown,
+                markdown: snapshot.exists ? (snapshot.content ?? "") : record.workingContent,
             };
         }
         const catalogFile = this.requirePluginCatalogFile(context, key);
@@ -375,23 +396,11 @@ class ContextFileService {
             managedPath: absolutePath,
             scope,
             agentProfileName,
+            workingContent: markdown,
         });
-        const revision = this.store.appendRevision({
-            contextFileKey: record.key,
-            kind: "working",
-            contentHash: hashContextFileContent(markdown),
-            content: markdown,
-            actorId: webSession.authSession.identity.userId,
-            note: "Managed context file created",
-        });
-        const updated = this.store.updateFile({
-            ...record,
-            activeRevisionId: revision.id,
-            updatedAt: new Date().toISOString(),
-        });
-        this.upsertManaged(updated);
-        const document = await this.read(context, updated.key);
-        this.snapshots.set(updated.key, this.snapshotFromInfo(document));
+        this.upsertManaged(record);
+        const document = await this.read(context, record.key);
+        this.snapshots.set(record.key, this.snapshotFromInfo(document));
         this.emitChanged(context, "context-file.created", "web", webSession.authSession.identity.userId, document);
         return document;
     }
@@ -404,45 +413,23 @@ class ContextFileService {
         const key = uniqueKey(`ctx:${slugSegment(label)}`, new Set(this.list(context).map((file) => file.key)));
         const targetDir = this.resolveManagedDir(scope, agentProfileName);
         const absolutePath = uniquePath(targetDir, managedFileName(label));
+        const sourceContent = sourceDescriptor.content ?? "";
         await mkdir(dirname(absolutePath), { recursive: true });
-        await writeFile(absolutePath, sourceDescriptor.content ?? "", "utf8");
+        await writeFile(absolutePath, sourceContent, "utf8");
         const record = this.store.createFile({
             key,
             label,
             managedPath: absolutePath,
             scope,
             agentProfileName,
+            workingContent: sourceContent,
             sourceRef: this.pluginSourceRef(sourceFile),
             sourceHash: sourceDescriptor.contentHash,
+            sourceContent,
         });
-        const sourceRevision = this.store.appendRevision({
-            contextFileKey: record.key,
-            kind: "source-snapshot",
-            contentHash: sourceDescriptor.contentHash,
-            content: sourceDescriptor.content ?? "",
-            actorId: webSession.authSession.identity.userId,
-            sourceHashAtCreation: sourceDescriptor.contentHash,
-            note: "Plugin source linked",
-        });
-        const workingRevision = this.store.appendRevision({
-            contextFileKey: record.key,
-            kind: "working",
-            contentHash: sourceDescriptor.contentHash,
-            content: sourceDescriptor.content ?? "",
-            actorId: webSession.authSession.identity.userId,
-            basedOnRevisionId: sourceRevision.id,
-            sourceHashAtCreation: sourceDescriptor.contentHash,
-            note: "Managed working copy created from plugin source",
-        });
-        const updated = this.store.updateFile({
-            ...record,
-            activeRevisionId: workingRevision.id,
-            sourceHash: sourceDescriptor.contentHash,
-            updatedAt: new Date().toISOString(),
-        });
-        this.upsertManaged(updated);
-        const document = await this.read(context, updated.key);
-        this.snapshots.set(updated.key, this.snapshotFromInfo(document));
+        this.upsertManaged(record);
+        const document = await this.read(context, record.key);
+        this.snapshots.set(record.key, this.snapshotFromInfo(document));
         this.emitChanged(context, "context-file.linked_from_plugin", "web", webSession.authSession.identity.userId, document);
         return document;
     }
@@ -456,10 +443,7 @@ class ContextFileService {
         }
         if (current.markdown === markdown)
             return current;
-        const updatedRecord = await this.writeWorkingContent(record, markdown, {
-            actorId: webSession.authSession.identity.userId,
-            note: "Managed context file updated",
-        });
+        const updatedRecord = await this.writeWorkingContent(record, markdown);
         const updated = await this.read(context, updatedRecord.key);
         this.snapshots.set(updated.key, this.snapshotFromInfo(updated));
         this.emitChanged(context, "context-file.updated", "web", webSession.authSession.identity.userId, updated);
@@ -486,6 +470,7 @@ class ContextFileService {
             managedPath: nextPath,
             scope,
             agentProfileName,
+            workingContent: this.currentWorkingContent(record),
             updatedAt: new Date().toISOString(),
         });
         this.upsertManaged(updated);
@@ -499,11 +484,10 @@ class ContextFileService {
         if (!record.sourceRef)
             throw new PiboWebHttpError("Only linked managed files can be reset to source", 400);
         const liveSource = this.requireLiveSourceForRecord(context, record);
-        this.ensureSourceSnapshot(record, liveSource, webSession.authSession.identity.userId, "Source snapshot refreshed during reset");
-        const updatedRecord = await this.writeWorkingContent(record, liveSource.content ?? "", {
-            actorId: webSession.authSession.identity.userId,
+        const sourceContent = liveSource.content ?? "";
+        const updatedRecord = await this.writeWorkingContent(record, sourceContent, {
             sourceHash: liveSource.contentHash,
-            note: "Working copy reset to source",
+            sourceContent,
         });
         const document = await this.read(context, updatedRecord.key);
         this.snapshots.set(updatedRecord.key, this.snapshotFromInfo(document));
@@ -515,39 +499,47 @@ class ContextFileService {
         if (!record.sourceRef)
             throw new PiboWebHttpError("Only linked managed files can adopt a source", 400);
         const liveSource = this.requireLiveSourceForRecord(context, record);
-        this.ensureSourceSnapshot(record, liveSource, webSession.authSession.identity.userId, "Source snapshot adopted");
-        const updatedRecord = await this.writeWorkingContent(record, liveSource.content ?? "", {
-            actorId: webSession.authSession.identity.userId,
+        const sourceContent = liveSource.content ?? "";
+        const updatedRecord = await this.writeWorkingContent(record, sourceContent, {
             sourceHash: liveSource.contentHash,
-            note: "Plugin source adopted",
+            sourceContent,
         });
         const document = await this.read(context, updatedRecord.key);
         this.snapshots.set(updatedRecord.key, this.snapshotFromInfo(document));
         this.emitChanged(context, "context-file.source_adopted", "web", webSession.authSession.identity.userId, document);
         return document;
     }
+    async createRevision(context, key, body, webSession) {
+        const record = this.ensureManagedRecordSynced(this.requireManagedRecord(key));
+        const name = normalizeRevisionName(body.name);
+        const content = this.currentWorkingContent(record);
+        const revision = this.store.appendRevision({
+            contextFileKey: key,
+            name,
+            contentHash: hashContextFileContent(content),
+            content,
+            actorId: webSession.authSession.identity.userId,
+        });
+        const document = await this.read(context, key);
+        this.emitChanged(context, "context-file.revision_created", "web", webSession.authSession.identity.userId, document);
+        return this.revisionInfoFromRecord(revision);
+    }
     async restoreRevision(context, key, body, webSession) {
         const record = this.requireManagedRecord(key);
         const revisionId = normalizeRevisionId(body.revisionId);
         const revision = this.store.getRevision(revisionId);
         if (!revision || revision.contextFileKey !== key)
             throw new PiboWebHttpError(`Unknown revision "${revisionId}"`, 404);
-        const updatedRecord = await this.writeWorkingContent(record, revision.content, {
-            actorId: webSession.authSession.identity.userId,
-            basedOnRevisionId: revision.id,
-            note: `Revision restored from ${revision.id}`,
-        });
+        const updatedRecord = await this.writeWorkingContent(record, revision.content);
         const document = await this.read(context, updatedRecord.key);
         this.snapshots.set(updatedRecord.key, this.snapshotFromInfo(document));
         this.emitChanged(context, "context-file.revision_restored", "web", webSession.authSession.identity.userId, document);
         return document;
     }
     listRevisions(context, key) {
-        const record = this.ensureManagedRecordSynced(this.requireManagedRecord(key));
-        const revisions = this.store.listRevisions(key).map((revision) => this.revisionInfoFromRecord(revision, record.activeRevisionId));
+        this.ensureManagedRecordSynced(this.requireManagedRecord(key));
         return {
-            revisions,
-            ...(record.activeRevisionId ? { activeRevisionId: record.activeRevisionId } : {}),
+            revisions: this.store.listRevisions(key).map((revision) => this.revisionInfoFromRecord(revision)),
         };
     }
     diff(context, key, baseKind, targetKind) {
@@ -586,7 +578,14 @@ class ContextFileService {
         for (const file of this.list(context))
             this.snapshots.set(file.key, this.snapshotFromInfo(file));
         this.pollTimer = setInterval(() => {
-            void this.poll(context);
+            void this.poll(context).then(() => {
+                this.pollFailureReported = false;
+            }).catch((error) => {
+                if (this.pollFailureReported)
+                    return;
+                this.pollFailureReported = true;
+                console.error(`[pibo] Context Files polling failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
         }, POLL_INTERVAL_MS);
         this.pollTimer.unref?.();
     }
@@ -645,30 +644,17 @@ class ContextFileService {
                 label,
                 managedPath: absolutePath,
                 scope: "global",
+                workingContent: snapshot.content ?? "",
                 createdAt: snapshot.updatedAt,
                 updatedAt: snapshot.updatedAt,
             });
-            const revision = this.store.appendRevision({
-                contextFileKey: record.key,
-                kind: "working",
-                contentHash: snapshot.version,
-                content: snapshot.content ?? "",
-                createdAt: snapshot.updatedAt,
-                note: "Global context file discovered on disk",
-            });
-            const updated = this.store.updateFile({
-                ...record,
-                activeRevisionId: revision.id,
-                updatedAt: snapshot.updatedAt ?? new Date().toISOString(),
-            });
-            this.upsertManaged(updated);
-            this.managed.set(updated.key, updated);
+            this.upsertManaged(record);
             knownPaths.add(absolutePath);
-            usedKeys.add(updated.key);
-            const info = this.resolveManagedInfo(context, updated);
-            discovered.push(updated);
+            usedKeys.add(record.key);
+            const info = this.resolveManagedInfo(context, record);
+            discovered.push(record);
             if (emitEvents) {
-                this.snapshots.set(updated.key, this.snapshotFromInfo(info));
+                this.snapshots.set(record.key, this.snapshotFromInfo(info));
                 this.emitChanged(context, "context-file.created", "filesystem", undefined, info);
             }
         }
@@ -707,10 +693,9 @@ class ContextFileService {
     resolveManagedInfo(context, file) {
         const record = this.ensureManagedRecordSynced(file);
         const snapshot = snapshotFromSync(record.managedPath);
-        const activeRevision = record.activeRevisionId ? this.store.getRevision(record.activeRevisionId) : undefined;
         const sourceDescriptor = record.sourceRef ? this.resolveLiveSource(context, record.sourceRef) : undefined;
         const sourceHash = sourceDescriptor?.contentHash ?? record.sourceHash;
-        const workingHash = snapshot.version ?? activeRevision?.contentHash;
+        const workingHash = snapshot.version ?? hashContextFileContent(record.workingContent);
         const linkState = this.computeLinkState(record, sourceDescriptor, workingHash);
         return {
             key: record.key,
@@ -725,13 +710,12 @@ class ContextFileService {
             editable: true,
             removable: true,
             exists: snapshot.exists,
-            bytes: snapshot.bytes ?? (activeRevision ? Buffer.byteLength(activeRevision.content, "utf8") : undefined),
+            bytes: snapshot.bytes ?? Buffer.byteLength(record.workingContent, "utf8"),
             updatedAt: snapshot.updatedAt ?? record.updatedAt,
-            version: snapshot.version ?? activeRevision?.contentHash,
+            version: snapshot.version ?? workingHash,
             sourceRef: record.sourceRef,
             sourceHash,
             linkState,
-            activeRevisionId: record.activeRevisionId,
         };
     }
     computeLinkState(record, sourceDescriptor, workingHash) {
@@ -747,21 +731,12 @@ class ContextFileService {
         const snapshot = snapshotFromSync(record.managedPath);
         if (!snapshot.exists || !snapshot.version)
             return record;
-        const activeRevision = record.activeRevisionId ? this.store.getRevision(record.activeRevisionId) : undefined;
-        if (activeRevision?.contentHash === snapshot.version)
+        const content = snapshot.content ?? "";
+        if (hashContextFileContent(record.workingContent) === snapshot.version)
             return record;
-        const revision = this.store.appendRevision({
-            contextFileKey: record.key,
-            kind: "working",
-            contentHash: snapshot.version,
-            content: snapshot.content ?? "",
-            basedOnRevisionId: record.activeRevisionId,
-            sourceHashAtCreation: record.sourceHash,
-            note: activeRevision ? "External file update detected" : "Recovered working content from disk",
-        });
         const updated = this.store.updateFile({
             ...record,
-            activeRevisionId: revision.id,
+            workingContent: content,
             updatedAt: snapshot.updatedAt ?? new Date().toISOString(),
         });
         this.upsertManaged(updated);
@@ -769,59 +744,29 @@ class ContextFileService {
     }
     currentWorkingContent(record) {
         const snapshot = snapshotFromSync(record.managedPath);
-        if (snapshot.exists)
-            return snapshot.content ?? "";
-        const revision = record.activeRevisionId ? this.store.getRevision(record.activeRevisionId) : undefined;
-        return revision?.content ?? "";
+        return snapshot.exists ? (snapshot.content ?? "") : record.workingContent;
     }
-    async writeWorkingContent(record, content, options) {
+    async writeWorkingContent(record, content, options = {}) {
         await mkdir(dirname(record.managedPath), { recursive: true });
         await writeFile(record.managedPath, content, "utf8");
-        const revision = this.store.appendRevision({
-            contextFileKey: record.key,
-            kind: "working",
-            contentHash: hashContextFileContent(content),
-            content,
-            actorId: options.actorId,
-            basedOnRevisionId: options.basedOnRevisionId ?? record.activeRevisionId,
-            sourceHashAtCreation: options.sourceHash ?? record.sourceHash,
-            note: options.note,
-        });
         const updated = this.store.updateFile({
             ...record,
-            activeRevisionId: revision.id,
+            workingContent: content,
             sourceHash: options.sourceHash ?? record.sourceHash,
+            sourceContent: options.sourceContent ?? record.sourceContent,
             updatedAt: new Date().toISOString(),
         });
         this.upsertManaged(updated);
         return updated;
     }
-    ensureSourceSnapshot(record, source, actorId, note) {
-        const existing = source.contentHash ? this.store.findLatestSourceSnapshot(record.key, source.contentHash) : undefined;
-        if (existing)
-            return existing;
-        return this.store.appendRevision({
-            contextFileKey: record.key,
-            kind: "source-snapshot",
-            contentHash: source.contentHash ?? hashContextFileContent(source.content ?? ""),
-            content: source.content ?? "",
-            actorId,
-            sourceHashAtCreation: source.contentHash,
-            note,
-        });
-    }
-    revisionInfoFromRecord(revision, activeRevisionId) {
+    revisionInfoFromRecord(revision) {
         return {
             id: revision.id,
-            kind: revision.kind,
+            name: revision.name,
             contentHash: revision.contentHash,
             createdAt: revision.createdAt,
             actorId: revision.actorId,
-            basedOnRevisionId: revision.basedOnRevisionId,
-            sourceHashAtCreation: revision.sourceHashAtCreation,
-            note: revision.note,
             content: revision.content,
-            active: revision.id === activeRevisionId,
         };
     }
     resolveDiffSide(context, record, kind) {
@@ -836,14 +781,11 @@ class ContextFileService {
                 contentHash: liveSource.contentHash,
             };
         }
-        const snapshot = record.sourceHash
-            ? this.store.findLatestSourceSnapshot(record.key, record.sourceHash)
-            : this.store.findLatestSourceSnapshot(record.key);
-        if (!snapshot)
+        if (record.sourceContent === undefined)
             throw new PiboWebHttpError("No source snapshot available for diff", 404);
         return {
-            content: snapshot.content,
-            contentHash: snapshot.contentHash,
+            content: record.sourceContent,
+            contentHash: record.sourceHash ?? hashContextFileContent(record.sourceContent),
         };
     }
     requirePluginCatalogFile(context, key) {
@@ -924,7 +866,6 @@ class ContextFileService {
             version: file.version,
             linkState: file.linkState,
             sourceHash: file.sourceHash,
-            activeRevisionId: file.activeRevisionId,
         };
     }
     emitChanged(context, type, source, actorId, file) {
@@ -1054,6 +995,12 @@ function createContextFilesWebApp(service) {
                 service.startWatcher(context);
                 return responseJson(service.listRevisions(context, path.key));
             }
+            if (path.action === "revisions" && request.method === "POST") {
+                const webSession = await context.requireSession({ request });
+                service.startWatcher(context);
+                const body = await readJsonBody(request);
+                return responseJson({ revision: await service.createRevision(context, path.key, body, webSession) }, { status: 201 });
+            }
             if (path.action === "diff" && request.method === "GET") {
                 await context.requireSession({ request });
                 service.startWatcher(context);
@@ -1076,6 +1023,7 @@ export function createPiboContextFilesPlugin(options = {}) {
         id: "pibo.context-files",
         name: "Pibo Context Files",
         register(api) {
+            assertContextFilesStorageOwnership(paths);
             const service = new ContextFileService(paths, api);
             api.registerWebApp(createContextFilesWebApp(service));
         },

package/dist/shared/trace-live-reducer.js

@@ -150,10 +150,15 @@ function makeStored(streamEvent, piboSessionId, type, payload, nextSequence, now
         streamFrameIndex,
         eventId: typeof payload.eventId === "string" ? payload.eventId : undefined,
         type,
-        createdAt: now(),
+        createdAt: streamEventCreatedAt(streamEvent) ?? now(),
         payload,
     };
 }
+function streamEventCreatedAt(event) {
+    if (typeof event.createdAt !== "string" || !Number.isFinite(Date.parse(event.createdAt)))
+        return undefined;
+    return event.createdAt;
+}
 function dropMatching(events, finalEvent, dropType) {
     const finalKey = eventGroupKey(finalEvent);
     return events.filter((event) => event.type !== dropType || eventGroupKey(event) !== finalKey);