@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/deviceFlowPolling.js

@@ -0,0 +1,28 @@
+import { SETTINGS_DEVICE_CODE_TTL_SECONDS, SETTINGS_DEVICE_POLL_INTERVAL_SECONDS } from './generated/settingsSchemaTables.js';
+function positiveSecondsOf(reading, key) {
+    try {
+        const desc = Object.getOwnPropertyDescriptor(reading, key);
+        if (desc === undefined || !('value' in desc))
+            return undefined;
+        const v = desc.value;
+        return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function deviceFlowPollingPlan(reading) {
+    let isObjectReading = false;
+    try {
+        isObjectReading = typeof reading === 'object' && reading !== null && !Array.isArray(reading);
+    }
+    catch {
+        isObjectReading = false;
+    }
+    if (!isObjectReading)
+        return undefined;
+    const r = reading;
+    const ttlSeconds = positiveSecondsOf(r, 'expires_in') ?? SETTINGS_DEVICE_CODE_TTL_SECONDS;
+    const intervalSeconds = Math.max(1, positiveSecondsOf(r, 'interval') ?? SETTINGS_DEVICE_POLL_INTERVAL_SECONDS);
+    return Object.freeze({ timeoutMs: ttlSeconds * 1000, intervalSeconds });
+}

package/dist/deviceRebind.d.ts

@@ -0,0 +1,88 @@
+import type { AgentClient } from '@sema-agent/sdk';
+export type DeviceListVerb = Pick<AgentClient['devices'], 'list'>;
+export type DeviceSessionBindingVerb = Pick<AgentClient['devices'], 'sessionBinding'>;
+export type DeviceRebindVerb = Pick<AgentClient['devices'], 'rebind'>;
+export interface DeviceRosterRow {
+    readonly deviceId: string;
+    readonly name?: string;
+    readonly status: 'online' | 'offline' | 'unknown';
+    readonly lastSeenAt?: string;
+}
+export interface DeviceBindingReading {
+    readonly deviceId: string;
+    readonly rev: number;
+    readonly boundAt?: string;
+}
+export interface DeviceRefused {
+    readonly kind: 'refused';
+    readonly status: number;
+    readonly errorCode?: string;
+    readonly message?: string;
+}
+export interface DeviceLaneAbsent {
+    readonly kind: 'lane-absent';
+    readonly runStoreOnly?: true;
+}
+export interface DeviceTransport {
+    readonly kind: 'transport';
+    readonly detail?: string;
+}
+export interface DeviceUnreadable {
+    readonly kind: 'unreadable';
+    readonly why: string;
+}
+export interface DeviceUnarmed {
+    readonly kind: 'unarmed';
+}
+export type DeviceListOutcome = {
+    readonly kind: 'ok';
+    readonly devices: readonly DeviceRosterRow[];
+    readonly dropped: number;
+} | DeviceUnreadable | DeviceLaneAbsent | DeviceRefused | DeviceTransport | DeviceUnarmed;
+export type DeviceSessionBindingOutcome = {
+    readonly kind: 'ok';
+    readonly rootSessionId: string;
+    readonly boundDevice: DeviceBindingReading;
+} | {
+    readonly kind: 'not-found';
+} | DeviceUnreadable | DeviceLaneAbsent | DeviceRefused | DeviceTransport | DeviceUnarmed;
+export interface DeviceRebindInput {
+    readonly rootSessionId: string;
+    readonly toDeviceId: string;
+    readonly expectedRev: number;
+    readonly fromDeviceId: string;
+}
+export interface DeviceRebindUnconfirmed {
+    readonly kind: 'unconfirmed';
+    readonly why: 'accepted-unreadable' | 'transport' | 'server-error';
+    readonly detail?: string;
+    readonly mayStillBeRunning: boolean;
+}
+export type DeviceRebindOutcome = {
+    readonly kind: 'ok';
+    readonly deviceId: string;
+    readonly rev: number;
+    readonly workspaceCarryover?: 'none';
+} | {
+    readonly kind: 'active-run';
+    readonly activeTaskId?: string;
+} | {
+    readonly kind: 'rev-conflict';
+    readonly currentRev?: number;
+} | {
+    readonly kind: 'not-found';
+} | DeviceRebindUnconfirmed | DeviceLaneAbsent | DeviceRefused | DeviceUnarmed;
+export type DeviceRebindReconcileVerdict = 'landed' | 'already-there' | 'unchanged' | 'unknown';
+export declare function listDevices(devices: DeviceListVerb | null | undefined, opts?: {
+    readonly signal?: AbortSignal | undefined;
+}): Promise<DeviceListOutcome>;
+export declare function readSessionBinding(devices: DeviceSessionBindingVerb | null | undefined, rootSessionId: string, opts?: {
+    readonly signal?: AbortSignal | undefined;
+}): Promise<DeviceSessionBindingOutcome>;
+export declare function rebindSession(devices: DeviceRebindVerb | null | undefined, req: DeviceRebindInput, opts?: {
+    readonly signal?: AbortSignal | undefined;
+}): Promise<DeviceRebindOutcome>;
+export declare function reconcileRebindOutcome(before: DeviceBindingReading, toDeviceId: string, after: DeviceBindingReading | null, opts: {
+    readonly serverMayStillBeRunning: boolean;
+}): DeviceRebindReconcileVerdict;
+export declare function rebindProvesRequestNotApplied(outcome: DeviceRebindOutcome): boolean;

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

@@ -38,4 +38,5 @@ export declare function credentialWashPasses(text: string, opts?: DisplayUntrust
     capped: boolean;
 };
 export declare function displayUntrusted(text: string, opts?: DisplayUntrustedOptions): string;
+export declare function quoteUntrustedForSentence(text: string, max: number): string | undefined;
 export declare function displayUntrustedMarks(text: string, opts?: DisplayUntrustedOptions): DisplayUntrustedMarked;