@skrr-ai/cli 0.1.114 → 0.1.115

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/computerUse.js

@@ -0,0 +1,358 @@
+/**
+ * Computer Use v1 is a host-to-host protocol, never a model tool schema.
+ * Models see exactly the runtime's js/js_reset surface. In particular, script
+ * contents cannot prove that a call is read-only or supply execution identity.
+ * Kept dependency-free so daemon, API, browser and native clients agree.
+ */
+export const COMPUTER_USE_TOOL = 'ComputerUse';
+export const COMPUTER_USE_PROVIDER = 'lcu';
+export const COMPUTER_USE_PROTOCOL = 'computer_use_mcp_v1';
+export const COMPUTER_USE_ROTATE_CREDENTIAL_EVENT = 'daemon:computer-use:rotate-credential';
+export const COMPUTER_USE_EXECUTION_CAPABILITY = 'computer_use';
+export const COMPUTER_USE_CLOUD_CONSENT = 'computer_use_cloud_agents_v1';
+export const COMPUTER_USE_PUBLIC_TOOLS = ['js', 'js_reset'];
+export const COMPUTER_USE_OPERATIONS = ['describe', 'call', 'end_turn', 'close', 'status', 'control_stop'];
+export const COMPUTER_USE_DEFAULT_BUDGETS = Object.freeze({
+    activeExecutionMs: 120_000,
+    humanResponseMs: 300_000,
+    totalLifetimeMs: 900_000,
+    cleanupGraceMs: 10_000,
+});
+/** Negotiated ceilings; exceeding a limit is an error, never silent clipping. */
+export const COMPUTER_USE_LIMITS = Object.freeze({
+    maxEnvelopeBytes: 32 * 1024 * 1024,
+    maxInstructionsBytes: 1024 * 1024,
+    maxSchemaBytes: 1024 * 1024,
+    maxContentBlocks: 512,
+    maxIdentityChars: 512,
+    maxActiveExecutionMs: 900_000,
+    maxHumanResponseMs: 900_000,
+    maxTotalLifetimeMs: 1_800_000,
+    maxCleanupGraceMs: 60_000,
+});
+/** Preserve original documentation while explaining the host's narrower lifecycle. */
+export function computerUseModelInstructions(surface) {
+    assertComputerUseSurface(surface);
+    if (!surface.runtimePolicy)
+        return surface.instructions;
+    return surface.instructions + '\n\nOverSky host policy\n' +
+        'Audio cleanup retires the complete runtime after js_reset and at the end of each host turn. ' +
+        'JavaScript variables and application handles persist only within the current turn. ' +
+        'Initialize fresh handles in the next turn; do not reuse handles from an earlier runtime.';
+}
+export const COMPUTER_USE_RUNTIME_STATES = [
+    'disabled', 'starting', 'ready', 'executing', 'awaiting_approval',
+    'ending_turn', 'unavailable', 'closed',
+];
+export const COMPUTER_USE_ELICITATION_CHOICES = ['once', 'session', 'always', 'decline'];
+export class ComputerUseContractError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ComputerUseContractError';
+    }
+}
+function fail(message) {
+    throw new ComputerUseContractError('invalid_computer_use_contract', message);
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function exactKeys(value, keys, name) {
+    if (Object.keys(value).some((key) => !keys.includes(key)))
+        fail(`Unsupported ${name} field`);
+}
+function identifier(value, name) {
+    if (typeof value !== 'string' || value.trim().length === 0 || value.length > COMPUTER_USE_LIMITS.maxIdentityChars)
+        fail(`Invalid ${name}`);
+}
+/** Reject non-JSON data before transport, including lossy NaN/undefined values. */
+function jsonSize(value) {
+    const seen = new Set();
+    const visit = (item) => {
+        if (item === null || typeof item === 'string' || typeof item === 'boolean')
+            return;
+        if (typeof item === 'number' && Number.isFinite(item))
+            return;
+        if (typeof item !== 'object' || !item || seen.has(item))
+            fail('Expected acyclic JSON data');
+        if (!Array.isArray(item) && Object.getPrototypeOf(item) !== Object.prototype && Object.getPrototypeOf(item) !== null)
+            fail('Expected plain JSON object');
+        seen.add(item);
+        for (const child of Array.isArray(item) ? item : Object.values(item))
+            visit(child);
+        seen.delete(item);
+    };
+    visit(value);
+    return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function boundedJson(value, max, name) {
+    if (jsonSize(value) > max)
+        fail(`${name} exceeds negotiated byte limit`);
+}
+/** Validate the hosted rotation envelope before changing runtime admission. */
+export function assertComputerUseRotateCredentialRequest(value) {
+    if (!record(value))
+        fail('Expected credential rotation request');
+    const ids = ['requestId', 'ownerUserId', 'machineUuid', 'leaseId'];
+    exactKeys(value, [...ids, 'generation'], 'credential rotation');
+    for (const key of ids) {
+        identifier(value[key], key);
+        if (value[key].length > 160)
+            fail(`Invalid ${key}`);
+    }
+    if (!Number.isSafeInteger(value.generation) || value.generation < 1)
+        fail('Invalid hosted desktop generation');
+}
+export function assertComputerUseHostContext(value) {
+    if (!record(value))
+        fail('Expected host context');
+    const required = ['principalId', 'machineId', 'sessionId', 'turnId'];
+    const optional = ['toolCallId', 'agentId', 'engine', 'conversationId', 'contextKey'];
+    exactKeys(value, [...required, ...optional, 'generation'], 'host context');
+    for (const key of required)
+        identifier(value[key], key);
+    for (const key of optional)
+        if (value[key] !== undefined)
+            identifier(value[key], key);
+    if (!Number.isSafeInteger(value.generation) || value.generation < 0)
+        fail('Invalid generation');
+}
+export function computerUseBudgets(value = {}) {
+    if (!record(value))
+        fail('Expected execution budgets');
+    const ceilings = {
+        activeExecutionMs: COMPUTER_USE_LIMITS.maxActiveExecutionMs,
+        humanResponseMs: COMPUTER_USE_LIMITS.maxHumanResponseMs,
+        totalLifetimeMs: COMPUTER_USE_LIMITS.maxTotalLifetimeMs,
+        cleanupGraceMs: COMPUTER_USE_LIMITS.maxCleanupGraceMs,
+    };
+    exactKeys(value, Object.keys(ceilings), 'budget');
+    const result = { ...COMPUTER_USE_DEFAULT_BUDGETS };
+    for (const key of Object.keys(ceilings)) {
+        if (value[key] === undefined)
+            continue;
+        if (!Number.isSafeInteger(value[key]) || value[key] <= 0 || value[key] > ceilings[key])
+            fail(`Invalid ${key}`);
+        result[key] = value[key];
+    }
+    if (result.totalLifetimeMs < result.activeExecutionMs || result.totalLifetimeMs < result.cleanupGraceMs)
+        fail('Total lifetime is shorter than execution or cleanup budget');
+    return result;
+}
+export function assertComputerUseInput(value) {
+    if (!record(value))
+        fail('Expected Computer Use operation');
+    switch (value.operation) {
+        case 'describe':
+            exactKeys(value, ['operation', 'surfaceMode'], 'describe');
+            if (value.surfaceMode !== undefined && !['computer', 'browser', 'all'].includes(value.surfaceMode))
+                fail('Unsupported surface mode');
+            break;
+        case 'call':
+            exactKeys(value, ['operation', 'tool', 'arguments', 'surfaceDigest', 'budgets'], 'call');
+            if (!COMPUTER_USE_PUBLIC_TOOLS.includes(value.tool))
+                fail('Unsupported public tool');
+            if (!record(value.arguments))
+                fail('Expected original tool arguments');
+            if (value.surfaceDigest !== undefined)
+                identifier(value.surfaceDigest, 'surfaceDigest');
+            if (value.budgets !== undefined)
+                computerUseBudgets(value.budgets);
+            break;
+        case 'end_turn':
+            exactKeys(value, ['operation', 'reason'], 'end_turn');
+            if (value.reason !== 'Stop' && value.reason !== 'Interrupt')
+                fail('Unsupported end reason');
+            break;
+        case 'close':
+        case 'control_stop':
+            exactKeys(value, ['operation', 'reason'], value.operation);
+            if (value.reason !== undefined)
+                identifier(value.reason, 'reason');
+            break;
+        case 'status':
+            exactKeys(value, ['operation'], 'status');
+            break;
+        default: fail('Unsupported Computer Use operation');
+    }
+    boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, 'Request');
+}
+export function assertComputerUseRequest(value) {
+    if (!record(value) || value.protocol !== COMPUTER_USE_PROTOCOL || value.provider !== COMPUTER_USE_PROVIDER)
+        fail('Unsupported Computer Use protocol/provider');
+    assertComputerUseHostContext(value.context);
+    const { protocol: _protocol, provider: _provider, context, ...input } = value;
+    assertComputerUseInput(input);
+    if (input.operation === 'call' && !context.toolCallId)
+        fail('Calls require exact host toolCallId');
+    boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, 'Request');
+}
+export function assertComputerUseSurface(value) {
+    if (!record(value) || value.protocol !== COMPUTER_USE_PROTOCOL || value.provider !== COMPUTER_USE_PROVIDER)
+        fail('Unsupported Computer Use surface');
+    if (typeof value.instructions !== 'string')
+        fail('Expected original runtime instructions');
+    if (new TextEncoder().encode(value.instructions).byteLength > COMPUTER_USE_LIMITS.maxInstructionsBytes)
+        fail('Instructions exceed negotiated byte limit');
+    identifier(value.digest, 'surface digest');
+    if (!['computer', 'browser', 'all'].includes(value.surfaceMode))
+        fail('Unsupported surface mode');
+    if (value.runtimePolicy !== undefined) {
+        if (!record(value.runtimePolicy))
+            fail('Invalid host runtime policy');
+        exactKeys(value.runtimePolicy, ['replPersistence', 'audioCleanup'], 'host runtime policy');
+        if (value.runtimePolicy.replPersistence !== 'turn' || value.runtimePolicy.audioCleanup !== 'retire-runtime')
+            fail('Unsupported host runtime policy');
+    }
+    if (!record(value.versions) || typeof value.versions.lcu !== 'string' || !value.versions.lcu)
+        fail('Missing LCU version');
+    if (Object.values(value.versions).some((v) => typeof v !== 'string'))
+        fail('Invalid runtime version');
+    if (!Array.isArray(value.tools) || value.tools.length !== 2)
+        fail('Expected js and js_reset descriptors');
+    const names = new Set();
+    for (const tool of value.tools) {
+        if (!record(tool) || !COMPUTER_USE_PUBLIC_TOOLS.includes(tool.name) || !record(tool.inputSchema))
+            fail('Invalid original tool descriptor');
+        if (tool.description !== undefined && typeof tool.description !== 'string')
+            fail('Invalid tool description');
+        if (names.has(tool.name))
+            fail('Duplicate public tool');
+        names.add(tool.name);
+        boundedJson(tool, COMPUTER_USE_LIMITS.maxSchemaBytes, 'Tool descriptor');
+    }
+    boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, 'Surface');
+}
+/** Validate the envelope without rewriting blocks or discarding upstream extensions. */
+export function assertComputerUseMcpResult(value) {
+    if (!record(value) || !Array.isArray(value.content) || value.content.length > COMPUTER_USE_LIMITS.maxContentBlocks)
+        fail('Invalid MCP result content');
+    if (value.isError !== undefined && typeof value.isError !== 'boolean')
+        fail('Invalid MCP isError');
+    if (value.structuredContent !== undefined && !record(value.structuredContent))
+        fail('Invalid MCP structuredContent');
+    for (const block of value.content) {
+        if (!record(block) || typeof block.type !== 'string' || !block.type)
+            fail('Invalid MCP content block');
+        if (block.type === 'text' && typeof block.text !== 'string')
+            fail('Invalid MCP text block');
+        if (block.type === 'image' && (typeof block.data !== 'string' || typeof block.mimeType !== 'string'))
+            fail('Invalid MCP image block');
+    }
+    boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, 'MCP result');
+}
+/** Compare full execution identity; a matching conversation alone never grants access. */
+export function sameComputerUseContext(left, right) {
+    return ['principalId', 'machineId', 'sessionId', 'turnId', 'generation', 'agentId', 'engine', 'conversationId', 'contextKey']
+        .every((key) => left[key] === right[key]);
+}
+export function assertComputerUseElicitationRequest(value) {
+    if (!record(value) || value.kind !== 'computer_use_runtime')
+        fail('Expected runtime elicitation');
+    exactKeys(value, ['kind', 'requestId', 'context', 'message', 'resource', 'options', 'expiresAt'], 'elicitation request');
+    identifier(value.requestId, 'requestId');
+    assertComputerUseHostContext(value.context);
+    identifier(value.context.toolCallId, 'toolCallId');
+    if (typeof value.message !== 'string' || !value.message)
+        fail('Missing runtime elicitation message');
+    if (value.resource !== undefined && !record(value.resource))
+        fail('Invalid runtime resource');
+    if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt <= 0)
+        fail('Invalid runtime elicitation expiry');
+    if (!Array.isArray(value.options) || value.options.length === 0 || value.options.length > COMPUTER_USE_ELICITATION_CHOICES.length)
+        fail('Invalid runtime choices');
+    const choices = new Set();
+    for (const option of value.options) {
+        if (!record(option))
+            fail('Invalid runtime option');
+        exactKeys(option, ['value', 'label', 'description'], 'elicitation option');
+        if (!COMPUTER_USE_ELICITATION_CHOICES.includes(option.value) || choices.has(option.value))
+            fail('Unsupported or duplicate runtime choice');
+        if (typeof option.label !== 'string' || !option.label || (option.description !== undefined && typeof option.description !== 'string'))
+            fail('Invalid runtime choice label');
+        choices.add(option.value);
+    }
+    boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, 'Runtime elicitation');
+}
+export function assertComputerUseElicitationResponse(value) {
+    if (!record(value))
+        fail('Expected runtime elicitation response');
+    exactKeys(value, ['requestId', 'context', 'choice'], 'elicitation response');
+    identifier(value.requestId, 'requestId');
+    assertComputerUseHostContext(value.context);
+    identifier(value.context.toolCallId, 'toolCallId');
+    if (!COMPUTER_USE_ELICITATION_CHOICES.includes(value.choice))
+        fail('Unsupported runtime choice');
+    boundedJson(value, COMPUTER_USE_LIMITS.maxEnvelopeBytes, 'Runtime elicitation response');
+}
+/** A human answer can only satisfy this exact pending request and offered scope.
+ * This matcher is not authentication: the caller must verify the human responder.
+ */
+export function acceptsComputerUseElicitationResponse(request, response, now = Date.now()) {
+    try {
+        assertComputerUseElicitationRequest(request);
+        assertComputerUseElicitationResponse(response);
+    }
+    catch {
+        return false;
+    }
+    return request.kind === 'computer_use_runtime' && request.requestId === response.requestId &&
+        Number.isFinite(request.expiresAt) && now < request.expiresAt &&
+        sameComputerUseContext(request.context, response.context) &&
+        typeof request.context.toolCallId === 'string' && request.context.toolCallId === response.context.toolCallId &&
+        COMPUTER_USE_ELICITATION_CHOICES.includes(response.choice) &&
+        request.options.some((option) => option.value === response.choice);
+}
+/**
+ * Consumer capability projection, never a rewrite of the canonical daemon
+ * result. Some model hosts accept MCP AudioContent but silently omit its bytes.
+ * Those hosts receive explicit references to already-persisted owned audio.
+ * This function never uploads, transcribes, invents a path or grants access.
+ */
+export function projectComputerUseResultForModel(result, options) {
+    assertComputerUseMcpResult(result);
+    if (!options || !['inline', 'artifact-reference'].includes(options.audio))
+        fail('Unsupported Computer Use model audio capability');
+    const audioCount = result.content.filter((block) => block.type === 'audio').length;
+    if (options.audio === 'inline' || audioCount === 0)
+        return result;
+    identifier(options.principalId, 'audio artifact owner');
+    identifier(options.sessionId, 'audio artifact session');
+    if (options.consumer !== undefined)
+        identifier(options.consumer, 'audio consumer');
+    const metadata = record(result._meta) ? result._meta : {};
+    const candidates = metadata['skrr.ai/computer-use-artifacts'];
+    const references = Array.isArray(candidates)
+        ? candidates.filter((item) => record(item) && typeof item.mimeType === 'string' && item.mimeType.startsWith('audio/'))
+        : [];
+    if (references.length < audioCount || references.some((item) => !record(item) || typeof item.fileId !== 'string' || !/^[A-Za-z0-9_-]{1,512}$/.test(item.fileId) ||
+        item.reference !== `file:${item.fileId}` || item.ownerUserId !== options.principalId ||
+        item.sessionId !== options.sessionId || !Number.isSafeInteger(item.bytes) || item.bytes <= 0 ||
+        typeof item.sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(item.sha256) ||
+        typeof item.mimeType !== 'string' || item.mimeType.length > 256 || !/^audio\/[A-Za-z0-9.+-]+(?:;[ -~]*)?$/.test(item.mimeType))) {
+        throw new ComputerUseContractError('computer_use_audio_artifact_required', 'This model cannot receive inline audio. Every audio block requires an existing owned file artifact for this exact session.');
+    }
+    const notice = [
+        'Audio is available as owned file artifacts. This model receives references instead of inline audio and has not listened to the recording.',
+        ...references.map((item) => `${item.reference} (${item.mimeType}; ${item.bytes} bytes; sha256 ${item.sha256})`),
+    ].join('\n');
+    let inserted = false;
+    const content = result.content.flatMap((block) => {
+        if (block.type !== 'audio')
+            return [block];
+        if (inserted)
+            return [];
+        inserted = true;
+        return [{ type: 'text', text: notice }];
+    });
+    const projected = { ...result, content, _meta: { ...metadata,
+            'skrr.ai/computer-use-model-projection': {
+                audio: 'artifact-reference', audioBlocks: audioCount,
+                ...(options.consumer ? { consumer: options.consumer } : {}),
+            },
+        } };
+    assertComputerUseMcpResult(projected);
+    return projected;
+}

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/daemonScopes.d.ts

@@ -52,16 +52,19 @@ export declare const SCOPES: Readonly<{
     readonly TOOLS_FS_WRITE: "daemon:tools:fs:write";
     readonly BROWSER_CDP: "daemon:browser:cdp";
     readonly NATIVE_UI_CONTROL: "daemon:native-ui:control";
+    readonly COMPUTER_USE_CONTROL: "daemon:computer-use:control";
     readonly SESSION_REPLAY: "daemon:session:replay";
     readonly OFFLINE_QUEUE: "daemon:offline-queue";
 }>;
 export type DaemonScope = (typeof SCOPES)[keyof typeof SCOPES];
 /**
- * The seven daemon scopes in canonical order. Frozen so consumers can
+ * All daemon scopes in canonical order. Login defaults are a separate opt-in policy. Frozen so consumers can
  * pass it directly to OAuth `scope` parameters without defensive
  * copies.
  */
 export declare const ALL_DAEMON_SCOPES: readonly DaemonScope[];
+/** Login defaults retain the existing surface; script control is explicit opt-in. */
+export declare const DEFAULT_DAEMON_SCOPES: readonly DaemonScope[];
 /**
  * Set form of `ALL_DAEMON_SCOPES` for O(1) membership checks.
  */

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/daemonScopes.js

@@ -52,11 +52,12 @@ export const SCOPES = Object.freeze({
     TOOLS_FS_WRITE: 'daemon:tools:fs:write',
     BROWSER_CDP: 'daemon:browser:cdp',
     NATIVE_UI_CONTROL: 'daemon:native-ui:control',
+    COMPUTER_USE_CONTROL: 'daemon:computer-use:control',
     SESSION_REPLAY: 'daemon:session:replay',
     OFFLINE_QUEUE: 'daemon:offline-queue',
 });
 /**
- * The seven daemon scopes in canonical order. Frozen so consumers can
+ * All daemon scopes in canonical order. Login defaults are a separate opt-in policy. Frozen so consumers can
  * pass it directly to OAuth `scope` parameters without defensive
  * copies.
  */
@@ -66,9 +67,12 @@ export const ALL_DAEMON_SCOPES = Object.freeze([
     SCOPES.TOOLS_FS_WRITE,
     SCOPES.BROWSER_CDP,
     SCOPES.NATIVE_UI_CONTROL,
+    SCOPES.COMPUTER_USE_CONTROL,
     SCOPES.SESSION_REPLAY,
     SCOPES.OFFLINE_QUEUE,
 ]);
+/** Login defaults retain the existing surface; script control is explicit opt-in. */
+export const DEFAULT_DAEMON_SCOPES = Object.freeze(ALL_DAEMON_SCOPES.filter((scope) => scope !== SCOPES.COMPUTER_USE_CONTROL));
 /**
  * Set form of `ALL_DAEMON_SCOPES` for O(1) membership checks.
  */

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/daemonWire.js

@@ -46,6 +46,7 @@
  * heard is `firstPartyHarness.ts`'s and the API's `sessionProvider.js`'s
  * decision, not this table's.
  */
+import { COMPUTER_DESKTOP_CAPABILITY, COMPUTER_DESKTOP_CONTROL_CAPABILITY, DAEMON_COMPUTER_DESKTOP_EVENTS } from './desktopWire.js';
 import { COMPUTER_CAPABILITIES, DAEMON_COMPUTER_EVENTS, DAEMON_COMPUTER_REPORT_EVENT_KEYS, } from './computerWire.js';
 // ---------------------------------------------------------------------------
 // Vocabulary
@@ -121,6 +122,15 @@ const CONNECTION = [
     toServer('daemon:shuttingDown', 'The daemon is draining before it exits, so the API can fail over without waiting for the socket to time out.'),
     toDaemon('server:draining', 'This API task is draining: reconnect (after jitter) to another one.'),
     toDaemon('auth:revoked', 'The credential this socket used was revoked: stop retrying and ask the person to sign in again.'),
+    toDaemon('error:stale-process', 'This daemon process was replaced by a fresher registration; stop transport drain recovery before disconnect.', {
+        payload: { kind: 'zod', schema: 'daemonConnectionFenceErrorSchema' },
+    }),
+    toDaemon('error:stale-generation', 'This Dedicated Runtime generation is no longer active; stop transport drain recovery before disconnect.', {
+        payload: { kind: 'zod', schema: 'daemonConnectionFenceErrorSchema' },
+    }),
+    toDaemon('error:stale-binding', 'This daemon credential was rebound to another account; stop transport drain recovery before disconnect.', {
+        payload: { kind: 'zod', schema: 'daemonConnectionFenceErrorSchema' },
+    }),
     toServer('daemon:auth-failed', 'The daemon could not refresh its own credential and needs the person to sign in again.'),
     toServer('daemon:auth-warning', "The daemon's credential expires soon."),
     toDaemon('error:unauthorized', 'The API refused an event this daemon sent, for lack of authority, naming the event.'),
@@ -273,6 +283,36 @@ const TOOLS = [
         capability: TOOL_RESPONSE_OUTBOX,
     }),
     toDaemon('daemon:tool:cancel', 'Abandon a running tool call.'),
+    toDaemon('daemon:computer:use-control', 'An authorized person observes, configures, stops or recovers the machine Computer Use provider.', {
+        stability: 'experimental', capability: 'computer_use_mcp_v1', delivery: 'acked', answeredBy: 'daemon:computer:ack',
+        payload: { kind: 'zod', schema: 'daemonComputerUseControlSchema' },
+    }),
+    toDaemon('daemon:computer-use:rotate-credential', 'The approved hosted-desktop owner requests credential rotation for this exact active machine lease generation.', {
+        stability: 'experimental', capability: 'computer_use_mcp_v1', delivery: 'acked', answeredBy: 'daemon:computer:ack',
+        payload: { kind: 'zod', schema: 'daemonComputerUseRotateCredentialSchema' },
+    }),
+    toDaemon('daemon:computer-use:revoke', 'Revoke cloud Computer Use bindings after owner machine authority was removed.', {
+        stability: 'experimental', capability: 'computer_use_mcp_v1',
+        payload: { kind: 'zod', schema: 'daemonComputerUseRevokeSchema' },
+    }),
+    ...['subscribe', 'protocol', 'unsubscribe'].map((operation) => toDaemon(DAEMON_COMPUTER_DESKTOP_EVENTS[operation], `Read-only desktop stream: ${operation}; bound to an authenticated attachment and generation.`, {
+        stability: 'experimental', capability: COMPUTER_DESKTOP_CAPABILITY,
+        delivery: 'acked', answeredBy: 'daemon:computer:ack',
+        payload: { kind: 'zod', schema: `daemonComputerDesktop${operation[0].toUpperCase()}${operation.slice(1)}Schema` },
+    })),
+    ...['control', 'input'].map((operation) => toDaemon(DAEMON_COMPUTER_DESKTOP_EVENTS[operation], `Human-only typed desktop ${operation}; exact authenticated attachment, stream and generation.`, {
+        stability: 'experimental', capability: COMPUTER_DESKTOP_CONTROL_CAPABILITY,
+        delivery: 'acked', answeredBy: 'daemon:computer:ack',
+        payload: { kind: 'zod', schema: `daemonComputerDesktop${operation[0].toUpperCase()}${operation.slice(1)}Schema` },
+    })),
+    toServer(DAEMON_COMPUTER_DESKTOP_EVENTS.controlChanged, 'Private desktop holder and input revocation fact; never carries a control token.', {
+        stability: 'experimental', capability: COMPUTER_DESKTOP_CONTROL_CAPABILITY,
+        payload: { kind: 'zod', schema: 'computerDesktopControlResultSchema' },
+    }),
+    toServer(DAEMON_COMPUTER_DESKTOP_EVENTS.data, 'Read-only desktop stream data or a terminal close fact for one attachment generation.', {
+        stability: 'experimental', capability: COMPUTER_DESKTOP_CAPABILITY,
+        payload: { kind: 'zod', schema: 'computerDesktopDataSchema' },
+    }),
     toServer('daemon:wire:chunk', 'One slice of a tool or session response above the single-message ceiling, sha256-checked and reassembled by the API before the reassembled event reaches its normal handler. Sent only to a server that announced `serverCaps.wireChunking`; the last slice is acked by that handler (OSK-16616).', {
         delivery: 'acked',
         stability: 'experimental',

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/desktopWire.d.ts

@@ -0,0 +1,140 @@
+/** A separately negotiated read-only desktop stream, not a browser surface or an input grant. */
+export declare const COMPUTER_DESKTOP_CAPABILITY: "computer_desktop_observe_v1";
+export declare const COMPUTER_DESKTOP_SURFACE_ID: "desktop:main";
+export declare const COMPUTER_DESKTOP_EVENTS: {
+    readonly subscribe: "computer:desktop:subscribe";
+    readonly protocol: "computer:desktop:protocol";
+    readonly unsubscribe: "computer:desktop:unsubscribe";
+    readonly data: "computer:desktop:data";
+    readonly control: "computer:desktop:control";
+    readonly input: "computer:desktop:input";
+    readonly controlChanged: "computer:desktop:control-changed";
+};
+export declare const DAEMON_COMPUTER_DESKTOP_EVENTS: {
+    readonly subscribe: "daemon:computer:desktop:subscribe";
+    readonly protocol: "daemon:computer:desktop:protocol";
+    readonly unsubscribe: "daemon:computer:desktop:unsubscribe";
+    readonly data: "daemon:computer:desktop:data";
+    readonly control: "daemon:computer:desktop:control";
+    readonly input: "daemon:computer:desktop:input";
+    readonly controlChanged: "daemon:computer:desktop:control-changed";
+};
+export declare const COMPUTER_DESKTOP_LIMITS: Readonly<{
+    maxIdChars: 160;
+    maxProtocolBase64Chars: number;
+    maxDataBase64Chars: number;
+}>;
+export declare const COMPUTER_DESKTOP_CLOSED_REASONS: readonly ["unavailable", "revoked", "protocol_error", "slow_viewer", "ended", "private_control"];
+export type ComputerDesktopClosedReason = (typeof COMPUTER_DESKTOP_CLOSED_REASONS)[number];
+export interface ComputerDesktopSubscribe {
+    attachmentId: string;
+    surfaceId: typeof COMPUTER_DESKTOP_SURFACE_ID;
+}
+export interface ComputerDesktopProtocol {
+    attachmentId: string;
+    streamId: string;
+    seq: number;
+    data: string;
+}
+export interface ComputerDesktopUnsubscribe {
+    attachmentId: string;
+    streamId: string;
+}
+export interface ComputerDesktopSubscribeResult {
+    attachmentId: string;
+    generation: number;
+    streamId: string;
+    surfaceId: typeof COMPUTER_DESKTOP_SURFACE_ID;
+    lane: 'desktop';
+    readOnly: true;
+}
+export type DaemonComputerDesktopSubscribe = ComputerDesktopSubscribe & {
+    requestId: string;
+    generation: number;
+};
+export type DaemonComputerDesktopProtocol = ComputerDesktopProtocol & {
+    requestId: string;
+    generation: number;
+};
+export type DaemonComputerDesktopUnsubscribe = ComputerDesktopUnsubscribe & {
+    requestId: string;
+    generation: number;
+};
+export type ComputerDesktopData = {
+    attachmentId: string;
+    generation: number;
+    streamId: string;
+    surfaceId: typeof COMPUTER_DESKTOP_SURFACE_ID;
+    lane: 'desktop';
+} & ({
+    kind: 'data';
+    seq: number;
+    data: string;
+} | {
+    kind: 'closed';
+    reason: ComputerDesktopClosedReason;
+});
+/** Canonical RFC 4648 base64 including zero pad bits; no whitespace/URL alphabet. */
+export declare function isComputerDesktopBase64(value: unknown, maxChars: number): value is string;
+/** Typed human input is independent of read-only RFB negotiation. */
+export declare const COMPUTER_DESKTOP_CONTROL_CAPABILITY: "computer_desktop_control_v1";
+export type ComputerDesktopInputEvent = {
+    type: 'pointer';
+    action: 'move' | 'down' | 'up' | 'scroll';
+    x: number;
+    y: number;
+    button?: 0 | 1 | 2;
+    deltaX?: number;
+    deltaY?: number;
+} | {
+    type: 'key';
+    action: 'down' | 'up';
+    key: string;
+} | {
+    type: 'text';
+    text: string;
+};
+export interface ComputerDesktopControl {
+    attachmentId: string;
+    streamId?: string;
+    action: 'takeover' | 'handback' | 'status' | 'recover_private';
+    expectedController?: {
+        sessionId: string;
+        turnId: string;
+        generation: number;
+    };
+    controlToken?: string;
+    epoch?: number;
+}
+export interface ComputerDesktopInput {
+    attachmentId: string;
+    streamId: string;
+    controlToken: string;
+    epoch: number;
+    seq: number;
+    event: ComputerDesktopInputEvent;
+}
+export interface ComputerDesktopControlResult {
+    attachmentId: string;
+    streamId?: string;
+    generation: number;
+    controlling: boolean;
+    private: boolean;
+    epoch: number;
+    controlToken?: string;
+    holderAttachmentId?: string;
+    holderUserId?: string;
+    state?: 'idle' | 'controlled' | 'private' | 'unavailable';
+    idleDeadline?: number;
+}
+export type DaemonComputerDesktopControl = ComputerDesktopControl & {
+    requestId: string;
+    generation: number;
+    userId: string;
+    label?: string;
+};
+export type DaemonComputerDesktopInput = ComputerDesktopInput & {
+    requestId: string;
+    generation: number;
+    userId: string;
+};

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/desktopWire.js

@@ -0,0 +1,42 @@
+/** A separately negotiated read-only desktop stream, not a browser surface or an input grant. */
+export const COMPUTER_DESKTOP_CAPABILITY = 'computer_desktop_observe_v1';
+export const COMPUTER_DESKTOP_SURFACE_ID = 'desktop:main';
+export const COMPUTER_DESKTOP_EVENTS = {
+    subscribe: 'computer:desktop:subscribe',
+    protocol: 'computer:desktop:protocol',
+    unsubscribe: 'computer:desktop:unsubscribe',
+    data: 'computer:desktop:data',
+    control: 'computer:desktop:control',
+    input: 'computer:desktop:input',
+    controlChanged: 'computer:desktop:control-changed',
+};
+export const DAEMON_COMPUTER_DESKTOP_EVENTS = {
+    subscribe: 'daemon:computer:desktop:subscribe',
+    protocol: 'daemon:computer:desktop:protocol',
+    unsubscribe: 'daemon:computer:desktop:unsubscribe',
+    data: 'daemon:computer:desktop:data',
+    control: 'daemon:computer:desktop:control',
+    input: 'daemon:computer:desktop:input',
+    controlChanged: 'daemon:computer:desktop:control-changed',
+};
+export const COMPUTER_DESKTOP_LIMITS = Object.freeze({
+    maxIdChars: 160,
+    maxProtocolBase64Chars: 88 * 1024,
+    maxDataBase64Chars: 128 * 1024,
+});
+export const COMPUTER_DESKTOP_CLOSED_REASONS = ['unavailable', 'revoked', 'protocol_error', 'slow_viewer', 'ended', 'private_control'];
+/** Canonical RFC 4648 base64 including zero pad bits; no whitespace/URL alphabet. */
+export function isComputerDesktopBase64(value, maxChars) {
+    if (typeof value !== 'string' || !value.length || value.length > maxChars || value.length % 4 !== 0)
+        return false;
+    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))
+        return false;
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    if (value.endsWith('=='))
+        return (alphabet.indexOf(value[value.length - 3]) & 15) === 0;
+    if (value.endsWith('='))
+        return (alphabet.indexOf(value[value.length - 2]) & 3) === 0;
+    return true;
+}
+/** Typed human input is independent of read-only RFB negotiation. */
+export const COMPUTER_DESKTOP_CONTROL_CAPABILITY = 'computer_desktop_control_v1';

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/firstPartyHarness.d.ts

@@ -365,7 +365,7 @@ export declare const FIRST_PARTY_HARNESS_ENGINE: Readonly<{
      * `readFirstPartyHarnessEngineEnv` to read one the way the engine does and
      * `firstPartyHarnessEngineEnvEntries` to set one every engine build honours.
      */
-    env: Readonly<Record<"appName" | "serverPassword" | "serverUsername" | "home" | "config" | "scriptName" | "allowUpstreamEgress" | "compatOpencode" | "noCompatPrompts" | "maxInputTokens" | "sessionId", string>>;
+    env: Readonly<Record<"sessionId" | "appName" | "serverPassword" | "serverUsername" | "home" | "config" | "scriptName" | "allowUpstreamEgress" | "compatOpencode" | "noCompatPrompts" | "maxInputTokens", string>>;
 }>;
 /**
  * Every name the engine reads for one purpose, current namespace first — the