@modelprofile.com/flexharness 10.17.0 → 10.18.0

package/dist_ts_tools_node/classes.workspacereversion.js

@@ -0,0 +1,202 @@
+import * as plugins from './plugins.js';
+import { fileImageBytes, fileImagesEqual, missingAncestors, readFileImage, removeEmptyDirectories, writeFileImage, } from './functions.fileimages.js';
+const DEFAULT_MAX_CAPTURE_BYTES = 64 * 1024 * 1024;
+const isCaptureReference = (valueArg) => !!valueArg
+    && typeof valueArg === 'object'
+    && !Array.isArray(valueArg)
+    && typeof valueArg.captureId === 'string';
+/**
+ * Turn reversion for the local filesystem tools, held in memory: FlexHarness `/undo` and `/redo`
+ * move a turn's file changes together with its transcript.
+ *
+ * Give each run's `createLocalToolExecutionContext` the observer `observerFor(context.runId)`. The
+ * first change of a file in a turn records what the file held before; `finalize` records what it
+ * holds after. Undo puts the before images back and redo the after images, each only while every
+ * file still holds what the other direction left, so a later edit of the user is never overwritten.
+ * A turn that ran a shell command is nonrevertible, since the command may have changed files no
+ * observer saw.
+ *
+ * Captures live as long as the process. A capture FlexHarness asks about after a restart is
+ * `missing`, and undoing past it fails without changing anything. Only root-session runs are
+ * captured; a change of a run without a prepared capture is refused.
+ */
+export class InMemoryWorkspaceReversion {
+    protocolVersion = 2;
+    workspace;
+    maxCaptureBytes;
+    captures = new Map();
+    captureIdsByRun = new Map();
+    constructor(optionsArg) {
+        this.workspace = { id: optionsArg.workspace.id, label: optionsArg.workspace.label };
+        this.maxCaptureBytes = optionsArg.maxCaptureBytes ?? DEFAULT_MAX_CAPTURE_BYTES;
+        if (!Number.isSafeInteger(this.maxCaptureBytes) || this.maxCaptureBytes <= 0) {
+            throw new Error('maxCaptureBytes must be a positive integer.');
+        }
+    }
+    /** The observer of one run's file changes and shell commands. */
+    observerFor(runIdArg) {
+        return {
+            beforeFileChange: (changeArg) => this.recordChange(runIdArg, changeArg),
+            beforeShellCommand: () => {
+                this.markNonrevertible(this.requirePreparedCapture(runIdArg), 'shell-command');
+            },
+        };
+    }
+    prepare(contextArg) {
+        contextArg.signal.throwIfAborted();
+        if (this.captures.has(contextArg.captureId))
+            return;
+        this.captures.set(contextArg.captureId, {
+            captureId: contextArg.captureId,
+            runId: contextArg.runId,
+            state: 'prepared',
+            files: new Map(),
+            bytes: 0,
+            appliedOperations: new Set(),
+            uncertainOperations: new Set(),
+        });
+        this.captureIdsByRun.set(contextArg.runId, contextArg.captureId);
+    }
+    inspectCapture(contextArg) {
+        const capture = this.captures.get(contextArg.captureId);
+        if (!capture)
+            return { status: 'missing' };
+        return capture.outcome ? { status: 'finalized', outcome: capture.outcome } : { status: 'prepared' };
+    }
+    async finalize(contextArg) {
+        contextArg.signal.throwIfAborted();
+        const capture = this.requireCapture(contextArg.captureId);
+        if (capture.outcome)
+            return capture.outcome;
+        const reference = { captureId: capture.captureId };
+        if (!capture.nonrevertibleReason) {
+            for (const [filePath, record] of capture.files) {
+                record.after = await readFileImage(filePath);
+                if (fileImagesEqual(record.before, record.after))
+                    capture.files.delete(filePath);
+            }
+        }
+        capture.state = 'finalized';
+        if (capture.nonrevertibleReason) {
+            capture.outcome = {
+                disposition: 'nonrevertible',
+                reference: { ...reference },
+                reasonCode: capture.nonrevertibleReason,
+                affectedWorkspaces: [this.workspace],
+            };
+        }
+        else if (capture.files.size === 0) {
+            capture.outcome = { disposition: 'no-change', reference: { ...reference } };
+        }
+        else {
+            capture.outcome = { disposition: 'revertible', reference: { ...reference }, affectedWorkspaces: [this.workspace] };
+        }
+        this.captureIdsByRun.delete(capture.runId);
+        return capture.outcome;
+    }
+    async apply(contextArg) {
+        contextArg.signal.throwIfAborted();
+        const capture = this.captureOf(contextArg.reference);
+        if (capture.outcome?.disposition !== 'revertible') {
+            throw new Error('This turn has no revertible workspace changes.');
+        }
+        const records = [...capture.files.entries()];
+        const expected = (recordArg) => (contextArg.direction === 'undo' ? recordArg.after : recordArg.before);
+        const target = (recordArg) => (contextArg.direction === 'undo' ? recordArg.before : recordArg.after);
+        for (const [filePath, record] of records) {
+            if (!fileImagesEqual(await readFileImage(filePath), expected(record))) {
+                throw new Error(`"${filePath}" changed after the turn; its changes were not ${contextArg.direction === 'undo' ? 'undone' : 'redone'}.`);
+            }
+        }
+        const written = [];
+        try {
+            for (const entry of records) {
+                await writeFileImage(entry[0], target(entry[1]));
+                written.push(entry);
+            }
+        }
+        catch (error) {
+            await this.rollBack(written, expected, contextArg.operationId, capture);
+            throw error;
+        }
+        if (contextArg.direction === 'undo') {
+            for (const [, record] of records)
+                await removeEmptyDirectories(record.createdDirectories);
+        }
+        capture.appliedOperations.add(contextArg.operationId);
+    }
+    inspectApply(contextArg) {
+        const capture = this.captures.get(isCaptureReference(contextArg.reference) ? contextArg.reference.captureId : '');
+        if (!capture)
+            return { status: 'not-applied' };
+        if (capture.appliedOperations.has(contextArg.operationId))
+            return { status: 'applied' };
+        if (capture.uncertainOperations.has(contextArg.operationId))
+            return { status: 'unknown' };
+        return { status: 'not-applied' };
+    }
+    release(contextArg) {
+        const captureId = isCaptureReference(contextArg.reference) ? contextArg.reference.captureId : contextArg.captureId;
+        const capture = this.captures.get(captureId);
+        if (!capture)
+            return;
+        this.captures.delete(captureId);
+        if (this.captureIdsByRun.get(capture.runId) === captureId)
+            this.captureIdsByRun.delete(capture.runId);
+    }
+    async recordChange(runIdArg, changeArg) {
+        const capture = this.requirePreparedCapture(runIdArg);
+        if (capture.nonrevertibleReason || capture.files.has(changeArg.path))
+            return;
+        const before = await readFileImage(changeArg.path);
+        const createdDirectories = before.kind === 'absent' && changeArg.kind === 'write'
+            ? await missingAncestors(changeArg.path)
+            : [];
+        if (capture.files.has(changeArg.path))
+            return;
+        capture.bytes += fileImageBytes(before);
+        if (capture.bytes > this.maxCaptureBytes) {
+            this.markNonrevertible(capture, 'capture-too-large');
+            return;
+        }
+        capture.files.set(changeArg.path, { before, createdDirectories });
+    }
+    markNonrevertible(captureArg, reasonArg) {
+        captureArg.nonrevertibleReason ??= reasonArg;
+        captureArg.files.clear();
+        captureArg.bytes = 0;
+    }
+    async rollBack(writtenArg, expectedArg, operationIdArg, captureArg) {
+        try {
+            for (const [filePath, record] of writtenArg.reverse())
+                await writeFileImage(filePath, expectedArg(record));
+        }
+        catch {
+            // the workspace holds part of the change; FlexHarness learns that the outcome is unknown
+            captureArg.uncertainOperations.add(operationIdArg);
+        }
+    }
+    requirePreparedCapture(runIdArg) {
+        const captureId = this.captureIdsByRun.get(runIdArg);
+        const capture = captureId ? this.captures.get(captureId) : undefined;
+        if (!capture || capture.state !== 'prepared') {
+            throw new Error(`No workspace capture is open for run "${runIdArg}"; the change was refused.`);
+        }
+        return capture;
+    }
+    requireCapture(captureIdArg) {
+        const capture = this.captures.get(captureIdArg);
+        if (!capture)
+            throw new Error(`The workspace capture "${captureIdArg}" is not held.`);
+        return capture;
+    }
+    captureOf(referenceArg) {
+        if (!isCaptureReference(referenceArg))
+            throw new Error('The workspace capture reference is malformed.');
+        const capture = this.captures.get(referenceArg.captureId);
+        if (!capture)
+            throw new Error('The workspace changes of this turn are no longer held in memory.');
+        return capture;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.workspacereversion.js","sourceRoot":"","sources":["../ts_tools_node/classes.workspacereversion.ts"],"names":[],"mappings":"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"}

package/dist_ts_tools_node/functions.fileimages.d.ts

@@ -0,0 +1,22 @@
+/** What one path holds at a moment: nothing, a regular file, or a symbolic link. */
+export type TFileImage = {
+    kind: 'absent';
+} | {
+    kind: 'file';
+    bytes: Buffer;
+    mode: number;
+} | {
+    kind: 'symlink';
+    target: string;
+};
+/** Reads what the path holds, without following a final symbolic link. */
+export declare const readFileImage: (pathArg: string) => Promise<TFileImage>;
+/** The bytes an image keeps in memory. */
+export declare const fileImageBytes: (imageArg: TFileImage) => number;
+export declare const fileImagesEqual: (leftArg: TFileImage, rightArg: TFileImage) => boolean;
+/** Puts the image at the path, creating parent directories as needed. */
+export declare const writeFileImage: (pathArg: string, imageArg: TFileImage) => Promise<void>;
+/** The ancestors of the path that do not exist yet, deepest first: a write would create them. */
+export declare const missingAncestors: (pathArg: string) => Promise<string[]>;
+/** Removes the directories, deepest first, as far as they are empty. */
+export declare const removeEmptyDirectories: (directoriesArg: readonly string[]) => Promise<void>;

package/dist_ts_tools_node/functions.fileimages.js

@@ -0,0 +1,87 @@
+import * as plugins from './plugins.js';
+const isMissing = (error) => {
+    const code = error.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+};
+/** Reads what the path holds, without following a final symbolic link. */
+export const readFileImage = async (pathArg) => {
+    let stats;
+    try {
+        stats = await plugins.fs.promises.lstat(pathArg);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return { kind: 'absent' };
+        throw error;
+    }
+    if (stats.isSymbolicLink())
+        return { kind: 'symlink', target: await plugins.fs.promises.readlink(pathArg) };
+    if (stats.isFile())
+        return { kind: 'file', bytes: await plugins.fs.promises.readFile(pathArg), mode: stats.mode & 0o7777 };
+    throw new Error(`"${pathArg}" is neither a file nor a symbolic link.`);
+};
+/** The bytes an image keeps in memory. */
+export const fileImageBytes = (imageArg) => imageArg.kind === 'file'
+    ? imageArg.bytes.byteLength
+    : imageArg.kind === 'symlink'
+        ? Buffer.byteLength(imageArg.target)
+        : 0;
+export const fileImagesEqual = (leftArg, rightArg) => {
+    if (leftArg.kind === 'absent' || rightArg.kind === 'absent')
+        return leftArg.kind === rightArg.kind;
+    if (leftArg.kind === 'symlink' || rightArg.kind === 'symlink') {
+        return leftArg.kind === 'symlink' && rightArg.kind === 'symlink' && leftArg.target === rightArg.target;
+    }
+    return leftArg.bytes.equals(rightArg.bytes);
+};
+/** Puts the image at the path, creating parent directories as needed. */
+export const writeFileImage = async (pathArg, imageArg) => {
+    if (imageArg.kind === 'absent') {
+        await plugins.fs.promises.rm(pathArg, { force: true });
+        return;
+    }
+    await plugins.fs.promises.mkdir(plugins.path.dirname(pathArg), { recursive: true });
+    if (imageArg.kind === 'symlink') {
+        await plugins.fs.promises.rm(pathArg, { force: true });
+        await plugins.fs.promises.symlink(imageArg.target, pathArg);
+        return;
+    }
+    if ((await readFileImage(pathArg)).kind === 'symlink')
+        await plugins.fs.promises.rm(pathArg);
+    await plugins.fs.promises.writeFile(pathArg, imageArg.bytes);
+    await plugins.fs.promises.chmod(pathArg, imageArg.mode);
+};
+/** The ancestors of the path that do not exist yet, deepest first: a write would create them. */
+export const missingAncestors = async (pathArg) => {
+    const missing = [];
+    let current = plugins.path.dirname(pathArg);
+    while (current !== plugins.path.dirname(current)) {
+        try {
+            await plugins.fs.promises.lstat(current);
+            break;
+        }
+        catch (error) {
+            if (!isMissing(error))
+                throw error;
+            missing.push(current);
+            current = plugins.path.dirname(current);
+        }
+    }
+    return missing;
+};
+/** Removes the directories, deepest first, as far as they are empty. */
+export const removeEmptyDirectories = async (directoriesArg) => {
+    for (const directory of directoriesArg) {
+        try {
+            await plugins.fs.promises.rmdir(directory);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOTEMPTY' || code === 'EEXIST')
+                return;
+            if (!isMissing(error))
+                throw error;
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tools_node/index.d.ts

@@ -1,5 +1,7 @@
 export { createLocalToolExecutionContext } from './tool.context.js';
-export type { ILocalToolExecutionContextOptions } from './tool.context.js';
+export type { ILocalToolExecutionContextOptions, IToolFileChange, IToolFileChangeObserver, } from './tool.context.js';
+export { InMemoryWorkspaceReversion } from './classes.workspacereversion.js';
+export type { IInMemoryWorkspaceReversionOptions } from './classes.workspacereversion.js';
 export { FileToolJobStore } from './tool.persistence.js';
 export type { IFileToolJobStoreOptions } from './tool.persistence.js';
 export * from './tools.local.js';

package/dist_ts_tools_node/index.js

@@ -1,4 +1,5 @@
 export { createLocalToolExecutionContext } from './tool.context.js';
+export { InMemoryWorkspaceReversion } from './classes.workspacereversion.js';
 export { FileToolJobStore } from './tool.persistence.js';
 export * from './tools.local.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190b29sc19ub2RlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXBFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXpELGNBQWMsa0JBQWtCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190b29sc19ub2RlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBTXBFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRTdFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXpELGNBQWMsa0JBQWtCLENBQUMifQ==

package/dist_ts_tools_node/plugins.d.ts

@@ -11,3 +11,4 @@ import { createFilesystemTools, createShellTools } from '@modelprofile.com/flexh
 export { createFilesystemTools, createShellTools };
 export type { ICreateFilesystemToolsOptions, ICreateShellToolsOptions, ToolSet } from '@modelprofile.com/flexharness/tools';
 export type { IBrowserToolInput, IShellCommand, IShellFinishedResult, IShellStartedResult, IToolBrowserContext, IToolBrowserRunOptions, IToolExecutionContext, IToolFilesystemContext, IToolFilesystemListOptions, IToolFilesystemReadOptions, IToolInvocationOptions, IToolJobContext, IToolJobEvent, IToolJobHandle, IToolJobOutputEvent, IToolJobRequest, IToolJobSnapshot, IToolJobState, IToolJobStore, IToolPermissionRequest, IToolRunOptions, IToolShellContext, IToolShellResult, TBrowserToolAction, TToolJobEvent, TToolJobEventListener, } from '@modelprofile.com/flexharness-agent';
+export type { IFlexAffectedWorkspace, IFlexTurnReversionApplyContext, IFlexTurnReversionApplyInspection, IFlexTurnReversionBaseContext, IFlexTurnReversionProviderV2, IFlexTurnReversionReleaseContext, TFlexTurnReversionCaptureInspectionV2, TFlexTurnReversionFinalizedOutcome, TJsonValue, } from '@modelprofile.com/flexharness';

package/dist_ts_tools_node/tool.context.d.ts

@@ -1,4 +1,22 @@
 import type { IToolJobStore, IToolPermissionRequest, IToolJobState, IToolExecutionContext } from './plugins.js';
+/** A file a tool is about to change, named by its canonical path. */
+export interface IToolFileChange {
+    kind: 'write' | 'delete';
+    /**
+     * The canonical absolute path the operation changes. A write follows a symlink to its target; a
+     * delete removes the link itself, so its path is the link's.
+     */
+    path: string;
+}
+/**
+ * Sees every change the local filesystem tools make, after the path checks and before the change,
+ * and every shell command before it starts. A rejection refuses the operation.
+ */
+export interface IToolFileChangeObserver {
+    beforeFileChange(change: IToolFileChange): Promise<void> | void;
+    /** A shell command or background job may change files the observer does not see. */
+    beforeShellCommand(): Promise<void> | void;
+}
 export interface ILocalToolExecutionContextOptions {
     cwd?: string;
     rootDir?: string;
@@ -7,6 +25,8 @@ export interface ILocalToolExecutionContextOptions {
     abortSignal?: AbortSignal;
     /** Guards each local filesystem operation or shell side effect. */
     beforeOperation?: () => Promise<void> | void;
+    /** Observes every file change and shell command, for example to capture a turn for undo. */
+    fileChangeObserver?: IToolFileChangeObserver;
     /** Hard combined stdout/stderr capture limit for each local shell command. Default: 1 MiB. */
     maxShellOutputBytes?: number;
     /** Number of terminal background job snapshots retained for get/list. Default: 100. */