@indigoai-us/hq-cli 5.345.54 → 5.345.56

package/dist/lib/import-scan/run.js

@@ -0,0 +1,308 @@
+/**
+ * Runs the HQ import-context scanner with `--progress-json` and relays its
+ * JSON Lines event stream (contract: ./events.ts).
+ *
+ * The scanner is the HQ tree's own copy at
+ * `<hq root>/.claude/skills/import-context/scan.sh`, the same place the
+ * /import-context skill runs it from. The scan is local only: the scanner
+ * reads the filesystem and writes one report.json; nothing here touches the
+ * network.
+ *
+ * HQ root: `--hq-root` when given, else the root the HQ installer recorded in
+ * `~/.hq/menubar.json` (`hqPath`). Nothing else is trusted: no walk up from
+ * the current folder and no `$HQ_ROOT`, because this command runs a script
+ * from that tree.
+ *
+ * Output modes:
+ *   stream  every valid event, rebuilt from its v1 fields (invalid lines are
+ *           dropped with a warning on stderr that never echoes the line)
+ *   final   only the final `done` object
+ *   human   short progress lines and a summary
+ *
+ * The `done` event is held until the scanner exits. When the scan cannot run
+ * or does not finish cleanly (HQ not found, scanner missing or too old,
+ * scanner exited non-zero or without `done`, cancelled), an `error` event
+ * (source "scanner") comes first, then `done` (zeroed with `report: null`
+ * unless the scanner produced one), and the command exits non-zero.
+ *
+ * Process handling: the scanner runs in its own process group. SIGINT/SIGTERM
+ * to hq-cli are forwarded to the whole group and escalated to SIGKILL after
+ * `killTimeoutMs`. When the scanner exits, anything still left in its group
+ * is terminated so an orphan holding stdout open cannot stall the command.
+ *
+ * Scanner stderr is not forwarded verbatim: each line is passed through with
+ * paths and token-like strings replaced, at most MAX_STDERR_LINES lines, then
+ * a count of the rest.
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { SCAN_CLI_ERROR_SOURCE, SCAN_EVENT_VERSION, } from "./events.js";
+import { parseScanEventLine } from "./validate.js";
+export const SCANNER_RELATIVE_PATH = path.join(".claude", "skills", "import-context", "scan.sh");
+const MAX_STDERR_LINES = 20;
+const DEFAULT_KILL_TIMEOUT_MS = 5000;
+const DRAIN_TIMEOUT_MS = 2000;
+/** UTC scan id in the /import-context skill's format: YYYYMMDDTHHMMSSZ. */
+export function scanId(date) {
+    return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+export class HqRootError extends Error {
+}
+/**
+ * --hq-root, else the installer-recorded root in ~/.hq/menubar.json. Throws
+ * HqRootError with a plain-words message otherwise.
+ */
+export function resolveScanHqRoot(opts) {
+    if (opts.hqRoot) {
+        const root = path.resolve(opts.hqRoot);
+        if (!isDirectory(root))
+            throw new HqRootError("The folder given with --hq-root does not exist.");
+        return root;
+    }
+    const menubar = path.join(opts.home ?? os.homedir(), ".hq", "menubar.json");
+    let recorded;
+    try {
+        recorded = JSON.parse(fs.readFileSync(menubar, "utf8")).hqPath;
+    }
+    catch {
+        recorded = undefined;
+    }
+    if (typeof recorded !== "string" || !path.isAbsolute(recorded) || !isDirectory(recorded)) {
+        throw new HqRootError("Could not find your HQ folder. Pass --hq-root <path>, or open the HQ app once so it records where HQ is installed.");
+    }
+    return path.resolve(recorded);
+}
+function isDirectory(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Replace paths and token-like strings in one scanner stderr line. A path
+ * runs from its first "/" (or a leading ~ / $HOME) to the next quote or the
+ * end of the line, because folder names may contain spaces: stopping at
+ * whitespace would leak the rest of "/Users/x/My Project/secret".
+ */
+export function redactScannerLine(line) {
+    return line
+        .replace(/(?<![^\s'"`=:([])(?:\$HOME|~)?\/[^'"`]*/g, "<path>")
+        .replace(/\b[A-Za-z0-9_+=-]{24,}\b/g, "<redacted>")
+        .replace(/\S+@\S+/g, "<redacted>")
+        .slice(0, 300);
+}
+function zeroDone() {
+    return {
+        v: SCAN_EVENT_VERSION,
+        type: "done",
+        report: null,
+        summary: { companies: 0, projects: 0, sessions: 0 },
+    };
+}
+function cliError(message, code) {
+    return { v: SCAN_EVENT_VERSION, type: "error", source: SCAN_CLI_ERROR_SOURCE, message, code };
+}
+const failed = (message) => ({ message, code: "scan_failed" });
+const outdated = (message) => ({ message, code: "scanner_outdated" });
+function humanLine(event, labels) {
+    switch (event.type) {
+        case "source": {
+            const label = labels.get(event.id) ?? event.id;
+            if (event.status === "scanning")
+                return `Scanning ${label}...`;
+            if (event.status === "done") {
+                const parts = Object.entries(event.counts ?? {})
+                    .filter(([, n]) => n > 0)
+                    .map(([k, n]) => `${n} ${k.replace(/_/g, " ")}`);
+                return `  ${label}: ${parts.length ? parts.join(", ") : "nothing found"}`;
+            }
+            return `  ${label}: ${event.status}${event.message ? ` - ${event.message}` : ""}`;
+        }
+        case "company":
+            return `  company: ${event.name}`;
+        case "error":
+            return `  warning: ${event.message}`;
+        case "done":
+            return (`Found ${event.summary.companies} companies, ${event.summary.projects} projects, ` +
+                `${event.summary.sessions} sessions.` + (event.report ? `\nReport: ${event.report}` : ""));
+        default:
+            return undefined;
+    }
+}
+function signalGroup(child, signal) {
+    if (child.pid === undefined)
+        return;
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch {
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // already gone
+        }
+    }
+}
+/** Run the scan. Resolves to the process exit code. */
+export async function runImportScan(opts, io) {
+    const labels = new Map();
+    const write = (event) => {
+        if (event.type === "start")
+            for (const s of event.sources)
+                labels.set(s.id, s.label);
+        if (opts.mode === "stream") {
+            io.stdout.write(`${JSON.stringify(event)}\n`);
+        }
+        else if (opts.mode === "human") {
+            const line = humanLine(event, labels);
+            if (line)
+                io.stdout.write(`${line}\n`);
+        }
+    };
+    const finish = (done, error, code = 1) => {
+        if (error)
+            write(cliError(error.message, error.code));
+        write(done);
+        if (opts.mode === "final")
+            io.stdout.write(`${JSON.stringify(done)}\n`);
+        return error ? code : 0;
+    };
+    let hqRoot;
+    try {
+        hqRoot = resolveScanHqRoot({ hqRoot: opts.hqRoot, home: opts.home });
+    }
+    catch (err) {
+        return finish(zeroDone(), failed(err instanceof HqRootError ? err.message : "Could not find your HQ folder."));
+    }
+    const scanner = path.join(hqRoot, SCANNER_RELATIVE_PATH);
+    if (!fs.existsSync(scanner)) {
+        return finish(zeroDone(), outdated("The import-context scanner is not installed in this HQ. Update HQ and try again."));
+    }
+    const output = path.resolve(opts.output ??
+        path.join(hqRoot, "workspace", "imports", scanId((opts.now ?? (() => new Date()))()), "report.json"));
+    const args = [scanner, `--hq-root=${hqRoot}`, `--output=${output}`, "--progress-json"];
+    for (const scope of opts.scopes ?? [])
+        args.push(`--scope=${scope}`);
+    if (opts.claudeExport)
+        args.push(`--claude-export=${opts.claudeExport}`);
+    if (opts.noDefaultScopes)
+        args.push("--no-default-scopes");
+    const child = spawn(opts.bash ?? "bash", args, {
+        cwd: hqRoot,
+        env: opts.env ?? process.env,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: true,
+    });
+    // Signal forwarding to the whole scanner process group, with escalation.
+    let cancelledBy;
+    let killTimer;
+    const onSignal = (signal) => {
+        if (!cancelledBy)
+            cancelledBy = signal;
+        signalGroup(child, signal);
+        if (!killTimer) {
+            killTimer = setTimeout(() => signalGroup(child, "SIGKILL"), opts.killTimeoutMs ?? DEFAULT_KILL_TIMEOUT_MS);
+            killTimer.unref();
+        }
+    };
+    const onInt = () => onSignal("SIGINT");
+    const onTerm = () => onSignal("SIGTERM");
+    process.on("SIGINT", onInt);
+    process.on("SIGTERM", onTerm);
+    opts.abortSignal?.addEventListener("abort", onTerm, { once: true });
+    // Scanner stderr: redacted, capped.
+    let stderrTail = "";
+    let stderrShown = 0;
+    let stderrHidden = 0;
+    const errLines = readline.createInterface({ input: child.stderr, crlfDelay: Infinity });
+    errLines.on("line", (line) => {
+        stderrTail = (stderrTail + line + "\n").slice(-4096);
+        if (!line.trim())
+            return;
+        if (stderrShown < MAX_STDERR_LINES) {
+            stderrShown += 1;
+            io.stderr.write(`hq import scan: scanner: ${redactScannerLine(line)}\n`);
+        }
+        else {
+            stderrHidden += 1;
+        }
+    });
+    let lineNo = 0;
+    let dropped = 0;
+    let heldDone;
+    const lines = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+    const consumed = (async () => {
+        for await (const raw of lines) {
+            lineNo += 1;
+            const line = raw.trim();
+            if (!line)
+                continue;
+            if (heldDone) {
+                dropped += 1;
+                io.stderr.write(`hq import scan: dropped scan event on line ${lineNo}: received after done\n`);
+                continue;
+            }
+            const parsed = parseScanEventLine(line);
+            if (!parsed.ok) {
+                dropped += 1;
+                io.stderr.write(`hq import scan: dropped scan event on line ${lineNo}: ${parsed.reason}\n`);
+                continue;
+            }
+            if (parsed.event.type === "done")
+                heldDone = parsed.event;
+            else
+                write(parsed.event);
+        }
+    })();
+    const exit = await new Promise((resolve) => {
+        child.once("error", (error) => resolve({ code: null, signal: null, error }));
+        child.once("exit", (code, signal) => resolve({ code, signal }));
+    });
+    // The scanner is gone; stop anything it left behind so stdout can close.
+    signalGroup(child, "SIGTERM");
+    const drained = await Promise.race([
+        consumed.then(() => true),
+        new Promise((r) => setTimeout(() => r(false), DRAIN_TIMEOUT_MS).unref()),
+    ]);
+    if (!drained) {
+        signalGroup(child, "SIGKILL");
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+        lines.close();
+    }
+    errLines.close();
+    if (killTimer)
+        clearTimeout(killTimer);
+    process.removeListener("SIGINT", onInt);
+    process.removeListener("SIGTERM", onTerm);
+    opts.abortSignal?.removeEventListener("abort", onTerm);
+    if (stderrHidden > 0) {
+        io.stderr.write(`hq import scan: ${stderrHidden} more scanner diagnostic line(s) not shown\n`);
+    }
+    if (dropped > 0 && opts.mode !== "stream") {
+        io.stderr.write(`hq import scan: ${dropped} invalid scan event(s) were dropped\n`);
+    }
+    if (exit.error) {
+        return finish(zeroDone(), failed("The scanner could not be started."));
+    }
+    if (cancelledBy) {
+        return finish(heldDone ?? zeroDone(), failed("The scan was cancelled."), cancelledBy === "SIGINT" ? 130 : 143);
+    }
+    if (!heldDone) {
+        if (exit.code === 2 && /unknown arg: --progress-json/.test(stderrTail)) {
+            return finish(zeroDone(), outdated("The installed import-context scanner does not support streaming. Update HQ and try again."));
+        }
+        return finish(zeroDone(), failed(`The scan stopped before it finished (scanner exit ${exit.code ?? exit.signal ?? "unknown"}).`));
+    }
+    if (exit.code !== 0) {
+        return finish(heldDone, failed(`The scanner reported a problem after finishing (exit ${exit.code ?? exit.signal ?? "unknown"}).`));
+    }
+    return finish(heldDone);
+}
+//# sourceMappingURL=run.js.map

package/dist/lib/import-scan/scan-event.schema.json

@@ -0,0 +1,127 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://hq.computer/schemas/import-scan/scan-event.v1.schema.json",
+  "title": "HQ import scan event (v1)",
+  "description": "One line of `hq import scan --json --stream` / `scan.sh --progress-json`. Each type is also addressable as #/$defs/<type>. Unknown extra fields are allowed within v1; hq-cli forwards only the fields listed here.",
+  "type": "object",
+  "required": ["v", "type"],
+  "properties": {
+    "v": { "const": 1 },
+    "type": { "enum": ["start", "source", "count", "company", "project", "error", "done"] }
+  },
+  "oneOf": [
+    { "$ref": "#/$defs/start" },
+    { "$ref": "#/$defs/source" },
+    { "$ref": "#/$defs/nonNegative" },
+    { "$ref": "#/$defs/company" },
+    { "$ref": "#/$defs/project" },
+    { "$ref": "#/$defs/error" },
+    { "$ref": "#/$defs/done" }
+  ],
+  "$defs": {
+    "name": { "type": "string", "minLength": 1, "maxLength": 512 },
+    "nonNegative": { "type": "integer", "minimum": 0 },
+    "baseName": {
+      "description": "A folder or repository basename: a name without \"/\".",
+      "allOf": [{ "$ref": "#/$defs/name" }, { "pattern": "^[^/]+$" }]
+    },
+    "start": {
+      "type": "object",
+      "required": ["v", "type", "sources"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "start" },
+        "sources": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["id", "label"],
+            "properties": {
+              "id": { "$ref": "#/$defs/name" },
+              "label": { "$ref": "#/$defs/name" }
+            }
+          }
+        }
+      }
+    },
+    "source": {
+      "type": "object",
+      "required": ["v", "type", "id", "status"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "source" },
+        "id": { "$ref": "#/$defs/name" },
+        "status": { "enum": ["scanning", "done", "skipped", "error"] },
+        "counts": {
+          "type": "object",
+          "propertyNames": { "pattern": "^[a-z0-9_-]{1,64}$" },
+          "additionalProperties": { "$ref": "#/$defs/nonNegative" }
+        },
+        "message": { "type": "string", "maxLength": 2000 }
+      }
+    },
+    "count": {
+      "type": "object",
+      "required": ["v", "type", "source", "key", "value"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "count" },
+        "source": { "$ref": "#/$defs/name" },
+        "key": { "type": "string", "pattern": "^[a-z0-9_-]{1,64}$" },
+        "value": { "$ref": "#/$defs/nonNegative" }
+      }
+    },
+    "company": {
+      "type": "object",
+      "required": ["v", "type", "id", "name", "basis"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "company" },
+        "id": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$", "maxLength": 128 },
+        "name": { "$ref": "#/$defs/name" },
+        "basis": { "enum": ["hq-company", "repo-org", "folder"] }
+      }
+    },
+    "project": {
+      "type": "object",
+      "required": ["v", "type", "id", "name", "company", "basis"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "project" },
+        "id": { "type": "string", "pattern": "^p_[0-9a-f]{12}$" },
+        "name": { "$ref": "#/$defs/baseName" },
+        "company": { "type": ["string", "null"] },
+        "basis": { "enum": ["repo", "claude-code-cwd", "codex-cwd"] }
+      }
+    },
+    "error": {
+      "type": "object",
+      "required": ["v", "type", "source", "message"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "error" },
+        "source": { "$ref": "#/$defs/name" },
+        "message": { "type": "string", "minLength": 1, "maxLength": 2000 },
+        "code": { "enum": ["scanner_outdated", "scan_failed"] }
+      }
+    },
+    "done": {
+      "type": "object",
+      "required": ["v", "type", "report", "summary"],
+      "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "done" },
+        "report": { "type": ["string", "null"] },
+        "summary": {
+          "type": "object",
+          "required": ["companies", "projects", "sessions"],
+          "properties": {
+            "companies": { "$ref": "#/$defs/nonNegative" },
+            "projects": { "$ref": "#/$defs/nonNegative" },
+            "sessions": { "$ref": "#/$defs/nonNegative" }
+          }
+        }
+      }
+    }
+  }
+}

package/dist/lib/import-scan/validate.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Validates one line of the import-scan event stream against
+ * `scan-event.schema.json` (Ajv, draft 2020-12) and rebuilds the event from
+ * the v1 fields only.
+ *
+ * Validation dispatches on `type`: the common envelope is checked first, then
+ * the line is validated against `#/$defs/<type>` alone, so a drop reason names
+ * the real problem instead of the first failing `oneOf` branch.
+ *
+ * Failure reasons name the type, the schema path and Ajv's generic message
+ * only. They never echo values from the line, so a malformed event that
+ * happens to carry content cannot leak through the warning hq-cli prints.
+ */
+import { type ScanEvent } from "./events.js";
+export declare const SCAN_EVENT_SCHEMA_PATH: string;
+export type ParsedScanLine = {
+    ok: true;
+    event: ScanEvent;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Parse and validate one JSON Lines record. */
+export declare function parseScanEventLine(line: string): ParsedScanLine;
+export declare function validateScanEvent(value: unknown): ParsedScanLine;
+/**
+ * Rebuild an already-validated event from the v1 fields only, so fields a
+ * scanner adds (or smuggles) never reach stdout.
+ */
+export declare function pickScanEvent(event: ScanEvent): ScanEvent;
+//# sourceMappingURL=validate.d.ts.map

package/dist/lib/import-scan/validate.js

@@ -0,0 +1,111 @@
+/**
+ * Validates one line of the import-scan event stream against
+ * `scan-event.schema.json` (Ajv, draft 2020-12) and rebuilds the event from
+ * the v1 fields only.
+ *
+ * Validation dispatches on `type`: the common envelope is checked first, then
+ * the line is validated against `#/$defs/<type>` alone, so a drop reason names
+ * the real problem instead of the first failing `oneOf` branch.
+ *
+ * Failure reasons name the type, the schema path and Ajv's generic message
+ * only. They never echo values from the line, so a malformed event that
+ * happens to carry content cannot leak through the warning hq-cli prints.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import Ajv2020 from "ajv/dist/2020.js";
+import { SCAN_EVENT_TYPES, SCAN_EVENT_VERSION } from "./events.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const SCAN_EVENT_SCHEMA_PATH = join(HERE, "scan-event.schema.json");
+let validators;
+function getValidators() {
+    if (validators)
+        return validators;
+    const schema = JSON.parse(readFileSync(SCAN_EVENT_SCHEMA_PATH, "utf8"));
+    const ajv = new Ajv2020({ allErrors: false, strict: false, validateFormats: false });
+    ajv.addSchema(schema);
+    const map = new Map();
+    for (const type of SCAN_EVENT_TYPES) {
+        const fn = ajv.getSchema(`${schema.$id}#/$defs/${type}`);
+        if (!fn)
+            throw new Error(`scan-event schema has no $defs/${type}`);
+        map.set(type, fn);
+    }
+    validators = map;
+    return map;
+}
+/** Parse and validate one JSON Lines record. */
+export function parseScanEventLine(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return { ok: false, reason: "not valid JSON" };
+    }
+    return validateScanEvent(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function validateScanEvent(value) {
+    if (!isRecord(value))
+        return { ok: false, reason: "not a JSON object" };
+    if (value.v !== SCAN_EVENT_VERSION)
+        return { ok: false, reason: "missing or unsupported version (v)" };
+    const type = value.type;
+    if (typeof type !== "string" || !SCAN_EVENT_TYPES.includes(type)) {
+        return { ok: false, reason: "missing or unknown event type" };
+    }
+    const validate = getValidators().get(type);
+    if (!validate(value)) {
+        const first = validate.errors?.[0];
+        const where = first ? `${first.instancePath || "/"} ${first.message ?? first.keyword}` : "schema";
+        return { ok: false, reason: `event "${type}" does not match the v1 schema (${where})` };
+    }
+    return { ok: true, event: pickScanEvent(value) };
+}
+/**
+ * Rebuild an already-validated event from the v1 fields only, so fields a
+ * scanner adds (or smuggles) never reach stdout.
+ */
+export function pickScanEvent(event) {
+    const v = SCAN_EVENT_VERSION;
+    switch (event.type) {
+        case "start":
+            return { v, type: "start", sources: event.sources.map((s) => ({ id: s.id, label: s.label })) };
+        case "source": {
+            const out = { v, type: "source", id: event.id, status: event.status };
+            if (event.counts)
+                out.counts = Object.fromEntries(Object.entries(event.counts));
+            if (event.message !== undefined)
+                out.message = event.message;
+            return out;
+        }
+        case "count":
+            return { v, type: "count", source: event.source, key: event.key, value: event.value };
+        case "company":
+            return { v, type: "company", id: event.id, name: event.name, basis: event.basis };
+        case "project":
+            return { v, type: "project", id: event.id, name: event.name, company: event.company, basis: event.basis };
+        case "error": {
+            const out = { v, type: "error", source: event.source, message: event.message };
+            if (event.code !== undefined)
+                out.code = event.code;
+            return out;
+        }
+        case "done":
+            return {
+                v,
+                type: "done",
+                report: event.report,
+                summary: {
+                    companies: event.summary.companies,
+                    projects: event.summary.projects,
+                    sessions: event.summary.sessions,
+                },
+            };
+    }
+}
+//# sourceMappingURL=validate.js.map

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

@@ -53,12 +53,14 @@ export interface DrainDeps {
 }
 export interface LaneDrainHookInput {
     transcript_path?: string | null;
-    session_id?: string;
     hook_event_name?: string;
+    hookEventName?: string;
+    session_id?: string;
 }
 export interface RunDrainHookDeps {
     readLane?: typeof tryReadLane;
     probeCompactionsSince?: typeof import("./compaction.js").probeProviderCompactionsSince;
+    readLifecycleDeliveryFlag?: () => Promise<boolean>;
 }
 export declare function mintClaimId(): string;
 export declare function assertSafeLaneId(laneId: string): void;
@@ -102,7 +104,7 @@ export declare function formatOperatorInstruction(messages: DropboxMessage[]): s
 export declare function formatMonitorEvent(message: DropboxMessage): string;
 /** Keep event order while framing monitor output separately from operator messages. */
 export declare function formatDropboxMessages(messages: DropboxMessage[]): string;
-export declare function hookAdditionalContextJson(messages: DropboxMessage[], hookEventName?: "PreToolUse" | "UserPromptSubmit", leadingNote?: string): string;
+export declare function hookAdditionalContextJson(messages: DropboxMessage[], hookEventName?: "PreToolUse" | "PostToolUse" | "UserPromptSubmit", leadingNote?: string): string;
 export interface DrainHookResult {
     exitCode: number;
     stdout: string;