@deksden-com/dd-flow-cli 0.9.0-beta.14 → 0.9.0-beta.140

package/dist/cli/memory-storage-admission.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import path from "node:path";
+import { prepareCommandRoute } from "./command-inputs.js";
+import { parseOutputOptions } from "./output-options.js";
+import { createContext } from "../runtime/context.js";
+import { getResourceDatabase } from "../storage/database.js";
+import { withStoreCleanup } from "../storage/native-cleanup.js";
+import { PreparedMemoryInitRuntimeStorage } from "../services/memory-init-storage.js";
+import { PreparedMemoryInitResourceStorage } from "../services/memory-init-resource-storage.js";
+import { hybridDigest } from "../services/hybrid-contracts.js";
+import { AppError, errorRecord } from "../shared/errors.js";
+import { writePreparationError } from "./error-output.js";
+/** Selected engine's non-migrating operation admission. No AppContext initialize. */
+export function runMemoryStorageAdmissionCli(args, env = process.env, io = process) {
+    try {
+        const output = parseOutputOptions(args), route = prepareCommandRoute(output.args);
+        if (route.key !== "runtime storage admit" || output.responseFile || output.progressJsonl) {
+            throw new AppError("usage", "Storage admission accepts stdout output only", 2, { effect: "no_effect" });
+        }
+        const home = env.DD_FLOW_HOME;
+        if (!home || !path.isAbsolute(home) || path.resolve(home) !== home || fs.realpathSync(home) !== home) {
+            throw new AppError("usage", "Storage admission requires an explicit canonical absolute DD_FLOW_HOME", 2, { effect: "no_effect" });
+        }
+        const file = path.join(home, "db.sqlite"), owner = fs.lstatSync(file);
+        if (!owner.isFile() || owner.nlink !== 1)
+            throw new AppError("run_storage_unprepared", "RUN storage must be a regular single-linked file", 1, { effect: "no_effect" });
+        const resource = PreparedMemoryInitResourceStorage.prepare({ ddFlowHome: home, env });
+        const context = createContext(env, "prepared_existing");
+        const facts = withStoreCleanup(() => {
+            const run = PreparedMemoryInitRuntimeStorage.prepare(context);
+            const resourceWriter = getResourceDatabase(path.dirname(resource.facts().store_path), "prepared_existing");
+            return withStoreCleanup(() => {
+                if (resourceWriter.get("SELECT dd_flow_writer_version() AS version")?.version !== resource.facts().executing_writer_version) {
+                    throw new AppError("store_writer_incompatible", "Resource connection writer differs from admitted storage", 1, { effect: "no_effect" });
+                }
+                resource.revalidate({ ddFlowHome: home, env });
+                const current = fs.lstatSync(file);
+                if (!current.isFile() || current.nlink !== 1 || current.dev !== owner.dev || current.ino !== owner.ino) {
+                    throw new AppError("run_storage_changed", "RUN store changed during admission", 1, { effect: "no_effect" });
+                }
+                return { schema_id: "dd-flow/memory-init-engine-storage@1", operation: "memory-init", route: "verified-no-op", outcome: "no-op",
+                    run: { ...run.facts(), store_dev: owner.dev, store_ino: owner.ino }, resource: resource.facts() };
+            }, () => resourceWriter.close?.());
+        }, () => context.db.close?.());
+        io.stdout.write(`${JSON.stringify({ ok: true, action: "runtime_storage_admit", facts, sha256: hybridDigest(facts) }, null, output.json ? undefined : 2)}\n`);
+        return 0;
+    }
+    catch (error) {
+        const record = errorRecord(error);
+        writePreparationError(io, args, record);
+        return record.exitCode;
+    }
+}

package/dist/cli/models.js

@@ -0,0 +1,39 @@
+import { prepareCommandRoute } from "./command-inputs.js";
+import { optionalOption } from "./argument-values.js";
+import { parseOutputOptions } from "./output-options.js";
+import { prepareResponseDestination, writeResponseFile } from "./response-file.js";
+import { listOperatorModels } from "../services/model-catalog.js";
+import { AppError, errorRecord } from "../shared/errors.js";
+import { writePreparationError } from "./error-output.js";
+/** Model listing never opens an AppContext, starts a probe or reads credentials. */
+export function runModelsCli(args, io = process) {
+    let json = false;
+    try {
+        const output = parseOutputOptions(args);
+        json = output.json;
+        if (output.responseFile)
+            prepareResponseDestination(output.responseFile);
+        const route = prepareCommandRoute(output.args);
+        if (!["models list", "models show"].includes(route.key))
+            throw new AppError("usage", "Unknown models command; see dd-flow models --help", 2, { effect: "no_effect" });
+        const input = {};
+        for (const [option, field] of [["harness", "harness"], ["provider", "provider"], ["account-sha256", "accountSha256"],
+            ["seed-file", "seedFile"], ["observation-file", "observationFile"]]) {
+            const value = optionalOption(route.parsed, option);
+            if (value !== undefined)
+                input[field] = value;
+        }
+        if (route.key === "models show")
+            input.model = route.parsed.positional[0];
+        const models = listOperatorModels(input);
+        if (route.key === "models show" && models.entries.length === 0)
+            throw new AppError("model_not_found", "Model is absent from the selected seed and scoped observation", 1, { effect: "no_effect", help: "models" });
+        io.stdout.write(`${JSON.stringify(writeResponseFile({ ok: true, action: route.key.replaceAll(" ", "_"), ...models }, output), null, json ? undefined : 2)}\n`);
+        return 0;
+    }
+    catch (error) {
+        const record = errorRecord(error);
+        writePreparationError(io, args, record);
+        return record.exitCode;
+    }
+}

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

@@ -0,0 +1,80 @@
+import { AppError, errorRecord } from "../shared/errors.js";
+import { parseCommandArgs } from "../services/lifecycle-command.js";
+import { channel } from "node:diagnostics_channel";
+/** 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 started = performance.now();
+    const deadline = env.DD_FLOW_HOOK_DEADLINE_AT ? Number(env.DD_FLOW_HOOK_DEADLINE_AT) : undefined;
+    if (deadline !== undefined && !Number.isSafeInteger(deadline))
+        throw new AppError("hook_deadline_invalid", "Native hook deadline must be an absolute millisecond timestamp", 1, { effect: "unknown" });
+    const phase = (name) => {
+        if (deadline !== undefined && deadline <= Date.now())
+            throw new AppError("native_hook_timeout", "Native hook deadline expired", 1, { phase: name, effect: "unknown" });
+        process.stderr.write(`${JSON.stringify({ kind: "native_hook_phase", phase: name, elapsed_ms: Math.round(performance.now() - started), ...(deadline !== undefined ? { remaining_ms: Math.max(0, deadline - Date.now()) } : {}) })}\n`);
+    };
+    phase("import");
+    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")
+    ]);
+    phase("imported");
+    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() {
+            if (!opened) {
+                phase("store_open");
+                opened = createContext(env, "hook");
+                phase("store_opened");
+            }
+            return opened.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;
+    const timing = channel("dd-flow.sqlite.ingress");
+    // This command owns one synchronous store; there is no concurrent handler here.
+    let previousPhase;
+    const log = (value) => {
+        const record = value;
+        if (record.phase === previousPhase)
+            return;
+        previousPhase = record.phase;
+        process.stderr.write(`${JSON.stringify({ kind: "native_hook_phase", phase: record.phase, elapsed_ms: Math.round(performance.now() - started), ...(record.remaining_ms !== undefined ? { remaining_ms: record.remaining_ms } : {}) })}\n`);
+    };
+    timing.subscribe(log);
+    try {
+        phase("receipt");
+        return await handler(context, { projectRoot, stdin });
+    }
+    finally {
+        timing.unsubscribe(log);
+        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(25_000, process.env.DD_FLOW_HOOK_DEADLINE_AT ? Number(process.env.DD_FLOW_HOOK_DEADLINE_AT) : null));
+        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;
+    }
+}

package/dist/cli/operator-profiles.js

@@ -0,0 +1,61 @@
+import { requiredOption, optionalOption } from "./argument-values.js";
+import { AppError } from "../shared/errors.js";
+import { errorRecord } from "../shared/errors.js";
+import { prepareCommandRoute } from "./command-inputs.js";
+import { parseOutputOptions } from "./output-options.js";
+import { writePreparationError } from "./error-output.js";
+import { resolveDdFlowHome } from "../storage/paths.js";
+import { prepareResponseDestination, writeResponseFile } from "./response-file.js";
+import { readOperatorProfiles, resolveOperatorProfile, mutateOperatorProfiles, readOperatorProfileInput } from "../services/operator-profiles.js";
+/** Home-only entrypoint; does not create AppContext, project registration or runtime DB. */
+export function dispatchOperatorProfiles(home, route) {
+    const action = route.command, parsed = route.parsed;
+    if (action === "list")
+        return { ok: true, action: "profiles_list", settings: readOperatorProfiles(home) };
+    if (action === "show") {
+        const settings = readOperatorProfiles(home), id = parsed.positional[0];
+        return { ok: true, action: "profiles_show", selected: id, revision: settings.revision, profile: resolveOperatorProfile(settings, id) };
+    }
+    let mutation;
+    if (action === "create")
+        mutation = { action, profile: readOperatorProfileInput(requiredOption(parsed, "file")), setDefault: parsed.options.has("set-default") };
+    else if (action === "edit")
+        mutation = { action, profile: readOperatorProfileInput(requiredOption(parsed, "file")) };
+    else if (action === "remove")
+        mutation = { action, id: parsed.positional[0] };
+    else if (action === "alias") {
+        const target = optionalOption(parsed, "target"), remove = parsed.options.has("remove");
+        if (Boolean(target) === remove)
+            throw new AppError("usage", "Use exactly one of --target ID or --remove; see dd-flow profiles alias --help", 2, { effect: "no_effect" });
+        mutation = { action, alias: parsed.positional[0], target: target ?? null };
+    }
+    else if (action === "set-default") {
+        const id = parsed.positional[0], clear = parsed.options.has("clear");
+        if (Boolean(id) === clear)
+            throw new AppError("usage", "Select one profile ID or --clear; see dd-flow profiles set-default --help", 2, { effect: "no_effect" });
+        mutation = { action, id: id ?? null };
+    }
+    else
+        throw new AppError("usage", "Unknown profiles command; use dd-flow profiles --help", 2, { effect: "no_effect" });
+    const settings = mutateOperatorProfiles(home, requiredOption(parsed, "expected-revision"), mutation);
+    return { ok: true, action: `profiles_${action}`, effect: "committed", settings };
+}
+/** Lightweight executable ingress; never imports the project/runtime business router. */
+export function runOperatorProfilesCli(args, env, io = { stdout: process.stdout, stderr: process.stderr }) {
+    let json = false;
+    try {
+        const output = parseOutputOptions(args);
+        json = output.json;
+        if (output.responseFile)
+            prepareResponseDestination(output.responseFile);
+        const route = prepareCommandRoute(output.args);
+        const result = dispatchOperatorProfiles(resolveDdFlowHome(env), route);
+        io.stdout.write(`${JSON.stringify(writeResponseFile(result, output), null, json ? undefined : 2)}\n`);
+        return 0;
+    }
+    catch (error) {
+        const record = errorRecord(error);
+        writePreparationError(io, args, record);
+        return record.exitCode;
+    }
+}

package/dist/cli/output-options.js

@@ -0,0 +1,35 @@
+import { AppError } from "../shared/errors.js";
+/** Shared execution transport grammar. Help resolves before this function. */
+export function parseOutputOptions(args) {
+    const stripped = [];
+    let json = false, progressJsonl = false, responseFile = null;
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (arg === "--") {
+            stripped.push(...args.slice(index));
+            break;
+        }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--progress-jsonl") {
+            progressJsonl = true;
+            continue;
+        }
+        if (arg === "--response-file" || arg.startsWith("--response-file=")) {
+            if (responseFile !== null)
+                throw new AppError("usage", "--response-file may be supplied only once", 2);
+            const file = arg === "--response-file" ? args[++index] : arg.slice("--response-file=".length);
+            if (!file?.trim() || file.startsWith("--"))
+                throw new AppError("usage", "--response-file requires a path", 2);
+            responseFile = file;
+            continue;
+        }
+        stripped.push(arg);
+    }
+    if (responseFile && !json)
+        throw new AppError("usage", "--response-file requires --json", 2);
+    const hookJsonOnly = stripped[0] === "codex" && stripped[1] === "hook" && stripped[2] === "handle";
+    return { json: json || hookJsonOnly, progressJsonl, args: stripped, hookJsonOnly, responseFile };
+}

package/dist/cli/response-file.js

@@ -0,0 +1,71 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+/** Preflight does not create a parent, destination or runtime home. */
+export function prepareResponseDestination(value) {
+    const file = path.resolve(value);
+    try {
+        const inspect = (target) => {
+            try {
+                return fs.lstatSync(target);
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return null;
+                throw error;
+            }
+        };
+        let parent = path.dirname(file);
+        let parentStat = inspect(parent);
+        while (!parentStat) {
+            const next = path.dirname(parent);
+            if (next === parent)
+                break;
+            parent = next;
+            parentStat = inspect(parent);
+        }
+        if (parentStat?.isSymbolicLink())
+            parentStat = fs.statSync(parent);
+        const targetStat = inspect(file);
+        if (!parentStat?.isDirectory() || targetStat && !targetStat.isFile())
+            throw new Error();
+    }
+    catch {
+        throw new AppError("response_file_invalid", "Response destination must be a regular file under a directory", 2, { parameter: "response-file", effect: "no_effect" });
+    }
+}
+/** Optional publication failure never changes the accepted operation outcome. */
+export function writeResponseFile(payload, output) {
+    if (!output.responseFile)
+        return payload;
+    const file = path.resolve(output.responseFile), temporary = `${file}.tmp-${randomUUID()}`;
+    const visible = payload && typeof payload === "object" && !Array.isArray(payload) ? { ...payload } : { ok: true, result: payload };
+    let ownsTemporary = false;
+    try {
+        prepareResponseDestination(file);
+        fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        const fd = fs.openSync(temporary, "wx", 0o600);
+        ownsTemporary = true;
+        try {
+            fs.writeFileSync(fd, `${JSON.stringify(payload, null, 2)}\n`);
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        fs.renameSync(temporary, file);
+    }
+    catch {
+        return { ...visible, response_file: file, response_file_error: "Response publication failed; reconcile the accepted operation before retrying" };
+    }
+    finally {
+        try {
+            if (ownsTemporary && fs.existsSync(temporary))
+                fs.unlinkSync(temporary);
+        }
+        catch { /* Own temporary only; never mask the operation outcome. */ }
+    }
+    delete visible.worker_prompt_markdown;
+    return { ...visible, response_file: file };
+}