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

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;

package/dist/workspace-files.js

@@ -1,46 +0,0 @@
-export const compareStrings = (a, b) => a < b ? -1 : a > b ? 1 : 0;
-export const DEFAULT_FILE_MODE = 0o644;
-export const PRIVATE_FILE_MODE = 0o600;
-export const EXECUTABLE_FILE_MODE = 0o755;
-export const SAFE_WRITE_FLAGS = fsConstants.O_WRONLY |
-    fsConstants.O_CREAT |
-    fsConstants.O_EXCL |
-    (typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0);
-export function normalizeWorkspaceRelativePath(pathValue) {
-    if (typeof pathValue !== "string" ||
-        !pathValue ||
-        hasControlCharacter(pathValue)) {
-        throw new Error("Workspace file path must be non-empty and contain no control characters");
-    }
-    if (isAbsolute(pathValue) ||
-        win32.isAbsolute(pathValue) ||
-        /^[A-Za-z]:/.test(pathValue)) {
-        throw new Error(`Workspace file path must be relative: ${pathValue}`);
-    }
-    const segments = pathValue.replace(/\\/g, "/").split("/");
-    if (segments.some((segment) => !segment ||
-        segment === "." ||
-        segment === ".." ||
-        segment === ".git" ||
-        segment === ".sidecar")) {
-        throw new Error(`Workspace file path must be canonical: ${pathValue}`);
-    }
-    return segments.join("/");
-}
-export function hasControlCharacter(value) {
-    for (let index = 0; index < value.length; index++) {
-        const code = value.charCodeAt(index);
-        if (code < 0x20 || code === 0x7f)
-            return true;
-    }
-    return false;
-}
-export function validateFileMode(mode) {
-    const normalized = mode ?? DEFAULT_FILE_MODE;
-    if (!Number.isInteger(normalized) || normalized < 0 || normalized > 0o777) {
-        throw new Error(`Workspace file mode must be between 0o000 and 0o777: ${mode}`);
-    }
-    return normalized;
-}
-import { constants as fsConstants } from "node:fs";
-import { isAbsolute, win32 } from "node:path";

package/dist/workspace-launch.d.ts

@@ -1,3 +0,0 @@
-import type { WorkspacePlan } from "./plan-types.js";
-/** Bind launch paths; omit the workspace to hash portable content identity. */
-export declare function bindWorkspaceLaunchFlags<T>(plan: WorkspacePlan, flags: readonly T[], workspaceDir?: string): (T | string)[];

package/dist/workspace-launch.js

@@ -1,13 +0,0 @@
-import { resolve } from "node:path";
-import { CODEX_SYSTEM_PROMPT_FILE } from "./harness.js";
-import { tomlStr } from "./plan-json.js";
-/** Bind launch paths; omit the workspace to hash portable content identity. */
-export function bindWorkspaceLaunchFlags(plan, flags, workspaceDir) {
-    return flags.map((flag, at) => plan.harness === "codex" &&
-        plan.flags[at - 1] === "-c" &&
-        plan.flags[at] === `model_instructions_file=${CODEX_SYSTEM_PROMPT_FILE}`
-        ? workspaceDir === undefined
-            ? `model_instructions_file=${CODEX_SYSTEM_PROMPT_FILE}`
-            : `model_instructions_file=${tomlStr(resolve(workspaceDir, CODEX_SYSTEM_PROMPT_FILE))}`
-        : flag);
-}