@deksden-com/dd-flow-cli 0.9.0-beta.15 → 0.9.0-beta.150

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,72 @@
+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 record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
+    const visible = record ? { ...(record.prompt_delivery ? { prompt_delivery: record.prompt_delivery } : {}), ...record } : { 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 };
+}