intentdna 1.9.0 → 1.9.3

package/dist/runtime/plan-store.d.ts

@@ -0,0 +1,30 @@
+import { type ExecutableRunPlanPayload, type Sha256Digest, type StoredExecutableRunPlan } from "./executable-run-plan.js";
+export interface DurablePlanStoreOptions {
+    /** The shared `.dna/runtime` directory. */
+    readonly root_directory: string;
+}
+export type PlanStoreErrorCode = "invalid_options" | "invalid_plan_id" | "invalid_plan" | "plan_not_found" | "corrupt_plan" | "immutable_conflict";
+export declare class PlanStoreError extends Error {
+    readonly code: PlanStoreErrorCode;
+    constructor(code: PlanStoreErrorCode, message: string, options?: ErrorOptions);
+}
+/**
+ * Durable immutable storage for canonical executable plans.
+ *
+ * A plan is first written and synced under a private temporary name. Linking
+ * that complete inode to its digest path is the publication CAS: link(2) is
+ * atomic and never replaces an existing destination.
+ */
+export declare class DurablePlanStore {
+    private readonly rootDirectory;
+    constructor(options: DurablePlanStoreOptions);
+    private plansDirectory;
+    private planPath;
+    private readStoredPlan;
+    commitPlan(plan: ExecutableRunPlanPayload): Promise<StoredExecutableRunPlan>;
+    loadPlan(planId: string): Promise<StoredExecutableRunPlan | null>;
+    requirePlan(planId: string): Promise<StoredExecutableRunPlan>;
+    hasPlan(planId: string): Promise<boolean>;
+    listPlanIds(): Promise<readonly Sha256Digest[]>;
+    loadAllPlans(): Promise<readonly StoredExecutableRunPlan[]>;
+}

package/dist/runtime/plan-store.js

@@ -0,0 +1,231 @@
+import { randomUUID } from "node:crypto";
+import { chmod, link, lstat, mkdir, open, readFile, readdir, unlink, } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { canonicalizeJson } from "./canonical-json.js";
+import { createStoredExecutableRunPlan, parseStoredExecutableRunPlan, } from "./executable-run-plan.js";
+export class PlanStoreError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "PlanStoreError";
+        this.code = code;
+    }
+}
+const DIRECTORY_MODE = 0o700;
+const TEMPORARY_FILE_MODE = 0o600;
+const STORED_FILE_MODE = 0o400;
+const PLAN_FILE_PATTERN = /^([a-f0-9]{64})\.json$/u;
+const PLAN_ID_PATTERN = /^sha256:([a-f0-9]{64})$/u;
+function isErrno(error, code) {
+    return (error instanceof Error
+        && "code" in error
+        && error.code === code);
+}
+function assertPlanId(planId) {
+    if (!PLAN_ID_PATTERN.test(planId)) {
+        throw new PlanStoreError("invalid_plan_id", "plan_id must be a lowercase sha256 digest");
+    }
+}
+function planFileName(planId) {
+    return `${planId.slice("sha256:".length)}.json`;
+}
+function isUnsupportedDirectorySync(error) {
+    if (!(error instanceof Error) || !("code" in error))
+        return false;
+    const code = error.code;
+    return (code === "EINVAL"
+        || code === "ENOTSUP"
+        || code === "EISDIR"
+        || (code === "EPERM" && process.platform === "win32"));
+}
+async function syncDirectory(path) {
+    let handle;
+    try {
+        handle = await open(path, "r");
+        await handle.sync();
+    }
+    catch (error) {
+        if (!isUnsupportedDirectorySync(error))
+            throw error;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+async function ensurePrivateDirectory(path) {
+    await mkdir(path, { recursive: true, mode: DIRECTORY_MODE });
+    const metadata = await lstat(path);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+        throw new PlanStoreError("immutable_conflict", `plan store path is not a real directory: ${path}`);
+    }
+    await chmod(path, DIRECTORY_MODE);
+}
+async function requireRealDirectoryIfPresent(path) {
+    let metadata;
+    try {
+        metadata = await lstat(path);
+    }
+    catch (error) {
+        if (isErrno(error, "ENOENT"))
+            return false;
+        throw error;
+    }
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+        throw new PlanStoreError("immutable_conflict", `plan store path is not a real directory: ${path}`);
+    }
+    return true;
+}
+/**
+ * Durable immutable storage for canonical executable plans.
+ *
+ * A plan is first written and synced under a private temporary name. Linking
+ * that complete inode to its digest path is the publication CAS: link(2) is
+ * atomic and never replaces an existing destination.
+ */
+export class DurablePlanStore {
+    rootDirectory;
+    constructor(options) {
+        if (!options.root_directory.trim()) {
+            throw new PlanStoreError("invalid_options", "root_directory must not be empty");
+        }
+        this.rootDirectory = resolve(options.root_directory);
+    }
+    plansDirectory() {
+        return join(this.rootDirectory, "plans");
+    }
+    planPath(planId) {
+        return join(this.plansDirectory(), planFileName(planId));
+    }
+    async readStoredPlan(planId) {
+        if (!await requireRealDirectoryIfPresent(this.rootDirectory))
+            return null;
+        if (!await requireRealDirectoryIfPresent(this.plansDirectory()))
+            return null;
+        const path = this.planPath(planId);
+        let metadata;
+        try {
+            metadata = await lstat(path);
+        }
+        catch (error) {
+            if (isErrno(error, "ENOENT"))
+                return null;
+            throw error;
+        }
+        if (!metadata.isFile() || metadata.isSymbolicLink()) {
+            throw new PlanStoreError("corrupt_plan", `stored plan ${planId} is not a regular file`);
+        }
+        if ((metadata.mode & 0o222) !== 0) {
+            throw new PlanStoreError("corrupt_plan", `stored plan ${planId} must be read-only`);
+        }
+        let value;
+        try {
+            value = JSON.parse(await readFile(path, "utf8"));
+        }
+        catch (error) {
+            if (isErrno(error, "ENOENT"))
+                return null;
+            if (error instanceof SyntaxError) {
+                throw new PlanStoreError("corrupt_plan", `stored plan ${planId} contains invalid JSON`, { cause: error });
+            }
+            throw error;
+        }
+        let stored;
+        try {
+            stored = parseStoredExecutableRunPlan(value);
+        }
+        catch (error) {
+            throw new PlanStoreError("corrupt_plan", `stored plan ${planId} failed schema or digest validation`, { cause: error });
+        }
+        if (stored.plan_id !== planId) {
+            throw new PlanStoreError("corrupt_plan", `stored plan ${stored.plan_id} does not match requested identity ${planId}`);
+        }
+        return stored;
+    }
+    async commitPlan(plan) {
+        let stored;
+        try {
+            stored = createStoredExecutableRunPlan(plan);
+        }
+        catch (error) {
+            throw new PlanStoreError("invalid_plan", "executable run plan failed schema validation", { cause: error });
+        }
+        const plansDirectory = this.plansDirectory();
+        await ensurePrivateDirectory(this.rootDirectory);
+        await ensurePrivateDirectory(plansDirectory);
+        const destination = this.planPath(stored.plan_id);
+        const temporaryPath = join(plansDirectory, `.${planFileName(stored.plan_id)}.tmp.${process.pid}.${randomUUID()}`);
+        let handle;
+        try {
+            handle = await open(temporaryPath, "wx", TEMPORARY_FILE_MODE);
+            await handle.writeFile(`${canonicalizeJson(stored)}\n`, "utf8");
+            await handle.chmod(STORED_FILE_MODE);
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            while (true) {
+                try {
+                    await link(temporaryPath, destination);
+                    await syncDirectory(plansDirectory);
+                    return stored;
+                }
+                catch (error) {
+                    if (!isErrno(error, "EEXIST"))
+                        throw error;
+                    await syncDirectory(plansDirectory);
+                    const existing = await this.readStoredPlan(stored.plan_id);
+                    if (existing)
+                        return existing;
+                    // A concurrent external deletion raced the EEXIST check; retry the CAS.
+                }
+            }
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+            await unlink(temporaryPath).catch((error) => {
+                if (!isErrno(error, "ENOENT"))
+                    throw error;
+            });
+        }
+    }
+    async loadPlan(planId) {
+        assertPlanId(planId);
+        return this.readStoredPlan(planId);
+    }
+    async requirePlan(planId) {
+        const stored = await this.loadPlan(planId);
+        if (!stored) {
+            throw new PlanStoreError("plan_not_found", `stored plan ${planId} was not found`);
+        }
+        return stored;
+    }
+    async hasPlan(planId) {
+        return (await this.loadPlan(planId)) !== null;
+    }
+    async listPlanIds() {
+        if (!await requireRealDirectoryIfPresent(this.rootDirectory))
+            return [];
+        if (!await requireRealDirectoryIfPresent(this.plansDirectory()))
+            return [];
+        let entries;
+        try {
+            entries = await readdir(this.plansDirectory(), { withFileTypes: true });
+        }
+        catch (error) {
+            if (isErrno(error, "ENOENT"))
+                return [];
+            throw error;
+        }
+        const ids = entries
+            .map((entry) => entry.name.match(PLAN_FILE_PATTERN)?.[1])
+            .filter((digest) => digest !== undefined)
+            .sort()
+            .map((digest) => `sha256:${digest}`);
+        for (const planId of ids) {
+            await this.requirePlan(planId);
+        }
+        return ids;
+    }
+    async loadAllPlans() {
+        return Promise.all((await this.listPlanIds()).map((planId) => this.requirePlan(planId)));
+    }
+}

package/dist/runtime/process-tree.d.ts

@@ -41,7 +41,16 @@ export interface ProcessTreeRunResult {
     readonly processLimitExceeded: boolean;
     readonly outputLimitExceeded: boolean;
     readonly terminationReason: ProcessTerminationReason | null;
+    readonly processId: number | null;
+    readonly processTreeDrained: boolean;
     readonly error?: NodeJS.ErrnoException;
 }
+export interface ProcessCommandSpec {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly windowsVerbatimArguments?: boolean;
+    readonly windowsBatchTransport?: boolean;
+}
+export declare function resolveProcessCommand(command: string, args: readonly string[], platform: NodeJS.Platform, env: NodeJS.ProcessEnv, cwd?: string): ProcessCommandSpec;
 export declare function runProcessTree(command: string, args: readonly string[], options?: ProcessTreeRunOptions): Promise<ProcessTreeRunResult>;
 export declare const runProcessTreeWithTimeout: typeof runProcessTree;

package/dist/runtime/process-tree.js

@@ -8,7 +8,7 @@
  */
 import { spawn, spawnSync, } from "node:child_process";
 import { readdirSync, readFileSync, statSync } from "node:fs";
-import { basename, delimiter, extname, join, } from "node:path";
+import { win32 as win32Path, } from "node:path";
 const DEFAULT_TERMINATION_GRACE_MS = 1_000;
 const DEFAULT_PROCESS_LIMIT_POLL_MS = 100;
 const WINDOWS_DIRECT_EXTENSIONS = new Set([".com", ".exe"]);
@@ -42,8 +42,8 @@ function fileExists(path) {
         return false;
     }
 }
-function resolveWindowsCommand(command, env) {
-    const hasPath = /^[A-Za-z]:/.test(command) || /[\\/]/.test(command);
+function resolveWindowsCommand(command, env, cwd) {
+    const hasPath = win32Path.isAbsolute(command) || /[\\/]/.test(command);
     const rawExtensions = String(env.PATHEXT ?? "").trim();
     const extensions = rawExtensions === ""
         ? WINDOWS_DEFAULT_PATHEXT
@@ -53,10 +53,12 @@ function resolveWindowsCommand(command, env) {
             ])];
     const directories = hasPath
         ? [""]
-        : String(env.Path ?? env.PATH ?? "").split(delimiter).filter(Boolean);
-    const extension = extname(command);
+        : [cwd, ...String(env.Path ?? env.PATH ?? "").split(win32Path.delimiter).filter(Boolean)];
+    const extension = win32Path.extname(command);
     for (const directory of directories) {
-        const base = directory === "" ? command : join(directory, command);
+        const base = hasPath
+            ? win32Path.isAbsolute(command) ? command : win32Path.resolve(cwd, command)
+            : win32Path.join(directory, command);
         const candidates = extension ? [base] : [...extensions.map((item) => `${base}${item}`), base];
         for (const candidate of candidates) {
             if (fileExists(candidate))
@@ -65,49 +67,63 @@ function resolveWindowsCommand(command, env) {
     }
     return null;
 }
-function commandSpec(command, args, platform, env) {
+export function resolveProcessCommand(command, args, platform, env, cwd = process.cwd()) {
     if (platform !== "win32")
         return { command, args: [...args] };
-    const resolved = resolveWindowsCommand(command, env);
+    const resolved = resolveWindowsCommand(command, env, cwd);
     if (!resolved)
         return { command, args: [...args] };
-    const extension = extname(resolved).toLowerCase();
+    const extension = win32Path.extname(resolved).toLowerCase();
     if (WINDOWS_CMD_EXTENSIONS.has(extension)) {
-        const quote = (value) => `"${value.replace(/"/g, "\"\"")}"`;
+        const quote = (value) => {
+            const escapedQuotes = value.replace(/"/g, "\"\"");
+            const escapedTrailingBackslashes = escapedQuotes.replace(/(\\+)$/, "$1$1");
+            return `"${escapedTrailingBackslashes}"`;
+        };
         const commandLine = [resolved, ...args].map(quote).join(" ");
         return {
             command: env.ComSpec || "cmd.exe",
             args: ["/d", "/s", "/c", `"${commandLine}"`],
             windowsVerbatimArguments: true,
+            windowsBatchTransport: true,
         };
     }
     if (extension === ".ps1") {
+        const escapedScript = resolved.replace(/'/g, "''");
+        const encodedArgs = Buffer.from(JSON.stringify({ args }), "utf8").toString("base64");
+        const script = [
+            "$PSNativeCommandArgumentPassing = 'Standard'",
+            `$intentdnaDoc = ConvertFrom-Json -InputObject ([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encodedArgs}')))`,
+            "[string[]] $intentdnaArgs = [string[]]::new($intentdnaDoc.args.Count)",
+            "for ($intentdnaIndex = 0; $intentdnaIndex -lt $intentdnaDoc.args.Count; $intentdnaIndex++) { $intentdnaArgs[$intentdnaIndex] = [string] $intentdnaDoc.args[$intentdnaIndex] }",
+            `& '${escapedScript}' @intentdnaArgs`,
+            "exit $LASTEXITCODE",
+        ].join("; ");
         return {
-            command: "powershell.exe",
+            command: "pwsh.exe",
             args: [
                 "-NoLogo",
                 "-NoProfile",
                 "-ExecutionPolicy",
                 "Bypass",
-                "-File",
-                resolved,
-                ...args,
+                "-EncodedCommand",
+                Buffer.from(script, "utf16le").toString("base64"),
             ],
         };
     }
-    if (WINDOWS_DIRECT_EXTENSIONS.has(extension) || basename(resolved) !== "") {
+    if (WINDOWS_DIRECT_EXTENSIONS.has(extension) || win32Path.basename(resolved) !== "") {
         return { command: resolved, args: [...args] };
     }
     return { command, args: [...args] };
 }
 function terminateProcessTree(child, platform, signal) {
     if (child.pid === undefined)
-        return;
+        return true;
     if (platform === "win32") {
         const force = signal === "SIGKILL" ? ["/F"] : [];
         const result = spawnSync("taskkill", ["/PID", String(child.pid), "/T", ...force], { windowsHide: true, stdio: "ignore" });
         if (!result.error && result.status === 0)
-            return;
+            return true;
     }
     try {
         if (platform === "win32") {
@@ -120,7 +136,7 @@ function terminateProcessTree(child, platform, signal) {
     catch (error) {
         const code = error.code;
         if (code === "ESRCH")
-            return;
+            return platform !== "win32";
         try {
             child.kill(signal);
         }
@@ -128,8 +144,52 @@ function terminateProcessTree(child, platform, signal) {
             if (fallbackError.code !== "ESRCH") {
                 throw fallbackError;
             }
+            return platform !== "win32";
         }
     }
+    return false;
+}
+function processTreeExists(processId, platform) {
+    if (platform === "win32")
+        return null;
+    try {
+        process.kill(-processId, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ESRCH")
+            return false;
+        if (code === "EPERM")
+            return true;
+        return null;
+    }
+}
+async function drainProcessTree(child, platform, signal, graceMs) {
+    if (child.pid === undefined)
+        return true;
+    if (terminateProcessTree(child, platform, signal) && platform === "win32")
+        return true;
+    const deadline = Date.now() + graceMs;
+    for (;;) {
+        const exists = processTreeExists(child.pid, platform);
+        if (exists === false)
+            return true;
+        if (exists === null || Date.now() >= deadline)
+            break;
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    if (terminateProcessTree(child, platform, "SIGKILL") && platform === "win32")
+        return true;
+    const forceDeadline = Date.now() + Math.max(100, graceMs);
+    for (;;) {
+        const exists = processTreeExists(child.pid, platform);
+        if (exists === false)
+            return true;
+        if (exists === null || Date.now() >= forceDeadline)
+            return false;
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
 }
 function readLinuxProcessTable() {
     try {
@@ -195,11 +255,13 @@ export function runProcessTree(command, args, options = {}) {
             processLimitExceeded: false,
             outputLimitExceeded: false,
             terminationReason: "cancellation",
+            processId: null,
+            processTreeDrained: true,
         });
     }
     const platform = options.platform ?? process.platform;
     const env = options.env ?? process.env;
-    const spec = commandSpec(command, args, platform, env);
+    const spec = resolveProcessCommand(command, args, platform, env, options.cwd ?? process.cwd());
     const spawnImpl = options.spawnImpl ?? spawn;
     const timeoutMs = positiveInteger(options.timeoutMs);
     const killSignal = options.killSignal ?? "SIGTERM";
@@ -223,6 +285,7 @@ export function runProcessTree(command, args, options = {}) {
         let settled = false;
         let timeoutTimer;
         let forceKillTimer;
+        let residualKillTimer;
         let processLimitTimer;
         const spawnOptions = {
             cwd: options.cwd,
@@ -248,6 +311,8 @@ export function runProcessTree(command, args, options = {}) {
                 processLimitExceeded: false,
                 outputLimitExceeded: false,
                 terminationReason: null,
+                processId: null,
+                processTreeDrained: true,
                 error: error,
             });
             return;
@@ -294,7 +359,7 @@ export function runProcessTree(command, args, options = {}) {
             requestTermination("cancellation", cancellationGraceMs);
         };
         cancellationSignal?.addEventListener("abort", cancellationHandler, { once: true });
-        const finish = (status, signal, error) => {
+        const finish = async (status, signal, error) => {
             if (settled)
                 return;
             settled = true;
@@ -302,10 +367,16 @@ export function runProcessTree(command, args, options = {}) {
                 clearTimeout(timeoutTimer);
             if (forceKillTimer)
                 clearTimeout(forceKillTimer);
+            if (residualKillTimer)
+                clearTimeout(residualKillTimer);
             if (processLimitTimer)
                 clearInterval(processLimitTimer);
             cancellationSignal?.removeEventListener("abort", cancellationHandler);
             removeParentHandlers();
+            const residualGraceMs = terminationReason === "cancellation"
+                ? cancellationGraceMs
+                : timeoutGraceMs;
+            const processTreeDrained = await drainProcessTree(child, platform, killSignal, residualGraceMs);
             resolve({
                 stdout,
                 stderr,
@@ -319,6 +390,8 @@ export function runProcessTree(command, args, options = {}) {
                 processLimitExceeded,
                 outputLimitExceeded,
                 terminationReason,
+                processId: child.pid ?? null,
+                processTreeDrained,
                 ...(error ? { error } : {}),
             });
         };
@@ -356,7 +429,7 @@ export function runProcessTree(command, args, options = {}) {
         });
         child.stdin?.end(options.stdin);
         child.on("error", (error) => {
-            finish(null, null, error);
+            void finish(null, null, error);
         });
         child.on("exit", () => {
             if (platform === "win32")
@@ -365,13 +438,13 @@ export function runProcessTree(command, args, options = {}) {
             const residualGraceMs = terminationReason === "cancellation"
                 ? cancellationGraceMs
                 : timeoutGraceMs;
-            const residualTimer = setTimeout(() => {
+            residualKillTimer = setTimeout(() => {
                 terminateProcessTree(child, platform, "SIGKILL");
             }, residualGraceMs);
-            residualTimer.unref?.();
+            residualKillTimer.unref?.();
         });
         child.on("close", (status, signal) => {
-            finish(status, signal);
+            void finish(status, signal);
         });
         if (cancellationSignal?.aborted)
             cancellationHandler();

package/dist/runtime/providers/codex.js

@@ -18,9 +18,9 @@ export function createCodexExecutionProvider(options = {}) {
                     "--sandbox",
                     options.sandbox ?? "workspace-write",
                     ...(options.extraArgs ?? []),
-                    packet.standalone_prompt,
+                    "-",
                 ],
-                stdin: null,
+                stdin: packet.standalone_prompt,
                 cwd: packet.workspace.working_directory,
                 ...(options.env ? { env: options.env } : {}),
             };