@tangle-network/agent-profile-materialize 1.1.6 → 1.1.8

package/dist/tool-bin-path.js

@@ -1,61 +0,0 @@
-import { isAbsolute } from "node:path";
-/** The colon-separated, absolute CLI bin dirs a sandbox app mounts for its tools. */
-export const SANDBOX_TOOL_BIN_DIRS_ENV = "SANDBOX_TOOL_BIN_DIRS";
-/**
- * The tool bin dirs a `SANDBOX_TOOL_BIN_DIRS` value names, or `[]` when it is
- * unset or blank.
- *
- * Fail loud, never silently degrade: a malformed value (a relative segment,
- * or an empty segment from a stray/leading/trailing colon) throws rather than
- * silently dropping a tool dir from PATH or admitting a relative path that
- * resolves against whatever the process cwd happens to be.
- */
-export function parseSandboxToolBinDirs(value) {
-    const trimmed = value?.trim();
-    if (!trimmed)
-        return [];
-    const segments = trimmed.split(":");
-    for (const segment of segments) {
-        if (!segment || !isAbsolute(segment)) {
-            throw new Error(`SANDBOX_TOOL_BIN_DIRS must be a colon-separated list of absolute paths with no empty segments, got: ${trimmed}`);
-        }
-    }
-    return segments;
-}
-function assertToolBinDir(dir) {
-    // A ':' would split one declared dir into several PATH entries, admitting
-    // a dir no profile declared.
-    if (!dir || !isAbsolute(dir) || dir.includes(":")) {
-        throw new Error(`a tool bin dir must be an absolute path without ':', got: ${dir}`);
-    }
-}
-/**
- * A launch environment whose tool bin dirs are `toolBinDirs`, at the TAIL of
- * PATH after every Nix, npm, image and system entry, so a tool never shadows
- * a platform-owned binary of the same name.
- *
- * They replace `appToolBinDirs` (by default the dirs the environment's own
- * `SANDBOX_TOOL_BIN_DIRS` names) wherever those sit in PATH, so an app's older
- * copy of the same tool cannot win by PATH order. Relative PATH entries are
- * dropped too: they resolve against whatever cwd the turn moves to.
- */
-export function bindLaunchToolBinDirs(env, toolBinDirs, appToolBinDirs = parseSandboxToolBinDirs(env[SANDBOX_TOOL_BIN_DIRS_ENV])) {
-    for (const dir of toolBinDirs)
-        assertToolBinDir(dir);
-    const dirs = [...new Set(toolBinDirs)];
-    // No PATH to bind: the spawner appends SANDBOX_TOOL_BIN_DIRS to its default.
-    if (env.PATH === undefined) {
-        return { ...env, [SANDBOX_TOOL_BIN_DIRS_ENV]: dirs.join(":") };
-    }
-    const replaced = new Set(appToolBinDirs);
-    const entries = env.PATH.split(":").filter((entry) => isAbsolute(entry) && !replaced.has(entry));
-    for (const dir of dirs) {
-        if (!entries.includes(dir))
-            entries.push(dir);
-    }
-    return {
-        ...env,
-        PATH: entries.join(":"),
-        [SANDBOX_TOOL_BIN_DIRS_ENV]: dirs.join(":"),
-    };
-}

package/dist/workspace-apply-files.d.ts

@@ -1,57 +0,0 @@
-declare function workspaceFileExists(pathValue: string): boolean;
-/**
- * A regular file's text, or `undefined` when no regular file is there or its
- * bytes are not UTF-8. This package writes only UTF-8, so such bytes are not
- * its output, and decoding them lossily would rewrite them on replacement.
- */
-declare function regularFileContent(pathValue: string): string | undefined;
-declare function workspaceFileMatches(file: NormalizedPlanFile & {
-    absPath: string;
-}): boolean;
-declare function workspaceFileHasOwnership(pathValue: string, ownership: {
-    uid: number;
-    gid: number;
-}): boolean;
-declare function validateWorkspaceOwnership(ownership: ApplyWorkspacePlanOptions["ownership"]): {
-    uid: number;
-    gid: number;
-} | undefined;
-/**
- * The refusal names what differs — planned versus existing content digest,
- * mode, or file kind — plus the plan digest, so the operator can tell a
- * mid-session profile swap from an agent-edited workspace file without
- * reproducing the workspace. Reads here are best-effort diagnosis inside an
- * already-failing path; an unreadable existing file is reported, not thrown
- * over.
- */
-declare function workspaceFileConflictMessage(file: NormalizedPlanFile & {
-    absPath: string;
-}, existingFiles: "allow-identical" | "reject", planDigest: string): string;
-interface WorkspaceFileIdentity {
-    device: number;
-    inode: number;
-}
-interface PreparedWorkspaceFile {
-    file: NormalizedPlanFile & {
-        absPath: string;
-    };
-    temporaryPath: string;
-    identity: WorkspaceFileIdentity;
-    published: boolean;
-    /** A link to the replaced file while it holds an agent's text, for rollback. */
-    superseded?: string;
-}
-declare function prepareWorkspaceFile(workspaceRoot: string, file: NormalizedPlanFile & {
-    absPath: string;
-}, ownership: {
-    uid: number;
-    gid: number;
-} | undefined): PreparedWorkspaceFile;
-declare function workspacePathHasIdentity(pathValue: string, identity: WorkspaceFileIdentity): boolean;
-declare function resolveWorkspaceFilePath(workspaceRoot: string, relativePath: string): string;
-declare function assertNoSymlinkPathComponents(workspaceRoot: string, targetPath: string): void;
-declare function isFsError(error: unknown, code: string): error is NodeJS.ErrnoException;
-export type { PreparedWorkspaceFile };
-export { assertNoSymlinkPathComponents, isFsError, prepareWorkspaceFile, regularFileContent, resolveWorkspaceFilePath, validateWorkspaceOwnership, workspaceFileConflictMessage, workspaceFileExists, workspaceFileHasOwnership, workspaceFileMatches, workspacePathHasIdentity, };
-import type { NormalizedPlanFile } from "./plan-normalize.js";
-import type { ApplyWorkspacePlanOptions } from "./plan-types.js";

package/dist/workspace-apply-files.js

@@ -1,193 +0,0 @@
-function workspaceFileExists(pathValue) {
-    try {
-        lstatSync(pathValue);
-        return true;
-    }
-    catch (error) {
-        if (isFsError(error, "ENOENT"))
-            return false;
-        throw error;
-    }
-}
-const STRICT_UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-/**
- * A regular file's text, or `undefined` when no regular file is there or its
- * bytes are not UTF-8. This package writes only UTF-8, so such bytes are not
- * its output, and decoding them lossily would rewrite them on replacement.
- */
-function regularFileContent(pathValue) {
-    if (!lstatSync(pathValue).isFile())
-        return undefined;
-    const bytes = readFileSync(pathValue);
-    try {
-        return STRICT_UTF8.decode(bytes);
-    }
-    catch (error) {
-        if (error instanceof TypeError)
-            return undefined;
-        throw error;
-    }
-}
-function workspaceFileMatches(file) {
-    const stats = lstatSync(file.absPath);
-    return (stats.isFile() &&
-        (stats.mode & 0o777) === file.mode &&
-        readFileSync(file.absPath, "utf8") === file.content);
-}
-function workspaceFileHasOwnership(pathValue, ownership) {
-    const stats = lstatSync(pathValue);
-    return (stats.isFile() && stats.uid === ownership.uid && stats.gid === ownership.gid);
-}
-function validateWorkspaceOwnership(ownership) {
-    if (ownership === undefined)
-        return undefined;
-    if (!Number.isInteger(ownership.uid) ||
-        ownership.uid < 0 ||
-        !Number.isInteger(ownership.gid) ||
-        ownership.gid < 0) {
-        throw new Error("Workspace file ownership must use non-negative integer uid/gid values");
-    }
-    return ownership;
-}
-function sha256Hex(content) {
-    return createHash("sha256").update(content).digest("hex");
-}
-/**
- * The refusal names what differs — planned versus existing content digest,
- * mode, or file kind — plus the plan digest, so the operator can tell a
- * mid-session profile swap from an agent-edited workspace file without
- * reproducing the workspace. Reads here are best-effort diagnosis inside an
- * already-failing path; an unreadable existing file is reported, not thrown
- * over.
- */
-function workspaceFileConflictMessage(file, existingFiles, planDigest) {
-    const rootLabel = file.root === "workspace" ? "workspace" : "agent-directory";
-    const prefix = `Refusing to replace existing ${rootLabel} file: ${file.relPath}`;
-    if (existingFiles === "reject") {
-        return `${prefix} — the reject policy forbids any pre-existing plan path (plan ${planDigest})`;
-    }
-    const planned = `planned sha256:${sha256Hex(file.content)} mode ${file.mode.toString(8)}`;
-    let existing;
-    try {
-        const stats = lstatSync(file.absPath);
-        if (!stats.isFile()) {
-            existing = stats.isSymbolicLink()
-                ? "existing path is a symlink, not a regular file"
-                : "existing path is not a regular file";
-        }
-        else {
-            const mode = (stats.mode & 0o777).toString(8);
-            existing = `existing sha256:${sha256Hex(readFileSync(file.absPath))} mode ${mode}`;
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        existing = `existing file unreadable: ${message}`;
-    }
-    return `${prefix} — ${planned} != ${existing} (plan ${planDigest})`;
-}
-function prepareWorkspaceFile(workspaceRoot, file, ownership) {
-    assertNoSymlinkPathComponents(workspaceRoot, file.absPath);
-    const temporaryPath = join(dirname(file.absPath), `.agent-profile-${randomUUID()}.tmp`);
-    let descriptor;
-    try {
-        descriptor = openSync(temporaryPath, SAFE_WRITE_FLAGS, 0o600);
-        writeFileSync(descriptor, file.content, "utf8");
-        if (ownership)
-            fchownSync(descriptor, ownership.uid, ownership.gid);
-        fchmodSync(descriptor, file.mode);
-        const stats = fstatSync(descriptor);
-        const descriptorToClose = descriptor;
-        descriptor = undefined;
-        closeSync(descriptorToClose);
-        return {
-            file,
-            temporaryPath,
-            identity: { device: stats.dev, inode: stats.ino },
-            published: false,
-        };
-    }
-    catch (error) {
-        const cleanupErrors = [];
-        if (descriptor !== undefined) {
-            try {
-                closeSync(descriptor);
-            }
-            catch (cleanupError) {
-                cleanupErrors.push(cleanupError);
-            }
-        }
-        try {
-            unlinkSync(temporaryPath);
-        }
-        catch (cleanupError) {
-            if (!isFsError(cleanupError, "ENOENT"))
-                cleanupErrors.push(cleanupError);
-        }
-        if (cleanupErrors.length > 0) {
-            throw new AggregateError([error, ...cleanupErrors], `Failed to prepare workspace file: ${file.relPath}`);
-        }
-        throw error;
-    }
-}
-function workspacePathHasIdentity(pathValue, identity) {
-    try {
-        const stats = lstatSync(pathValue);
-        return stats.dev === identity.device && stats.ino === identity.inode;
-    }
-    catch (error) {
-        if (isFsError(error, "ENOENT"))
-            return false;
-        throw error;
-    }
-}
-function resolveWorkspaceFilePath(workspaceRoot, relativePath) {
-    const targetPath = resolve(workspaceRoot, ...relativePath.split("/"));
-    const targetRelativePath = relative(workspaceRoot, targetPath);
-    if (!targetRelativePath ||
-        targetRelativePath === ".." ||
-        targetRelativePath.startsWith(`..${sep}`) ||
-        isAbsolute(targetRelativePath)) {
-        throw new Error(`Refusing to materialize profile file outside workspace: ${relativePath}`);
-    }
-    return targetPath;
-}
-function assertNoSymlinkPathComponents(workspaceRoot, targetPath) {
-    const targetRelativePath = relative(workspaceRoot, targetPath);
-    let currentPath = workspaceRoot;
-    const components = ["", ...targetRelativePath.split(sep)];
-    for (const [index, component] of components.entries()) {
-        if (component)
-            currentPath = join(currentPath, component);
-        let stats;
-        try {
-            stats = lstatSync(currentPath);
-        }
-        catch (error) {
-            if (isFsError(error, "ENOENT"))
-                return;
-            if (isFsError(error, "ELOOP")) {
-                throw new Error(`Refusing to materialize profile file through symlink path: ${targetRelativePath}`);
-            }
-            throw error;
-        }
-        if (stats.isSymbolicLink()) {
-            throw new Error(`Refusing to materialize profile file through symlink path: ${targetRelativePath}`);
-        }
-        const isTarget = index === components.length - 1;
-        if ((!isTarget && !stats.isDirectory()) || (isTarget && !stats.isFile())) {
-            throw new Error(`Refusing to materialize profile file through non-file path: ${targetRelativePath}`);
-        }
-    }
-}
-function isFsError(error, code) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === code);
-}
-export { assertNoSymlinkPathComponents, isFsError, prepareWorkspaceFile, regularFileContent, resolveWorkspaceFilePath, validateWorkspaceOwnership, workspaceFileConflictMessage, workspaceFileExists, workspaceFileHasOwnership, workspaceFileMatches, workspacePathHasIdentity, };
-import { createHash, randomUUID } from "node:crypto";
-import { closeSync, fchmodSync, fchownSync, fstatSync, lstatSync, openSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { SAFE_WRITE_FLAGS } from "./workspace-files.js";

package/dist/workspace-apply-publish.d.ts

@@ -1,22 +0,0 @@
-export type ExistingFilePolicy = "allow-identical" | "reject";
-export type ApplyFile = NormalizedPlanFile & {
-    rootDir: string;
-    absPath: string;
-};
-/** What one publication needs once the files to write are chosen. */
-export interface PublishContext {
-    rootFor: (root: NormalizedPlanFile["root"]) => string;
-    existingFiles: ExistingFilePolicy;
-    ownership: ApplyWorkspacePlanOptions["ownership"];
-    publicPlanDigest: string;
-    plannedContent: Map<string, string>;
-}
-export declare const fileIdentity: (file: NormalizedPlanFile) => string;
-export declare function holdsCurrentOwnership(absPath: string, ownership: ApplyWorkspacePlanOptions["ownership"]): boolean;
-export declare function planWrites(filesToApply: ApplyFile[], context: PublishContext): ApplyFile[];
-export declare function publishWrites(writes: ApplyFile[], prepared: PreparedWorkspaceFile[], context: PublishContext): void;
-export declare function rollbackPublished(prepared: PreparedWorkspaceFile[], error: unknown): never;
-export declare function removeTemporaries(prepared: PreparedWorkspaceFile[], receipt: WorkspacePlanReceipt): void;
-import type { NormalizedPlanFile } from "./plan-normalize.js";
-import type { ApplyWorkspacePlanOptions, WorkspacePlanReceipt } from "./plan-types.js";
-import { type PreparedWorkspaceFile } from "./workspace-apply-files.js";

package/dist/workspace-apply-publish.js

@@ -1,178 +0,0 @@
-export const fileIdentity = (file) => `${file.root}\0${file.relPath}`;
-export function holdsCurrentOwnership(absPath, ownership) {
-    return (ownership === undefined || workspaceFileHasOwnership(absPath, ownership));
-}
-/** Only materializer-owned files are held to the writer's ownership. */
-function ownershipCurrent(file, ownership) {
-    return (file.ownership !== "materializer" ||
-        holdsCurrentOwnership(file.absPath, ownership));
-}
-// An owned path holds this package's own earlier output, so re-applying
-// into the same workspace replaces it rather than failing the turn — once
-// the bytes already there prove that provenance. The replacement keeps what
-// an agent appended below a generated context file (its memory), so it can
-// differ from the planned bytes. `reject` still refuses: that policy is
-// "nothing may pre-exist here", which is a statement about the workspace,
-// not authorship.
-function replacementContent(file, context) {
-    const planned = context.plannedContent.get(fileIdentity(file));
-    if (context.existingFiles !== "allow-identical" ||
-        file.ownership !== "materializer" ||
-        planned === undefined) {
-        return undefined;
-    }
-    return materializerReplacement(file.relPath, () => regularFileContent(file.absPath), planned);
-}
-// Validate the complete plan before the first write so a late traversal or
-// existing symlink cannot leave a partially materialized workspace.
-export function planWrites(filesToApply, context) {
-    const writes = [];
-    for (const file of filesToApply) {
-        assertNoSymlinkPathComponents(file.rootDir, file.absPath);
-        if (!workspaceFileExists(file.absPath)) {
-            writes.push(file);
-            continue;
-        }
-        const content = replacementContent(file, context);
-        if (content !== undefined) {
-            writes.push({ ...file, content });
-            continue;
-        }
-        if (context.existingFiles === "reject" || !workspaceFileMatches(file)) {
-            throw new Error(workspaceFileConflictMessage(file, context.existingFiles, context.publicPlanDigest));
-        }
-        writes.push(file);
-    }
-    return writes;
-}
-// rename() replaces in one step, so no window exists in which the path is
-// missing and a concurrent spawn reads nothing. The staged inode moves onto the
-// path, which is what rollback identifies the file by, so an abort still
-// removes exactly what this call published — leaving the path ABSENT rather
-// than restored to the superseded bytes. That is the fail-closed direction: the
-// harness whose flag names a missing file refuses to start, whereas silently
-// restored previous-turn bytes would run the wrong prompt. A replaced file that
-// holds an agent's appended text is the exception: it is linked aside first and
-// restored, because removing it would delete the agent's own text.
-function replacePublishedFile(entry, context) {
-    assertNoSymlinkPathComponents(context.rootFor(entry.file.root), entry.file.absPath);
-    if (entry.file.content !== context.plannedContent.get(fileIdentity(entry.file))) {
-        const superseded = join(dirname(entry.file.absPath), `.agent-profile-${randomUUID()}.superseded`);
-        linkSync(entry.file.absPath, superseded);
-        entry.superseded = superseded;
-    }
-    renameSync(entry.temporaryPath, entry.file.absPath);
-    entry.published = true;
-}
-function publishPreparedFile(entry, context) {
-    assertNoSymlinkPathComponents(context.rootFor(entry.file.root), entry.file.absPath);
-    try {
-        linkSync(entry.temporaryPath, entry.file.absPath);
-        entry.published = true;
-    }
-    catch (error) {
-        if (isFsError(error, "EEXIST") &&
-            context.existingFiles === "allow-identical" &&
-            workspaceFileMatches(entry.file) &&
-            ownershipCurrent(entry.file, context.ownership)) {
-            return;
-        }
-        if (isFsError(error, "EEXIST") &&
-            replacementContent(entry.file, context) === entry.file.content) {
-            // The replacement is recomposed from the bytes there now, so an
-            // agent append that landed since validation refuses below instead
-            // of being overwritten; one landing between that read and the
-            // rename is not detected.
-            replacePublishedFile(entry, context);
-            return;
-        }
-        if (isFsError(error, "EEXIST")) {
-            throw new Error(workspaceFileConflictMessage(entry.file, context.existingFiles, context.publicPlanDigest), { cause: error });
-        }
-        throw error;
-    }
-}
-// Prepared temp links stay alive through publication and rollback. Their
-// inodes distinguish files created here from concurrent replacements.
-export function publishWrites(writes, prepared, context) {
-    for (const file of writes) {
-        if (context.existingFiles === "allow-identical" &&
-            workspaceFileExists(file.absPath) &&
-            workspaceFileMatches(file) &&
-            ownershipCurrent(file, context.ownership)) {
-            continue;
-        }
-        prepared.push(prepareWorkspaceFile(file.rootDir, file, context.ownership));
-    }
-    for (const entry of prepared)
-        publishPreparedFile(entry, context);
-}
-export function rollbackPublished(prepared, 
-// oxlint-disable-next-line anti-slop/no-unknown-parameters -- rollback rethrows the caught failure unchanged; an exception has no schema to parse at a boundary.
-error) {
-    const cleanupErrors = [];
-    for (const entry of [...prepared].reverse()) {
-        try {
-            if (entry.published &&
-                workspacePathHasIdentity(entry.file.absPath, entry.identity)) {
-                if (entry.superseded) {
-                    renameSync(entry.superseded, entry.file.absPath);
-                }
-                else {
-                    unlinkSync(entry.file.absPath);
-                }
-            }
-        }
-        catch (cleanupError) {
-            cleanupErrors.push(cleanupError);
-        }
-        try {
-            if (entry.superseded)
-                unlinkSync(entry.superseded);
-        }
-        catch (cleanupError) {
-            if (!isFsError(cleanupError, "ENOENT"))
-                cleanupErrors.push(cleanupError);
-        }
-        try {
-            if (workspacePathHasIdentity(entry.temporaryPath, entry.identity)) {
-                unlinkSync(entry.temporaryPath);
-            }
-        }
-        catch (cleanupError) {
-            cleanupErrors.push(cleanupError);
-        }
-    }
-    if (cleanupErrors.length > 0) {
-        throw new AggregateError([error, ...cleanupErrors], "Failed to apply workspace plan and roll back published files");
-    }
-    throw error;
-}
-export function removeTemporaries(prepared, receipt) {
-    const cleanupErrors = [];
-    const temporaryPaths = [];
-    for (const entry of prepared) {
-        for (const path of [entry.temporaryPath, entry.superseded]) {
-            if (path === undefined)
-                continue;
-            try {
-                unlinkSync(path);
-            }
-            catch (error) {
-                if (!isFsError(error, "ENOENT")) {
-                    cleanupErrors.push(error);
-                    temporaryPaths.push(path);
-                }
-            }
-        }
-    }
-    if (cleanupErrors.length > 0) {
-        throw new WorkspacePlanCleanupError(cleanupErrors, receipt, temporaryPaths);
-    }
-}
-import { randomUUID } from "node:crypto";
-import { linkSync, renameSync, unlinkSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { materializerReplacement } from "./harness.js";
-import { WorkspacePlanCleanupError } from "./plan-types.js";
-import { assertNoSymlinkPathComponents, isFsError, prepareWorkspaceFile, regularFileContent, workspaceFileConflictMessage, workspaceFileExists, workspaceFileHasOwnership, workspaceFileMatches, workspacePathHasIdentity, } from "./workspace-apply-files.js";

package/dist/workspace-apply.d.ts

@@ -1,11 +0,0 @@
-export declare function applyResolvedWorkspacePlan(publicPlan: WorkspacePlan, resolvedPlan: ResolvedWorkspacePlan, workspaceDir: string, options: ApplyWorkspacePlanOptions, publicPlanDigest?: string): WorkspacePlanApplication;
-export interface ResolvedWorkspacePlan {
-    files: NormalizedPlanFile[];
-    env: Record<string, string>;
-    flags: string[];
-    systemPrompt?: string;
-    appendSystemPrompt?: string;
-    systemPromptBinding?: WorkspacePlanSystemPromptBinding;
-}
-import { type NormalizedPlanFile } from "./plan-normalize.js";
-import type { ApplyWorkspacePlanOptions, WorkspacePlan, WorkspacePlanApplication, WorkspacePlanSystemPromptBinding } from "./plan-types.js";

package/dist/workspace-apply.js

@@ -1,124 +0,0 @@
-function readApplyInput(publicPlan, workspaceDir, options) {
-    const workspaceRoot = resolve(workspaceDir);
-    if (options.agentDir !== undefined && !isAbsolute(options.agentDir)) {
-        throw new Error("ApplyWorkspacePlanOptions.agentDir must be absolute");
-    }
-    const agentRoot = options.agentDir === undefined ? undefined : resolve(options.agentDir);
-    const publicFiles = normalizePlanFiles(publicPlan.files);
-    if (publicFiles.some((file) => file.root === "agent") && !agentRoot) {
-        throw new Error("Workspace plan contains agent-root files but ApplyWorkspacePlanOptions.agentDir is missing");
-    }
-    const rootFor = (root) => root === "workspace" ? workspaceRoot : agentRoot;
-    const runtimeOnlyFiles = new Set((options.runtimeOnlyFiles ?? []).map(normalizeWorkspaceRelativePath));
-    const ownership = validateWorkspaceOwnership(options.ownership);
-    const privateFilePaths = new Set(publicFiles.filter((file) => file.secretSlots.length > 0).map(fileIdentity));
-    const existingFiles = options.existingFiles ?? "allow-identical";
-    if (existingFiles !== "allow-identical" && existingFiles !== "reject") {
-        throw new Error(`Unsupported existing workspace file policy: ${existingFiles}`);
-    }
-    return {
-        rootFor,
-        runtimeOnlyFiles,
-        ownership,
-        privateFilePaths,
-        existingFiles,
-    };
-}
-// A prior application of this exact plan makes the workspace live agent
-// state. Preserve changed and removed files. Refresh private generated files
-// because the public digest excludes secret values, and repair unchanged
-// materializer files that still have the writer's ownership.
-function selectResumeFiles(files, ownership, privateFilePaths) {
-    return files.filter((file) => {
-        if (file.ownership !== "materializer")
-            return false;
-        assertNoSymlinkPathComponents(file.rootDir, file.absPath);
-        if (!workspaceFileExists(file.absPath))
-            return false;
-        const matches = workspaceFileMatches(file);
-        const hasCurrentOwnership = holdsCurrentOwnership(file.absPath, ownership);
-        if (privateFilePaths.has(fileIdentity(file))) {
-            return !matches || !hasCurrentOwnership;
-        }
-        return matches && !hasCurrentOwnership;
-    });
-}
-export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDir, options, publicPlanDigest = hashWorkspacePlan(publicPlan)) {
-    const { rootFor, runtimeOnlyFiles, ownership, privateFilePaths, existingFiles, } = readApplyInput(publicPlan, workspaceDir, options);
-    const privateRuntimeFiles = Object.fromEntries(resolvedPlan.files
-        .filter((file) => file.root === "workspace" && runtimeOnlyFiles.has(file.relPath))
-        .map((file) => [file.relPath, file.content]));
-    const files = resolvedPlan.files
-        .filter((file) => file.root !== "workspace" || !runtimeOnlyFiles.has(file.relPath))
-        .map((file) => ({
-        ...file,
-        rootDir: rootFor(file.root),
-        absPath: resolveWorkspaceFilePath(rootFor(file.root), file.relPath),
-    }));
-    const application = {
-        receipt: {
-            workspacePlanDigest: publicPlanDigest,
-            env: Object.fromEntries(Object.entries(publicPlan.env).map(([name, value]) => [
-                name,
-                typeof value === "string" ? value : { ...value },
-            ])),
-            flags: bindWorkspaceLaunchFlags(publicPlan, publicPlan.flags, workspaceDir).map(normalizeWorkspacePlanArgument),
-            ...promptIntentFields(publicPlan, samePromptIntentValue),
-            ...systemPromptBindingField(publicPlan),
-            unsupported: publicPlan.unsupported.map((entry) => ({ ...entry })),
-            written: files
-                .filter((file) => file.root === "workspace")
-                .map((file) => file.relPath),
-            writtenFiles: files.map(({ root, relPath }) => ({ root, relPath })),
-        },
-        spawn: {
-            env: { ...resolvedPlan.env },
-            flags: bindWorkspaceLaunchFlags(publicPlan, resolvedPlan.flags, workspaceDir),
-            ...promptIntentFields(resolvedPlan, samePromptIntentValue),
-            ...systemPromptBindingField(resolvedPlan),
-        },
-        runtimeOnlyFiles: privateRuntimeFiles,
-    };
-    // `reject` does not resume because it requires an empty target.
-    const resumeSamePlan = existingFiles === "allow-identical" &&
-        options.appliedPlanDigest !== undefined &&
-        options.appliedPlanDigest === publicPlanDigest;
-    const filesToApply = resumeSamePlan
-        ? selectResumeFiles(files, ownership, privateFilePaths)
-        : files;
-    if (resumeSamePlan && filesToApply.length === 0) {
-        return application;
-    }
-    const context = {
-        rootFor,
-        existingFiles,
-        ownership,
-        publicPlanDigest,
-        plannedContent: new Map(filesToApply.map((file) => [fileIdentity(file), file.content])),
-    };
-    const writes = planWrites(filesToApply, context);
-    // Parent directories remain on failure because they may contain concurrent
-    // workspace state that this call does not own.
-    for (const file of writes) {
-        mkdirSync(dirname(file.absPath), { recursive: true });
-        assertNoSymlinkPathComponents(file.rootDir, file.absPath);
-    }
-    const prepared = [];
-    try {
-        publishWrites(writes, prepared, context);
-    }
-    catch (error) {
-        rollbackPublished(prepared, error);
-    }
-    removeTemporaries(prepared, application.receipt);
-    return application;
-}
-import { mkdirSync } from "node:fs";
-import { dirname, isAbsolute, resolve } from "node:path";
-import { hashWorkspacePlan } from "./plan-digest.js";
-import { normalizePlanFiles, normalizeWorkspacePlanArgument, } from "./plan-normalize.js";
-import { promptIntentFields, samePromptIntentValue, systemPromptBindingField, } from "./plan-prompt.js";
-import { assertNoSymlinkPathComponents, resolveWorkspaceFilePath, validateWorkspaceOwnership, workspaceFileExists, workspaceFileMatches, } from "./workspace-apply-files.js";
-import { fileIdentity, holdsCurrentOwnership, planWrites, publishWrites, removeTemporaries, rollbackPublished, } from "./workspace-apply-publish.js";
-import { normalizeWorkspaceRelativePath } from "./workspace-files.js";
-import { bindWorkspaceLaunchFlags } from "./workspace-launch.js";

package/dist/workspace-files.d.ts

@@ -1,8 +0,0 @@
-export declare const compareStrings: (a: string, b: string) => 1 | 0 | -1;
-export declare const DEFAULT_FILE_MODE = 420;
-export declare const PRIVATE_FILE_MODE = 384;
-export declare const EXECUTABLE_FILE_MODE = 493;
-export declare const SAFE_WRITE_FLAGS: number;
-export declare function normalizeWorkspaceRelativePath(pathValue: string): string;
-export declare function hasControlCharacter(value: string): boolean;
-export declare function validateFileMode(mode: number | undefined): number;