@ours.network/fleet 1.2.0-nightly.45 → 1.2.0-nightly.47

package/dist/session/codex-app-server.js

@@ -227,6 +227,14 @@ export class CodexAppServerSession {
             throw error;
         }
     }
+    liveVoiceSupported = true;
+    async interruptPrompt(generation, promptId) {
+        if (generation !== this.sessionGeneration)
+            throw new Error('session_changed: Agent session changed.');
+        if (this.activeTurn?.promptId !== promptId)
+            return { state: 'settled' };
+        return this.interrupt('local-console');
+    }
     async interrupt(source = 'local-console') {
         const active = this.activeTurn;
         if (!active || !this.threadId)
@@ -376,6 +384,8 @@ export class CodexAppServerSession {
             return existing;
         if (command.expectedSessionGeneration !== undefined && command.expectedSessionGeneration !== this.conversationSnapshot().sessionGeneration)
             throw new Error('session_changed: Agent session changed. Record a new voice message.');
+        if (command.requireIdle && (this.queueDepth > 0 || this.conversationSnapshot().readiness !== 'idle'))
+            throw new Error('voice_busy: Agent is already working. Wait for the current turn.');
         const queued = await this.queuePrompt(command.text, {
             origin: { kind: 'owner-admin-console', commandId: command.commandId },
             actor: { browserSession: command.actorBrowserSession },

package/dist/session/control.d.ts

@@ -11,11 +11,13 @@ export interface ControlRequest {
     version: 1 | 2 | 3;
     id: string;
     token: string;
-    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'submit_voice_prompt' | 'interrupt_v2' | 'layout_control' | 'agent_contacts' | 'agent_history' | 'respond_permission_v2' | 'fleet_spawn' | 'fleet_audit_begin' | 'fleet_audit_present' | 'fleet_audit_finish';
+    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'submit_voice_prompt' | 'interrupt_v2' | 'interrupt_voice_v2' | 'layout_control' | 'agent_contacts' | 'agent_history' | 'respond_permission_v2' | 'fleet_spawn' | 'fleet_audit_begin' | 'fleet_audit_present' | 'fleet_audit_finish';
     layout?: LayoutControlRequest;
     agentHistory?: AgentHistoryQuery;
     text?: string;
     expectedSessionGeneration?: string;
+    requireIdle?: boolean;
+    promptId?: string;
     permissionId?: string;
     optionId?: string;
     since?: number;

package/dist/session/control.js

@@ -9,7 +9,7 @@ import { interruptSession, queueSessionPrompt, respondSessionPermission, respond
 const MAX_LINE_BYTES = 64 * 1024;
 /** Commands that require protocol version 3. */
 const V3_COMMANDS = new Set([
-    'conversation_page', 'conversation_follow', 'submit_prompt_v2', 'submit_voice_prompt', 'interrupt_v2',
+    'conversation_page', 'conversation_follow', 'submit_prompt_v2', 'submit_voice_prompt', 'interrupt_v2', 'interrupt_voice_v2',
     'respond_permission_v2',
 ]);
 /** The one retained-range projection shared by polling and live-follow admission. */
@@ -243,6 +243,7 @@ export class RoleControlServer {
                                 ...(this.correspondence ? ['agent_correspondence'] : []),
                                 ...(this.session.conversationPage ? ['conversation_v3'] : []),
                                 ...(this.session.submitPromptBrowser ? ['generation_bound_prompts'] : []),
+                                ...(this.session.liveVoiceSupported ? ['idle_bound_prompts', 'targeted_voice_interrupt'] : []),
                                 ...(this.session.capabilities?.steering ? ['steering'] : []),
                                 ...(this.session.capabilities?.permissions ? ['permissions'] : []),
                                 ...(this.session.capabilities?.messagePhases ? ['message_phases'] : []),
@@ -466,7 +467,7 @@ export class RoleControlServer {
                         const receipt = await this.session.submitPromptBrowser({
                             commandId: request.commandId, text: request.text,
                             source: 'owner_admin_console', actorBrowserSession: request.actor,
-                            expectedSessionGeneration: request.expectedSessionGeneration,
+                            expectedSessionGeneration: request.expectedSessionGeneration, requireIdle: request.requireIdle === true,
                         });
                         this.write(socket, { version: 1, id: request.id, ok: true, result: receipt });
                     }
@@ -477,6 +478,29 @@ export class RoleControlServer {
                     }
                     return;
                 }
+                case 'interrupt_voice_v2': {
+                    this.requireConversation(request);
+                    if (!request.commandId?.trim() || !request.expectedSessionGeneration?.trim() || !request.promptId?.trim())
+                        throw new SessionControlError('rejected', 'commandId, expectedSessionGeneration and promptId are required');
+                    if (!this.session.interruptPrompt)
+                        throw new SessionControlError('rejected', 'targeted voice interrupt unavailable');
+                    const key = 'voice:' + request.commandId;
+                    const signature = JSON.stringify([request.expectedSessionGeneration, request.promptId]);
+                    const existing = this.interruptCommands.get(key);
+                    if (existing) {
+                        if (existing.signature !== signature)
+                            throw new SessionControlError('rejected', 'idempotency_conflict: interrupt target changed');
+                        this.write(socket, { version: 1, id: request.id, ok: true, result: existing.receipt });
+                        return;
+                    }
+                    const outcome = await this.session.interruptPrompt(request.expectedSessionGeneration, request.promptId);
+                    const receipt = { accepted: true, commandId: request.commandId, ...outcome };
+                    this.interruptCommands.set(key, { signature, receipt });
+                    if (this.interruptCommands.size > 200)
+                        this.interruptCommands.delete(this.interruptCommands.keys().next().value);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result: receipt });
+                    return;
+                }
                 case 'interrupt_v2': {
                     this.requireConversation(request);
                     if (!request.commandId?.trim())

package/dist/session/conversation-types.d.ts

@@ -264,6 +264,8 @@ export interface ConversationEventV1 {
 }
 export interface SubmitPromptCommand {
     expectedSessionGeneration?: string;
+    /** Live speech must not silently queue behind an unrelated turn. */
+    requireIdle?: boolean;
     /** Idempotency-Key / clientRequestId. Reuse with a different body is a conflict. */
     commandId: string;
     text: string;

package/dist/session/types.d.ts

@@ -319,6 +319,9 @@ export interface AgentSession {
      * keep compiling. Read it through `interruptOutcome`, never directly.
      */
     interrupt(source?: TurnCancellationSource): Promise<InterruptResult>;
+    /** Atomically bind cancellation to one voice-owned turn. */
+    readonly liveVoiceSupported?: boolean;
+    interruptPrompt?(generation: string, promptId: string): Promise<InterruptResult>;
     respondPermission(permissionId: string, optionId: string): boolean;
     /** Generation-bound browser decision; stale/settled/invalid all fail closed. */
     respondPermissionV2?(permissionId: string, optionId: string, sessionGeneration: string): 'accepted' | 'stale';

package/dist/tunnel-setup-input.d.ts

@@ -6,3 +6,14 @@ export declare function readTunnelSetupStdin(input?: AsyncIterable<Buffer | stri
 export declare function readTunnelSetupArgument(input: string): string;
 /** Redeem the grant by HTTPS POST; long-lived connector credentials remain off argv and URLs. */
 export declare function redeemTunnelSetup(input: string, request?: typeof fetch): Promise<WorkspacePayload>;
+/** Inspect only public destination metadata; this never consumes a one-use grant. */
+export declare function inspectTunnelSetup(input: string, request?: typeof fetch): Promise<{
+    workspaceId: string;
+    serverCid: string;
+    appOrigin: string;
+} | undefined>;
+export declare function verifyTunnelSetupTarget(target: {
+    workspaceId: string;
+    serverCid: string;
+    appOrigin: string;
+} | undefined, payload: WorkspacePayload): void;

package/dist/tunnel-setup-input.js

@@ -80,3 +80,45 @@ export async function redeemTunnelSetup(input, request = fetch) {
         throw Error('Tunnel setup response origin mismatch');
     return payload;
 }
+/** Inspect only public destination metadata; this never consumes a one-use grant. */
+export async function inspectTunnelSetup(input, request = fetch) {
+    let version;
+    try {
+        version = JSON.parse(Buffer.from(input.trim(), 'base64url').toString()).version;
+    }
+    catch { }
+    if (version === 1) {
+        const p = decodeWorkspacePayload(input);
+        return { workspaceId: p.challenge.workspaceId, serverCid: p.serverCid, appOrigin: p.appOrigin };
+    }
+    const grant = decodeTunnelSetupGrant(input);
+    let response;
+    try {
+        response = await request(grant.appOrigin + '/account-api/workspace-install-inspect', { method: 'POST', redirect: 'error', credentials: 'omit', signal: AbortSignal.timeout(15000), headers: { Origin: grant.appOrigin, 'Content-Type': 'application/json' }, body: JSON.stringify({ code: grant.code }) });
+    }
+    catch {
+        throw Error('Could not inspect the account setup command; existing setup and grant preserved');
+    }
+    if (response.status === 404 || response.status === 405) {
+        await response.body?.cancel();
+        return;
+    }
+    if (!response.ok) {
+        await response.body?.cancel();
+        throw Error('Setup command inspection failed; existing setup and grant preserved');
+    }
+    let target;
+    try {
+        target = await response.json();
+    }
+    catch {
+        throw Error('Invalid setup command inspection response');
+    }
+    if (!target || Object.keys(target).sort().join(',') !== 'serverCid,workspaceId' || typeof target.workspaceId !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(target.workspaceId) || typeof target.serverCid !== 'string' || !/^[a-f0-9]{64}$/i.test(target.serverCid))
+        throw Error('Invalid setup command inspection response');
+    return { ...target, appOrigin: grant.appOrigin };
+}
+export function verifyTunnelSetupTarget(target, payload) {
+    if (target && (target.workspaceId !== payload.challenge.workspaceId || target.serverCid.toUpperCase() !== payload.serverCid.toUpperCase() || target.appOrigin !== payload.appOrigin))
+        throw Error('Redeemed setup command differs from inspected destination; existing setup preserved');
+}

package/dist/web/server.js

@@ -691,6 +691,11 @@ export async function buildWebServer(services, boundary, options = {}) {
         const detail = await services.query.detail(request.params.id);
         return { ...detail, chatIdle: detail.role.lifetime === 'temporary' ? readChatIdle(agentDir(request.params.id, true)) ?? null : null };
     });
+    app.get('/api/v1/roles/:id/voice-capabilities', async (request) => {
+        auth.authenticate(request);
+        const descriptor = await (await services.session(request.params.id)).describe();
+        return { supported: ['generation_bound_prompts', 'idle_bound_prompts', 'targeted_voice_interrupt'].every(f => descriptor.features.includes(f)) };
+    });
     app.get('/api/v1/roles/:id/removal-preview', async (request) => {
         auth.authenticate(request);
         if (!ROLE_NAME_RE.test(request.params.id))
@@ -781,6 +786,8 @@ export async function buildWebServer(services, boundary, options = {}) {
         const body = request.body;
         if (body?.expectedSessionGeneration !== undefined && (typeof body.expectedSessionGeneration !== 'string' || !body.expectedSessionGeneration.trim()))
             throw new FleetError('invalid_request', 'expectedSessionGeneration must be a nonempty string');
+        if (body?.requireIdle !== undefined && typeof body.requireIdle !== 'boolean')
+            throw new FleetError('invalid_request', 'requireIdle must be boolean');
         let text = String(body?.text ?? '');
         if (body?.attachments !== undefined) {
             if (typeof body.commandId !== 'string' || !body.commandId.trim())
@@ -807,7 +814,7 @@ export async function buildWebServer(services, boundary, options = {}) {
             const admittedCommandId = commandId ?? randomBytes(16).toString('hex');
             const receipt = await control.submitPromptV2({
                 commandId: admittedCommandId, text, source: 'owner_admin_console',
-                expectedSessionGeneration: body.expectedSessionGeneration,
+                expectedSessionGeneration: body.expectedSessionGeneration, requireIdle: body.requireIdle === true,
                 actorBrowserSession: createHmac('sha256', digestKey).update(session.id).digest('hex').slice(0, 24),
             });
             await audit.record({
@@ -819,7 +826,7 @@ export async function buildWebServer(services, boundary, options = {}) {
             reply.code(202);
             return receipt;
         }
-        if (body.expectedSessionGeneration !== undefined)
+        if (body.expectedSessionGeneration !== undefined || body.requireIdle)
             throw new FleetError('capability_unavailable', 'session-bound voice input is unavailable for this role');
         const receipt = await control.sendText(text);
         await audit.record({
@@ -836,6 +843,16 @@ export async function buildWebServer(services, boundary, options = {}) {
         const commandId = typeof body?.commandId === 'string' && body.commandId.trim()
             ? body.commandId : undefined;
         const control = await services.session(request.params.id);
+        if (body?.expectedSessionGeneration !== undefined || body?.promptId !== undefined) {
+            if (!commandId || typeof body.expectedSessionGeneration !== 'string' || !body.expectedSessionGeneration.trim() || typeof body.promptId !== 'string' || !body.promptId.trim())
+                throw new FleetError('invalid_request', 'Targeted interrupt requires commandId, expectedSessionGeneration and promptId');
+            if (!control.interruptPromptV2)
+                throw new FleetError('capability_unavailable', 'Targeted voice interrupt is unavailable');
+            const receipt = await control.interruptPromptV2({ commandId, expectedSessionGeneration: body.expectedSessionGeneration, promptId: body.promptId });
+            await audit.record({ requestId: request.id, browser: session.id, roleId: request.params.id, action: 'session.interrupt_voice', result: 'accepted' });
+            reply.code(202);
+            return receipt;
+        }
         if (commandId && control.interruptV2) {
             const receipt = await control.interruptV2(commandId);
             await audit.record({
@@ -920,6 +937,70 @@ export async function buildWebServer(services, boundary, options = {}) {
             throw new FleetError('role_not_found', 'creation action not found');
         return action;
     });
+    // A fetch stream works through the same authenticated workspace transport as
+    // ordinary requests, and owns one ACP controller until its browser disconnects.
+    app.post('/api/v1/roles/:id/live-presence', async (request, reply) => {
+        const browser = auth.authenticate(request, true);
+        const generation = request.body?.expectedSessionGeneration;
+        if (typeof generation !== 'string' || !generation.trim())
+            throw new FleetError('invalid_request', 'expectedSessionGeneration is required');
+        const control = await services.session(request.params.id);
+        if (!control.followConversation || !control.conversationPage)
+            throw new FleetError('capability_unavailable', 'Live voice requires a conversation controller');
+        const page = await control.conversationPage({ limit: 1 });
+        if (page.snapshot.sessionGeneration !== generation)
+            throw new FleetError('stale_state', 'Agent session changed. Start live voice again.');
+        // Session/page discovery can await I/O; recheck revocation before attaching.
+        auth.authenticate(request, true);
+        if (reply.raw.destroyed)
+            return;
+        reply.hijack();
+        for (const [name, value] of Object.entries(reply.getHeaders()))
+            if (value !== undefined)
+                reply.raw.setHeader(name, Array.isArray(value) ? value : String(value));
+        reply.raw.writeHead(200, { 'Content-Type': 'application/x-ndjson', 'Cache-Control': 'no-store', 'X-Accel-Buffering': 'no' });
+        let ended = false;
+        let follow;
+        let heartbeat;
+        let unbind;
+        const close = () => { if (ended)
+            return; ended = true; unbind?.(); if (heartbeat)
+            clearInterval(heartbeat); follow?.close(); reply.raw.end(); };
+        const write = (value) => { if (!ended && !reply.raw.write(JSON.stringify(value) + '\n'))
+            close(); };
+        reply.raw.once('close', close);
+        unbind = auth.bindTransport(browser.id, close);
+        try {
+            follow = await control.followConversation({
+                after: page.nextCursor,
+                onPage: current => { if (current.snapshot.sessionGeneration !== generation) {
+                    write({ error: 'Agent session changed. Start live voice again.' });
+                    close();
+                }
+                else
+                    write({ ready: true }); },
+                onEvent: event => { if (event.sessionGeneration !== generation) {
+                    write({ error: 'Agent session changed. Start live voice again.' });
+                    close();
+                } },
+                onClose: () => close(),
+            });
+            if (ended)
+                follow.close();
+            else
+                heartbeat = setInterval(() => { try {
+                    auth.authenticate(request);
+                    write({ heartbeat: true });
+                }
+                catch {
+                    close();
+                } }, 10_000);
+        }
+        catch {
+            write({ error: 'Agent controller connection failed.' });
+            close();
+        }
+    });
     app.post('/api/v1/ws-tickets', async (request) => {
         const body = request.body;
         if (!body?.purpose || !['events', 'conversation'].includes(body.purpose))

package/dist/web/workspace-devices.d.ts

@@ -25,5 +25,7 @@ export declare class WorkspaceDeviceStore {
     valid(id: string): boolean;
     list(): WorkspaceDevice[];
     revoke(id: string): void;
+    /** Retire account links without changing the installation's stable host ID or other data. */
+    revokeAll(): void;
     close(): void;
 }

package/dist/web/workspace-devices.js

@@ -80,5 +80,18 @@ export class WorkspaceDeviceStore {
     valid(id) { return Boolean(this.db.prepare('SELECT id FROM devices WHERE id=? AND revokedAt IS NULL AND expiresAt>?').get(id, this.now())); }
     list() { return this.db.prepare('SELECT id,label,createdAt,lastUsedAt,expiresAt,revokedAt FROM devices ORDER BY createdAt DESC LIMIT 256').all().map(row => ({ id: String(row.id), label: String(row.label), createdAt: Number(row.createdAt), lastUsedAt: Number(row.lastUsedAt), expiresAt: Number(row.expiresAt), revokedAt: row.revokedAt === null ? null : Number(row.revokedAt) })); }
     revoke(id) { this.db.prepare('UPDATE devices SET revokedAt=? WHERE id=? AND revokedAt IS NULL').run(this.now(), id); this.db.prepare('DELETE FROM enrollments WHERE issuer=?').run(id); }
+    /** Retire account links without changing the installation's stable host ID or other data. */
+    revokeAll() {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.db.prepare('UPDATE devices SET revokedAt=? WHERE revokedAt IS NULL').run(this.now());
+            this.db.exec('DELETE FROM enrollments');
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
     close() { this.db.close(); }
 }

package/dist/workspace-enrollment.d.ts

@@ -6,7 +6,7 @@ export interface WorkspacePayload {
     rootName: string;
     name: string;
     surname: string;
-    connectorToken: string;
+    connectorToken?: string;
     invitation: string;
     serverCid: string;
     challenge: {
@@ -17,7 +17,11 @@ export interface WorkspacePayload {
     };
 }
 export declare function readWorkspacePayload(file: string): WorkspacePayload;
-export declare function decodeWorkspacePayload(input: string): WorkspacePayload;
+export declare function decodeWorkspacePayload(input: string, options?: {
+    allowExpired?: boolean;
+}): WorkspacePayload;
+/** Credential-free renewal is allowed only on the host already holding this private connector. */
+export declare function checkWorkspaceConnector(payload: WorkspacePayload): void;
 type DaemonClient = Pick<OursClient, 'listIdentities' | 'chooseIdentity' | 'addContact' | 'listContacts' | 'sendCommand' | 'removeContact' | 'releaseLease' | 'close'>;
 /** How tunnel setup reaches this host's daemon; replaced only by tests. */
 export type AttachDaemonClient = (options: AttachOursClientOptions) => Promise<DaemonClient>;
@@ -29,6 +33,7 @@ export declare function checkWorkspaceConfiguration(configuration?: string, atta
 export declare function enrollWorkspace(payload: WorkspacePayload, configuration?: string, options?: {
     migrateAppOrigin?: boolean;
     preserveProfile?: boolean;
+    replacingWorkspace?: string;
     attach?: AttachDaemonClient;
     contactWaitMs?: number;
     afterInvitation?: () => void;
@@ -51,4 +56,27 @@ export declare function configureWorkspacePort(payload: Pick<WorkspacePayload, '
  * so the setup can be finished later. A removal that fails is reported and does not undo the setup.
  */
 export declare function confirmWorkspaceTarget(payload: Pick<WorkspacePayload, 'appOrigin' | 'challenge'>, hostWorkspaceId: string, rootCid: string, port: number, cleanupFailed?: (error: unknown) => void): Promise<void>;
+/** Retire exactly the original registration using the same signed Human root that bound it. */
+export declare function unregisterWorkspace(previous: {
+    workspaceId: string;
+    hostWorkspaceId: string;
+    appOrigin: string;
+    serverCid: string;
+    proofRootCid?: string;
+}, payload: WorkspacePayload, operationNonce: string, attach?: AttachDaemonClient, options?: {
+    request?: typeof fetch;
+    waitMs?: number;
+    checkOnly?: boolean;
+    beforeSend?: () => void;
+    operationExpiresAt?: number;
+    onReceipt?: (status: {
+        deleted?: boolean;
+        retired?: boolean;
+        absent?: boolean;
+        rejected?: boolean;
+        expired?: boolean;
+        deadlineEnforced?: boolean;
+        oldBindingPresent?: boolean;
+    }) => void;
+}): Promise<string>;
 export {};