@indigoai-us/hq-cli 5.345.53 → 5.345.55

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

@@ -0,0 +1,135 @@
+/**
+ * Streaming context-scan events (contract v1).
+ *
+ * `hq import scan --json --stream` relays these as JSON Lines, one object per
+ * line. They are produced by the HQ import-context scanner
+ * (`.claude/skills/import-context/scan.sh --progress-json` in an HQ tree) and
+ * validated here before they reach stdout. The HQ desktop first-run setup
+ * renders them as a knowledge tree that grows while the scan runs.
+ *
+ * The canonical contract lives next to the scanner
+ * (`.claude/skills/import-context/progress-json.md` in hq-core) and in
+ * `docs/import-scan-stream.md` in this repo. The JSON Schema is
+ * `scan-event.schema.json` in this directory (shipped next to the compiled
+ * module as `dist/lib/import-scan/scan-event.schema.json`).
+ *
+ * Desktop consumers can import these types from
+ * `@indigoai-us/hq-cli/dist/lib/import-scan/events.js` or mirror them.
+ *
+ * Versioning: within v1, fields, source ids, count keys and messages may be
+ * added. Consumers ignore unknown fields and must not parse message text.
+ * Removing or retyping a field, or adding a new `type`, `status` or `basis`
+ * value, bumps `v`.
+ */
+export declare const SCAN_EVENT_VERSION: 1;
+/** Event types, in the order a stream introduces them. */
+export declare const SCAN_EVENT_TYPES: readonly ["start", "source", "count", "company", "project", "error", "done"];
+export type ScanEventType = (typeof SCAN_EVENT_TYPES)[number];
+export declare const SCAN_SOURCE_STATUSES: readonly ["scanning", "done", "skipped", "error"];
+export type ScanSourceStatus = (typeof SCAN_SOURCE_STATUSES)[number];
+export declare const SCAN_COMPANY_BASES: readonly ["hq-company", "repo-org", "folder"];
+export type ScanCompanyBasis = (typeof SCAN_COMPANY_BASES)[number];
+export declare const SCAN_PROJECT_BASES: readonly ["repo", "claude-code-cwd", "codex-cwd"];
+export type ScanProjectBasis = (typeof SCAN_PROJECT_BASES)[number];
+/**
+ * Source ids the v1 scanner emits, in scan order. Other ids may appear in
+ * later v1 scanners; show them by their `label`.
+ */
+export declare const KNOWN_SCAN_SOURCE_IDS: readonly ["hq", "repos", "claude-code", "codex", "grok", "claude-ai", "artifacts"];
+export type KnownScanSourceId = (typeof KNOWN_SCAN_SOURCE_IDS)[number];
+/**
+ * Source id used on `error` events that hq-cli itself emits (HQ not found,
+ * scanner missing or too old, scanner crashed). Never listed in `start`.
+ */
+export declare const SCAN_CLI_ERROR_SOURCE: "scanner";
+/**
+ * Stable machine-readable codes on `error` events. hq-cli sets one on every
+ * error it emits itself (source "scanner"); scanner-emitted errors may omit it.
+ *
+ *   scanner_outdated  the HQ tree's scanner is missing or predates
+ *                     --progress-json; updating HQ fixes it
+ *   scan_failed       any other reason the scan could not run or finish
+ *                     (HQ not found, scanner crashed, cancelled, non-zero exit)
+ *
+ * Consumers branch on `code`, never on `message`. Treat an error without a
+ * code as non-fatal unless the stream ends with `report: null`.
+ */
+export declare const SCAN_ERROR_CODES: readonly ["scanner_outdated", "scan_failed"];
+export type ScanErrorCode = (typeof SCAN_ERROR_CODES)[number];
+/** Project ids: "p_" + 12 lowercase hex (pid() in scan-progress.sh). */
+export declare const SCAN_PROJECT_ID_PATTERN: RegExp;
+export interface ScanSourceInfo {
+    id: string;
+    label: string;
+}
+interface ScanEventBase {
+    v: typeof SCAN_EVENT_VERSION;
+}
+/** First line: the sources present on this machine, in scan order. */
+export interface ScanStartEvent extends ScanEventBase {
+    type: "start";
+    sources: ScanSourceInfo[];
+}
+/** Source lifecycle: `scanning` once, then one of done/skipped/error. */
+export interface ScanSourceEvent extends ScanEventBase {
+    type: "source";
+    id: string;
+    status: ScanSourceStatus;
+    /** Final counts, on `done`. Each value repeats the last `count` event for that key. */
+    counts?: Record<string, number>;
+    /** Plain-words reason, on `skipped` and `error`. */
+    message?: string;
+}
+/** Running count; fires at 1-2-5 milestones and once with the final value. */
+export interface ScanCountEvent extends ScanEventBase {
+    type: "count";
+    source: string;
+    key: string;
+    value: number;
+}
+/** A company from the deterministic rule pass. Emitted once per id. */
+export interface ScanCompanyEvent extends ScanEventBase {
+    type: "company";
+    id: string;
+    name: string;
+    basis: ScanCompanyBasis;
+}
+/**
+ * A project. Upsert by `id`: an id repeats only when a later rule pass
+ * attaches a company to a project that had `company: null`.
+ */
+export interface ScanProjectEvent extends ScanEventBase {
+    type: "project";
+    /** "p_" + 12 lowercase hex, the same for the same project on any machine. */
+    id: string;
+    /** Folder or repository basename; never contains "/". */
+    name: string;
+    company: string | null;
+    basis: ScanProjectBasis;
+}
+/** Non-fatal problem, in plain words. */
+export interface ScanErrorEvent extends ScanEventBase {
+    type: "error";
+    source: string;
+    message: string;
+    /** Stable code (SCAN_ERROR_CODES). Always set on hq-cli's own errors. */
+    code?: ScanErrorCode;
+}
+export interface ScanSummary {
+    companies: number;
+    projects: number;
+    sessions: number;
+}
+/**
+ * Last line. `report` is the absolute path of report.json, or `null` when
+ * hq-cli could not run the scan (then `summary` is all zeros and the command
+ * exits non-zero).
+ */
+export interface ScanDoneEvent extends ScanEventBase {
+    type: "done";
+    report: string | null;
+    summary: ScanSummary;
+}
+export type ScanEvent = ScanStartEvent | ScanSourceEvent | ScanCountEvent | ScanCompanyEvent | ScanProjectEvent | ScanErrorEvent | ScanDoneEvent;
+export {};
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1,71 @@
+/**
+ * Streaming context-scan events (contract v1).
+ *
+ * `hq import scan --json --stream` relays these as JSON Lines, one object per
+ * line. They are produced by the HQ import-context scanner
+ * (`.claude/skills/import-context/scan.sh --progress-json` in an HQ tree) and
+ * validated here before they reach stdout. The HQ desktop first-run setup
+ * renders them as a knowledge tree that grows while the scan runs.
+ *
+ * The canonical contract lives next to the scanner
+ * (`.claude/skills/import-context/progress-json.md` in hq-core) and in
+ * `docs/import-scan-stream.md` in this repo. The JSON Schema is
+ * `scan-event.schema.json` in this directory (shipped next to the compiled
+ * module as `dist/lib/import-scan/scan-event.schema.json`).
+ *
+ * Desktop consumers can import these types from
+ * `@indigoai-us/hq-cli/dist/lib/import-scan/events.js` or mirror them.
+ *
+ * Versioning: within v1, fields, source ids, count keys and messages may be
+ * added. Consumers ignore unknown fields and must not parse message text.
+ * Removing or retyping a field, or adding a new `type`, `status` or `basis`
+ * value, bumps `v`.
+ */
+export const SCAN_EVENT_VERSION = 1;
+/** Event types, in the order a stream introduces them. */
+export const SCAN_EVENT_TYPES = [
+    "start",
+    "source",
+    "count",
+    "company",
+    "project",
+    "error",
+    "done",
+];
+export const SCAN_SOURCE_STATUSES = ["scanning", "done", "skipped", "error"];
+export const SCAN_COMPANY_BASES = ["hq-company", "repo-org", "folder"];
+export const SCAN_PROJECT_BASES = ["repo", "claude-code-cwd", "codex-cwd"];
+/**
+ * Source ids the v1 scanner emits, in scan order. Other ids may appear in
+ * later v1 scanners; show them by their `label`.
+ */
+export const KNOWN_SCAN_SOURCE_IDS = [
+    "hq",
+    "repos",
+    "claude-code",
+    "codex",
+    "grok",
+    "claude-ai",
+    "artifacts",
+];
+/**
+ * Source id used on `error` events that hq-cli itself emits (HQ not found,
+ * scanner missing or too old, scanner crashed). Never listed in `start`.
+ */
+export const SCAN_CLI_ERROR_SOURCE = "scanner";
+/**
+ * Stable machine-readable codes on `error` events. hq-cli sets one on every
+ * error it emits itself (source "scanner"); scanner-emitted errors may omit it.
+ *
+ *   scanner_outdated  the HQ tree's scanner is missing or predates
+ *                     --progress-json; updating HQ fixes it
+ *   scan_failed       any other reason the scan could not run or finish
+ *                     (HQ not found, scanner crashed, cancelled, non-zero exit)
+ *
+ * Consumers branch on `code`, never on `message`. Treat an error without a
+ * code as non-fatal unless the stream ends with `report: null`.
+ */
+export const SCAN_ERROR_CODES = ["scanner_outdated", "scan_failed"];
+/** Project ids: "p_" + 12 lowercase hex (pid() in scan-progress.sh). */
+export const SCAN_PROJECT_ID_PATTERN = /^p_[0-9a-f]{12}$/;
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ */
+export declare const SCANNER_RELATIVE_PATH: string;
+export type ImportScanMode = "stream" | "final" | "human";
+export interface ImportScanOptions {
+    mode: ImportScanMode;
+    /** Explicit HQ root (--hq-root). */
+    hqRoot?: string;
+    /** Home directory used to find ~/.hq/menubar.json (tests). */
+    home?: string;
+    /** Report path. Defaults to <hq>/workspace/imports/<scan id>/report.json. */
+    output?: string;
+    scopes?: string[];
+    claudeExport?: string;
+    noDefaultScopes?: boolean;
+    /** Shell used to run scan.sh (default "bash"). */
+    bash?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    /** Grace period between forwarding a signal and SIGKILL (default 5000). */
+    killTimeoutMs?: number;
+    /** Cancels the scan like SIGTERM (for embedding callers and tests). */
+    abortSignal?: AbortSignal;
+}
+export interface ImportScanIo {
+    stdout: NodeJS.WritableStream;
+    stderr: NodeJS.WritableStream;
+}
+/** UTC scan id in the /import-context skill's format: YYYYMMDDTHHMMSSZ. */
+export declare function scanId(date: Date): string;
+export declare class HqRootError extends Error {
+}
+/**
+ * --hq-root, else the installer-recorded root in ~/.hq/menubar.json. Throws
+ * HqRootError with a plain-words message otherwise.
+ */
+export declare function resolveScanHqRoot(opts: {
+    hqRoot?: string;
+    home?: string;
+}): string;
+/**
+ * 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 declare function redactScannerLine(line: string): string;
+/** Run the scan. Resolves to the process exit code. */
+export declare function runImportScan(opts: ImportScanOptions, io: ImportScanIo): Promise<number>;
+//# sourceMappingURL=run.d.ts.map

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