@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/lib/lanes/message-replay.js

@@ -1,122 +0,0 @@
-import { randomBytes } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { probeProviderCompactionsSince, providerTranscriptSize, } from "./compaction.js";
-import { LanesError } from "./errors.js";
-export const MESSAGE_REPLAY_STATE_NAME = "message-compaction-replay.json";
-export const MESSAGE_COMPACTION_REPLAY_NOTE = "These messages were delivered before a context compaction and still apply.";
-export function readMessageReplayState(filePath, turnId, onLegacyFlag) {
-    const text = fs.readFileSync(filePath, "utf8");
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch (err) {
-        throw new LanesError("message_replay_state_invalid", `Replay state ${filePath} is invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new LanesError("message_replay_state_invalid", `Replay state ${filePath} is not an object`);
-    }
-    const state = parsed;
-    if (state.schema_version !== 1 ||
-        state.turn_id !== turnId ||
-        (state.last_compaction_marker !== null &&
-            (!Number.isSafeInteger(state.last_compaction_marker) || Number(state.last_compaction_marker) < 0)) ||
-        (state.transcript_offset !== undefined &&
-            (!Number.isSafeInteger(state.transcript_offset) || Number(state.transcript_offset) < 0)) ||
-        (state.transcript_path !== undefined && typeof state.transcript_path !== "string") ||
-        (state.provider !== undefined && !isLaneProvider(state.provider)) ||
-        (state.flag_enabled !== undefined && typeof state.flag_enabled !== "boolean")) {
-        throw new LanesError("message_replay_state_invalid", `Replay state ${filePath} does not match the current provider turn`);
-    }
-    // Older state files persisted the removed per-turn flag. Accept it, but
-    // remove it before the next write so the stale cache does not live on.
-    if (state.flag_enabled !== undefined) {
-        delete state.flag_enabled;
-        onLegacyFlag?.();
-    }
-    return state;
-}
-function isLaneProvider(value) {
-    return value === "claude" || value === "codex" || value === "grok";
-}
-export function writeMessageReplayState(filePath, state) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const tempPath = `${filePath}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
-    fs.writeFileSync(tempPath, `${JSON.stringify(state)}\n`, { mode: 0o600 });
-    try {
-        fs.renameSync(tempPath, filePath);
-    }
-    catch (err) {
-        fs.rmSync(tempPath, { force: true });
-        throw err;
-    }
-}
-function safeProviderTranscriptPath(transcriptPath, provider, env) {
-    if (provider === "grok")
-        return transcriptPath;
-    const home = provider === "claude" ? env.CLAUDE_CONFIG_DIR : env.CODEX_HOME;
-    if (!home) {
-        throw new LanesError("message_replay_provider_home_missing", `Cannot validate ${provider} transcript without its provider home`);
-    }
-    if (!path.isAbsolute(transcriptPath) || path.extname(transcriptPath) !== ".jsonl") {
-        throw new LanesError("message_replay_transcript_path_invalid", `The ${provider} hook transcript path must be an absolute JSONL path`);
-    }
-    const configuredHomePath = path.resolve(home);
-    const homePath = fs.realpathSync(home);
-    const candidate = path.resolve(transcriptPath);
-    const expectedRoot = provider === "claude" ? "projects" : "sessions";
-    const assertWithinProviderHome = (root, resolvedTranscript, message) => {
-        const relative = path.relative(root, resolvedTranscript);
-        if (relative === "" ||
-            relative === ".." ||
-            relative.startsWith(`..${path.sep}`) ||
-            path.isAbsolute(relative) ||
-            relative.split(path.sep)[0] !== expectedRoot) {
-            throw new LanesError("message_replay_transcript_outside_provider_home", message);
-        }
-    };
-    try {
-        const realTranscript = fs.realpathSync(candidate);
-        assertWithinProviderHome(homePath, realTranscript, `The ${provider} hook transcript resolves outside its ${expectedRoot} directory`);
-        return realTranscript;
-    }
-    catch (err) {
-        if (err.code === "ENOENT") {
-            assertWithinProviderHome(configuredHomePath, candidate, `The ${provider} hook transcript is outside its configured ${expectedRoot} directory`);
-            return candidate;
-        }
-        throw err;
-    }
-}
-export function updateMessageReplayTranscript(state, transcriptPath, provider, env, probe = probeProviderCompactionsSince) {
-    if (provider === "grok") {
-        state.provider = provider;
-        state.last_compaction_marker = 0;
-        return "unchanged";
-    }
-    const canonicalPath = safeProviderTranscriptPath(transcriptPath, provider, env);
-    const providerChanged = state.provider !== undefined && state.provider !== provider;
-    state.provider = provider;
-    if (providerChanged ||
-        state.last_compaction_marker === null ||
-        state.transcript_path !== canonicalPath ||
-        state.transcript_offset === undefined) {
-        state.last_compaction_marker = 0;
-        state.transcript_path = canonicalPath;
-        state.transcript_offset = providerTranscriptSize(canonicalPath);
-        return "baseline";
-    }
-    const delta = probe(canonicalPath, provider, state.transcript_offset);
-    state.transcript_offset = delta.next_offset;
-    if (delta.replaced) {
-        state.last_compaction_marker = 0;
-        return "replaced";
-    }
-    if (delta.count > 0) {
-        state.last_compaction_marker += delta.count;
-        return "compacted";
-    }
-    return "unchanged";
-}
-//# sourceMappingURL=message-replay.js.map

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

@@ -1,86 +0,0 @@
-/**
- * Per-provider known model ids, for validating `hq lanes create --model`.
- *
- * No provider adapter in this package carries a model list, so each id set
- * is read from where the provider itself keeps it, the way the accounts
- * probes read provider state: from the account home or the provider CLI,
- * never from a list written into this package.
- *
- * - codex: `<CODEX_HOME>/models_cache.json`, the model catalog the codex CLI
- *   fetches and caches per home. Every `models[].slug` is accepted.
- * - grok: `grok models` (run with `GROK_HOME` set to the account home),
- *   which prints `Available models:` followed by one id per line. It lists
- *   models even when the home is not logged in.
- * - claude: `claude --help`, whose `--model` text names the accepted aliases
- *   (`'fable', 'opus', or 'sonnet'`) and says a full name is accepted too.
- *   An alias from that text or any `claude-` full name passes.
- *
- * A source that cannot be read (no cache yet, CLI missing, probe failed)
- * returns null and the caller skips validation: the provider's own
- * rejection at run time is still classified `provider_rejected`.
- */
-import type { LaneProvider } from "./types.js";
-export declare const CODEX_MODELS_CACHE_NAME = "models_cache.json";
-export declare const MODEL_PROBE_TIMEOUT_MS = 10000;
-export interface ProbeResult {
-    status: number | null;
-    stdout: string;
-    stderr: string;
-}
-export type ProbeCommand = (command: string, args: string[], env: NodeJS.ProcessEnv) => ProbeResult;
-export interface KnownModelsDeps {
-    readFileSync?: (p: string, encoding: "utf8") => string;
-    probe?: ProbeCommand;
-    env?: NodeJS.ProcessEnv;
-}
-export interface KnownModels {
-    provider: LaneProvider;
-    /** Exact ids the provider accepts. */
-    ids: string[];
-    /** Prefixes accepted in addition to `ids` (claude full names). */
-    prefixes: string[];
-    /** Where the list came from, for the refusal and the report. */
-    source: string;
-}
-export declare function defaultProbe(command: string, args: string[], env: NodeJS.ProcessEnv): ProbeResult;
-/** Read `models[].slug` from the codex catalog cache in `home`. Null when absent or unreadable. */
-export declare function codexKnownModels(home: string, readFileSync?: NonNullable<KnownModelsDeps["readFileSync"]>): KnownModels | null;
-/**
- * Parse `grok models` output:
- *
- *     Available models:
- *       * grok-4.7 (default)
- *       - grok-4.7-build-fast
- */
-export declare function parseGrokModelsOutput(text: string): string[];
-export declare function grokKnownModels(home: string, probe?: ProbeCommand, env?: NodeJS.ProcessEnv): KnownModels | null;
-/**
- * Parse the `--model` option text of `claude --help`:
- *
- *     --model <model>   Model for the current session. Provide an alias for
- *                       the latest model (e.g. 'fable', 'opus', or 'sonnet')
- *                       or a model's full name (e.g. 'claude-fable-5').
- *
- * Returns the quoted aliases and the prefix of the quoted full-name example.
- */
-export declare function parseClaudeHelpModels(text: string): {
-    aliases: string[];
-    prefixes: string[];
-};
-/** Prefix of every Claude model full name, e.g. `claude-sonnet-5-5`. */
-export declare const CLAUDE_FULL_NAME_PREFIX = "claude-";
-export declare function claudeKnownModels(probe?: ProbeCommand, env?: NodeJS.ProcessEnv): KnownModels | null;
-export declare function knownModels(provider: LaneProvider, home: string, deps?: KnownModelsDeps): KnownModels | null;
-export declare function modelIsKnown(known: KnownModels, model: string): boolean;
-/**
- * Refuse a `--model` the provider does not know. Returns the source used, or
- * null when no source was readable and the value passed unvalidated.
- */
-export declare function validateLaneModel(provider: LaneProvider, model: string, home: string, deps?: KnownModelsDeps): string | null;
-/**
- * Validate a model supplied by a reusable worker profile. Keep the provider
- * catalog and refusal semantics identical to `--model`, while making the
- * profile origin visible to callers and JSON error consumers.
- */
-export declare function validateProfileLaneModel(provider: LaneProvider, model: string, home: string, profileId: string, deps?: KnownModelsDeps): string | null;
-//# sourceMappingURL=models.d.ts.map

package/dist/lib/lanes/models.js

@@ -1,234 +0,0 @@
-/**
- * Per-provider known model ids, for validating `hq lanes create --model`.
- *
- * No provider adapter in this package carries a model list, so each id set
- * is read from where the provider itself keeps it, the way the accounts
- * probes read provider state: from the account home or the provider CLI,
- * never from a list written into this package.
- *
- * - codex: `<CODEX_HOME>/models_cache.json`, the model catalog the codex CLI
- *   fetches and caches per home. Every `models[].slug` is accepted.
- * - grok: `grok models` (run with `GROK_HOME` set to the account home),
- *   which prints `Available models:` followed by one id per line. It lists
- *   models even when the home is not logged in.
- * - claude: `claude --help`, whose `--model` text names the accepted aliases
- *   (`'fable', 'opus', or 'sonnet'`) and says a full name is accepted too.
- *   An alias from that text or any `claude-` full name passes.
- *
- * A source that cannot be read (no cache yet, CLI missing, probe failed)
- * returns null and the caller skips validation: the provider's own
- * rejection at run time is still classified `provider_rejected`.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { spawnSync } from "node:child_process";
-import { LanesError } from "./errors.js";
-import { PROVIDER_HOME_ENV } from "./accounts.js";
-export const CODEX_MODELS_CACHE_NAME = "models_cache.json";
-export const MODEL_PROBE_TIMEOUT_MS = 10_000;
-export function defaultProbe(command, args, env) {
-    const result = spawnSync(command, args, {
-        env,
-        encoding: "utf8",
-        timeout: MODEL_PROBE_TIMEOUT_MS,
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    if (result.error) {
-        return { status: null, stdout: "", stderr: result.error.message };
-    }
-    return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
-}
-function isPlainObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/** Read `models[].slug` from the codex catalog cache in `home`. Null when absent or unreadable. */
-export function codexKnownModels(home, readFileSync = (p, enc) => fs.readFileSync(p, enc)) {
-    const source = path.join(home, CODEX_MODELS_CACHE_NAME);
-    let text;
-    try {
-        text = readFileSync(source, "utf8");
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === "ENOENT")
-            return null;
-        // EACCES, EISDIR, EIO: the list cannot be read, which is the same
-        // contract as a missing or corrupt cache. Reported, never an internal failure.
-        process.stderr.write(`hq lanes: cannot read ${source} (${err instanceof Error ? err.message : String(err)}); --model is not validated for codex\n`);
-        return null;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes: ${source} is not JSON (${err instanceof Error ? err.message : String(err)}); --model is not validated for codex\n`);
-        return null;
-    }
-    if (!isPlainObject(parsed) || !Array.isArray(parsed.models))
-        return null;
-    const ids = [];
-    for (const entry of parsed.models) {
-        if (isPlainObject(entry) && typeof entry.slug === "string" && entry.slug.trim().length > 0) {
-            ids.push(entry.slug.trim());
-        }
-    }
-    if (ids.length === 0)
-        return null;
-    return { provider: "codex", ids, prefixes: [], source };
-}
-/**
- * Parse `grok models` output:
- *
- *     Available models:
- *       * grok-4.7 (default)
- *       - grok-4.7-build-fast
- */
-export function parseGrokModelsOutput(text) {
-    const ids = [];
-    let inList = false;
-    for (const raw of text.split("\n")) {
-        const line = raw.trim();
-        if (/^available models:/i.test(line)) {
-            inList = true;
-            continue;
-        }
-        if (!inList)
-            continue;
-        const match = /^[*-]\s+(\S+)/.exec(line);
-        if (match) {
-            ids.push(match[1]);
-        }
-        else if (line.length === 0 && ids.length > 0) {
-            break;
-        }
-    }
-    return ids;
-}
-export function grokKnownModels(home, probe = defaultProbe, env = process.env) {
-    const source = "grok models";
-    const result = probe("grok", ["models"], { ...env, [PROVIDER_HOME_ENV.grok]: home });
-    // Only a probe that exited 0 is a catalog. A wrapper or auth check can
-    // print a partial list and then fail; an id missing from that output must
-    // not refuse the model, so a failed probe skips validation.
-    if (result.status !== 0) {
-        process.stderr.write(`hq lanes: \`${source}\` failed (exit ${result.status ?? "spawn error"}${result.stderr.trim() ? `: ${result.stderr.trim().split("\n")[0]}` : ""}); --model is not validated for grok\n`);
-        return null;
-    }
-    const ids = parseGrokModelsOutput(result.stdout);
-    if (ids.length === 0) {
-        process.stderr.write(`hq lanes: \`${source}\` listed no models (exit ${result.status ?? "spawn error"}${result.stderr.trim() ? `: ${result.stderr.trim().split("\n")[0]}` : ""}); --model is not validated for grok\n`);
-        return null;
-    }
-    return { provider: "grok", ids, prefixes: [], source };
-}
-/**
- * Parse the `--model` option text of `claude --help`:
- *
- *     --model <model>   Model for the current session. Provide an alias for
- *                       the latest model (e.g. 'fable', 'opus', or 'sonnet')
- *                       or a model's full name (e.g. 'claude-fable-5').
- *
- * Returns the quoted aliases and the prefix of the quoted full-name example.
- */
-export function parseClaudeHelpModels(text) {
-    const start = text.indexOf("--model");
-    if (start === -1)
-        return { aliases: [], prefixes: [] };
-    const rest = text.slice(start);
-    const end = rest.search(/\n\s*-{1,2}[A-Za-z]/);
-    const block = end === -1 ? rest : rest.slice(0, end);
-    const aliases = [];
-    const prefixes = new Set();
-    // Only quoted tokens shaped like an id: the possessive in "model's" also
-    // opens a quote, and must not be read as one.
-    for (const match of block.matchAll(/'([A-Za-z0-9][A-Za-z0-9._[\]-]*)'/g)) {
-        const value = match[1];
-        const dash = value.indexOf("-");
-        if (dash > 0) {
-            prefixes.add(value.slice(0, dash + 1));
-        }
-        else {
-            aliases.push(value);
-        }
-    }
-    return { aliases, prefixes: [...prefixes] };
-}
-/** Prefix of every Claude model full name, e.g. `claude-sonnet-5-5`. */
-export const CLAUDE_FULL_NAME_PREFIX = "claude-";
-export function claudeKnownModels(probe = defaultProbe, env = process.env) {
-    const source = "claude --help";
-    const result = probe("claude", ["--help"], env);
-    if (result.status !== 0) {
-        process.stderr.write(`hq lanes: \`${source}\` failed (exit ${result.status ?? "spawn error"}${result.stderr.trim() ? `: ${result.stderr.trim().split("\n")[0]}` : ""}); --model is not validated for claude\n`);
-        return null;
-    }
-    const parsed = parseClaudeHelpModels(result.stdout);
-    if (parsed.aliases.length === 0 && parsed.prefixes.length === 0) {
-        process.stderr.write(`hq lanes: \`${source}\` named no --model aliases (exit ${result.status ?? "spawn error"}); --model is not validated for claude\n`);
-        return null;
-    }
-    // Every Claude model's full name starts with `claude-`. Accept it even when
-    // this help text carries no full-name example, as some releases' help does.
-    const prefixes = [...new Set([CLAUDE_FULL_NAME_PREFIX, ...parsed.prefixes])];
-    return { provider: "claude", ids: parsed.aliases, prefixes, source };
-}
-export function knownModels(provider, home, deps = {}) {
-    switch (provider) {
-        case "codex":
-            return codexKnownModels(home, deps.readFileSync);
-        case "grok":
-            return grokKnownModels(home, deps.probe, deps.env);
-        case "claude":
-            return claudeKnownModels(deps.probe, deps.env);
-        default: {
-            const _exhaustive = provider;
-            return _exhaustive;
-        }
-    }
-}
-export function modelIsKnown(known, model) {
-    if (known.ids.includes(model))
-        return true;
-    return known.prefixes.some((prefix) => model.startsWith(prefix) && model.length > prefix.length);
-}
-/**
- * Refuse a `--model` the provider does not know. Returns the source used, or
- * null when no source was readable and the value passed unvalidated.
- */
-export function validateLaneModel(provider, model, home, deps = {}) {
-    const known = knownModels(provider, home, deps);
-    if (known === null)
-        return null;
-    if (modelIsKnown(known, model))
-        return known.source;
-    const accepted = [...known.ids, ...known.prefixes.map((prefix) => `${prefix}*`)];
-    const message = `Provider ${provider} does not know model ${JSON.stringify(model)} (source: ${known.source}). Accepted: ${accepted.join(", ")}`;
-    // `message` is in details too: LanesError.toJSON prints details only.
-    throw new LanesError("model_unsupported", message, { provider, model, accepted, source: known.source, message });
-}
-/**
- * Validate a model supplied by a reusable worker profile. Keep the provider
- * catalog and refusal semantics identical to `--model`, while making the
- * profile origin visible to callers and JSON error consumers.
- */
-export function validateProfileLaneModel(provider, model, home, profileId, deps = {}) {
-    try {
-        return validateLaneModel(provider, model, home, deps);
-    }
-    catch (err) {
-        if (!(err instanceof LanesError) || err.error !== "model_unsupported") {
-            throw err;
-        }
-        const message = `Worker profile ${JSON.stringify(profileId)} supplied model ${JSON.stringify(model)}; ` +
-            `the model came from the profile. ${err.message}`;
-        throw new LanesError("model_unsupported", message, {
-            ...err.details,
-            profile_id: profileId,
-            worker_profile: profileId,
-            model_source: "profile",
-            message,
-        });
-    }
-}
-//# sourceMappingURL=models.js.map

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

@@ -1,48 +0,0 @@
-export declare const MONITOR_MAX_TIMEOUT_MS = 1800000;
-export declare const MONITOR_UNCOVERED_EXIT_CODE = 2;
-export declare const MONITOR_ERROR_EXIT_CODE = 3;
-export declare const MONITOR_TRANSCRIPT_MAX_BYTES: number;
-export declare const MONITOR_TASK_OUTPUT_MAX_BYTES: number;
-export type MonitorEngine = "claude" | "codex" | "grok";
-export declare const MONITOR_ENGINES: readonly MonitorEngine[];
-export interface MonitorTaskEvidence {
-    taskId: string;
-    command: string;
-    startedAt: string;
-    timeoutMs: number;
-    persistent?: boolean;
-    stopped?: boolean;
-    outputPresent: boolean;
-    outputText?: string;
-    processAlive?: boolean;
-    outputPath?: string;
-}
-export interface MonitorEvidence {
-    sessionId: string;
-    tasks: readonly MonitorTaskEvidence[];
-    transcriptPaths?: readonly string[];
-    taskOutputPaths?: readonly string[];
-    processCommands?: readonly string[];
-}
-export interface LiveMonitorEvidenceOptions {
-    homedir?: () => string;
-    env?: NodeJS.ProcessEnv;
-    now?: () => Date;
-    transcriptMaxBytes?: number;
-    taskOutputMaxBytes?: number;
-    readProcessCommands?: () => readonly string[];
-}
-/**
- * Parse only the JSONL shape emitted by Claude Code's Monitor tool. The
- * caller supplies a bounded tail; malformed or partial lines are ignored so a
- * torn final write cannot turn into positive liveness evidence.
- */
-export declare function parseMonitorTranscript(text: string): MonitorTaskEvidence[];
-/** Return argv only for the exact command form the gate arms. */
-export declare function parseCanonicalWatchCommand(command: string): string[] | null;
-export declare function isMonitorTaskLive(task: MonitorTaskEvidence, now: Date): boolean;
-export declare function coveredLaneIds(evidence: MonitorEvidence, now: Date): Set<string>;
-export declare function readLiveMonitorEvidence(sessionId: string, options?: LiveMonitorEvidenceOptions): MonitorEvidence;
-export type MonitorEvidenceReader = (sessionId: string) => MonitorEvidence | Promise<MonitorEvidence>;
-export declare function monitorReminderText(): string;
-//# sourceMappingURL=monitor.d.ts.map