@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/engineSwapCrossing.js

@@ -0,0 +1,297 @@
+import { checkpointQueueRowSortOf } from './hitl/approvalQueueRow.js';
+import { durableDecideLegOf } from './adapter/activeRunSelfHeal.js';
+import { checkpointRowVerdictOf } from './checkpointRowVerdict.js';
+import { compareReleaseVersions } from './supportFloor.js';
+import { engineIdentityOf } from './engineIdentity.js';
+import { slotReadOf } from './wireFailureShape.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export const ENGINE_DRAIN_CLASSES = Object.freeze(['parked_tool_approvals']);
+function own(o, key) {
+    if (typeof o !== 'object' || o === null)
+        return undefined;
+    const r = slotReadOf(o, key);
+    return r.presence === 'present' ? r.value : undefined;
+}
+function isArray(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function isObject(v) {
+    return typeof v === 'object' && v !== null && !isArray(v);
+}
+function isCount(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+}
+function nonEmpty(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function elementsOf(v) {
+    if (!isArray(v))
+        return undefined;
+    const len = own(v, 'length');
+    if (!isCount(len))
+        return undefined;
+    const out = [];
+    for (let i = 0; i < len; i++) {
+        const r = slotReadOf(v, String(i));
+        if (r.presence !== 'present')
+            return undefined;
+        out.push(r.value);
+    }
+    return out;
+}
+function failedOf(c) {
+    return Object.freeze({ class: c, state: 'failed' });
+}
+function crossingOf(v) {
+    const kind = own(v, 'kind');
+    if (kind === 'none')
+        return { crossing: 'none' };
+    if (kind === 'attach')
+        return isObject(own(v, 'engine')) ? { crossing: 'same' } : { crossing: 'unknown' };
+    if (kind === 'ahead' || kind === 'behind') {
+        const running = own(v, 'running');
+        const mine = own(v, 'own');
+        if (typeof running !== 'string' || typeof mine !== 'string')
+            return { crossing: 'unknown' };
+        const cmp = compareReleaseVersions(running, mine);
+        if (kind === 'ahead')
+            return cmp === -1 && isObject(own(v, 'engine')) ? { crossing: 'older' } : { crossing: 'unknown' };
+        const source = own(v, 'source');
+        if (cmp !== 1 || (source !== 'running' && source !== 'high-water'))
+            return { crossing: 'unknown' };
+        return { crossing: 'newer', running, own: mine, source };
+    }
+    return { crossing: 'unknown' };
+}
+function targetOf(v) {
+    const engine = own(v, 'engine');
+    const anchored = own(v, 'anchored');
+    const src = isObject(engine) ? own(engine, 'identity') : isObject(anchored) ? anchored : v;
+    const id = engineIdentityOf({ pid: own(src, 'pid'), instanceId: own(src, 'instanceId'), startedAt: own(src, 'startedAt') });
+    return { ...(id.pid !== undefined ? { pid: id.pid } : {}), ...(id.instanceId !== undefined ? { instanceId: id.instanceId } : {}), ...(id.startedAt !== undefined ? { startedAt: id.startedAt } : {}) };
+}
+function drainEntryOf(e) {
+    if (!isObject(e))
+        return undefined;
+    const c = own(e, 'class');
+    if (!ENGINE_DRAIN_CLASSES.includes(c))
+        return undefined;
+    const cls = c;
+    const state = own(e, 'state');
+    if (state === 'failed')
+        return failedOf(cls);
+    if (state === 'unsupported')
+        return Object.freeze({ class: cls, state: 'unsupported' });
+    if (state !== 'count')
+        return undefined;
+    const count = own(e, 'count');
+    const rows = elementsOf(own(e, 'sessions'));
+    if (!isCount(count) || rows === undefined)
+        return undefined;
+    const sessions = [];
+    const seen = new Set();
+    let sum = 0;
+    for (const s of rows) {
+        const sessionId = nonEmpty(own(s, 'sessionId'));
+        const n = own(s, 'count');
+        if (sessionId === undefined || !isCount(n) || n === 0 || seen.has(sessionId))
+            return undefined;
+        seen.add(sessionId);
+        sum += n;
+        sessions.push(Object.freeze({ sessionId, count: n }));
+    }
+    if (sum !== count)
+        return undefined;
+    sessions.sort((a, b) => (a.sessionId < b.sessionId ? -1 : a.sessionId > b.sessionId ? 1 : 0));
+    return Object.freeze({ class: cls, state: 'count', count, sessions: Object.freeze(sessions) });
+}
+function drainOf(raw) {
+    const entries = elementsOf(raw);
+    const byClass = new Map();
+    let bad = entries === undefined;
+    for (const e of entries ?? []) {
+        const r = drainEntryOf(e);
+        if (r === undefined || byClass.has(r.class)) {
+            bad = true;
+            break;
+        }
+        byClass.set(r.class, r);
+    }
+    return Object.freeze(ENGINE_DRAIN_CLASSES.map(c => (bad ? undefined : byClass.get(c)) ?? failedOf(c)));
+}
+function fingerprintOf(crossing, v, drain) {
+    const running = own(v, 'running');
+    const mine = own(v, 'own');
+    return JSON.stringify([
+        'engine-swap-crossing/1',
+        crossing,
+        targetOf(v),
+        typeof running === 'string' ? running : null,
+        typeof mine === 'string' ? mine : null,
+        drain.map(r => (r.state === 'count' ? [r.class, r.state, r.count, r.sessions.map(s => [s.sessionId, s.count])] : [r.class, r.state])),
+    ]);
+}
+function judge(facts) {
+    const engine = own(facts, 'engine');
+    const d = crossingOf(engine);
+    if (d.crossing === 'newer') {
+        return Object.freeze({ kind: 'hold', reason: 'newer_engine', crossing: 'newer', running: d.running, own: d.own, source: d.source });
+    }
+    if (d.crossing === 'none' || d.crossing === 'same')
+        return Object.freeze({ kind: 'clear', crossing: d.crossing });
+    const drain = drainOf(own(facts, 'drain'));
+    const classes = Object.freeze(drain.filter(r => !(r.state === 'count' && r.count === 0)));
+    const holding = drain.some(r => r.state === 'failed' || (r.state === 'count' && r.count > 0));
+    const fingerprint = fingerprintOf(d.crossing, engine, drain);
+    const informedRaw = own(facts, 'informed');
+    const informed = typeof informedRaw === 'string' && informedRaw === fingerprint;
+    if (d.crossing === 'older') {
+        if (!holding)
+            return Object.freeze({ kind: 'clear', crossing: 'older' });
+        if (informed)
+            return Object.freeze({ kind: 'swap_and_tell', crossing: 'older', classes });
+        return Object.freeze({ kind: 'hold', reason: 'drain_unconfirmed', crossing: 'older', classes, fingerprint });
+    }
+    if (informed) {
+        return holding
+            ? Object.freeze({ kind: 'swap_and_tell', crossing: 'unknown', classes })
+            : Object.freeze({ kind: 'clear', crossing: 'unknown' });
+    }
+    return Object.freeze({ kind: 'unknown', crossing: 'unknown', classes, fingerprint });
+}
+const UNKNOWN_ALL_FAILED = () => {
+    const drain = Object.freeze(ENGINE_DRAIN_CLASSES.map(failedOf));
+    return Object.freeze({ kind: 'unknown', crossing: 'unknown', classes: drain, fingerprint: fingerprintOf('unknown', undefined, drain) });
+};
+export function engineSwapCrossingVerdict(facts) {
+    try {
+        return judge(facts);
+    }
+    catch {
+        return UNKNOWN_ALL_FAILED();
+    }
+}
+const PARKED = 'parked_tool_approvals';
+function parkedOf(emission) {
+    if (!isObject(emission) || own(emission, 'kind') !== 'snapshot')
+        return failedOf(PARKED);
+    const droppedSlot = slotReadOf(emission, 'pendingDropped');
+    if (droppedSlot.presence === 'unreadable')
+        return failedOf(PARKED);
+    if (droppedSlot.presence === 'present' && droppedSlot.value !== undefined && !(isCount(droppedSlot.value) && droppedSlot.value === 0))
+        return failedOf(PARKED);
+    const rows = elementsOf(own(emission, 'pending'));
+    if (rows === undefined)
+        return failedOf(PARKED);
+    const tally = new Map();
+    for (const row of rows) {
+        if (!isObject(row))
+            return failedOf(PARKED);
+        const sort = checkpointQueueRowSortOf(row);
+        if (sort === 'excluded')
+            continue;
+        if (sort === 'unreadable')
+            return failedOf(PARKED);
+        const gate = slotReadOf(row, 'gateKind');
+        const leg = gate.presence === 'unreadable' ? 'unreadable' : durableDecideLegOf({ gateKind: typeof gate.value === 'string' ? gate.value : null });
+        if (leg === 'plan_review' || leg === 'other_gate')
+            continue;
+        const verdict = checkpointRowVerdictOf(row);
+        if (verdict !== undefined && verdict.kind !== 'ok')
+            continue;
+        if (leg !== 'approval')
+            return failedOf(PARKED);
+        const sessionId = nonEmpty(own(row, 'sessionId'));
+        if (sessionId === undefined)
+            return failedOf(PARKED);
+        tally.set(sessionId, (tally.get(sessionId) ?? 0) + 1);
+    }
+    const sessions = [...tally.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([sessionId, count]) => Object.freeze({ sessionId, count }));
+    const count = sessions.reduce((n, s) => n + s.count, 0);
+    return Object.freeze({ class: PARKED, state: 'count', count, sessions: Object.freeze(sessions) });
+}
+export function parkedToolApprovalsBySession(emission) {
+    try {
+        return parkedOf(emission);
+    }
+    catch {
+        return failedOf(PARKED);
+    }
+}
+function say(key, lang, params) {
+    return renderMessage(msg(key, params), lang);
+}
+function classLine(r, lang) {
+    const state = own(r, 'state');
+    if (state === 'failed')
+        return say('localEngine.swapGuard.parked.failed', lang);
+    if (state === 'unsupported')
+        return say('localEngine.swapGuard.parked.unsupported', lang);
+    const count = own(r, 'count');
+    if (state !== 'count' || !isCount(count) || count === 0)
+        return undefined;
+    if (count === 1)
+        return say('localEngine.swapGuard.parked.one', lang);
+    const sessions = elementsOf(own(r, 'sessions'));
+    if (sessions !== undefined && sessions.length > 1)
+        return say('localEngine.swapGuard.parked.manySessions', lang, { count, sessions: sessions.length });
+    return say('localEngine.swapGuard.parked.oneSession', lang, { count });
+}
+function toldLine(r, lang) {
+    const state = own(r, 'state');
+    if (state === 'failed' || state === 'unsupported')
+        return say('localEngine.swapGuard.told.unknown', lang);
+    const count = own(r, 'count');
+    if (state !== 'count' || !isCount(count) || count === 0)
+        return undefined;
+    return count === 1 ? say('localEngine.swapGuard.told.one', lang) : say('localEngine.swapGuard.told.other', lang, { count });
+}
+function classesOf(v) {
+    return elementsOf(own(v, 'classes')) ?? [];
+}
+function joined(parts, lang) {
+    const out = parts.filter((p) => typeof p === 'string' && p.length > 0);
+    return out.length > 0 ? out.join(lang === 'zh' ? '' : ' ') : undefined;
+}
+export function engineSwapCrossingText(verdict, lane, upgrade, lang) {
+    try {
+        const kind = own(verdict, 'kind');
+        const reason = own(verdict, 'reason');
+        if (kind === 'hold' && reason === 'newer_engine') {
+            const running = own(verdict, 'running');
+            const mine = own(verdict, 'own');
+            const source = own(verdict, 'source');
+            if (typeof running !== 'string' || typeof mine !== 'string' || compareReleaseVersions(running, mine) !== 1)
+                return undefined;
+            if (source !== 'running' && source !== 'high-water')
+                return undefined;
+            const head = say(source === 'high-water' ? 'localEngine.swapGuard.newer.highWater' : 'localEngine.swapGuard.newer', lang, { running, own: mine });
+            const way = upgrade === 'cli-update'
+                ? say('localEngine.swapGuard.newer.cliUpdate', lang)
+                : upgrade === 'app-update'
+                    ? say('localEngine.swapGuard.newer.appUpdate', lang)
+                    : undefined;
+            return joined([head, way], lang);
+        }
+        const wayOut = () => say(lane === 'interactive' ? 'localEngine.swapGuard.wayOut.interactive' : 'localEngine.swapGuard.wayOut.print', lang);
+        if (kind === 'hold' && reason === 'drain_unconfirmed') {
+            return joined([say('localEngine.swapGuard.hold', lang), ...classesOf(verdict).map(r => classLine(r, lang)), wayOut()], lang);
+        }
+        if (kind === 'unknown') {
+            return joined([say('localEngine.swapGuard.unknown', lang), ...classesOf(verdict).map(r => classLine(r, lang)), wayOut()], lang);
+        }
+        if (kind === 'swap_and_tell')
+            return joined(classesOf(verdict).map(r => toldLine(r, lang)), lang);
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/engineUnavailable.d.ts

@@ -0,0 +1,44 @@
+import type { RequestLane } from './request/taskRequest.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const ENGINE_UNAVAILABLE_REASONS: readonly ["not_running", "not_answering", "address_refused", "version_refused", "model_setup", "credential_conflict", "credential_refused", "data_root_refused"];
+export type EngineUnavailableReason = (typeof ENGINE_UNAVAILABLE_REASONS)[number];
+export type EngineBootRefusalReason = Extract<EngineUnavailableReason, 'model_setup' | 'credential_conflict' | 'credential_refused' | 'data_root_refused'>;
+export declare const ENGINE_INSTALL_SHAPES: readonly ["npm-global", "managed", "npm-local", "dev", "app", "unknown"];
+export type EngineInstallShape = (typeof ENGINE_INSTALL_SHAPES)[number];
+export type EngineBootRefusalForm = {
+    readonly kind: 'embedded';
+    readonly install: EngineInstallShape;
+    readonly dataDir?: string;
+} | {
+    readonly kind: 'deployment';
+};
+export type EngineDataRootVariant = 'newer_root' | 'unreadable' | 'unknown';
+export type EngineBootWayOut = 'newer_build' | 'separate_data_root' | 'restore_backup' | 'repair_access';
+export declare const ENGINE_BOOT_REFUSAL_CODES: Readonly<Record<string, EngineBootRefusalReason>>;
+export interface LocalEngineBootRefusal {
+    readonly code?: string;
+    readonly hint?: string;
+    readonly text: string;
+    readonly reason?: EngineBootRefusalReason;
+    readonly restartWouldHelp?: false;
+    readonly variant?: EngineDataRootVariant;
+    readonly findings?: readonly string[];
+    readonly highWater?: string;
+    readonly engineVersion?: string;
+    readonly markerPath?: string;
+    readonly waysOut?: readonly EngineBootWayOut[];
+}
+export declare function engineBootRefusalOf(lines: readonly string[], scrub: (s: string) => string): LocalEngineBootRefusal | undefined;
+export declare function engineBootRefusalSentence(refusal: LocalEngineBootRefusal, lang?: UiLanguage, form?: EngineBootRefusalForm): string | undefined;
+export interface EngineUnavailableFacts {
+    readonly reason?: EngineUnavailableReason;
+    readonly code?: string;
+    readonly detail?: string;
+    readonly refusal?: LocalEngineBootRefusal;
+    readonly engineExitCode?: number | null;
+    readonly engineSignal?: string | null;
+    readonly pid?: number;
+    readonly answer?: 'silent' | 'answered' | 'drain-stuck';
+    readonly form?: EngineBootRefusalForm;
+}
+export declare function engineUnavailableLine(facts: EngineUnavailableFacts, lane: RequestLane, lang?: UiLanguage): string | undefined;