@deksden-com/dd-flow-cli 0.9.0-beta.11 → 0.9.0-beta.110

package/dist/cli/input-preparation.js

@@ -0,0 +1,116 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { AppError, isAppError } from "../shared/errors.js";
+import { validateSchema } from "../services/schema-validation.js";
+export function prepareError(error, input = {}) {
+    if (isAppError(error)) {
+        // A malformed user input is safely correctable.  A broken schema registry,
+        // binding, or storage is not; do not disguise infrastructure damage as a
+        // retryable command typo.
+        const inputErrorCodes = new Set([
+            "usage", "validation", "schema_validation", "invalid_json", "not_found",
+            "path_escape", "input_file_missing", "input_file_not_regular", "input_file_unreadable",
+            "response_file_parent_invalid", "response_file_invalid", "context_checksum_mismatch", "invalid_run_config_state", "invalid_work_state", "invalid_stage_state", "runtime_budget_invalid", "runtime_scope_manifest_invalid", "runtime_scope_resume_invalid",
+            "fork_path_conflict", "fork_output_not_empty", "fork_checkpoint_invalid", "fork_engine_unavailable", "snapshot_missing",
+            "repair_check_declaration_missing", "review_repair_check_required", "review_check_reference_unknown", "semantic_status_inconsistent", "migration_report_invalid", "controller_context_missing", "snapshot_output_inside_runtime"
+        ]);
+        if (!inputErrorCodes.has(error.code) && error.details.phase !== "prepare")
+            throw error;
+        throw new AppError(error.code, error.message, 2, {
+            ...error.details,
+            phase: "prepare",
+            effect: error.details.effect ?? "no_effect",
+            recoverable: error.details.recoverable ?? true,
+            ...input
+        });
+    }
+    const code = error?.code;
+    if (typeof input.file !== "string" || !["ENOENT", "EACCES", "EPERM", "EISDIR", "ENOTDIR", "ELOOP", "ENAMETOOLONG"].includes(code ?? ""))
+        throw error;
+    throw new AppError("input_file_unreadable", `Cannot read input file${typeof input.file === "string" ? `: ${input.file}` : ""}`, 2, {
+        phase: "prepare", effect: "no_effect", recoverable: true, ...input, cause: code ?? String(error)
+    });
+}
+export function prepareTextFile(file, label = "input file") {
+    const prepared = prepareFileBytes(file, label);
+    return { file: prepared.file, text: prepared.bytes.toString("utf8") };
+}
+export function prepareFileBytes(file, label = "input file") {
+    const absolute = path.resolve(file);
+    let descriptor;
+    try {
+        descriptor = fs.openSync(absolute, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+        const stat = fs.fstatSync(descriptor);
+        if (!stat.isFile()) {
+            throw new AppError("input_file_not_regular", `${label} must be a readable regular file: ${absolute}`, 2, { file: absolute, label });
+        }
+        return { file: absolute, bytes: fs.readFileSync(descriptor) };
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            throw new AppError("input_file_missing", `${label} does not exist: ${absolute}`, 2, {
+                phase: "prepare", effect: "no_effect", recoverable: true, file: absolute, label
+            });
+        }
+        return prepareError(error, { file: absolute, label });
+    }
+    finally {
+        if (descriptor !== undefined)
+            fs.closeSync(descriptor);
+    }
+}
+export function prepareJsonText(text, input) {
+    try {
+        return { file: input.file, text, value: JSON.parse(text) };
+    }
+    catch {
+        // Keep the established public code so agents can recognise this as a
+        // safe correction-and-retry condition.
+        throw new AppError("invalid_json", `Invalid JSON in ${input.label ?? "input"}: ${input.file}`, 2, {
+            phase: "prepare", effect: "no_effect", recoverable: true, file: input.file, label: input.label ?? "input",
+            cause: "Invalid JSON syntax", input_sha256: crypto.createHash("sha256").update(text).digest("hex")
+        });
+    }
+}
+export function prepareJsonFile(file, label = "input JSON") {
+    const prepared = prepareTextFile(file, label);
+    return prepareJsonText(prepared.text, { file: prepared.file, label });
+}
+export function prepareJsonSchema(file, label, schema) {
+    const prepared = prepareJsonFile(file, label);
+    try {
+        validateSchema({ ...schema, file: prepared.file, data: prepared.value });
+    }
+    catch (error) {
+        return prepareError(error, { file: prepared.file, label });
+    }
+    return prepared;
+}
+/** Read-only destination check; execution still handles filesystem races. */
+export function prepareOutputFile(value) { return prepareOutput(value, false); }
+export function prepareOutputDirectory(value) { return prepareOutput(value, true); }
+function prepareOutput(value, directory) {
+    const file = path.resolve(value);
+    try {
+        let ancestor = directory ? file : path.dirname(file);
+        while (!fs.existsSync(ancestor) && path.dirname(ancestor) !== ancestor)
+            ancestor = path.dirname(ancestor);
+        if (!fs.statSync(ancestor).isDirectory())
+            throw new AppError("validation", "Output parent must be a directory", 2);
+        fs.accessSync(ancestor, fs.constants.W_OK | fs.constants.X_OK);
+        if (fs.existsSync(file)) {
+            const stat = fs.statSync(file);
+            if (directory ? !stat.isDirectory() : !stat.isFile())
+                throw new AppError("validation", directory ? "Output must name a directory" : "Output must name a regular file", 2);
+            fs.accessSync(file, fs.constants.W_OK | (directory ? fs.constants.X_OK : 0));
+        }
+        return file;
+    }
+    catch (error) {
+        const code = error?.code;
+        if (["ENOENT", "EACCES", "EPERM", "ENOTDIR", "ELOOP", "ENAMETOOLONG"].includes(code ?? ""))
+            return prepareError(new AppError("validation", "Output destination is not writable or has an invalid parent", 2, { cause: code }), { file, parameter: "output" });
+        return prepareError(error, { file, parameter: "output" });
+    }
+}

package/dist/cli/native-hook-ingress.js

@@ -0,0 +1,48 @@
+import { AppError, errorRecord } from "../shared/errors.js";
+import { parseCommandArgs } from "../services/lifecycle-command.js";
+/** These ingress commands consume a prepared store; they never prepare it. */
+export function isNativeHookIngress(args) {
+    return args[2] === "handle" && ((args[1] === "event" && ["agy", "grok", "droid", "opencode", "zcode"].includes(args[0] ?? ""))
+        || args[0] === "zcode" && args[1] === "hook");
+}
+export async function dispatchNativeHook(args, stdin, env) {
+    const parsed = parseCommandArgs(args.slice(3));
+    const projectRoot = parsed.options.get("project-root")?.[0];
+    if (!isNativeHookIngress(args) || parsed.positional.length || !projectRoot || projectRoot === "__dd_flow_flag__")
+        throw new AppError("usage", "Native hook requires --project-root", 2);
+    for (const [name, values] of parsed.options)
+        if (!["project-root", "json"].includes(name) || values.length !== 1 || name === "json" && values[0] !== "__dd_flow_flag__")
+            throw new AppError("usage", `Invalid native hook option: ${name}`, 2);
+    const [hooks, { createContext }, { resolveDdFlowHome }] = await Promise.all([
+        import("../services/hooks.js"), import("../runtime/context.js"), import("../storage/paths.js")
+    ]);
+    let opened;
+    // Reuse the actual envelope validators and shell parser. They return for
+    // unrelated tools before their first DB access, without duplicating policy.
+    const context = {
+        env, ddFlowHome: resolveDdFlowHome(env), now: () => new Date().toISOString(),
+        get db() { return (opened ??= createContext(env, "hook")).db; }
+    };
+    const handler = args[0] === "agy" ? hooks.handleAgyEvent : args[0] === "grok" ? hooks.handleGrokEvent
+        : args[0] === "droid" ? hooks.handleDroidEvent : args[0] === "opencode" ? hooks.handleOpenCodeEvent
+            : args[1] === "hook" ? hooks.handleZcodeHook : hooks.handleZcodeEvent;
+    try {
+        return await handler(context, { projectRoot, stdin });
+    }
+    finally {
+        opened?.db.close?.();
+    }
+}
+export async function runNativeHookIngress(args) {
+    try {
+        const { readNativeHookInput, hookBudget } = await import("../harness-runtime/lib/native-hook-command.mjs");
+        const stdin = await readNativeHookInput(process.stdin, hookBudget());
+        process.stdout.write(`${JSON.stringify(await dispatchNativeHook(args, stdin, process.env))}\n`);
+        return 0;
+    }
+    catch (error) {
+        const record = errorRecord(error);
+        process.stderr.write(`${JSON.stringify({ ok: false, error: record })}\n`);
+        return record.exitCode;
+    }
+}