@dsh-workbench/shared 1.1.14-beta.2 → 1.1.15

package/dist/host/seam/run.js

@@ -0,0 +1,415 @@
+import { now } from '../time.js';
+import { mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { workbenchRoot } from '../data-root.js';
+import { shellKindOf } from '../shell-text.js';
+import { callOperatorOf, invocationOf, quotedArgvLine, quotedLineOf } from '../shell-render.js';
+import { runShell } from '../shell.js';
+import { deniedPathOf, sandboxDeniedOf } from './denial.js';
+import { seamProductEnv } from './env.js';
+import { definedEnvOf, hostEnvOf } from './host-env.js';
+import { SeamError, } from './intent.js';
+import { denialScopeOf, narrowerMode, pathsPolicy, policyOf, productPolicy, seamModeOf, workspacePolicy } from './policy.js';
+import { createNodeProcessHost } from './process.js';
+const DENIAL_MARKER = /\[sandbox: file access denied under [a-z-]+ mode\]/i;
+const DEFAULT_MAX_BYTES = 8 * 1024 * 1024;
+function scopeText(scope) {
+    if (scope === 'product')
+        return '工作台自己的目录';
+    if (scope === 'workspace')
+        return '会话工作区';
+    if (scope === 'external')
+        return '工作区之外的路径';
+    return '没认出来的路径';
+}
+function denialMessageOf(scope, path, output) {
+    const where = path === undefined ? '' : `：${path}`;
+    const marker = DENIAL_MARKER.test(output) ? '' : '（输出里没有沙箱标记，按拒绝处理）';
+    const next = scope === 'external'
+        ? '要写工作区外的路径得先让用户点头：把目标改到工作区，或让工具补上审批后再试'
+        : '这是工作台自己的声明问题，不是用户的配置问题：把命令、域与路径一起记下来交给维护者';
+    return `被沙箱挡住了（${scopeText(scope)}${where}）${marker}。${next}`;
+}
+function settle(result, denial) {
+    return {
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        aborted: result.aborted,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        truncated: result.truncated,
+        stalled: result.stalled,
+        ...(denial === undefined ? {} : { denial }),
+    };
+}
+function targetOf(request) {
+    const hasCommand = request.command !== undefined;
+    const hasArgv = request.argv !== undefined;
+    if (hasArgv && !hasCommand) {
+        const argv = request.argv ?? [];
+        if (argv.length === 0)
+            throw new SeamError('scope-not-declared', 'argv 是空的：至少给一个可执行文件');
+        return { argv };
+    }
+    if (hasCommand && !hasArgv)
+        return { line: request.command ?? '' };
+    throw new SeamError('scope-not-declared', '这条执行请求要么给 argv，要么给一条命令行，不能两个都给或都不给');
+}
+function displayOf(target) {
+    return 'argv' in target ? quotedArgvLine(target.argv) : target.line;
+}
+function targetInvocationOf(target, shellKind) {
+    if ('argv' in target) {
+        const [file, ...args] = target.argv;
+        if (file === undefined)
+            throw new SeamError('scope-not-declared', 'argv 是空的：至少给一个可执行文件');
+        return { file, args };
+    }
+    return invocationOf(shellKind ?? shellKindOf(), target.line);
+}
+function sandboxedLineOf(target, shellKind) {
+    const line = 'argv' in target ? quotedArgvLine(target.argv) : target.line;
+    if (shellKind === undefined)
+        return callOperatorOf(shellKindOf(), line);
+    return callOperatorOf(shellKindOf(), quotedLineOf(invocationOf(shellKind, line)));
+}
+export function createSeam(ports) {
+    const runtimeRoot = ports.runtimeRoot ?? workbenchRoot();
+    const ceiling = ports.ceiling ?? seamModeOf(process.env['DSH_PERMISSION_MODE']);
+    const allowHost = ports.allowHost === true;
+    const processes = ports.processes ?? createNodeProcessHost();
+    const limit = ports.factLimit ?? 80;
+    const facts = [];
+    function record(fact) {
+        facts.push(fact);
+        if (facts.length > limit)
+            facts.splice(0, facts.length - limit);
+    }
+    function grantFor(session) {
+        if (ports.grantOf === undefined || session === undefined || session === null)
+            return undefined;
+        try {
+            return ports.grantOf(session);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function requireHost(intent) {
+        if (intent.kind !== 'host') {
+            throw new SeamError('scope-not-declared', '这条调用要走宿主进程执行，但写入域不是 host');
+        }
+        if (!allowHost)
+            throw new SeamError('scope-not-declared', '宿主域只给宿主侧接线开出来；模块与普通调用点拿不到');
+    }
+    async function attempt(request, policy, line) {
+        return runShell(ports.shell, line, {
+            ...(request.workdir === undefined ? {} : { workdir: request.workdir }),
+            ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
+            ...(request.signal === undefined ? {} : { signal: request.signal }),
+            env: { ...seamProductEnv({ runtimeRoot, realHome: ports.realHome }), ...definedEnvOf(request.env) },
+            sandboxPolicy: policy,
+        });
+    }
+    function healPolicyOf(intent, scope, granted) {
+        if (scope === 'product' && intent.kind !== 'product')
+            return productPolicy(ceiling, runtimeRoot);
+        if (scope === 'workspace' && intent.kind === 'workspace') {
+            if (granted === undefined)
+                return undefined;
+            try {
+                return workspacePolicy(ceiling, granted);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    async function runHost(request, target) {
+        const invocation = targetInvocationOf(target, request.shellKind);
+        const child = processes.spawn({
+            file: invocation.file,
+            args: invocation.args,
+            env: hostEnvOf(request.env),
+            ...(request.workdir === undefined ? {} : { cwd: request.workdir }),
+            detached: false,
+            stdio: 'pipe',
+            windowsHide: true,
+        });
+        const state = { stdout: '', stderr: '', truncated: false };
+        const append = (which, chunk) => {
+            const total = state.stdout.length + state.stderr.length;
+            const room = (request.maxBytes ?? DEFAULT_MAX_BYTES) - total;
+            if (room <= 0) {
+                state.truncated = true;
+                return;
+            }
+            const text = chunk.length > room ? chunk.slice(0, room) : chunk;
+            state[which] += text;
+            if (chunk.length > room)
+                state.truncated = true;
+        };
+        child.stdout?.onData((chunk) => append('stdout', chunk));
+        child.stderr?.onData((chunk) => append('stderr', chunk));
+        let timer;
+        let timedOut = false;
+        if (request.timeoutMs !== undefined) {
+            timer = setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGKILL');
+            }, request.timeoutMs);
+        }
+        const exit = await new Promise((resolve) => {
+            child.onExit((event) => resolve(event));
+            child.onError((error) => {
+                state.stderr = `${state.stderr}${String(error)}`;
+                resolve({ code: null, signal: null });
+            });
+        });
+        if (timer !== undefined)
+            clearTimeout(timer);
+        return {
+            exitCode: exit.code,
+            timedOut,
+            aborted: false,
+            stdout: state.stdout,
+            stderr: state.stderr,
+            truncated: state.truncated,
+            stalled: false,
+        };
+    }
+    function spawnHost(request) {
+        const invocation = targetInvocationOf(request.target, undefined);
+        const logFile = request.logFile ?? join(runtimeRoot, 'logs', `${request.label ?? 'spawn'}-${String(now())}.log`);
+        mkdirSync(dirname(logFile), { recursive: true });
+        const child = processes.spawn({
+            file: invocation.file,
+            args: invocation.args,
+            env: hostEnvOf(request.env),
+            ...(request.cwd === undefined ? {} : { cwd: request.cwd }),
+            detached: true,
+            stdio: 'log',
+            logFile,
+            windowsHide: true,
+        });
+        child.unref();
+        record({
+            at: now(),
+            verb: 'spawn',
+            command: displayOf(request.target),
+            intent: 'host',
+            mode: 'host',
+            workspaceRoot: '',
+            exitCode: null,
+            timedOut: false,
+            stalled: false,
+        });
+        const display = displayOf(request.target);
+        const errorListeners = new Set();
+        const exitWaiters = [];
+        let settled;
+        let failure;
+        const settleExit = (event) => {
+            if (settled !== undefined)
+                return;
+            settled = event;
+            for (const waiter of exitWaiters.splice(0))
+                waiter(event);
+        };
+        child.onExit((event) => settleExit(event));
+        child.onError((error) => {
+            failure = error;
+            settleExit({ code: null, signal: null });
+            if (errorListeners.size === 0) {
+                ports.logger?.warn?.(`[dsh-workbench] 起进程没跑起来（${display}）：${String(error)}`);
+                return;
+            }
+            for (const listener of errorListeners)
+                listener(error);
+        });
+        return {
+            pid: child.pid,
+            logFile,
+            exit: () => settled === undefined
+                ? new Promise((resolve) => exitWaiters.push(resolve))
+                : Promise.resolve(settled),
+            onError(listener) {
+                if (failure !== undefined) {
+                    listener(failure);
+                    return () => { };
+                }
+                errorListeners.add(listener);
+                return () => errorListeners.delete(listener);
+            },
+            kill: (signal) => child.kill(signal ?? 'SIGTERM'),
+        };
+    }
+    function openHost(request) {
+        const invocation = targetInvocationOf(request.target, undefined);
+        const child = processes.spawn({
+            file: invocation.file,
+            args: invocation.args,
+            env: hostEnvOf(request.env),
+            ...(request.cwd === undefined ? {} : { cwd: request.cwd }),
+            detached: false,
+            stdio: 'pipe',
+            windowsHide: true,
+        });
+        record({
+            at: now(),
+            verb: 'open',
+            command: displayOf(request.target),
+            intent: 'host',
+            mode: 'host',
+            workspaceRoot: '',
+            exitCode: null,
+            timedOut: false,
+            stalled: false,
+        });
+        const display = displayOf(request.target);
+        const errorListeners = new Set();
+        const exitListeners = new Set();
+        let failure;
+        let settled;
+        const settleExit = (event) => {
+            if (settled !== undefined)
+                return;
+            settled = event;
+            for (const listener of exitListeners)
+                listener(event);
+        };
+        child.onExit((event) => settleExit(event));
+        child.onError((error) => {
+            failure = error;
+            settleExit({ code: null, signal: null });
+            if (errorListeners.size === 0) {
+                ports.logger?.warn?.(`[dsh-workbench] 双向通道起不来（${display}）：${String(error)}`);
+                return;
+            }
+            for (const listener of errorListeners)
+                listener(error);
+        });
+        return {
+            pid: child.pid,
+            write: (chunk) => child.stdin?.write(chunk),
+            onData(listener) {
+                const offOut = child.stdout?.onData(listener) ?? (() => { });
+                const offErr = child.stderr?.onData(listener) ?? (() => { });
+                return () => {
+                    offOut();
+                    offErr();
+                };
+            },
+            onExit(listener) {
+                if (settled !== undefined) {
+                    listener(settled);
+                    return () => { };
+                }
+                exitListeners.add(listener);
+                return () => exitListeners.delete(listener);
+            },
+            onError(listener) {
+                if (failure !== undefined) {
+                    listener(failure);
+                    return () => { };
+                }
+                errorListeners.add(listener);
+                return () => errorListeners.delete(listener);
+            },
+            kill: (signal) => child.kill(signal ?? 'SIGTERM'),
+        };
+    }
+    return {
+        async run(request) {
+            const target = targetOf(request);
+            if (request.intent.kind === 'host') {
+                requireHost(request.intent);
+                const started = now();
+                const result = await runHost(request, target);
+                record({
+                    at: started,
+                    verb: 'run',
+                    command: displayOf(target),
+                    intent: 'host',
+                    mode: 'host',
+                    workspaceRoot: '',
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stalled: result.stalled,
+                });
+                return settle(result);
+            }
+            const granted = grantFor(request.session);
+            const intent = request.intent;
+            const policy = policyOf(intent, ceiling, runtimeRoot, granted);
+            const line = sandboxedLineOf(target, request.shellKind);
+            let result = await attempt(request, policy, line);
+            if (!sandboxDeniedOf(result.sandbox)) {
+                record({
+                    at: now(),
+                    verb: 'run',
+                    command: line,
+                    intent: intent.kind,
+                    mode: policy.mode,
+                    workspaceRoot: policy.workspaceRoot,
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stalled: result.stalled,
+                });
+                return settle(result);
+            }
+            const path = deniedPathOf(result.stderr, result.stdout);
+            const scope = denialScopeOf(path, policy, runtimeRoot, granted);
+            const healedPolicy = request.retry === 'safe' ? healPolicyOf(intent, scope, granted) : undefined;
+            let healed = false;
+            if (healedPolicy !== undefined) {
+                const retried = await attempt(request, healedPolicy, line).catch(() => undefined);
+                if (retried !== undefined && !sandboxDeniedOf(retried.sandbox)) {
+                    result = retried;
+                    healed = true;
+                }
+            }
+            const denial = {
+                ...(path === undefined ? {} : { path }),
+                scope,
+                ...(healed ? { healed: true } : {}),
+            };
+            record({
+                at: now(),
+                verb: 'run',
+                command: line,
+                intent: intent.kind,
+                mode: policy.mode,
+                workspaceRoot: policy.workspaceRoot,
+                exitCode: result.exitCode,
+                timedOut: result.timedOut,
+                stalled: result.stalled,
+                denial,
+            });
+            if (healed)
+                return settle(result, denial);
+            if (request.bestEffort === true) {
+                ports.logger?.warn?.(`[dsh-workbench] ${denialMessageOf(scope, path, `${result.stderr}\n${result.stdout}`)}`);
+                return settle(result, denial);
+            }
+            throw new SeamError('sandbox-denied', denialMessageOf(scope, path, `${result.stderr}\n${result.stdout}`), {
+                ...(path === undefined ? {} : { path }),
+                scope,
+            });
+        },
+        spawn(request) {
+            requireHost(request.intent);
+            return spawnHost(request);
+        },
+        open(request) {
+            requireHost(request.intent);
+            return openHost(request);
+        },
+        facts: () => facts,
+    };
+}
+export function sealedPolicyOf(policy, ceiling) {
+    return { mode: narrowerMode(ceiling, policy.mode), workspaceRoot: policy.workspaceRoot };
+}
+export { pathsPolicy, policyOf, productPolicy, workspacePolicy };

package/dist/host/seam/service.d.ts

@@ -0,0 +1,4 @@
+import type { DshHostContext } from '../../api/dsh.js';
+import type { Seam } from './run.js';
+export declare const WORKBENCH_SEAM = "workbenchSeam";
+export declare function seamOf(ctx: DshHostContext): Seam | undefined;

package/dist/host/seam/service.js

@@ -0,0 +1,4 @@
+export const WORKBENCH_SEAM = 'workbenchSeam';
+export function seamOf(ctx) {
+    return ctx.get(WORKBENCH_SEAM, false);
+}

package/dist/host/seam/unit-seam.d.ts

@@ -0,0 +1,14 @@
+import { type UnitSeamRequest, type UnitWriteScope } from './intent.js';
+import type { Seam, SeamOutcome } from './run.js';
+export interface UnitSeamPorts {
+    readonly seam: Seam;
+    readonly unit: string;
+    readonly runtimeRoot: string;
+    readonly declared?: readonly UnitWriteScope[] | undefined;
+    readonly realHome?: string | undefined;
+}
+export interface UnitSeam {
+    run(request: UnitSeamRequest): Promise<SeamOutcome>;
+}
+export declare function unitDataRoot(runtimeRoot: string, unit: string): string;
+export declare function createUnitSeam(ports: UnitSeamPorts): UnitSeam;

package/dist/host/seam/unit-seam.js

@@ -0,0 +1,43 @@
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { seamUnitEnv } from './env.js';
+import { SeamError } from './intent.js';
+export function unitDataRoot(runtimeRoot, unit) {
+    return join(runtimeRoot, 'units', unit);
+}
+export function createUnitSeam(ports) {
+    const unitRoot = unitDataRoot(ports.runtimeRoot, ports.unit);
+    mkdirSync(unitRoot, { recursive: true });
+    const declared = new Set(ports.declared ?? []);
+    const env = seamUnitEnv({ runtimeRoot: ports.runtimeRoot, unitRoot, realHome: ports.realHome });
+    return {
+        async run(request) {
+            const common = {
+                command: request.command,
+                ...(request.workdir === undefined ? {} : { workdir: request.workdir }),
+                ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
+                ...(request.signal === undefined ? {} : { signal: request.signal }),
+                ...(request.retry === undefined ? {} : { retry: request.retry }),
+            };
+            if (request.scope === 'unit') {
+                return ports.seam.run({
+                    ...common,
+                    intent: { kind: 'product' },
+                    env: { ...env, ...(request.env ?? {}) },
+                });
+            }
+            if (!declared.has('workspace')) {
+                throw new SeamError('scope-not-declared', `${ports.unit} 的清单没有声明 host.writes 里的 workspace：要写当前工作区，先在清单里声明`);
+            }
+            if (request.session === undefined || request.session === null) {
+                throw new SeamError('workspace-unknown', `${ports.unit} 请求写工作区，但这次调用没有会话`);
+            }
+            return ports.seam.run({
+                ...common,
+                intent: { kind: 'workspace' },
+                session: request.session,
+                env: { ...(request.env ?? {}) },
+            });
+        },
+    };
+}

package/dist/host/shell-render.d.ts

@@ -0,0 +1,9 @@
+import type { ShellKind } from './shell-text.js';
+export interface ShellInvocation {
+    readonly file: string;
+    readonly args: readonly string[];
+}
+export declare function callOperatorOf(kind: ShellKind, script: string): string;
+export declare function invocationOf(kind: ShellKind, script: string): ShellInvocation;
+export declare function quotedArgvLine(argv: readonly string[], platform?: NodeJS.Platform): string;
+export declare function quotedLineOf(invocation: ShellInvocation, platform?: NodeJS.Platform): string;

package/dist/host/shell-render.js

@@ -0,0 +1,18 @@
+import { quoteShellArgFor } from './shell-text.js';
+const QUOTED_HEAD = /^\s*['"]/;
+export function callOperatorOf(kind, script) {
+    if (kind !== 'pwsh' || !QUOTED_HEAD.test(script))
+        return script;
+    return `& ${script}`;
+}
+export function invocationOf(kind, script) {
+    return kind === 'pwsh'
+        ? { file: 'pwsh', args: ['-NoProfile', '-NonInteractive', '-Command', callOperatorOf('pwsh', script)] }
+        : { file: 'bash', args: ['-c', script] };
+}
+export function quotedArgvLine(argv, platform = process.platform) {
+    return argv.map((one) => quoteShellArgFor(one, platform)).join(' ');
+}
+export function quotedLineOf(invocation, platform = process.platform) {
+    return quotedArgvLine([invocation.file, ...invocation.args], platform);
+}

package/dist/host/shell.d.ts

@@ -1,4 +1,10 @@
 import type { DshShell } from '../api/dsh.js';
+export interface ShellSandboxFacts {
+    readonly mode?: string | undefined;
+    readonly denied?: boolean | undefined;
+    readonly enforcement?: string | undefined;
+    readonly runnerFailed?: boolean | undefined;
+}
 export interface ShellResult {
     readonly exitCode: number | null;
     readonly timedOut: boolean;
@@ -7,10 +13,16 @@ export interface ShellResult {
     readonly stderr: string;
     readonly truncated: boolean;
     readonly stalled: boolean;
+    readonly sandbox?: ShellSandboxFacts | undefined;
+}
+export interface DshShellSandboxPolicy {
+    readonly mode: 'read-only' | 'workspace-write' | 'danger-full-access';
+    readonly workspaceRoot: string;
 }
 export declare function runShell(shell: DshShell, command: string, options?: {
     workdir?: string;
     timeoutMs?: number;
     signal?: AbortSignal;
     env?: Readonly<Record<string, string>>;
+    sandboxPolicy?: DshShellSandboxPolicy | undefined;
 }): Promise<ShellResult>;

package/dist/host/shell.js

@@ -26,7 +26,7 @@ async function settleWithin(work, limitMs) {
     }
 }
 export async function runShell(shell, command, options = {}) {
-    const { workdir, timeoutMs = GIT_TIMEOUT_MS, signal, env } = options;
+    const { workdir, timeoutMs = GIT_TIMEOUT_MS, signal, env, sandboxPolicy } = options;
     const spec = shell.resolve({
         command,
         ...(workdir === undefined ? {} : { workdir }),
@@ -35,6 +35,7 @@ export async function runShell(shell, command, options = {}) {
         stdoutMaxBytes: DEFAULT_MAX_BYTES,
         ...(signal === undefined ? {} : { signal }),
         ...(env === undefined ? {} : { env }),
+        ...(sandboxPolicy === undefined ? {} : { sandboxPolicy }),
     });
     const settled = await settleWithin((async () => {
         const execution = await shell.execute(spec);
@@ -47,6 +48,7 @@ export async function runShell(shell, command, options = {}) {
             stderr: result.stderr.text,
             truncated: result.stdout.truncated || result.stderr.truncated,
             stalled: false,
+            ...(result.sandbox === undefined ? {} : { sandbox: result.sandbox }),
         };
     })(), timeoutMs + GUARD_SLACK_MS);
     return settled ?? stalledResult();

package/dist/host/time.d.ts

@@ -10,3 +10,13 @@ export declare function clockOf(value: string | number | Date): string;
  * @returns 毫秒时间戳或 `NaN`。
  */
 export declare function epochOf(value: string | number | Date): number;
+/**
+ * 当前时间（毫秒）。宿主里要「现在几点」只走这里，测试可以点住 `Date.now`。
+ * @returns 毫秒时间戳。
+ */
+export declare function now(): number;
+/**
+ * 当前时间的 ISO 字符串。
+ * @returns `new Date().toISOString()` 的等价物。
+ */
+export declare function nowIso(): string;

package/dist/host/time.js

@@ -17,3 +17,17 @@ export function clockOf(value) {
 export function epochOf(value) {
     return dayjs(value).valueOf();
 }
+/**
+ * 当前时间（毫秒）。宿主里要「现在几点」只走这里，测试可以点住 `Date.now`。
+ * @returns 毫秒时间戳。
+ */
+export function now() {
+    return Date.now();
+}
+/**
+ * 当前时间的 ISO 字符串。
+ * @returns `new Date().toISOString()` 的等价物。
+ */
+export function nowIso() {
+    return new Date(now()).toISOString();
+}

package/dist/host/value-handoff.js

@@ -1,3 +1,4 @@
+import { now as clockNow } from './time.js';
 import { HANDOFF_TTL_MS } from '../config/constants.js';
 export function handoffId(entry) {
     return `${String(entry.fact.length)}:${entry.fact}${entry.key}`;
@@ -6,10 +7,10 @@ export function createValueHandoff(options = {}) {
     const ttlMs = options.ttlMs ?? HANDOFF_TTL_MS;
     const held = new Map();
     return {
-        hand(entry, value, now = Date.now()) {
+        hand(entry, value, now = clockNow()) {
             held.set(handoffId(entry), { value, at: now });
         },
-        take(entry, now = Date.now()) {
+        take(entry, now = clockNow()) {
             const id = handoffId(entry);
             const hit = held.get(id);
             if (hit === undefined)

package/dist/host/workspace-store.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { workspacesRoot } from '../host/data-root.js';
+import { writeJsonFile } from './fs-write.js';
 function slug(raw, max = 40) {
     const cleaned = raw
         .replace(/[^A-Za-z0-9._-]+/g, '-')
@@ -53,9 +54,6 @@ function memoryStore(dir) {
     };
 }
 function fileStore(dir) {
-    const ensureFor = (file) => {
-        fs.mkdirSync(path.dirname(file), { recursive: true });
-    };
     return {
         dir,
         read: (name) => {
@@ -68,11 +66,7 @@ function fileStore(dir) {
             }
         },
         write: (name, value) => {
-            const file = inside(dir, name);
-            ensureFor(file);
-            const tmp = `${file}.tmp`;
-            fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
-            fs.renameSync(tmp, file);
+            writeJsonFile(inside(dir, name), value);
         },
         remove: (name) => {
             const file = inside(dir, name);

package/dist/host.d.ts

@@ -37,7 +37,9 @@ export * from './host/profile-create.js';
 export * from './host/context-ref.js';
 export * from './host/diy-debug.js';
 export * from './host/diy-record.js';
+export * from './host/env-policy.js';
 export * from './host/facts.js';
+export * from './host/fs-write.js';
 export * from './host/git.js';
 export * from './host/http.js';
 export * from './host/lib-capabilities.js';
@@ -65,7 +67,17 @@ export * from './host/write-result.js';
 export * from './host/cli-error.js';
 export * from './host/data-root.js';
 export * from './host/shell-text.js';
+export * from './host/shell-render.js';
 export * from './host/shell.js';
+export * from './host/seam/intent.js';
+export * from './host/seam/policy.js';
+export * from './host/seam/env.js';
+export * from './host/seam/denial.js';
+export * from './host/seam/run.js';
+export * from './host/seam/exec.js';
+export * from './host/seam/process.js';
+export * from './host/seam/unit-seam.js';
+export * from './host/seam/service.js';
 export * from './host/data-error.js';
 export * from './host/install-failure.js';
 export * from './host/provision.js';