@deksden-com/dd-flow-cli 0.9.0-beta.134 → 0.9.0-beta.136

package/dist/services/executor-onboarding.js

@@ -0,0 +1,56 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { prepareOperatorProfile, readOperatorProfileInput, resolveOperatorProfile, validateProfileCreationIntent } from "./operator-profiles.js";
+function refuse(code, message, exitCode = 2) {
+    throw new AppError(code, message, exitCode, { phase: "executor_onboarding", effect: "no_effect", help: "profiles" });
+}
+/** Shared setup/first-flow admission; settings are read lazily, never written. */
+export function selectOnboardingExecutor(choice, readSettings, policy) {
+    if (!choice || typeof choice !== "object" || Array.isArray(choice)
+        || Object.keys(choice).some(key => !["profileId", "profile", "profileFile", "skip", "profileCreation"].includes(key))
+        || choice.profileFile !== undefined && (typeof choice.profileFile !== "string" || !choice.profileFile.trim())
+        || choice.skip !== undefined && typeof choice.skip !== "boolean"
+        || choice.profileId !== undefined && (typeof choice.profileId !== "string" || !choice.profileId.trim())) {
+        refuse("usage", "Invalid executor selection");
+    }
+    if ([choice.profileId !== undefined, choice.profile !== undefined, choice.profileFile !== undefined, choice.skip === true].filter(Boolean).length > 1) {
+        refuse("usage", "Executor profile, profile ID and skip are mutually exclusive");
+    }
+    if (choice.profileCreation !== undefined) {
+        validateProfileCreationIntent(choice.profileCreation);
+        if (choice.profile === undefined || hybridDigest(choice.profile) !== hybridDigest(choice.profileCreation.profile))
+            refuse("usage", "Profile save intent requires its exact explicit profile");
+    }
+    if (choice.skip) {
+        if (!policy.allowSkip)
+            refuse("agent_profile_missing", "This operation requires an executor profile", 1);
+        return { profile: null, revision: null, source: "skip" };
+    }
+    const explicit = choice.profile !== undefined || choice.profileFile !== undefined || choice.profileId !== undefined;
+    if (!explicit && policy.projectProfileId !== undefined && (typeof policy.projectProfileId !== "string" || !policy.projectProfileId.trim())) {
+        refuse("usage", "Invalid project executor profile selection");
+    }
+    const profile = prepareOperatorProfile(choice.profile !== undefined ? choice.profile : choice.profileFile !== undefined
+        ? readOperatorProfileInput(choice.profileFile) : resolveOperatorProfile(readSettings(), choice.profileId ?? policy.projectProfileId));
+    return { profile: structuredClone(profile), revision: hybridDigest(profile),
+        ...(choice.profileCreation ? { profileCreation: structuredClone(choice.profileCreation) } : {}),
+        source: choice.profile !== undefined ? "explicit-profile" : choice.profileFile !== undefined ? "explicit-file" : choice.profileId !== undefined ? "explicit-id" : policy.projectProfileId !== undefined ? "project-default" : "default" };
+}
+/** Interactive decisions use exactly the same admission as headless choices. */
+export async function onboardExecutor(choice, readSettings, policy, ask) {
+    try {
+        return selectOnboardingExecutor(choice, readSettings, policy);
+    }
+    catch (error) {
+        if (!(error instanceof AppError) || error.code !== "agent_profile_missing"
+            || choice.profileId !== undefined || choice.profile !== undefined || choice.profileFile !== undefined || choice.skip === true
+            || policy.projectProfileId !== undefined || policy.nonInteractive || !ask)
+            throw error;
+        // No speculative defaults or writes: the human supplies a concrete choice.
+        const decision = await ask(structuredClone(readSettings()));
+        if (decision.profileId === undefined && decision.profile === undefined && decision.profileFile === undefined && decision.skip !== true) {
+            refuse("agent_profile_missing", "Onboarding requires an explicit choice", 1);
+        }
+        return selectOnboardingExecutor(decision, readSettings, policy);
+    }
+}

package/dist/services/external-work-launch.js

@@ -123,7 +123,7 @@ export async function launchExternalWork(context, input) {
             prompted = await call(["session", "prompt", "--session-id", sessionId, "--prompt-file", promptFile, ...common], null);
         }
         catch (error) {
-            if (runtimeHarness(resolved.worker) !== "codex-desktop")
+            if (!["codex-desktop", "opencode-server"].includes(runtimeHarness(resolved.worker)))
                 throw error;
             const retained = context.db.get("SELECT adapter_receipt_json FROM work_launches WHERE operation_id = ?", [operationId]);
             const capacityIntents = retained?.adapter_receipt_json ? JSON.parse(retained.adapter_receipt_json).capacity_intents ?? [] : [];

package/dist/services/harness-discovery.js

@@ -0,0 +1,29 @@
+import { randomUUID } from "node:crypto";
+import { validateHybridContract } from "./hybrid-contracts.js";
+import { AppError } from "../shared/errors.js";
+import { discoverCodex } from "./discovery/codex-discovery.js";
+import { discoverZcode } from "./discovery/zcode-discovery.js";
+import { discoverAgy } from "./discovery/agy-discovery.js";
+import { discoverOpenCode } from "./discovery/opencode-discovery.js";
+import { discoverGrok } from "./discovery/grok-discovery.js";
+import { discoverDroid } from "./discovery/droid-discovery.js";
+import { readOnlyProbeScope, runScopedProbe, staticDiscoveryEffects } from "./harness-probe-effects.js";
+const modules = { codex: discoverCodex, zcode: discoverZcode, agy: discoverAgy, opencode: discoverOpenCode, grok: discoverGrok, droid: discoverDroid };
+export const harnessCatalog = {
+    schema_id: "dd-flow/harness-catalog@1", version: "1.0.0",
+    entries: Object.keys(modules).map(id => ({ id, executable_candidates: [id], probe_module: `${id}-discovery`,
+        probe_timeout_ms: 3000, version_range: "unknown_requires_review", protocol_version: "unknown_requires_protocol_probe" }))
+};
+export function discoverHarnesses(input) {
+    if (input.harness && !Object.hasOwn(modules, input.harness))
+        throw new AppError("usage", "Unknown harness family", 2, { effect: "no_effect" });
+    if (input.executable && !input.harness)
+        throw new AppError("usage", "Explicit executable requires one harness family", 2, { effect: "no_effect" });
+    const families = input.harness ? [input.harness] : Object.keys(modules);
+    const result = { schema_id: "dd-flow/discovery-result@1", request_id: input.requestId ?? randomUUID(), observed_at: new Date().toISOString(),
+        probe_scope: "static", live_authorization_receipt: null, entries: families.map(family => runScopedProbe(staticDiscoveryEffects, readOnlyProbeScope, () => modules[family](input))) };
+    if (validateHybridContract("harness-catalog", harnessCatalog).length || validateHybridContract("discovery-result", result).length) {
+        throw new AppError("discovery_contract", "Discovery owner produced invalid facts", 1, { effect: "no_effect" });
+    }
+    return result;
+}

package/dist/services/harness-doctor.js

@@ -0,0 +1,75 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "semver";
+import { AppError } from "../shared/errors.js";
+import { legacyDoctorEffects, runScopedProbe } from "./harness-probe-effects.js";
+import { readBoundedReleaseFile } from "./release-source.js";
+import { discoverExecutable } from "./discovery/static.js";
+const binOptions = {
+    codex: "codex-bin", zcode: "zcode-acp-bin", agy: "agy-bin", opencode: "opencode-bin", grok: "grok-bin", droid: "droid-bin"
+};
+function refuse(code, message, exitCode = 1) {
+    throw new AppError(code, message, exitCode, { phase: "harness_doctor", help: "harnesses doctor" });
+}
+/** Existing non-generative adapter doctor, bounded by its owner transport.
+ * Reported compatibility is not qualification or verified account access.
+ * OpenCode observes an explicitly bound existing daemon; it never starts one.
+ */
+export async function probeHarnessDoctor(input) {
+    const timeoutMs = input.timeoutMs ?? 30_000;
+    if (!Object.hasOwn(binOptions, input.harness) || !path.isAbsolute(input.executable)
+        || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60_000
+        || input.stateDir !== undefined && !path.isAbsolute(input.stateDir)
+        || input.nativeExecutable !== undefined && (!path.isAbsolute(input.nativeExecutable) || input.harness !== "zcode")
+        || input.stateDir !== undefined && input.harness !== "opencode")
+        refuse("usage", "Doctor requires explicit contained diagnostic inputs", 2);
+    return runScopedProbe(legacyDoctorEffects[input.harness], input.scope, async () => {
+        if (input.harness === "droid" && discoverExecutable("system-ps", ["ps"], { env: { ...process.env, ...input.env } }).candidates.length === 0) {
+            throw new AppError("doctor_prerequisite_missing", "Droid doctor requires the OS ps utility for physical process settlement", 1, { phase: "harness_doctor", effect: "no_effect", prerequisite: "ps", help: "harnesses doctor" });
+        }
+        const args = [fileURLToPath(new URL(`../harness-runtime/bin/dd-${input.harness}.mjs`, import.meta.url)), "doctor",
+            `--${binOptions[input.harness]}`, input.executable, "--timeout-ms", String(timeoutMs), "--json"];
+        if (input.harness === "zcode") {
+            if (!input.nativeExecutable)
+                refuse("harness_selection_required", "ZCode doctor also requires --native-executable for its native runtime");
+            args.push("--zcode-path", input.nativeExecutable);
+        }
+        if (input.harness === "opencode") {
+            if (!input.stateDir)
+                refuse("harness_selection_required", "OpenCode doctor requires --state-dir for an existing owned daemon; no service is started");
+            let state;
+            try {
+                state = JSON.parse(readBoundedReleaseFile(path.join(input.stateDir, "daemon.json"), 1024 * 1024).toString("utf8"));
+            }
+            catch {
+                return refuse("doctor_state_unavailable", "Selected daemon identity cannot be read");
+            }
+            const selected = state;
+            if (selected?.config?.bin !== input.executable)
+                refuse("doctor_state_mismatch", "Selected daemon does not bind the discovered executable");
+            args.push("--state-dir", input.stateDir);
+        }
+        const transport = await import(new URL("../harness-runtime/lib/process-json.mjs", import.meta.url).href);
+        let report;
+        try {
+            report = await transport.commandJson(process.execPath, args, { env: input.env, timeoutMs, signal: AbortSignal.timeout(timeoutMs), phase: "native-doctor" });
+        }
+        catch {
+            return refuse("harness_doctor_failed", "Adapter doctor failed or could not confirm its observation; no model Turn was requested");
+        }
+        if (!report || typeof report !== "object" || Array.isArray(report) || report.ok !== true)
+            refuse("harness_doctor_failed", "Adapter doctor did not return an accepted diagnostic");
+        const observed = report.observed_runtime && typeof report.observed_runtime === "object" ? report.observed_runtime : {};
+        const versionField = input.harness === "codex" ? "codex_cli" : input.harness === "zcode" ? "zcode_acp" : input.harness;
+        const versions = report.versions && typeof report.versions === "object" && !Array.isArray(report.versions) ? report.versions : {};
+        // Existing OpenCode doctor reports versions separately from observed_runtime.
+        const versionValue = input.harness === "opencode" ? versions.opencode : observed[versionField];
+        const version = typeof versionValue === "string" ? parse(versionValue)?.version ?? null : null;
+        const protocol = observed.dd_harness_contract;
+        const models = Array.isArray(report.models) ? report.models.filter((model) => typeof model === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/+-]{0,255}$/.test(model)).slice(0, 10_000) : [];
+        return { harness: input.harness, effects: legacyDoctorEffects[input.harness], reported_version: version,
+            reported_protocol: typeof protocol === "string" && /^dd-[a-z0-9-]+@[0-9]+$/.test(protocol) ? protocol : null,
+            reported_models: [...new Set(models)].sort(), models_complete: false, reported_compatible: typeof report.compatible === "boolean" ? report.compatible : null,
+            account_access: "unknown", qualified: "unknown", model_turn: "not_requested" };
+    });
+}

package/dist/services/harness-probe-effects.js

@@ -0,0 +1,51 @@
+import { AppError } from "../shared/errors.js";
+export const readOnlyProbeScope = Object.freeze({
+    processes: false, services: false, credentials: false, writes: false
+});
+/** Source-grounded effects of existing adapters; this is not permission to invoke them. */
+export const legacyDoctorEffects = {
+    codex: { child_process: true, service_process: true, credential_access: "possible", filesystem: "temporary_or_runtime_writes", model_turn: "not_requested", source_owner: "harness-runtime/lib/dd-codex.mjs:doctor/withBridge" },
+    zcode: { child_process: true, service_process: false, credential_access: "possible", filesystem: "read_only", model_turn: "not_requested", source_owner: "harness-runtime/lib/dd-zcode.mjs:doctor" },
+    agy: { child_process: true, service_process: false, credential_access: "possible", filesystem: "temporary_or_runtime_writes", model_turn: "not_requested", source_owner: "harness-runtime/lib/dd-agy.mjs:doctor" },
+    opencode: { child_process: true, service_process: true, credential_access: "possible", filesystem: "temporary_or_runtime_writes", model_turn: "not_requested", source_owner: "harness-runtime/lib/dd-opencode-daemon.mjs:daemon.doctor/startDaemon" },
+    grok: { child_process: true, service_process: false, credential_access: "possible", filesystem: "read_only", model_turn: "not_requested", source_owner: "harness-runtime/lib/dd-grok.mjs:doctor" },
+    droid: { child_process: true, service_process: true, credential_access: "possible", filesystem: "temporary_or_runtime_writes", model_turn: "not_requested", source_owner: "harness-runtime/lib/dd-droid-daemon.mjs:runtime.start" }
+};
+for (const effects of Object.values(legacyDoctorEffects))
+    Object.freeze(effects);
+Object.freeze(legacyDoctorEffects);
+export const staticDiscoveryEffects = Object.freeze({
+    child_process: false, service_process: false, credential_access: "none", filesystem: "read_only", model_turn: "not_requested",
+    source_owner: "services/discovery/static.ts:discoverExecutable"
+});
+/** Enforce effect ceilings before invoking a probe. A non-generative label alone is insufficient. */
+export function assertProbeWithinScope(effects, scope) {
+    const scopeKeys = ["processes", "services", "credentials", "writes"];
+    const effectKeys = ["child_process", "service_process", "credential_access", "filesystem", "model_turn", "source_owner"];
+    if (!scope || typeof scope !== "object" || Array.isArray(scope)
+        || Object.keys(scope).some(key => !scopeKeys.includes(key))
+        || scopeKeys.some(key => !Object.hasOwn(scope, key) || typeof scope[key] !== "boolean")
+        || !effects || typeof effects !== "object" || Array.isArray(effects)
+        || effectKeys.some(key => !Object.hasOwn(effects, key)) || Object.keys(effects).some(key => !effectKeys.includes(key))
+        || typeof effects.child_process !== "boolean" || typeof effects.service_process !== "boolean"
+        || !["none", "possible"].includes(effects.credential_access)
+        || !["read_only", "temporary_or_runtime_writes"].includes(effects.filesystem)
+        || !["not_requested", "possible"].includes(effects.model_turn)
+        || typeof effects.source_owner !== "string" || !effects.source_owner.trim()) {
+        throw new AppError("probe_scope_invalid", "Probe effects and permissions require an explicit typed scope", 2, { phase: "probe_admission", effect: "no_effect", help: "harnesses" });
+    }
+    const blocked = [
+        effects.child_process && !scope.processes ? "child_process" : null,
+        effects.service_process && !scope.services ? "service_process" : null,
+        effects.credential_access !== "none" && !scope.credentials ? "credential_access" : null,
+        effects.filesystem !== "read_only" && !scope.writes ? "filesystem_writes" : null,
+        effects.model_turn !== "not_requested" ? "live_authorization_required" : null
+    ].filter(Boolean);
+    if (blocked.length)
+        throw new AppError("probe_effects_not_authorized", "Probe exceeds the selected effect scope", 1, { phase: "probe_admission", effect: "no_effect", blocked_effects: blocked, help: "harnesses" });
+}
+/** The callback is not entered, including synchronous effects, until admission succeeds. */
+export function runScopedProbe(effects, scope, probe) {
+    assertProbeWithinScope(effects, scope);
+    return probe();
+}

package/dist/services/harness-version-probe.js

@@ -0,0 +1,100 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { parse } from "semver";
+import { stopProcessGroup } from "../harness-runtime/lib/managed-daemon.mjs";
+import { AppError } from "../shared/errors.js";
+import { runScopedProbe } from "./harness-probe-effects.js";
+// Even --version runs operator-installed code. Do not infer credential/write
+// isolation from an argument spelling or execute it during static discovery.
+export const versionProbeEffects = Object.freeze({
+    child_process: true, service_process: false, credential_access: "possible",
+    filesystem: "temporary_or_runtime_writes", model_turn: "not_requested",
+    source_owner: "services/harness-version-probe.ts:probeHarnessVersion"
+});
+/** Recognized version fields only; unrelated diagnostic numbers are not facts. */
+export function parseHarnessVersion(harness, stdout) {
+    const normalize = (value) => {
+        const version = parse(value);
+        return version ? `${version.version}${version.build.length ? `+${version.build.join(".")}` : ""}` : null;
+    };
+    if (harness === "grok") {
+        try {
+            const value = JSON.parse(stdout);
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return null;
+            const reported = value.currentVersion;
+            return typeof reported === "string" ? normalize(reported.trim().split(/\s+/)[0]) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    const labels = {
+        codex: "codex(?:-cli)?", zcode: "zcode", agy: "(?:agy|antigravity)", opencode: "opencode", droid: "droid"
+    };
+    const pattern = new RegExp(`^(?:${labels[harness]}\\s+)?(v?[0-9]+\\.[0-9]+\\.[0-9]+(?:-[A-Za-z0-9.-]+)?(?:\\+[A-Za-z0-9.-]+)?)$`, "i");
+    const versions = new Set(stdout.split(/\r?\n/).flatMap(line => {
+        const matched = line.trim().match(pattern)?.[1];
+        const version = matched ? normalize(matched) : null;
+        return version ? [version] : [];
+    }));
+    return versions.size === 1 ? [...versions][0] : null;
+}
+/** Diagnostic only: a version is not protocol, account or flow qualification. */
+export function probeHarnessVersion(input) {
+    const timeoutMs = input.timeoutMs ?? 3000;
+    if (!["codex", "zcode", "agy", "opencode", "grok", "droid"].includes(input.harness)) {
+        throw new AppError("usage", "Unknown harness family", 2, { effect: "no_effect" });
+    }
+    if (!path.isAbsolute(input.executable) || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60_000) {
+        throw new AppError("usage", "Version probe requires an absolute executable and a timeout of 1–60000 ms", 2, { effect: "no_effect" });
+    }
+    return runScopedProbe(versionProbeEffects, input.scope, () => new Promise((resolve, reject) => {
+        const args = input.harness === "grok" ? ["version", "--json"] : ["--version"];
+        const detached = process.platform !== "win32";
+        const child = spawn(input.executable, args, { env: input.env, detached, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let bytes = 0;
+        let failure;
+        let cleanup;
+        const stop = (code, message) => {
+            failure ??= new AppError(code, message, 1, { phase: "version_probe", effect: "process_dispatched" });
+            cleanup ??= stopProcessGroup(child, 1000, { detached });
+            // Observe immediately; close may arrive after asynchronous cleanup failure.
+            void cleanup.catch(() => { });
+        };
+        const timer = setTimeout(() => stop("probe_timeout", "Version probe exceeded its deadline"), timeoutMs);
+        child.stdout.setEncoding("utf8").on("data", (chunk) => {
+            bytes += Buffer.byteLength(chunk);
+            if (bytes > 64_000)
+                stop("probe_output_limit", "Version probe exceeded its output limit");
+            else
+                stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > 64_000)
+                stop("probe_output_limit", "Version probe exceeded its output limit");
+        });
+        child.on("error", () => { failure ??= new AppError("probe_launch_failed", "Version probe could not start", 1); });
+        child.on("close", (code, signal) => {
+            clearTimeout(timer);
+            void (async () => {
+                try {
+                    await cleanup;
+                    if (failure)
+                        throw failure;
+                    if (code !== 0 || signal)
+                        throw new AppError("probe_failed", "Version probe did not exit successfully", 1);
+                    // Never expose arbitrary subprocess output: it can contain secrets.
+                    const version = parseHarnessVersion(input.harness, stdout);
+                    resolve({ harness: input.harness, version, status: version ? "observed" : "unrecognized",
+                        compatible: "unknown", protocol: "unknown", auth: "unknown", qualified: "unknown" });
+                }
+                catch (error) {
+                    reject(error instanceof AppError ? error : new AppError("probe_cleanup_unconfirmed", "Version probe cleanup could not be confirmed", 1));
+                }
+            })();
+        });
+    }));
+}

package/dist/services/hooks.js

@@ -843,7 +843,7 @@ function handleControlledToolEvent(context, input, event, harness) {
         });
         return { ok: true, observed: inserted, duplicate: !inserted, event_key: baseKey, phase, harness, session: nativeSessionIdentity(harness, providerSessionId), ...(nativeParentId ? { parent_session: nativeSessionIdentity(harness, nativeParentId) } : {}) };
     }
-    if (!command || !(droid ? ["Execute"] : ["bash", "Bash", "run_command", "run_terminal_command", "RunTerminalCommand"]).includes(toolName)) {
+    if (!command || !(droid ? ["Execute"] : ["bash", "Bash", "shell", "run_command", "run_terminal_command", "RunTerminalCommand"]).includes(toolName)) {
         return { ok: true, observed: false, reason: command ? "non_bash_tool" : "event_not_participating" };
     }
     const lifecycle = lifecycleFacts(command);