@modelprofile.com/flexharness-agent 6.0.0 → 6.1.0

package/ts_agent/smartagent.events.ts

@@ -202,7 +202,7 @@ export type TModelMessageEventIdentityFactory = (
 ) => string;
 
 export const createAgentEventId = (prefix = 'event'): string =>
-  `${prefix}_${plugins.crypto.randomUUID()}`;
+  `${prefix}_${globalThis.crypto.randomUUID()}`;
 
 export function createAgentEvent<TEvent extends TAgentEvent>(
   event: TAgentEventInput<TEvent>,

package/ts_agent/smartagent.persistence.ts

@@ -1,4 +1,3 @@
-import * as plugins from './plugins.js';
 import type { TAgentEvent } from './smartagent.events.js';
 
 const SNAPSHOT_SCHEMA_VERSION = 2 as const;
@@ -543,9 +542,9 @@ export class AgentEventStoreConflictError extends Error {
   }
 }
 
-const clone = <TValue>(value: TValue): TValue => structuredClone(value);
+export const clone = <TValue>(value: TValue): TValue => structuredClone(value);
 
-const createSnapshot = (
+export const createSnapshot = (
   sessionId: string,
   revision: number,
   events: readonly TAgentEvent[],
@@ -604,224 +603,3 @@ export class InMemoryAgentEventStore implements IAgentEventStoreV2 {
     return archive ? clone(archive) : undefined;
   }
 }
-
-export interface IFileAgentEventStoreOptions {
-  rootDir: string;
-  /** Maximum time spent waiting for another writer. Default: 10 seconds. */
-  lockTimeoutMs?: number;
-}
-
-const assertSessionId = (sessionId: string): void => {
-  if (!sessionId.trim()) throw new Error('Agent event store sessionId must not be empty.');
-};
-
-const decodeSnapshot = (value: unknown, sessionId: string): TAgentEventSnapshot => {
-  const snapshot = value as Partial<TAgentEventSnapshot>;
-  if (snapshot?.schemaVersion === SNAPSHOT_SCHEMA_VERSION) {
-    try {
-      return validateAgentEventSnapshotV2(value, sessionId);
-    } catch {
-      throw new Error(`Invalid agent event snapshot for session "${sessionId}".`);
-    }
-  }
-  if (
-    !snapshot
-    || snapshot.schemaVersion !== 1
-    || snapshot.sessionId !== sessionId
-    || !Number.isSafeInteger(snapshot.revision)
-    || (snapshot.revision ?? -1) < 1
-    || !Array.isArray(snapshot.events)
-  ) {
-    throw new Error(`Invalid agent event snapshot for session "${sessionId}".`);
-  }
-  return snapshot as TAgentEventSnapshot;
-};
-
-const decodeArchive = (
-  value: unknown,
-  sessionId: string,
-  archiveId: string,
-): TAgentEventArchive => {
-  const archive = value as Partial<TAgentEventArchive>;
-  if (archive?.schemaVersion === ARCHIVE_SCHEMA_VERSION) {
-    try {
-      return validateAgentEventArchiveV2(value, sessionId, archiveId);
-    } catch {
-      throw new Error(`Invalid agent event archive "${archiveId}" for session "${sessionId}".`);
-    }
-  }
-  if (
-    !archive
-    || archive.schemaVersion !== 1
-    || archive.sessionId !== sessionId
-    || archive.archiveId !== archiveId
-    || !Array.isArray(archive.events)
-  ) {
-    throw new Error(`Invalid agent event archive "${archiveId}" for session "${sessionId}".`);
-  }
-  return archive as TAgentEventArchive;
-};
-
-const sleep = async (milliseconds: number): Promise<void> => {
-  await new Promise((resolve) => setTimeout(resolve, milliseconds));
-};
-
-export class FileAgentEventStore implements IAgentEventStoreV2 {
-  public readonly eventSchemaVersion = 2 as const;
-  private readonly rootDir: string;
-  private readonly lockTimeoutMs: number;
-
-  constructor(options: IFileAgentEventStoreOptions) {
-    if (!options.rootDir.trim()) throw new Error('FileAgentEventStore rootDir must not be empty.');
-    this.rootDir = plugins.path.resolve(options.rootDir);
-    this.lockTimeoutMs = options.lockTimeoutMs ?? 10_000;
-    if (!Number.isSafeInteger(this.lockTimeoutMs) || this.lockTimeoutMs <= 0) {
-      throw new Error('lockTimeoutMs must be a positive integer.');
-    }
-  }
-
-  private sessionKey(sessionId: string): string {
-    assertSessionId(sessionId);
-    return plugins.crypto.createHash('sha256').update(sessionId).digest('hex');
-  }
-
-  private snapshotPath(sessionId: string): string {
-    return plugins.path.join(this.rootDir, 'sessions', `${this.sessionKey(sessionId)}.bin`);
-  }
-
-  private archivePath(sessionId: string, archiveId: string): string {
-    if (!archiveId.trim()) throw new Error('Agent event archiveId must not be empty.');
-    const archiveKey = plugins.crypto.createHash('sha256').update(archiveId).digest('hex');
-    return plugins.path.join(this.rootDir, 'archives', this.sessionKey(sessionId), `${archiveKey}.bin`);
-  }
-
-  private async readValue(filePath: string): Promise<unknown | undefined> {
-    try {
-      return plugins.v8.deserialize(await plugins.fs.readFile(filePath));
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return undefined;
-      throw error;
-    }
-  }
-
-  private async syncDirectory(directoryPath: string): Promise<void> {
-    const handle = await plugins.fs.open(directoryPath, 'r');
-    try {
-      await handle.sync();
-    } finally {
-      await handle.close();
-    }
-  }
-
-  private async writeAtomic(filePath: string, value: unknown): Promise<void> {
-    const directoryPath = plugins.path.dirname(filePath);
-    await plugins.fs.mkdir(directoryPath, { recursive: true });
-    const temporaryPath = `${filePath}.${process.pid}.${plugins.crypto.randomUUID()}.tmp`;
-    let handle: Awaited<ReturnType<typeof plugins.fs.open>> | undefined;
-    try {
-      handle = await plugins.fs.open(temporaryPath, 'wx');
-      await handle.writeFile(plugins.v8.serialize(value));
-      await handle.sync();
-      await handle.close();
-      handle = undefined;
-      await plugins.fs.rename(temporaryPath, filePath);
-      await this.syncDirectory(directoryPath);
-    } finally {
-      if (handle) await handle.close().catch(() => undefined);
-      await plugins.fs.rm(temporaryPath, { force: true });
-    }
-  }
-
-  private async withSessionLock<TValue>(
-    sessionId: string,
-    operation: () => Promise<TValue>,
-  ): Promise<TValue> {
-    const lockPath = plugins.path.join(this.rootDir, 'locks', `${this.sessionKey(sessionId)}.lock`);
-    const ownerPath = plugins.path.join(lockPath, 'owner');
-    const ownerToken = plugins.crypto.randomUUID();
-    const ownerRecord = JSON.stringify({ token: ownerToken });
-    await plugins.fs.mkdir(plugins.path.dirname(lockPath), { recursive: true });
-    const startedAt = Date.now();
-    while (true) {
-      try {
-        await plugins.fs.mkdir(lockPath);
-        try {
-          await plugins.fs.writeFile(ownerPath, ownerRecord, 'utf8');
-        } catch (error) {
-          await plugins.fs.rm(lockPath, { recursive: true, force: true });
-          throw error;
-        }
-        break;
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
-        if (Date.now() - startedAt >= this.lockTimeoutMs) {
-          throw new Error(
-            `Timed out waiting for the event-store lock for session "${sessionId}" at "${lockPath}".`,
-          );
-        }
-        await sleep(20);
-      }
-    }
-    try {
-      return await operation();
-    } finally {
-      let stillOwner = false;
-      try {
-        const owner = JSON.parse(await plugins.fs.readFile(ownerPath, 'utf8')) as { token?: unknown };
-        stillOwner = owner.token === ownerToken;
-      } catch {}
-      if (stillOwner) await plugins.fs.rm(lockPath, { recursive: true, force: true });
-    }
-  }
-
-  public async load(sessionId: string): Promise<TAgentEventSnapshot | undefined> {
-    const value = await this.readValue(this.snapshotPath(sessionId));
-    return value === undefined ? undefined : decodeSnapshot(value, sessionId);
-  }
-
-  public async save(
-    sessionId: string,
-    events: readonly TAgentEvent[],
-    expectedRevision: number,
-  ): Promise<number> {
-    return this.withSessionLock(sessionId, async () => {
-      const filePath = this.snapshotPath(sessionId);
-      const currentValue = await this.readValue(filePath);
-      const actualRevision = currentValue === undefined
-        ? 0
-        : decodeSnapshot(currentValue, sessionId).revision;
-      if (actualRevision !== expectedRevision) {
-        throw new AgentEventStoreConflictError(sessionId, expectedRevision, actualRevision);
-      }
-      const revision = expectedRevision + 1;
-      await this.writeAtomic(filePath, createSnapshot(sessionId, revision, events));
-      return revision;
-    });
-  }
-
-  public async archive(archive: IAgentEventArchiveV2): Promise<void> {
-    const nextArchive = clone(archive);
-    await this.withSessionLock(archive.sessionId, async () => {
-      const filePath = this.archivePath(archive.sessionId, archive.archiveId);
-      const currentValue = await this.readValue(filePath);
-      if (currentValue !== undefined) {
-        const current = decodeArchive(currentValue, archive.sessionId, archive.archiveId);
-        const currentIds = current.events.map((event) => event.id).join('\n');
-        const nextIds = nextArchive.events.map((event) => event.id).join('\n');
-        if (currentIds !== nextIds) {
-          throw new Error(`Archive "${archive.archiveId}" already exists with different events.`);
-        }
-        return;
-      }
-      await this.writeAtomic(filePath, nextArchive);
-    });
-  }
-
-  public async loadArchive(
-    sessionId: string,
-    archiveId: string,
-  ): Promise<TAgentEventArchive | undefined> {
-    const value = await this.readValue(this.archivePath(sessionId, archiveId));
-    return value === undefined ? undefined : decodeArchive(value, sessionId, archiveId);
-  }
-}