@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/deviceRebind.js

@@ -0,0 +1,242 @@
+import { atMostOnceVerdictOf } from './atMostOnce.js';
+import { readOwnDataValue } from './ownKey.js';
+const LANE_ABSENT = 'capability.device_lane_required';
+const RUN_STORE_ABSENT = 'capability.run_store_required';
+const NOT_FOUND = 'not_found.device';
+const ACTIVE_RUN = 'device.rebind_active_run';
+const REV_CONFLICT = 'device.rebind_rev_conflict';
+const SERVICE_TOKEN_REQUIRED = 'auth.service_token_required';
+function own(v, key) {
+    if (v === null || typeof v !== 'object')
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function slot(e, key) {
+    if (e === null || (typeof e !== 'object' && typeof e !== 'function'))
+        return undefined;
+    try {
+        return e[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+function nonEmpty(v) {
+    return typeof v === 'string' && v !== '' ? v : undefined;
+}
+function nonNegInt(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 0 ? v : undefined;
+}
+function isArraySafely(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function refusedOf(status, code, e) {
+    const message = nonEmpty(slot(e, 'message'));
+    return { kind: 'refused', status, ...(code !== undefined ? { errorCode: code } : {}), ...(message !== undefined ? { message } : {}) };
+}
+function transportOf(v) {
+    return { kind: 'transport', ...(v.name !== undefined ? { detail: v.name } : {}) };
+}
+function commonOf(status, code) {
+    if (status === 501 && code === LANE_ABSENT)
+        return { kind: 'lane-absent' };
+    if (status === 501 && code === RUN_STORE_ABSENT)
+        return { kind: 'lane-absent', runStoreOnly: true };
+    if (status === 404 && code === NOT_FOUND)
+        return { kind: 'not-found' };
+    return null;
+}
+function readFailureOf(e) {
+    const v = atMostOnceVerdictOf(e);
+    const common = commonOf(v.status, v.code);
+    if (common !== null)
+        return common;
+    return v.status !== undefined ? refusedOf(v.status, v.code, e) : transportOf(v);
+}
+function verbOf(slice, name) {
+    const v = slot(slice, name);
+    return typeof v === 'function' ? v : undefined;
+}
+function signalOpts(opts) {
+    const s = slot(opts, 'signal');
+    return s !== undefined && s !== null ? { signal: s } : {};
+}
+function rowOf(raw) {
+    const deviceId = nonEmpty(own(raw, 'deviceId'));
+    if (deviceId === undefined)
+        return null;
+    const st = own(raw, 'status');
+    const name = nonEmpty(own(raw, 'name'));
+    const lastSeenAt = nonEmpty(own(raw, 'lastSeenAt'));
+    return {
+        deviceId,
+        ...(name !== undefined ? { name } : {}),
+        status: st === 'online' ? 'online' : st === 'offline' ? 'offline' : 'unknown',
+        ...(lastSeenAt !== undefined ? { lastSeenAt } : {}),
+    };
+}
+export async function listDevices(devices, opts) {
+    const verb = verbOf(devices, 'list');
+    if (verb === undefined)
+        return { kind: 'unarmed' };
+    let body;
+    try {
+        body = await verb.call(devices, signalOpts(opts));
+    }
+    catch (e) {
+        const f = readFailureOf(e);
+        return f.kind === 'not-found' ? refusedOf(404, NOT_FOUND, e) : f;
+    }
+    const raw = own(body, 'devices');
+    if (!isArraySafely(raw)) {
+        return { kind: 'unreadable', why: 'the body carries no device list (the `devices` key is absent or not an array) — refusing to render that as an empty roster' };
+    }
+    const rows = [];
+    let dropped = 0;
+    const len = nonNegInt(own(raw, 'length')) ?? 0;
+    for (let i = 0; i < len; i++) {
+        const r = rowOf(own(raw, String(i)));
+        if (r === null)
+            dropped++;
+        else
+            rows.push(r);
+    }
+    return { kind: 'ok', devices: rows, dropped };
+}
+function bindingOf(raw) {
+    const deviceId = nonEmpty(own(raw, 'deviceId'));
+    const rev = nonNegInt(own(raw, 'rev'));
+    if (deviceId === undefined || rev === undefined)
+        return null;
+    const boundAt = nonEmpty(own(raw, 'boundAt'));
+    return { deviceId, rev, ...(boundAt !== undefined ? { boundAt } : {}) };
+}
+export async function readSessionBinding(devices, rootSessionId, opts) {
+    const verb = verbOf(devices, 'sessionBinding');
+    if (verb === undefined)
+        return { kind: 'unarmed' };
+    let body;
+    try {
+        body = await verb.call(devices, rootSessionId, signalOpts(opts));
+    }
+    catch (e) {
+        return readFailureOf(e);
+    }
+    const rid = own(body, 'rootSessionId');
+    if (typeof rid !== 'string' || rid !== rootSessionId) {
+        return { kind: 'unreadable', why: "the binding it returned does not echo the session id that was asked for — refusing to use another session's binding as this one's prior state" };
+    }
+    const bound = bindingOf(own(body, 'boundDevice'));
+    if (bound === null) {
+        return { kind: 'unreadable', why: 'the binding it returned has no usable prior state (deviceId + rev) — refusing to treat it as a binding' };
+    }
+    return { kind: 'ok', rootSessionId: rid, boundDevice: bound };
+}
+function rebindFailureOf(e) {
+    const v = atMostOnceVerdictOf(e);
+    const { status, code } = v;
+    const common = commonOf(status, code);
+    if (common !== null)
+        return common;
+    if (status === 409 && code === ACTIVE_RUN) {
+        const activeTaskId = nonEmpty(own(e, 'activeTaskId'));
+        return { kind: 'active-run', ...(activeTaskId !== undefined ? { activeTaskId } : {}) };
+    }
+    if (status === 409 && code === REV_CONFLICT) {
+        const currentRev = nonNegInt(own(e, 'currentRev'));
+        return { kind: 'rev-conflict', ...(currentRev !== undefined ? { currentRev } : {}) };
+    }
+    if (status === 503 && code === SERVICE_TOKEN_REQUIRED)
+        return refusedOf(status, code, e);
+    if (v.delivery === 'rejected' && status !== undefined)
+        return refusedOf(status, code, e);
+    if (status !== undefined)
+        return { kind: 'unconfirmed', why: 'server-error', detail: String(status), mayStillBeRunning: true };
+    return { kind: 'unconfirmed', why: 'transport', ...(v.name !== undefined ? { detail: v.name } : {}), mayStillBeRunning: true };
+}
+export async function rebindSession(devices, req, opts) {
+    const rootSessionId = slot(req, 'rootSessionId');
+    const toDeviceId = slot(req, 'toDeviceId');
+    const expectedRev = slot(req, 'expectedRev');
+    const fromDeviceId = slot(req, 'fromDeviceId');
+    if (nonNegInt(expectedRev) === undefined) {
+        return {
+            kind: 'refused',
+            status: 0,
+            errorCode: 'request.field_invalid',
+            message: 'expectedRev must be a non-negative integer read from the current binding — refusing to send a made-up prior state',
+        };
+    }
+    const verb = verbOf(devices, 'rebind');
+    if (verb === undefined)
+        return { kind: 'unarmed' };
+    let body;
+    try {
+        body = await verb.call(devices, rootSessionId, { toDeviceId, expectedRev }, signalOpts(opts));
+    }
+    catch (e) {
+        return rebindFailureOf(e);
+    }
+    const deviceId = nonEmpty(own(body, 'deviceId'));
+    const rev = nonNegInt(own(body, 'rev'));
+    const echoed = own(body, 'rootSessionId');
+    const prior = expectedRev;
+    const sound = deviceId !== undefined &&
+        rev !== undefined &&
+        typeof echoed === 'string' &&
+        echoed === rootSessionId &&
+        deviceId === toDeviceId &&
+        (rev === prior + 1 || (rev === prior && fromDeviceId === toDeviceId));
+    if (!sound)
+        return { kind: 'unconfirmed', why: 'accepted-unreadable', mayStillBeRunning: false };
+    const carry = own(body, 'workspaceCarryover') === 'none' ? 'none' : undefined;
+    return { kind: 'ok', deviceId, rev, ...(carry !== undefined ? { workspaceCarryover: carry } : {}) };
+}
+export function reconcileRebindOutcome(before, toDeviceId, after, opts) {
+    if (after === null)
+        return 'unknown';
+    const b = bindingOf(before);
+    const a = bindingOf(after);
+    if (b === null || a === null || typeof toDeviceId !== 'string')
+        return 'unknown';
+    const onTarget = a.deviceId === toDeviceId;
+    const revStepped = a.rev === b.rev + 1;
+    const revStatic = a.rev === b.rev;
+    const wasMoveRequest = b.deviceId !== toDeviceId;
+    if (onTarget && revStepped && wasMoveRequest)
+        return 'landed';
+    if (slot(opts, 'serverMayStillBeRunning') !== false)
+        return 'unknown';
+    if (onTarget && revStatic && !wasMoveRequest)
+        return 'already-there';
+    if (!onTarget && a.deviceId === b.deviceId && revStatic)
+        return 'unchanged';
+    return 'unknown';
+}
+export function rebindProvesRequestNotApplied(outcome) {
+    const kind = slot(outcome, 'kind');
+    switch (kind) {
+        case 'active-run':
+        case 'rev-conflict':
+        case 'not-found':
+        case 'lane-absent':
+        case 'unarmed':
+            return true;
+        case 'refused': {
+            const status = slot(outcome, 'status');
+            return typeof status === 'number' && (status < 500 || slot(outcome, 'errorCode') === SERVICE_TOKEN_REQUIRED);
+        }
+        default:
+            return false;
+    }
+}

package/dist/displayUntrusted.d.ts

@@ -8,9 +8,6 @@ export interface DisplayFace {
     readonly mark: DisplayMark;
     readonly keepBlanks?: boolean;
 }
-export declare const LEGACY_ESCAPE_FACE: DisplayFace;
-export declare const LEGACY_LABEL_FACE: DisplayFace;
-export declare const LEGACY_NAME_FACE: DisplayFace;
 export declare function applyDisplayFace(text: string, face: DisplayFace): string;
 export interface DisplayUntrustedOptions {
     readonly credentialUrls?: boolean;
@@ -33,9 +30,17 @@ export interface DisplayUntrustedMarked {
     readonly text: string;
     readonly marks: readonly DisplayMarkSpan[];
 }
+export declare const ESCAPE_FACE: DisplayFace;
+export declare const LABEL_FACE: DisplayFace;
+export declare const PEER_NAME_FACE: DisplayFace;
+export declare function capDisplay(text: string, max: number | undefined, mark: DisplayMark): string;
+export declare function paintAndCap(text: string, face: DisplayFace, max?: number): string;
 export declare function credentialWashPasses(text: string, opts?: DisplayUntrustedOptions | null): {
     passes: number;
     capped: boolean;
 };
 export declare function displayUntrusted(text: string, opts?: DisplayUntrustedOptions): string;
+export declare function queryCarriesCredential(query: string): boolean;
+export declare function displayConfiguredUrl(url: string, opts?: DisplayUntrustedOptions): string;
+export declare function quoteUntrustedForSentence(text: string, max: number): string | undefined;
 export declare function displayUntrustedMarks(text: string, opts?: DisplayUntrustedOptions): DisplayUntrustedMarked;