@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/commands/lanes-move.d.ts

@@ -1,12 +0,0 @@
-import type { Ctx, LaneMoveHandlerDeps } from "./lanes-shared.js";
-export declare function createLaneMoveHandlers(deps: LaneMoveHandlerDeps): {
-    runMove: (ctx: Ctx, laneId: string, opts: {
-        placement?: string;
-    }) => Promise<void>;
-    runMoveTarget: (ctx: Ctx, laneId: string, opts: {
-        hostKind?: string;
-        hostId?: string;
-        account?: string;
-    }) => Promise<void>;
-};
-//# sourceMappingURL=lanes-move.d.ts.map

package/dist/commands/lanes-move.js

@@ -1,397 +0,0 @@
-import * as path from "node:path";
-import { chooseHostForLane } from "../lib/lanes/host-capacity.js";
-import { laneRunsHere, loadLanesConfig, loadWorkerProfile, readLane, updateLane, withLaneAdmissionLock, } from "../lib/lanes/index.js";
-import { LanesError, isLanesError } from "../lib/lanes/errors.js";
-import { buildOutpostMoveTargetCommand, dispatchErrorMessage, } from "../lib/lanes/outpost-dispatch.js";
-import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
-import { assertPlacementEnabled, parsePlacementPolicy, readLanePlacementEnabled, } from "./lanes-shared.js";
-export function createLaneMoveHandlers(deps) {
-    const { assertKnownOutpost, assertLaneRunsHereForOperatorMutation, dispatchCreatedOutpostLane, loadHostCapacitySnapshots, ownerErrorFromOutput, parseRemoteJson, printJson, readJsonFile, reconcileHostFromCtx, runDir, timeoutPath, } = deps;
-    function laneCanMoveBeforeStart(lane) {
-        return lane.state === "queued" &&
-            lane.pickup_validation_pending !== true &&
-            lane.admission_reserved_at === undefined &&
-            lane.provider_session_id === undefined &&
-            lane.provider_session_id_absent === undefined &&
-            lane.provider_home_at_spawn === undefined &&
-            lane.last_resume === undefined &&
-            lane.last_run_usage === undefined &&
-            lane.last_host_report_at === undefined &&
-            lane.pending_resume === undefined;
-    }
-    function sameHost(a, b) {
-        return a.kind === b.kind && a.id === b.id;
-    }
-    function reportAlreadyOnTarget(lane) {
-        printJson({
-            ok: true,
-            action: "move",
-            lane_id: lane.lane_id,
-            state: lane.state,
-            host: lane.host,
-            account: lane.account ?? null,
-            moved: false,
-            reason: "already_on_target",
-            lane,
-        });
-    }
-    async function reportAlreadyOnTargetIfCurrent(hqRoot, laneId, provider, target, callerHost, runtimeHost, ctx) {
-        const current = await withLaneAdmissionLock(hqRoot, provider, async () => {
-            const lane = readLane(hqRoot, laneId);
-            if (!laneCanMoveBeforeStart(lane)) {
-                throw new LanesError(lane.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} cannot move after it has started; current state is ${lane.state}`, { lane_id: laneId, state: lane.state });
-            }
-            return sameHost(lane.host, target) ||
-                (laneRunsHere(lane, runtimeHost) && sameHost(callerHost, target))
-                ? lane
-                : undefined;
-        }, ctx.sleep);
-        if (current === undefined)
-            return false;
-        reportAlreadyOnTarget(current);
-        return true;
-    }
-    function readLaneTimeout(hqRoot, laneId) {
-        const raw = readJsonFile(timeoutPath(hqRoot, laneId));
-        if (raw === null)
-            return undefined;
-        if (typeof raw !== "object" || Array.isArray(raw) ||
-            typeof raw.timeout_secs !== "number" ||
-            typeof raw.deadline_at !== "string" ||
-            !Number.isSafeInteger(raw.timeout_secs) ||
-            raw.timeout_secs <= 0 ||
-            !Number.isFinite(Date.parse(raw.deadline_at))) {
-            throw new LanesError("lane_timeout_invalid", `Lane ${laneId} has a malformed timeout record`, {
-                lane_id: laneId,
-            });
-        }
-        const record = raw;
-        return { timeout_secs: record.timeout_secs, deadline_at: record.deadline_at };
-    }
-    async function runMove(ctx, laneId, opts) {
-        const hqRoot = ctx.hqRoot();
-        const policy = parsePlacementPolicy(opts.placement ?? "");
-        const source = readLane(hqRoot, laneId);
-        const placementCompany = resolveLaneCompany(hqRoot, source).company ?? undefined;
-        let placementGate;
-        const placementEnabled = () => {
-            placementGate ??= readLanePlacementEnabled(ctx, placementCompany);
-            return placementGate;
-        };
-        await assertPlacementEnabled(ctx, placementCompany, placementEnabled);
-        if (!laneCanMoveBeforeStart(source)) {
-            throw new LanesError(source.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} cannot move after it has started; current state is ${source.state}`, { lane_id: laneId, state: source.state });
-        }
-        const sourceHost = source.host;
-        const runtimeHost = reconcileHostFromCtx(ctx);
-        const runningHere = laneRunsHere(source, runtimeHost);
-        const callerHost = runtimeHost.outpostId
-            ? { kind: "outpost", id: runtimeHost.outpostId }
-            : { kind: "local", id: runtimeHost.hostname };
-        const explicitTarget = policy.kind === "local"
-            ? callerHost
-            : policy.kind === "outpost"
-                ? { kind: "outpost", id: policy.id }
-                : undefined;
-        if (explicitTarget !== undefined &&
-            (sameHost(sourceHost, explicitTarget) ||
-                (runningHere && sameHost(callerHost, explicitTarget)))) {
-            if (await reportAlreadyOnTargetIfCurrent(hqRoot, laneId, source.provider, explicitTarget, callerHost, runtimeHost, ctx))
-                return;
-        }
-        const config = loadLanesConfig(hqRoot);
-        const capacity = await loadHostCapacitySnapshots(ctx, hqRoot, config);
-        let targetSnapshots = capacity.snapshots.filter((snapshot) => snapshot.host.kind !== sourceHost.kind || snapshot.host.id !== sourceHost.id);
-        if (policy.kind === "outpost") {
-            targetSnapshots = targetSnapshots.filter((snapshot) => snapshot.host.kind === "outpost" && snapshot.host.id === policy.id);
-        }
-        else if (policy.kind === "local") {
-            targetSnapshots = targetSnapshots.filter((snapshot) => snapshot.host.kind === "local");
-        }
-        const profileAccounts = source.worker_profile === undefined
-            ? undefined
-            : loadWorkerProfile(hqRoot, source.worker_profile).meta.accounts;
-        const allowedAccounts = source.admission_accounts ?? profileAccounts;
-        const choice = chooseHostForLane(targetSnapshots, {
-            provider: source.provider,
-            ...(source.account !== undefined ? { account: source.account } : {}),
-            ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
-        });
-        if (sameHost(sourceHost, choice.host) ||
-            (runningHere && sameHost(callerHost, choice.host))) {
-            if (await reportAlreadyOnTargetIfCurrent(hqRoot, laneId, source.provider, choice.host, callerHost, runtimeHost, ctx))
-                return;
-        }
-        let moved;
-        if (runningHere) {
-            moved = await commitLaneMove(ctx, laneId, choice.host, choice.account, placementEnabled);
-        }
-        else if (source.host.kind === "outpost") {
-            moved = await dispatchRemoteLaneMove(ctx, source, choice.host, choice.account);
-        }
-        else {
-            throw new LanesError("lane_remote", `Cannot move lane ${laneId} from this host; its state is owned by ${source.host.kind}:${source.host.id}`, { lane_id: laneId, host: source.host, action: "move" });
-        }
-        printJson({
-            ok: true,
-            action: "move",
-            lane_id: laneId,
-            state: moved.state,
-            host: moved.host,
-            account: moved.account ?? null,
-            lane: moved,
-        });
-    }
-    async function commitLaneMove(ctx, laneId, target, account, readPlacementEnabled) {
-        const hqRoot = ctx.hqRoot();
-        const before = readLane(hqRoot, laneId);
-        assertLaneRunsHereForOperatorMutation(ctx, before, "move-target");
-        await assertPlacementEnabled(ctx, resolveLaneCompany(hqRoot, before).company ?? undefined, readPlacementEnabled);
-        if (before.host.kind === target.kind && before.host.id === target.id) {
-            throw new LanesError("lane_move_same_host", `Lane ${laneId} is already on ${target.kind}:${target.id}`, {
-                lane_id: laneId,
-                host: target,
-            });
-        }
-        if (!laneCanMoveBeforeStart(before)) {
-            throw new LanesError(before.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} cannot move after it has started; current state is ${before.state}`, { lane_id: laneId, state: before.state });
-        }
-        if (target.kind === "outpost") {
-            let known;
-            try {
-                known = await ctx.listOutpostIds();
-            }
-            catch (err) {
-                throw new LanesError("outpost_list_unavailable", `Failed to list Outpost ids: ${dispatchErrorMessage(err)}`, {});
-            }
-            assertKnownOutpost(target.id, known);
-        }
-        const accountConfig = loadLanesConfig(hqRoot).providers[before.provider].accounts[account];
-        if (accountConfig === undefined || !accountConfig.enabled) {
-            throw new LanesError("lane_move_account_invalid", `Account ${account} is unavailable for ${before.provider}`, {
-                lane_id: laneId,
-                provider: before.provider,
-                account,
-            });
-        }
-        const profileAccounts = before.worker_profile === undefined
-            ? undefined
-            : loadWorkerProfile(hqRoot, before.worker_profile).meta.accounts;
-        const allowedAccounts = before.admission_accounts ?? profileAccounts;
-        if (allowedAccounts !== undefined &&
-            !allowedAccounts.includes(account)) {
-            throw new LanesError("lane_move_account_invalid", `Account ${account} is not allowed by lane ${laneId}`, {
-                lane_id: laneId,
-                account,
-                allowed_accounts: allowedAccounts,
-            });
-        }
-        const briefText = target.kind === "outpost"
-            ? (() => {
-                const briefPath = path.join(runDir(hqRoot, laneId), "brief.md");
-                if (!ctx.existsSync(briefPath)) {
-                    throw new LanesError("lane_move_brief_missing", `Lane ${laneId} has no stored brief to dispatch`, {
-                        lane_id: laneId,
-                    });
-                }
-                return ctx.readFileSync(briefPath, "utf8");
-            })()
-            : undefined;
-        const timeout = target.kind === "outpost" ? readLaneTimeout(hqRoot, laneId) : undefined;
-        const moved = await withLaneAdmissionLock(hqRoot, before.provider, async () => {
-            const current = readLane(hqRoot, laneId);
-            assertLaneRunsHereForOperatorMutation(ctx, current, "move-target");
-            if (!laneCanMoveBeforeStart(current)) {
-                throw new LanesError(current.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} started before the move could commit`, { lane_id: laneId, state: current.state });
-            }
-            return updateLane(hqRoot, laneId, current.version, "command", (live) => ({
-                ...live,
-                host: target,
-                account,
-                queued_reason: undefined,
-                queued_details: undefined,
-                admission_reserved_at: undefined,
-            }));
-        }, ctx.sleep);
-        if (target.kind !== "outpost")
-            return moved;
-        try {
-            return await dispatchCreatedOutpostLane(ctx, {
-                hqRoot,
-                lane: moved,
-                outpostId: target.id,
-                briefText: briefText ?? "",
-                timeout,
-                preserveQueuedOnFailure: true,
-            });
-        }
-        catch (err) {
-            const dispatchDetails = isLanesError(err) ? err.details : {};
-            const commandId = typeof dispatchDetails.command_id === "string" &&
-                dispatchDetails.command_id.trim() !== ""
-                ? dispatchDetails.command_id
-                : undefined;
-            const definitelyNotSubmitted = commandId === undefined &&
-                dispatchDetails.outcome_unknown !== true &&
-                dispatchDetails.done !== false;
-            const knownNoPersistence = (isLanesError(err) && err.error === "outpost_self_target") ||
-                (dispatchDetails.done === true && dispatchDetails.pickup_persisted === false);
-            if (!definitelyNotSubmitted && !knownNoPersistence) {
-                const checkCommand = `hq lanes show ${laneId}`;
-                const message = `Failed to dispatch lane ${laneId} to Outpost ${target.id}; outcome is unknown and the lane remains assigned to Outpost ${target.id}. ` +
-                    `Check the target copy by running \`${checkCommand}\` on Outpost ${target.id}. ` +
-                    dispatchErrorMessage(err);
-                throw new LanesError("lane_move_dispatch_failed", message, {
-                    lane_id: laneId,
-                    message,
-                    source_host: before.host,
-                    target_host: target,
-                    source_restored: false,
-                    outcome: "unknown",
-                    ...(commandId !== undefined ? { command_id: commandId } : {}),
-                    check_command: checkCommand,
-                    ...(dispatchDetails.owner_error !== undefined
-                        ? { owner_error: dispatchDetails.owner_error }
-                        : {}),
-                });
-            }
-            let restored = false;
-            let rollbackError;
-            try {
-                restored = await withLaneAdmissionLock(hqRoot, before.provider, async () => {
-                    const current = readLane(hqRoot, laneId);
-                    if (current.version !== moved.version ||
-                        current.state !== "queued" ||
-                        current.host.kind !== target.kind ||
-                        current.host.id !== target.id ||
-                        current.account !== account) {
-                        return false;
-                    }
-                    updateLane(hqRoot, laneId, current.version, "command", (live) => ({
-                        ...live,
-                        host: before.host,
-                        account: before.account,
-                        queued_reason: before.queued_reason,
-                        queued_details: before.queued_details,
-                        admission_reserved_at: before.admission_reserved_at,
-                    }));
-                    return true;
-                }, ctx.sleep);
-            }
-            catch (restoreErr) {
-                rollbackError = restoreErr;
-            }
-            const dispatchMessage = dispatchErrorMessage(err);
-            const outcome = restored
-                ? "the lane stayed queued on its source"
-                : rollbackError === undefined
-                    ? "the lane changed after the move and was not overwritten"
-                    : `source restoration failed: ${dispatchErrorMessage(rollbackError)}`;
-            const message = `Failed to dispatch lane ${laneId} to Outpost ${target.id}; ${outcome}: ${dispatchMessage}`;
-            throw new LanesError("lane_move_dispatch_failed", message, {
-                lane_id: laneId,
-                message,
-                source_host: before.host,
-                target_host: target,
-                source_restored: restored,
-                ...(dispatchDetails.owner_error !== undefined
-                    ? { owner_error: dispatchDetails.owner_error }
-                    : {}),
-                ...(rollbackError !== undefined
-                    ? { rollback_error: dispatchErrorMessage(rollbackError) }
-                    : {}),
-            });
-        }
-    }
-    async function dispatchRemoteLaneMove(ctx, source, target, account) {
-        if (source.host.kind !== "outpost") {
-            throw new LanesError("lane_move_wrong_host", `Lane ${source.lane_id} is not Outpost-hosted`, {
-                lane_id: source.lane_id,
-                host: source.host,
-            });
-        }
-        let dispatched;
-        try {
-            dispatched = await ctx.dispatchOutpostExec({
-                outpostId: source.host.id,
-                command: buildOutpostMoveTargetCommand({
-                    laneId: source.lane_id,
-                    host: target,
-                    account,
-                }),
-                timeoutSeconds: 120,
-                waitMs: 120_000,
-            });
-        }
-        catch (err) {
-            throw new LanesError("lane_move_dispatch_failed", `Could not ask Outpost ${source.host.id} to move lane ${source.lane_id}: ${dispatchErrorMessage(err)}`, { lane_id: source.lane_id, source_outpost: source.host.id });
-        }
-        const ownerError = ownerErrorFromOutput(dispatched.stdout);
-        if (ownerError) {
-            throw new LanesError("outpost_dispatch_failed", `Outpost ${source.host.id} rejected the lane move: ${ownerError.message}`, {
-                lane_id: source.lane_id,
-                source_outpost: source.host.id,
-                command_id: dispatched.commandId,
-                status: dispatched.status,
-                done: dispatched.done ?? false,
-                exit_code: dispatched.exitCode,
-                owner_error: ownerError,
-            });
-        }
-        if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
-            throw new LanesError("lane_move_dispatch_failed", `Outpost ${source.host.id} did not confirm the lane move`, {
-                lane_id: source.lane_id,
-                source_outpost: source.host.id,
-                command_id: dispatched.commandId,
-                status: dispatched.status,
-                done: dispatched.done ?? false,
-                exit_code: dispatched.exitCode,
-            });
-        }
-        const remote = parseRemoteJson(dispatched.stdout, "Outpost lane move");
-        const remoteHost = remote?.host;
-        if (remote?.ok !== true ||
-            remote.action !== "move-target" ||
-            remote.lane_id !== source.lane_id ||
-            remote.state !== "queued" ||
-            remote.account !== account ||
-            remoteHost === null || typeof remoteHost !== "object" || Array.isArray(remoteHost) ||
-            remoteHost.kind !== target.kind ||
-            remoteHost.id !== target.id) {
-            throw new LanesError("lane_move_unconfirmed", `Outpost ${source.host.id} returned an invalid lane move result`, {
-                lane_id: source.lane_id,
-                source_outpost: source.host.id,
-                target,
-            });
-        }
-        return {
-            ...source,
-            state: "queued",
-            host: target,
-            account,
-        };
-    }
-    async function runMoveTarget(ctx, laneId, opts) {
-        const kind = opts.hostKind?.trim();
-        const id = opts.hostId?.trim();
-        const account = opts.account?.trim();
-        if ((kind !== "local" && kind !== "outpost") || !id || !account) {
-            throw new LanesError("lane_move_target_invalid", "Move target requires a valid host kind, host id, and account", {
-                host_kind: kind ?? null,
-                host_id: id ?? null,
-                account: account ?? null,
-            });
-        }
-        const moved = await commitLaneMove(ctx, laneId, { kind, id }, account);
-        printJson({
-            ok: true,
-            action: "move-target",
-            lane_id: moved.lane_id,
-            state: moved.state,
-            host: moved.host,
-            account: moved.account ?? null,
-        });
-    }
-    return { runMove, runMoveTarget };
-}
-//# sourceMappingURL=lanes-move.js.map

package/dist/commands/lanes-questions.d.ts

@@ -1,36 +0,0 @@
-import { type QuestionBody, type LaneRecord, type QuestionRecord } from "../lib/lanes/index.js";
-import type { Ctx, FallbackQuestionCancellationResult, LaneQuestionsHandlerDeps } from "./lanes-shared.js";
-export declare function resolveAnswerChoice(choice: string, options: string[], freeform: boolean): string;
-export declare function createLaneQuestionsHandlers(deps: LaneQuestionsHandlerDeps): {
-    hasPendingQuestionForLane: (ctx: Ctx, lane: LaneRecord) => Promise<boolean>;
-    cancelFallbackQuestionsForLane: (ctx: Ctx, lane: LaneRecord, trigger: "message" | "resume", at: string) => Promise<FallbackQuestionCancellationResult>;
-    runQuestionsList: (ctx: Ctx, opts: {
-        allHosts?: boolean;
-        for?: string;
-        from?: string;
-        company?: string;
-        project?: string;
-        story?: string;
-        status?: string;
-    }) => Promise<void>;
-    runQuestionsShow: (ctx: Ctx, questionId: string) => Promise<void>;
-    runQuestionsAnswer: (ctx: Ctx, questionId: string, opts: {
-        choice?: string;
-        notes?: string;
-        freeform?: string;
-        company?: string;
-    }) => Promise<void>;
-    runQuestionsEscalate: (ctx: Ctx, questionId: string, opts: {
-        note?: string;
-    }) => Promise<void>;
-    runQuestionsCancel: (ctx: Ctx, questionId: string, opts: {
-        reason?: string;
-    }) => Promise<void>;
-    runSessionsList: (ctx: Ctx, opts: {
-        state?: string;
-        company?: string;
-    }) => Promise<void>;
-    runSessionsShow: (ctx: Ctx, sessionId: string) => Promise<void>;
-    requireQuestionBody: (hqRoot: string, question: QuestionRecord) => QuestionBody;
-};
-//# sourceMappingURL=lanes-questions.d.ts.map