@indigoai-us/hq-cli 5.272.0 → 5.273.0

package/dist/lib/lanes/merge-command.js

@@ -1,4 +1,6 @@
+import * as path from "node:path";
 import { LanesError } from "./errors.js";
+const MAX_COMMAND_WRAPPER_DEPTH = 4;
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
 }
@@ -45,11 +47,13 @@ function splitCommandChain(command) {
             current += character;
             continue;
         }
-        if (character === ";" || character === "|") {
+        if (character === ";" || character === "|" || character === "\n" || character === "\r") {
             segments.push(current.trim());
             current = "";
             if (character === "|" && command[index + 1] === "|")
                 index += 1;
+            if (character === "\r" && command[index + 1] === "\n")
+                index += 1;
             continue;
         }
         if (character === "&" && command[index + 1] === "&") {
@@ -69,16 +73,26 @@ function splitCommandChain(command) {
 function shellWords(segment) {
     const words = [];
     let current = "";
+    let wordStarted = false;
     let quote = null;
     let escaped = false;
+    const finishWord = () => {
+        if (!wordStarted)
+            return;
+        words.push(current);
+        current = "";
+        wordStarted = false;
+    };
     for (const character of segment) {
         if (escaped) {
             current += character;
+            wordStarted = true;
             escaped = false;
             continue;
         }
         if (character === "\\" && quote !== "'") {
             escaped = true;
+            wordStarted = true;
             continue;
         }
         if (quote) {
@@ -86,24 +100,24 @@ function shellWords(segment) {
                 quote = null;
             else
                 current += character;
+            wordStarted = true;
             continue;
         }
         if (character === "'" || character === "\"") {
             quote = character;
+            wordStarted = true;
             continue;
         }
         if (/\s/.test(character)) {
-            if (current)
-                words.push(current);
-            current = "";
+            finishWord();
             continue;
         }
         current += character;
+        wordStarted = true;
     }
-    if (escaped)
-        current += "\\";
-    if (current)
-        words.push(current);
+    if (quote !== null || escaped)
+        return fail("repo_hold_command_invalid", "Command has an unclosed quote or escape");
+    finishWord();
     return words;
 }
 function optionRepo(words) {
@@ -163,10 +177,8 @@ function skipEnvOptions(words, start) {
         }
         if (word === "--")
             return index + 1;
-        if (word.startsWith("-")) {
-            index += 1;
-            continue;
-        }
+        if (word.startsWith("-"))
+            return -1;
         break;
     }
     return index;
@@ -191,32 +203,223 @@ function skipTimeoutOptions(words, start) {
             index += 1;
             continue;
         }
-        if (word.startsWith("-")) {
-            index += 1;
-            continue;
-        }
+        if (word.startsWith("-"))
+            return -1;
         break;
     }
-    return Math.min(index + 1, words.length);
+    const duration = words[index];
+    if (!duration || !/^(?:\d+(?:\.\d*)?|\.\d+)(?:s|m|h|d)?$/.test(duration))
+        return -1;
+    index += 1;
+    if (words[index] === "--")
+        index += 1;
+    return index < words.length ? index : -1;
 }
-function unwrapCommand(words) {
-    let index = 0;
+const SHELL_SHORT_OPTIONS = new Set(["a", "b", "B", "C", "e", "E", "f", "h", "H", "i", "k", "l", "m", "n", "p", "P", "r", "s", "t", "T", "u", "v", "x"]);
+const SHELL_LONG_OPTIONS = new Set([
+    "--interactive", "--login", "--noprofile", "--norc", "--posix", "--restricted",
+    "--verbose", "--noediting", "--debugger",
+]);
+const SHELL_LONG_VALUE_OPTIONS = new Set(["--rcfile", "--init-file", "--emulate"]);
+function shellCommandWrapper(words) {
+    let index = 1;
     while (index < words.length) {
-        if (SHELL_ASSIGNMENT.test(words[index] ?? "")) {
+        const option = words[index] ?? "";
+        if (option === "--")
+            return null;
+        if (SHELL_LONG_VALUE_OPTIONS.has(option)) {
+            if (!words[index + 1])
+                return { kind: "invalid" };
+            index += 2;
+            continue;
+        }
+        if ([...SHELL_LONG_VALUE_OPTIONS].some((name) => option.startsWith(`${name}=`))) {
             index += 1;
             continue;
         }
-        if (words[index] === "env") {
-            index = skipEnvOptions(words, index);
+        if (SHELL_LONG_OPTIONS.has(option)) {
+            index += 1;
             continue;
         }
-        if (words[index] === "timeout") {
-            index = skipTimeoutOptions(words, index);
+        if (option.startsWith("--"))
+            return { kind: "invalid" };
+        if ((option.startsWith("-") || option.startsWith("+")) && option.length > 1) {
+            const flags = option.slice(1);
+            let consumedOptionValue = false;
+            for (let flagIndex = 0; flagIndex < flags.length; flagIndex += 1) {
+                const flag = flags[flagIndex] ?? "";
+                if (flag === "c") {
+                    const script = words[index + 1];
+                    return script === undefined ? { kind: "invalid" } : { kind: "script", script };
+                }
+                if (flag === "o" || flag === "O") {
+                    if (flagIndex + 1 < flags.length) {
+                        index += 1;
+                        consumedOptionValue = true;
+                        break;
+                    }
+                    if (!words[index + 1])
+                        return { kind: "invalid" };
+                    index += 2;
+                    consumedOptionValue = true;
+                    break;
+                }
+                if (!SHELL_SHORT_OPTIONS.has(flag))
+                    return { kind: "invalid" };
+            }
+            if (!consumedOptionValue)
+                index += 1;
             continue;
         }
-        break;
+        return null;
+    }
+    return null;
+}
+function commandWrapper(words) {
+    const command = path.basename(words[0] ?? "").toLowerCase();
+    if (["bash", "sh", "zsh"].includes(command))
+        return shellCommandWrapper(words);
+    if (command === "sudo") {
+        let index = 1;
+        while (index < words.length) {
+            const option = words[index] ?? "";
+            if (option === "--") {
+                index += 1;
+                break;
+            }
+            if (option === "-u" || option === "--user") {
+                if (!words[index + 1])
+                    return { kind: "invalid" };
+                index += 2;
+                continue;
+            }
+            if (option.startsWith("--user=") || /^-u.+/.test(option)) {
+                index += 1;
+                continue;
+            }
+            if (["-A", "-b", "-E", "-H", "-K", "-k", "-n", "-P", "-S", "-V", "--askpass", "--background", "--preserve-env", "--set-home", "--remove-timestamp", "--reset-timestamp", "--non-interactive", "--preserve-groups", "--stdin", "--version"].includes(option)) {
+                index += 1;
+                continue;
+            }
+            if (option.startsWith("-"))
+                return { kind: "invalid" };
+            break;
+        }
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "command") {
+        let index = 1;
+        while (words[index] === "-p")
+            index += 1;
+        if (words[index] === "--")
+            index += 1;
+        if (words[index]?.startsWith("-"))
+            return { kind: "invalid" };
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
     }
-    return words.slice(index);
+    if (command === "env") {
+        const index = skipEnvOptions(words, 0);
+        if (index < 0)
+            return { kind: "invalid" };
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "timeout") {
+        const index = skipTimeoutOptions(words, 0);
+        return index >= 0 ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "nice") {
+        let index = 1;
+        while (index < words.length) {
+            const option = words[index] ?? "";
+            if (option === "--") {
+                index += 1;
+                break;
+            }
+            if (option === "-n" || option === "--adjustment") {
+                if (!/^-?\d+$/.test(words[index + 1] ?? ""))
+                    return { kind: "invalid" };
+                index += 2;
+                continue;
+            }
+            if (/^--adjustment=-?\d+$/.test(option) || /^-\d+$/.test(option)) {
+                index += 1;
+                continue;
+            }
+            if (option.startsWith("-"))
+                return { kind: "invalid" };
+            break;
+        }
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "nohup") {
+        const index = words[1] === "--" ? 2 : 1;
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    return null;
+}
+function containsMergeCandidate(command) {
+    // This lossy scan only decides whether malformed input resembles a merge;
+    // the parser never uses it to recover a command or target.
+    const words = command.replace(/["'`\\]/g, " ").match(/\S+/g) ?? [];
+    const valueOptions = new Set([
+        "-R", "--repo", "--hostname", "--config", "--cache", "--jq", "--template",
+        "--preview", "--http-unix-socket", "--git-protocol",
+    ]);
+    for (let index = 0; index < words.length; index += 1) {
+        if (words[index]?.toLowerCase() !== "gh")
+            continue;
+        let subcommandIndex = index + 1;
+        while (subcommandIndex < words.length) {
+            const word = words[subcommandIndex] ?? "";
+            if (word === "--")
+                break;
+            if (valueOptions.has(word)) {
+                if (subcommandIndex + 1 >= words.length)
+                    break;
+                subcommandIndex += 2;
+                continue;
+            }
+            if (word.startsWith("--repo=") || word.startsWith("--hostname=") || /^-R.+/.test(word)) {
+                subcommandIndex += 1;
+                continue;
+            }
+            if (word.startsWith("-")) {
+                subcommandIndex += 1;
+                continue;
+            }
+            break;
+        }
+        const subcommand = words[subcommandIndex];
+        if (subcommand === "pr") {
+            let actionIndex = subcommandIndex + 1;
+            while (actionIndex < words.length) {
+                const word = words[actionIndex] ?? "";
+                if (word === "--")
+                    break;
+                if (valueOptions.has(word)) {
+                    if (actionIndex + 1 >= words.length)
+                        break;
+                    actionIndex += 2;
+                    continue;
+                }
+                if (word.startsWith("--repo=") || word.startsWith("--hostname=") || /^-R.+/.test(word)) {
+                    actionIndex += 1;
+                    continue;
+                }
+                if (word.startsWith("-")) {
+                    actionIndex += 1;
+                    continue;
+                }
+                break;
+            }
+            if (words[actionIndex] === "merge")
+                return true;
+        }
+        if (subcommand === "api" && words.slice(subcommandIndex + 1).some((word) => /\/merge\b/i.test(word) || /\bmergePullRequest\b/i.test(word))) {
+            return true;
+        }
+    }
+    return false;
 }
 function parsePullUrl(raw) {
     if (!/^https?:\/\//i.test(raw))
@@ -330,8 +533,7 @@ function apiMergeTarget(words, apiIndex) {
     }
     return null;
 }
-function parseSegment(segment) {
-    const words = unwrapCommand(shellWords(segment));
+function parseSegmentWords(words) {
     if (words[0] === "git" && words.slice(1).includes("merge")) {
         return {
             kind: "git",
@@ -351,13 +553,77 @@ function parseSegment(segment) {
         return null;
     return apiMergeTarget(words, apiIndex);
 }
+function unparseableMergeTarget() {
+    return {
+        kind: "pr",
+        repo: null,
+        pr: null,
+        pinnedHead: null,
+        unresolvedReason: "merge command could not be parsed safely",
+    };
+}
+function recordUnparseableMerge(state) {
+    state.unparseableMerge = true;
+    state.targets.push(unparseableMergeTarget());
+}
+function parseCommandWords(words, source, depth, state) {
+    let commandWords = words;
+    while (SHELL_ASSIGNMENT.test(commandWords[0] ?? ""))
+        commandWords = commandWords.slice(1);
+    if (commandWords.length === 0)
+        return;
+    const wrapper = commandWrapper(commandWords);
+    if (wrapper) {
+        if (wrapper.kind === "invalid" || depth >= MAX_COMMAND_WRAPPER_DEPTH) {
+            if (containsMergeCandidate(source))
+                recordUnparseableMerge(state);
+            return;
+        }
+        if (wrapper.kind === "script") {
+            parseCommandList(wrapper.script, depth + 1, state);
+            return;
+        }
+        parseCommandWords(wrapper.words, source, depth + 1, state);
+        return;
+    }
+    const target = parseSegmentWords(commandWords);
+    if (target)
+        state.targets.push(target);
+}
+function parseCommandList(command, depth, state) {
+    let segments;
+    try {
+        segments = splitCommandChain(command);
+    }
+    catch (error) {
+        if (error instanceof LanesError && error.error === "repo_hold_command_invalid" && containsMergeCandidate(command)) {
+            recordUnparseableMerge(state);
+            return;
+        }
+        throw error;
+    }
+    for (const segment of segments) {
+        let words;
+        try {
+            words = shellWords(segment);
+        }
+        catch (error) {
+            if (error instanceof LanesError && error.error === "repo_hold_command_invalid" && containsMergeCandidate(segment)) {
+                recordUnparseableMerge(state);
+                continue;
+            }
+            throw error;
+        }
+        parseCommandWords(words, segment, depth, state);
+    }
+}
 export function parseMergeCommands(command) {
-    const targets = splitCommandChain(command)
-        .map(parseSegment)
-        .filter((target) => target !== null);
+    const state = { targets: [], unparseableMerge: false };
+    parseCommandList(command, 0, state);
     return {
-        targets,
-        unresolved: targets.some((target) => target.unresolvedReason !== null),
+        targets: state.targets,
+        unresolved: state.targets.some((target) => target.unresolvedReason !== null),
+        unparseableMerge: state.unparseableMerge,
     };
 }
 //# sourceMappingURL=merge-command.js.map

package/dist/lib/lanes/orphans.d.ts

@@ -1,5 +1,6 @@
 import { type LaneRecord, type SeniorRef } from "./types.js";
 export declare const DEFAULT_ORPHAN_MIN_AGE_MINUTES = 30;
+export declare const DEFAULT_ORPHAN_USER_IDLE_HOURS = 72;
 export interface OrphanLaneFinding {
     lane_id: string;
     senior: SeniorRef;
@@ -7,12 +8,18 @@ export interface OrphanLaneFinding {
     age_minutes: number;
     account: string | null;
     host: LaneRecord["host"];
+    reason: "senior_ended" | "senior_missing" | "user_idle";
 }
 export declare function parseOrphanMinAge(value: string | undefined): number;
+export declare function parseOrphanUserIdleHours(value: string | undefined): number;
 export declare function findOrphanLanes(input: {
     lanes: readonly LaneRecord[];
+    candidateLaneIds: ReadonlySet<string>;
     now: Date;
     minAgeMinutes: number;
+    userIdleHours: number;
     sessionState: (sessionId: string, now: Date) => string | null;
+    lastActivityAt: (lane: LaneRecord) => number;
+    hasOpenStory: (lane: LaneRecord) => boolean;
 }): OrphanLaneFinding[];
 //# sourceMappingURL=orphans.d.ts.map

package/dist/lib/lanes/orphans.js

@@ -1,6 +1,7 @@
 import { LanesError } from "./errors.js";
 import { isTerminalLaneState } from "./types.js";
 export const DEFAULT_ORPHAN_MIN_AGE_MINUTES = 30;
+export const DEFAULT_ORPHAN_USER_IDLE_HOURS = 72;
 const LIVE_LANE_STATES = new Set(["running", "queued", "blocked", "awaiting_input"]);
 export function parseOrphanMinAge(value) {
     if (value === undefined)
@@ -14,6 +15,18 @@ export function parseOrphanMinAge(value) {
     }
     return minutes;
 }
+export function parseOrphanUserIdleHours(value) {
+    if (value === undefined)
+        return DEFAULT_ORPHAN_USER_IDLE_HOURS;
+    if (!/^(0|[1-9]\d*)$/.test(value)) {
+        throw new LanesError("orphan_user_idle_hours_invalid", "User-senior idle hours must be a non-negative whole number", { value });
+    }
+    const hours = Number(value);
+    if (!Number.isSafeInteger(hours) || hours > Math.floor(Number.MAX_SAFE_INTEGER / 3_600_000)) {
+        throw new LanesError("orphan_user_idle_hours_invalid", "User-senior idle hours are outside the supported range", { value });
+    }
+    return hours;
+}
 export function findOrphanLanes(input) {
     const nowMs = input.now.getTime();
     if (!Number.isFinite(nowMs)) {
@@ -21,12 +34,24 @@ export function findOrphanLanes(input) {
     }
     const byId = new Map(input.lanes.map((lane) => [lane.lane_id, lane]));
     const minAgeMs = input.minAgeMinutes * 60_000;
+    const userIdleMs = input.userIdleHours * 3_600_000;
     const findings = [];
     for (const lane of input.lanes) {
+        if (!input.candidateLaneIds.has(lane.lane_id))
+            continue;
         if (!LIVE_LANE_STATES.has(lane.state))
             continue;
-        if (lane.keep_alive_standing === true || lane.senior.kind === "user")
+        if (lane.keep_alive_standing === true)
             continue;
+        let userLastActivity;
+        if (lane.senior.kind === "user") {
+            userLastActivity = input.lastActivityAt(lane);
+            if (!Number.isFinite(userLastActivity)) {
+                throw new LanesError("orphan_lane_timestamp_invalid", `Lane ${lane.lane_id} has an invalid last activity timestamp`, { lane_id: lane.lane_id, field: "last_activity" });
+            }
+            if (userLastActivity > nowMs || nowMs - userLastActivity < userIdleMs || input.hasOpenStory(lane))
+                continue;
+        }
         const createdAt = Date.parse(lane.created_at);
         if (!Number.isFinite(createdAt)) {
             throw new LanesError("orphan_lane_timestamp_invalid", `Lane ${lane.lane_id} has an invalid created_at timestamp`, { lane_id: lane.lane_id, field: "created_at" });
@@ -38,20 +63,29 @@ export function findOrphanLanes(input) {
         if (ageMs < minAgeMs)
             continue;
         let seniorState;
-        if (lane.senior.kind === "lane") {
+        let reason;
+        if (lane.senior.kind === "user") {
+            seniorState = "user_idle";
+            reason = "user_idle";
+        }
+        else if (lane.senior.kind === "lane") {
             const senior = byId.get(lane.senior.id ?? "");
             if (!senior) {
                 seniorState = "missing";
+                reason = "senior_missing";
             }
             else if (isTerminalLaneState(senior.state)) {
                 seniorState = senior.state;
+                reason = "senior_ended";
             }
         }
         else if (lane.senior.kind === "session" && lane.senior.id !== undefined) {
-            if (input.sessionState(lane.senior.id, input.now) === "ended")
+            if (input.sessionState(lane.senior.id, input.now) === "ended") {
                 seniorState = "ended";
+                reason = "senior_ended";
+            }
         }
-        if (seniorState === undefined)
+        if (seniorState === undefined || reason === undefined)
             continue;
         findings.push({
             lane_id: lane.lane_id,
@@ -60,6 +94,7 @@ export function findOrphanLanes(input) {
             age_minutes: Math.floor(ageMs / 60_000),
             account: lane.account ?? null,
             host: { ...lane.host },
+            reason,
         });
     }
     return findings.sort((a, b) => b.age_minutes - a.age_minutes || a.lane_id.localeCompare(b.lane_id));

package/dist/lib/lanes/tracker-store.d.ts

@@ -10,25 +10,9 @@ export interface TrackerRecord {
     updated_at: string;
     [key: string]: unknown;
 }
-export interface TrackerRecordInput {
-    kind: TrackerKind;
-    id?: string;
-    company: string;
-    project_id: string;
-    [key: string]: unknown;
-}
-export type StoreValue<T> = T | Promise<T>;
-export interface TrackerStore {
-    read(kind: TrackerKind, id: string): StoreValue<TrackerRecord | null>;
-    list(kind: TrackerKind): StoreValue<TrackerRecord[]>;
-    create(record: TrackerRecordInput): StoreValue<TrackerRecord>;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): StoreValue<TrackerRecord>;
-}
-export interface LocalTrackerStore extends TrackerStore {
+export interface LocalTrackerStore {
     read(kind: TrackerKind, id: string): TrackerRecord | null;
     list(kind: TrackerKind): TrackerRecord[];
-    create(record: TrackerRecordInput): TrackerRecord;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): TrackerRecord;
 }
-export declare function createLocalTrackerStore(projectDirectory: string, now?: () => Date): LocalTrackerStore;
+export declare function createLocalTrackerStore(projectDirectory: string): LocalTrackerStore;
 //# sourceMappingURL=tracker-store.d.ts.map