@deksden-com/dd-flow-cli 0.9.0-beta.1 → 0.9.0-beta.100

package/dist/services/lanes.js

@@ -1,6 +1,4 @@
 import crypto from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { AppError } from "../shared/errors.js";
 import { appendAudit } from "./audit.js";
@@ -8,6 +6,32 @@ import { requireProjectByRoot } from "./projects.js";
 import { resolveProjectRoot } from "../storage/paths.js";
 const defaultTtlSeconds = 300;
 const defaultPollIntervalSeconds = 10;
+export function prepareLaneWaitTiming(input) {
+    return {
+        timeoutSeconds: normalizeNonNegativeNumber(input.timeoutSeconds, 0, "timeout"),
+        pollIntervalSeconds: normalizePositiveNumber(input.pollIntervalSeconds, defaultPollIntervalSeconds, "poll-interval")
+    };
+}
+export function prepareLaneLock(context, input, action) {
+    if (typeof input.workerId !== "string" || !input.workerId.trim())
+        throw new AppError("validation", "Lane lock requires a nonempty worker ID", 2);
+    if (["acquire", "release", "wait-acquire"].includes(action) && (typeof input.reason !== "string" || !input.reason.trim()))
+        throw new AppError("validation", "Lane lock requires a nonempty reason", 2);
+    if (input.leaseToken !== undefined && (typeof input.leaseToken !== "string" || !input.leaseToken.trim()))
+        throw new AppError("validation", "Lease token must be nonempty text", 2);
+    const ttlSeconds = normalizePositiveNumber(input.ttlSeconds, defaultTtlSeconds, "ttl");
+    const { timeoutSeconds, pollIntervalSeconds } = prepareLaneWaitTiming(input);
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const lane = normalizeLane(input.lane);
+    if (input.workspacePath !== undefined)
+        requireMatchingLaneWorkspace(context, project.id, lane, input.workspacePath);
+    else if (["acquire", "wait", "wait-acquire"].includes(action))
+        throw new AppError("validation", "Lane lock requires a workspace path", 2);
+    if (action === "acquire" || action === "wait-acquire")
+        assertWorkerMayAcquireLaneLock(context, project.id, lane, input.workerId);
+    const lock = action === "heartbeat" || action === "release" ? requireOwnedActiveLock(context, project.id, lane, input.workerId, input.leaseToken) : undefined;
+    return { project, lane, ttlSeconds, timeoutSeconds, pollIntervalSeconds, lock };
+}
 export function getLaneStatus(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     return {
@@ -23,10 +47,16 @@ export function expireProjectLaneLocks(context, projectId) {
 export function expireProjectLaneWaiters(context, projectId) {
     expireStaleWaiters(context, projectId);
 }
-export function setLaneWorkspace(context, input) {
+export function prepareLaneWorkspace(context, input) {
+    if (input.branch !== undefined && (typeof input.branch !== "string" || !input.branch.trim()))
+        throw new AppError("validation", "Expected branch must be nonempty text", 2);
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const lane = normalizeLane(input.lane);
     const workspacePath = resolveExistingPath(input.workspacePath);
+    return { project, lane, workspacePath };
+}
+export function setLaneWorkspace(context, input) {
+    const { project, lane, workspacePath } = prepareLaneWorkspace(context, input);
     const now = context.now();
     const existing = laneRecord(context, project.id, lane);
     context.db.run(`INSERT INTO lanes
@@ -69,11 +99,7 @@ export function checkLaneWorkspace(context, input) {
     };
 }
 export function acquireLaneLock(context, input) {
-    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
-    const lane = normalizeLane(input.lane);
-    requireMatchingLaneWorkspace(context, project.id, lane, input.workspacePath);
-    assertWorkerMayAcquireLaneLock(context, project.id, lane, input.workerId);
-    const ttlSeconds = normalizePositiveNumber(input.ttlSeconds, defaultTtlSeconds, "ttl");
+    const { project, lane, ttlSeconds } = prepareLaneLock(context, input, "acquire");
     expireStaleLocks(context, project.id);
     const active = activeLaneLock(context, project.id, lane);
     if (active) {
@@ -116,13 +142,8 @@ export function acquireLaneLock(context, input) {
     };
 }
 export function heartbeatLaneLock(context, input) {
-    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
-    const lane = normalizeLane(input.lane);
-    if (input.workspacePath) {
-        requireMatchingLaneWorkspace(context, project.id, lane, input.workspacePath);
-    }
-    const lock = requireOwnedActiveLock(context, project.id, lane, input.workerId, input.leaseToken);
-    const ttlSeconds = normalizePositiveNumber(input.ttlSeconds, defaultTtlSeconds, "ttl");
+    const { project, lock: preparedLock, ttlSeconds } = prepareLaneLock(context, input, "heartbeat");
+    const lock = preparedLock;
     const now = context.now();
     context.db.run(`UPDATE lane_locks SET heartbeat_at = ?, expires_at = ?, updated_at = ? WHERE id = ?`, [now, expiresAt(now, ttlSeconds), now, lock.id]);
     appendAudit(context, {
@@ -133,12 +154,8 @@ export function heartbeatLaneLock(context, input) {
     return { ok: true, lock: activeLaneLock(context, project.id, lock.lane) };
 }
 export function releaseLaneLock(context, input) {
-    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
-    const lane = normalizeLane(input.lane);
-    if (input.workspacePath) {
-        requireMatchingLaneWorkspace(context, project.id, lane, input.workspacePath);
-    }
-    const lock = requireOwnedActiveLock(context, project.id, lane, input.workerId, input.leaseToken);
+    const { project, lock: preparedLock } = prepareLaneLock(context, input, "release");
+    const lock = preparedLock;
     const now = context.now();
     context.db.run(`UPDATE lane_locks
      SET status = 'released', released_at = ?, reason = ?, updated_at = ?
@@ -152,11 +169,7 @@ export function releaseLaneLock(context, input) {
     return { ok: true, lock: laneLockById(context, lock.id) };
 }
 export async function waitForLaneLock(context, input) {
-    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
-    const lane = normalizeLane(input.lane);
-    requireMatchingLaneWorkspace(context, project.id, lane, input.workspacePath);
-    const timeoutSeconds = normalizeNonNegativeNumber(input.timeoutSeconds, 0, "timeout");
-    const pollIntervalSeconds = normalizePositiveNumber(input.pollIntervalSeconds, defaultPollIntervalSeconds, "poll-interval");
+    const { project, lane, timeoutSeconds, pollIntervalSeconds } = prepareLaneLock(context, input, "wait");
     const start = Date.now();
     while (true) {
         expireStaleLocks(context, project.id);
@@ -186,13 +199,18 @@ export function getLaneWaiters(context, input) {
         }))
     };
 }
-export function cancelLaneWaiter(context, input) {
+export function prepareLaneWaiterCancellation(context, input) {
+    if (typeof input.workerId !== "string" || !input.workerId.trim())
+        throw new AppError("validation", "Lane waiter requires a nonempty worker ID", 2);
+    if (typeof input.reason !== "string" || !input.reason.trim())
+        throw new AppError("validation", "lane waiter cancel requires --reason", 2);
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const lane = normalizeLane(input.lane);
     const reason = input.reason.trim();
-    if (!reason) {
-        throw new AppError("validation", "lane waiter cancel requires --reason", 2);
-    }
+    return { project, lane, reason };
+}
+export function cancelLaneWaiter(context, input) {
+    const { project, lane, reason } = prepareLaneWaiterCancellation(context, input);
     expireStaleWaiters(context, project.id);
     const now = context.now();
     const waiter = activeLaneWaiterForWorker(context, project.id, lane, input.workerId);
@@ -245,13 +263,7 @@ export function expireLaneWaiterById(context, input) {
     return { ok: true, expired: result.changes === 1, waiter_id: input.waiterId };
 }
 export async function waitAcquireLaneLock(context, input) {
-    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
-    const lane = normalizeLane(input.lane);
-    requireMatchingLaneWorkspace(context, project.id, lane, input.workspacePath);
-    assertWorkerMayAcquireLaneLock(context, project.id, lane, input.workerId);
-    const timeoutSeconds = normalizeNonNegativeNumber(input.timeoutSeconds, 0, "timeout");
-    const pollIntervalSeconds = normalizePositiveNumber(input.pollIntervalSeconds, defaultPollIntervalSeconds, "poll-interval");
-    const ttlSeconds = normalizePositiveNumber(input.ttlSeconds, defaultTtlSeconds, "ttl");
+    const { project, lane, timeoutSeconds, pollIntervalSeconds, ttlSeconds } = prepareLaneLock(context, input, "wait-acquire");
     const startedAt = Date.now();
     const waiterDeadline = timeoutSeconds > 0 ? new Date(startedAt + timeoutSeconds * 1000).toISOString() : null;
     while (true) {
@@ -288,6 +300,7 @@ export async function waitAcquireLaneLock(context, input) {
                 timeoutSeconds
             });
         }
+        input.progress?.(`lane ${lane} is waiting at queue position ${String(result.payload.position ?? "unknown")}; next update in ${pollIntervalSeconds} seconds`);
         await delay(pollIntervalSeconds * 1000);
     }
 }
@@ -374,10 +387,9 @@ function laneWaitersForProject(context, projectId, lane) {
      LIMIT 100`, [projectId]);
 }
 function activeLaneLock(context, projectId, lane) {
-    expireStaleLocks(context, projectId);
     return context.db.get(`SELECT * FROM lane_locks
-     WHERE project_id = ? AND lane = ? AND status = 'active'
-     ORDER BY updated_at DESC, id DESC LIMIT 1`, [projectId, lane]);
+     WHERE project_id = ? AND lane = ? AND status = 'active' AND expires_at > ?
+     ORDER BY updated_at DESC, id DESC LIMIT 1`, [projectId, lane, context.now()]);
 }
 function activeLaneWaiterForWorker(context, projectId, lane, workerId) {
     return context.db.get(`SELECT * FROM lane_waiters
@@ -512,10 +524,10 @@ function ensureQueuedLaneWaiter(context, input) {
     return waiter;
 }
 function tryAcquireQueuedLaneLock(context, input) {
-    expireStaleLocks(context, input.projectId);
-    expireStaleWaiters(context, input.projectId);
-    context.db.exec("BEGIN IMMEDIATE");
+    context.db.beginWriteTransaction();
     try {
+        expireStaleLocks(context, input.projectId);
+        expireStaleWaiters(context, input.projectId);
         const existingLock = activeLaneLock(context, input.projectId, input.lane);
         if (existingLock?.worker_id === input.workerId) {
             context.db.exec("COMMIT");
@@ -617,11 +629,7 @@ function tryAcquireQueuedLaneLock(context, input) {
     }
 }
 function resolveExistingPath(value) {
-    const absolute = path.resolve(value);
-    if (!fs.existsSync(absolute)) {
-        throw new AppError("not_found", `Workspace path does not exist: ${absolute}`, 1);
-    }
-    return fs.realpathSync(absolute);
+    return resolveProjectRoot(value);
 }
 function detectBranch(workspacePath) {
     const result = spawnSync("git", ["-C", workspacePath, "rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8" });
@@ -634,7 +642,7 @@ function expiresAt(now, ttlSeconds) {
     return new Date(new Date(now).getTime() + ttlSeconds * 1000).toISOString();
 }
 function normalizeLane(value) {
-    const normalized = value.trim().toLowerCase();
+    const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
     if (!normalized || !/^[a-z0-9._-]+$/.test(normalized)) {
         throw new AppError("validation", "Lane name must contain only lowercase letters, numbers, dot, underscore, or hyphen", 2);
     }
@@ -642,15 +650,16 @@ function normalizeLane(value) {
 }
 function normalizePositiveNumber(value, fallback, label) {
     const normalized = value ?? fallback;
-    if (!Number.isFinite(normalized) || normalized <= 0) {
-        throw new AppError("validation", `--${label} must be a positive number`, 2);
+    if (!Number.isFinite(normalized) || normalized <= 0 ||
+        (label === "poll-interval" ? normalized * 1000 > 2 ** 31 - 1 : !Number.isFinite(new Date(Date.now() + normalized * 1000).getTime()))) {
+        throw new AppError("validation", `--${label} must be a positive number within the supported timer/date range`, 2);
     }
     return normalized;
 }
 function normalizeNonNegativeNumber(value, fallback, label) {
     const normalized = value ?? fallback;
-    if (!Number.isFinite(normalized) || normalized < 0) {
-        throw new AppError("validation", `--${label} must be zero or a positive number`, 2);
+    if (!Number.isFinite(normalized) || normalized < 0 || !Number.isFinite(new Date(Date.now() + normalized * 1000).getTime())) {
+        throw new AppError("validation", `--${label} must be zero or a positive number within the supported date range`, 2);
     }
     return normalized;
 }

package/dist/services/lifecycle-command.js

@@ -1,11 +1,45 @@
 import path from "node:path";
 import { parse, quote } from "shell-quote";
+import { lifecycleOperationForArgv } from "./lifecycle-contract.js";
+/** Native hooks and the lightweight ingress must recognize the same shell. */
+export function lifecycleCommandFromPayload(payload) {
+    const input = payload.tool_input && typeof payload.tool_input === "object" ? payload.tool_input : {};
+    const command = [payload.command, input.command, input.cmd].find(value => typeof value === "string" && value.length > 0);
+    return typeof command === "string" ? unwrapShellCommand(command) : undefined;
+}
 const controlOperators = new Set(["&&", "||", ";", "|", "|&", "&", "(", ")", "<(", ">("]);
 const redirectionOperators = new Set(["<", ">", ">>", ">|", "<&", ">&", "<<<"]);
 /** Parse the deliberately small direct-command surface accepted by lifecycle hooks. */
 export function parseLifecycleCommand(command) {
     return parseLifecycleCommandInner(command, false);
 }
+/** Exact diagnostic routes; these deliberately confer no lifecycle authority. */
+export function continuationCommand(command) {
+    let entries;
+    try {
+        entries = parse(command, name => `$${name}`);
+    }
+    catch {
+        return null;
+    }
+    if (!entries.every(entry => typeof entry === "string"))
+        return null;
+    const words = entries;
+    const start = words.findIndex(word => ["stage", "work"].includes(word));
+    if (start < 1)
+        return null;
+    const launcher = words.slice(0, start);
+    while (launcher[0] && /^[A-Za-z_][A-Za-z0-9_]*=/.test(launcher[0]))
+        launcher.shift();
+    const direct = launcher.length === 1 && (path.basename(launcher[0]) === "dd-flow" || launcher[0] === "$DD_FLOW_BIN");
+    const node = launcher.length === 2 && path.basename(launcher[0]) === "node" && (path.basename(launcher[1]) === "cli.js" || launcher[1] === "$DD_FLOW_BIN");
+    if (!direct && !node)
+        return null;
+    const args = parseCommandArgs(words.slice(start));
+    const route = args.positional.slice(0, 3).join(" ");
+    const operation = route === "work repair add" ? "work_repair_add" : args.positional[0] === "stage" && args.positional[1] === "block" ? "stage_block" : null;
+    return operation ? { operation, args } : null;
+}
 /** Preserve the historical Desktop contract: execute the payload, not its one-command shell wrapper. */
 export function unwrapShellCommand(command) {
     let entries;
@@ -32,7 +66,7 @@ function parseLifecycleCommandInner(command, wrapped) {
     const heredoc = stripHeredocBodies(command);
     let entries;
     try {
-        entries = parse(heredoc.command, (name) => `$${name}`);
+        entries = parse(withoutFileDescriptors(heredoc.command), (name) => `$${name}`);
     }
     catch {
         // A command that cannot be tokenized cannot create a trusted claim. The
@@ -56,11 +90,11 @@ function parseLifecycleCommandInner(command, wrapped) {
     if (!found.length)
         return { kind: "none" };
     const first = found[0];
-    if (found.length !== 1 || composed || first.nestedCompound) {
+    if (found.length !== 1 || composed || first.nestedCompound || (heredoc.present && !heredoc.safe)) {
         return {
             kind: "compound",
             invocation: { ...first.invocation, rewriteSafe: false },
-            reason: found.length !== 1 ? "multiple_lifecycle_invocations" : first.nestedCompound ? "nested_compound_invocation" : "shell_composition"
+            reason: found.length !== 1 ? "multiple_lifecycle_invocations" : first.nestedCompound ? "nested_compound_invocation" : heredoc.present && !heredoc.safe ? "unsafe_heredoc" : "shell_composition"
         };
     }
     return { kind: "standalone", invocation: first.invocation };
@@ -127,7 +161,7 @@ function invocationFromSegment(segment, heredoc, wrapped, inheritedEnv) {
         }
     }
     const executable = segment.words[index];
-    if (!executable || path.basename(executable) !== "dd-flow")
+    if (!executable || path.basename(executable) !== "dd-flow" && executable !== "$DD_FLOW_BIN")
         return null;
     const argv = segment.words.slice(index + 1);
     const operation = lifecycleOperation(argv);
@@ -138,7 +172,7 @@ function invocationFromSegment(segment, heredoc, wrapped, inheritedEnv) {
         executable,
         argv,
         env,
-        args: parseCommandArgs(argv.slice(2)),
+        args: parseCommandArgs(argv.slice(operation === "recovery_accept" ? 3 : 2)),
         command: quote(segment.words),
         rewriteSafe: !heredoc && !wrapped && !segment.dynamic,
         wrapped,
@@ -170,16 +204,7 @@ function wrappedInvocationFromSegment(segment) {
     return parseLifecycleCommandInner(payload, true);
 }
 function lifecycleOperation(argv) {
-    const key = `${argv[0] ?? ""} ${argv[1] ?? ""}`;
-    if (key === "session register")
-        return "session_register";
-    if (key === "stage start")
-        return "stage_start";
-    if (key === "stage resume")
-        return "stage_resume";
-    if (key === "work start")
-        return "work_start";
-    return null;
+    return lifecycleOperationForArgv(argv);
 }
 export function parseCommandArgs(argv) {
     const positional = [];
@@ -187,6 +212,12 @@ export function parseCommandArgs(argv) {
     for (let index = 0; index < argv.length; index += 1) {
         const value = argv[index];
         if (value?.startsWith("--")) {
+            const equals = value.indexOf("=");
+            if (equals > 2) {
+                const key = value.slice(2, equals);
+                options.set(key, [...(options.get(key) ?? []), value.slice(equals + 1)]);
+                continue;
+            }
             const key = value.slice(2);
             const next = argv[index + 1];
             const optionValue = !next || next.startsWith("--") ? "__dd_flow_flag__" : next;
@@ -213,6 +244,58 @@ export function commandPosition(invocation, index) {
 function assignment(word) {
     return /^[A-Za-z_][A-Za-z0-9_]*=/.test(word);
 }
+/** Source offsets matter: shell-quote loses the difference between `2>&1`
+ * and the literal argument `2 >&1`. Only inspect unquoted shell syntax. */
+function shellSyntaxOffsets(command) {
+    const offsets = [];
+    let quoted = null, escaped = false;
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\" && quoted !== "'") {
+            escaped = true;
+            continue;
+        }
+        if (quoted) {
+            if (char === quoted)
+                quoted = null;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quoted = char;
+            continue;
+        }
+        if (char === "#" && (i === 0 || /\s/.test(command[i - 1]))) {
+            offsets.push(i);
+            break;
+        }
+        if (char === "<" || char === ">")
+            offsets.push(i);
+    }
+    return offsets;
+}
+function descriptorStart(command, index) {
+    let start = index;
+    while (start > 0 && /[0-9]/.test(command[start - 1]))
+        start--;
+    return start === 0 || /[\s;&|]/.test(command[start - 1]) ? start : index;
+}
+export function shellSuffixOffset(command) {
+    const offset = shellSyntaxOffsets(command)[0];
+    return offset === undefined ? command.length : descriptorStart(command, offset);
+}
+function withoutFileDescriptors(command) {
+    for (const index of shellSyntaxOffsets(command).reverse()) {
+        if (command[index] === "#")
+            continue;
+        const start = descriptorStart(command, index);
+        command = command.slice(0, start) + command.slice(index);
+    }
+    return command;
+}
 function addAssignment(env, word) {
     const separator = word.indexOf("=");
     env[word.slice(0, separator)] = word.slice(separator + 1);
@@ -223,6 +306,7 @@ function stripHeredocBodies(command) {
     const pending = [];
     let active;
     let present = false;
+    let count = 0, quoted = true;
     for (const line of lines) {
         if (active) {
             const candidate = active.stripTabs ? line.replace(/^\t+/, "") : line;
@@ -233,13 +317,15 @@ function stripHeredocBodies(command) {
         if (line.trim())
             output.push(line);
         const found = heredocDelimiters(line);
+        count += found.length;
+        quoted &&= found.every(item => item.quoted);
         if (found.length) {
             present = true;
             active = found[0];
             pending.push(...found.slice(1));
         }
     }
-    return { command: output.join(" ; "), present };
+    return { command: output.join(" ; "), present, safe: count === 1 && quoted && !active && pending.length === 0 };
 }
 function heredocDelimiters(line) {
     const result = [];
@@ -282,7 +368,7 @@ function heredocDelimiters(line) {
                 index += 1;
         const delimiter = line.slice(start, index);
         if (delimiter)
-            result.push({ delimiter, stripTabs });
+            result.push({ delimiter, stripTabs, quoted: delimiterQuote !== null });
     }
     return result;
 }

package/dist/services/lifecycle-contract.js

@@ -0,0 +1,30 @@
+export const lifecycleRoutes = {
+    "session register": "session_register",
+    "stage start": "stage_start",
+    "stage finish": "stage_finish",
+    "stage pause": "stage_pause",
+    "stage resume": "stage_resume",
+    "work start": "work_start",
+    "work finish": "work_finish",
+    "work fail": "work_fail",
+    "merge apply": "merge_apply",
+    "merge repair": "merge_repair",
+    "run recovery accept": "recovery_accept"
+};
+export const lifecycleInternalOptions = ["invocation-id", "hook-event-id"];
+export function lifecycleOperationForArgv(argv) {
+    if (argv.some(arg => arg === "--help" || arg === "-h"))
+        return null;
+    for (const [route, operation] of Object.entries(lifecycleRoutes)) {
+        const parts = route.split(" ");
+        if (parts.every((part, index) => argv[index] === part))
+            return operation;
+    }
+    return null;
+}
+export function lifecycleRouteForOperation(operation) {
+    const entry = Object.entries(lifecycleRoutes).find(([, value]) => value === operation);
+    if (!entry)
+        throw new Error(`Unknown lifecycle operation: ${operation}`);
+    return entry[0];
+}