arcane-os 0.80.0 → 0.82.0

package/runtime/arcane/components/chat.html

@@ -886,6 +886,7 @@
     const aiActivationButton=shadowRoot.querySelector('#ai_activation_button');
     const [
         {default:MD},
+        {hydrateMarkdownMedia},
         {default:FileEntity},
         {ConversationSubmissionBarrier,requireConversationTimeboxDelivery},
         {requestAIRuntimeIntent,subscribeAIRuntimeState},
@@ -893,6 +894,7 @@
         {getBrowserDeviceClass}
     ]=await Promise.all([
         import('../modules/MD.js'),
+        import('../modules/MarkdownMedia.js'),
         import('../entities/File.js'),
         import('../modules/ConversationTimebox.js'),
         import('../modules/AIRuntimeState.js'),
@@ -946,15 +948,19 @@
     let destroyed=false;
     let recognitionDraft=null;
     let writingRecognitionDraft=false;
+    const transcriptMedia=new Map();
+    let printMediaRetains=null;
     const printViewPromise=import('../modules/PrintView.js').then(
         function registerChatPrint({createPrintView}){
             if(destroyed) return null;
             return createPrintView({
                 host,
-                content:function chatPrintContent(){return chatOutput;},
+                content:renderedChatPrintContent,
                 title:function chatPrintTitle(){return host.printTitle||'Conversation';},
                 active:function chatPrintActive(){return !destroyed&&chatOutput.children.length>0;},
                 signal:aiRuntimeStateAbortController.signal,
+                retain:retainChatPrintMedia,
+                prepare:prepareChatPrintMedia,
                 onError:reportChatPrintFailure
             });
         }
@@ -1190,6 +1196,7 @@
             for(const item of record.removedNodes) {
                 if(item.localName === 'li' && item.parentElement !== chatOutput) {
                     transcriptResizeObserver?.unobserve(item);
+                    releaseTranscriptMessageMedia(item);
                 }
             }
             for(const item of record.addedNodes) {
@@ -1427,14 +1434,72 @@
         return entry;
     }
 
+    function renderTranscriptMarkdown(target,content){
+        if(destroyed) return null;
+        const template=target.ownerDocument.createElement('template');
+        template.innerHTML=new MD(content).rendered;
+        const pending=[...template.content.querySelectorAll('img')].some(
+            function localChatImage(image){
+                return image.getAttribute('src')?.startsWith('arcane-media:');
+            }
+        );
+        // Remove local-reference src values while detached; text renders now,
+        // and the shared media owner observes independent storage and decoding.
+        const handle=hydrateMarkdownMedia(template.content,{
+            signal:aiRuntimeStateAbortController.signal
+        });
+        releaseTranscriptMarkdown(target);
+        const media={handle,pending,error:null,status:null,ready:null};
+        transcriptMedia.set(target,media);
+        if(printMediaRetains){
+            printMediaRetains.add(handle.retain());
+        }
+        target.raw=content;
+        target.replaceChildren(template.content);
+        media.ready=handle.ready.then(function transcriptImagesReady(){
+            media.pending=false;
+        },function transcriptImagesFailed(error){
+            media.pending=false;
+            media.error=error;
+            if(destroyed||transcriptMedia.get(target)!==media) return;
+            arcaneLogging.error('Unable to display saved Chat images.',error);
+            const status=target.ownerDocument.createElement('p');
+            status.className='message_media_status';
+            status.setAttribute('role','status');
+            status.textContent='Some saved images could not be displayed.';
+            media.status=status;
+            target.after(status);
+            scrollTranscriptToBottom();
+        });
+        return media;
+    }
+
+    function releaseTranscriptMarkdown(target){
+        const media=transcriptMedia.get(target);
+        if(!media) return;
+        transcriptMedia.delete(target);
+        media.status?.remove();
+        media.handle.destroy();
+    }
+
+    function releaseTranscriptMessageMedia(item){
+        const markdown=item?.querySelector('.markdown');
+        if(markdown) releaseTranscriptMarkdown(markdown);
+    }
+
+    function removeTranscriptMessage(item){
+        if(!item) return;
+        releaseTranscriptMessageMedia(item);
+        item.remove();
+    }
+
     function setTranscriptMessageContent(item,content,timestamp){
         if(!is.string(content)){
             throw new TypeError('Chat session message content must be a string.');
         }
         item.querySelector('.thinking')?.remove();
         const markdown=item.querySelector('.markdown');
-        markdown.raw=content;
-        markdown.innerHTML=new MD(content).rendered;
+        renderTranscriptMarkdown(markdown,content);
         if(timestamp!==undefined){
             item.querySelector('.message_timestamp')?.replaceWith(
                 transcriptTime(timestamp)
@@ -1495,12 +1560,11 @@
         header.append(heading);
         const markdown=chatOutput.ownerDocument.createElement('div');
         markdown.className='markdown';
-        markdown.raw=content;
-        markdown.innerHTML=new MD(content).rendered;
         item.append(header,markdown,transcriptTime(timestamp));
         for(const call of normalizeVisibleToolCalls(toolCalls)){
             appendVisibleToolCall(item,call);
         }
+        renderTranscriptMarkdown(markdown,content);
         return item;
     }
 
@@ -1642,6 +1706,9 @@
         setPendingStructuralToolCalls(
             actionable?[...restoredPendingToolCalls.values()]:[]
         );
+        for(const item of chatOutput.children){
+            releaseTranscriptMessageMedia(item);
+        }
         chatOutput.replaceChildren(fragment);
         transcriptFollowing = true;
         transcriptScrollTop = chatOutput.scrollTop;
@@ -3034,9 +3101,7 @@
             thinkingHTML.remove();
         }
         
-        target.raw ? target.raw+=text : target.raw=text;
-
-        target.innerHTML=new MD(target.raw).rendered;
+        renderTranscriptMarkdown(target,target.raw?target.raw+text:text);
         
         scrollTranscriptToBottom();
     }
@@ -3393,8 +3458,7 @@
         message.querySelector('.thinking')?.remove();
         const markdown=message.querySelector('.markdown');
         const text=visibleErrorMessage(error,'The AI request failed.');
-        markdown.raw=text;
-        markdown.innerHTML=new MD(text).rendered;
+        renderTranscriptMarkdown(markdown,text);
         scrollTranscriptToBottom();
         return true;
     }
@@ -3421,8 +3485,8 @@
         const response=[...chatOutput.children].find(
             candidate=>candidate.id===`message-${messageId}`
         )||null;
-        response?.remove();
-        for(const request of requestMessages) request.remove();
+        removeTranscriptMessage(response);
+        for(const request of requestMessages) removeTranscriptMessage(request);
         const existing=textArea.value;
         if(existing!==text){
             textArea.value=existing
@@ -3500,7 +3564,7 @@
         function removeTransientSessionCards(){
             if(retainTurn||!transientCards.length) return;
             // The submitter supplies only nodes created for this submission.
-            for(const card of transientCards) card.remove();
+            for(const card of transientCards) removeTranscriptMessage(card);
             transientCards.length=0;
             scrollTranscriptToBottom();
         }
@@ -3675,9 +3739,9 @@
                     const response=[...chatOutput.children].find(
                         candidate=>candidate.id===`message-${messageId}`
                     )||null;
-                    response?.remove();
+                    removeTranscriptMessage(response);
                     for(const requestMessage of requestMessages){
-                        requestMessage.remove();
+                        removeTranscriptMessage(requestMessage);
                     }
                     scrollTranscriptToBottom();
                 }else if(retainTurn){
@@ -3692,7 +3756,7 @@
                 arcaneLogging.error('Arcane chat request failed.',error);
                 if(sessionRequestMessages.every(message=>message.role==='tool')){
                     for(const requestMessage of requestMessages){
-                        requestMessage.remove();
+                        removeTranscriptMessage(requestMessage);
                     }
                 }
                 if(retainTurn) renderSessionMessageFailure(messageId,error);
@@ -4136,11 +4200,64 @@
         return message;
     }
 
+    function renderedChatPrintContent(){
+        for(const media of transcriptMedia.values()){
+            if(media.pending){
+                const error=new Error('Saved images are still loading. Print again when they finish.');
+                error.code='ARCANE_MARKDOWN_MEDIA_PENDING';
+                throw error;
+            }
+            if(media.error) throw media.error;
+        }
+        return chatOutput;
+    }
+
+    function retainChatPrintMedia(){
+        renderedChatPrintContent();
+        const releases=new Set();
+        for(const media of transcriptMedia.values()){
+            releases.add(media.handle.retain());
+        }
+        printMediaRetains=releases;
+        return function releaseChatPrintMedia(){
+            if(printMediaRetains===releases){
+                printMediaRetains=null;
+            }
+            for(const release of releases) release();
+            releases.clear();
+        };
+    }
+
+    async function prepareChatPrintMedia(signal){
+        let cancel;
+        const cancelled=new Promise(function waitForChatPrintCancellation(resolve){cancel=resolve;});
+        signal?.addEventListener('abort',cancel,{once:true});
+        try{
+            while(!destroyed&&!signal?.aborted){
+                const selected=[...transcriptMedia];
+                await Promise.race([
+                    Promise.all(selected.map(function readyChatMedia([,media]){return media.ready;})),
+                    cancelled
+                ]);
+                if(destroyed||signal?.aborted) return false;
+                if(selected.length!==transcriptMedia.size||selected.some(
+                    function replacedChatMedia([target,media]){return transcriptMedia.get(target)!==media;}
+                )) continue;
+                renderedChatPrintContent();
+                return true;
+            }
+            return false;
+        }finally{
+            signal?.removeEventListener('abort',cancel);
+        }
+    }
+
     async function print(){
         if(destroyed) return false;
         try{
             const view=await printViewPromise;
-            return destroyed||!view?false:await view.print();
+            if(destroyed||!view||!await prepareChatPrintMedia()) return false;
+            return await view.print();
         }catch(error){
             reportChatPrintFailure(error);
             throw error;
@@ -4150,7 +4267,9 @@
     function reportChatPrintFailure(error){
         arcaneLogging.error('Unable to print the conversation.',error);
         if(!destroyed){
-            setSessionStatus('error','Unable to open print preview. Please try again.');
+            setSessionStatus('error',error?.code==='ARCANE_MARKDOWN_MEDIA_PENDING'
+                ?'Saved images are still loading. Print again when they finish.'
+                :'Unable to open print preview. Please try again.');
         }
     }
 
@@ -4235,6 +4354,9 @@
             ownership.abort(destroyReason);
         }
         aiRuntimeStateAbortController.abort(destroyReason);
+        for(const target of transcriptMedia.keys()){
+            releaseTranscriptMarkdown(target);
+        }
         aiActivationController.destroy();
         window.removeEventListener('pagehide',handlePageHide);
         window.removeEventListener('pageshow',handlePageShow);

package/runtime/arcane/modules/AI.js

@@ -5018,6 +5018,7 @@ class AI {
         model,
         structuredOutput=false,
         localOnly=false,
+        speech=true,
         onChunk=function ignoreStreamChunk(){},
         toolText,
         onToolText,
@@ -5062,6 +5063,9 @@ class AI {
         if(localOnly!==true&&localOnly!==false){
             throw new TypeError('AI localOnly must be a boolean.');
         }
+        if(speech!==true&&speech!==false){
+            throw new TypeError('AI speech must be a boolean.');
+        }
         if(localOnly&&!this.#hasLocalRoute('llm',this.llmService)){
             const error=new Error(
                 'This AI request requires a configured local model.'
@@ -5163,7 +5167,7 @@ class AI {
                 if(signal?.aborted){
                     throw normalizeAIRequestAbort();
                 }
-                this.#finishStreamingSpeech();
+                if(speech)this.#finishStreamingSpeech();
                 return result;
             }catch(error){
                 if(handle){
@@ -5171,7 +5175,7 @@ class AI {
                         function retainProviderStreamCleanupFailure() {}
                     );
                 }
-                this.stopAudio();
+                if(speech)this.stopAudio();
                 throw isAIRequestAbort(error,signal)
                     ?normalizeAIRequestAbort(error)
                     :error;
@@ -5223,10 +5227,10 @@ class AI {
             if(signal?.aborted){
                 throw normalizeAIRequestAbort();
             }
-            this.#finishStreamingSpeech();
+            if(speech)this.#finishStreamingSpeech();
             return result;
         }catch(error){
-            this.stopAudio();
+            if(speech)this.stopAudio();
             throw isAIRequestAbort(error,signal)
                 ?normalizeAIRequestAbort(error)
                 :error;
@@ -6026,7 +6030,8 @@ class AI {
             }
             throw error;
         }finally{
-            if(!speechTurnCompleted){
+            // Provider transports leave speech lifecycle to their public caller.
+            if(finishSpeech&&!speechTurnCompleted){
                 this.stopAudio();
             }
         }

package/src/cli/app-control.mjs

@@ -0,0 +1,106 @@
+import {readFile, writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {connectAppControl} from '../core/app-control.mjs';
+import {CoreError, serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
+
+const HELP_TEXT=`Usage:
+  arcane app-control status --endpoint <pipe-or-socket>
+  arcane app-control inspect --endpoint <pipe-or-socket> [--selector <css-selector>]
+  arcane app-control capture --endpoint <pipe-or-socket> --output <png-file>
+  arcane app-control act --endpoint <pipe-or-socket> --request <json-file>
+
+Connects to the selected running native window. Results are complete JSON.
+Capture writes the PNG to --output and prints its metadata. Request and output
+filenames are relative to the current directory. This command does not launch
+an application or change its profile. --output selects the capture filename;
+the other Arcane commands retain their existing output-format option.
+`;
+
+function usage(message) {
+    throw new CoreError({code: 'APP_CONTROL_USAGE', message, exitCode: 2});
+}
+
+function parseArguments(argv) {
+    if (!argv.length || argv.includes('--help') || argv.includes('-h')) return {help: true};
+    const [action] = argv;
+    const allowed = {
+        status: ['endpoint'],
+        inspect: ['endpoint', 'selector'],
+        capture: ['endpoint', 'output'],
+        act: ['endpoint', 'request']
+    }[action];
+    if (!Array.isArray(allowed)) usage('Expected app-control status, inspect, capture, or act.');
+    const values = {};
+    for (let index = 1; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const equal = argument.indexOf('=');
+        const option = equal === -1 ? argument : argument.slice(0, equal);
+        if (!option.startsWith('--') || !allowed.includes(option.slice(2))) {
+            usage(`Unexpected argument for app-control ${action}: ${argument}`);
+        }
+        const value = equal === -1 ? argv[++index] : argument.slice(equal + 1);
+        if (value === undefined || value === '' || (equal === -1 && value.startsWith('--'))) {
+            usage(`${option} requires a value.`);
+        }
+        values[option.slice(2)] = value;
+    }
+    if (!values.endpoint) usage('App control requires --endpoint <pipe-or-socket>.');
+    if (action === 'capture' && !values.output) usage('App-control capture requires --output <png-file>.');
+    if (action === 'act' && !values.request) usage('App-control act requires --request <json-file>.');
+    return {action, ...values};
+}
+
+/** This command owns its filename option before the general output-mode parser. */
+export async function runAppControlCli(argv, {cwd = process.cwd(), stdout = process.stdout,
+    stderr = process.stderr, controller = new AbortController()} = {}) {
+    let connection;
+    let result;
+    const failures = [];
+    function failed(error) {
+        if (!failures.includes(error)) failures.push(error);
+    }
+    function interrupted() { controller.abort(new Error('Interrupted')); }
+    process.once('SIGINT', interrupted);
+    process.once('SIGTERM', interrupted);
+    try {
+        const selection = parseArguments(argv);
+        if (selection.help) {
+            stdout.write(HELP_TEXT);
+            return 0;
+        }
+        stderr.write(`${JSON.stringify({status: 'running', operation: selection.action,
+            endpoint: selection.endpoint})}\n`);
+        const signal = controller.signal;
+        const parameters = selection.action === 'act'
+            ? JSON.parse(await readFile(path.resolve(cwd, selection.request), {encoding: 'utf8', signal}))
+            : selection.selector === undefined ? {} : {selector: selection.selector};
+        connection = await connectAppControl({endpoint: selection.endpoint, signal, onError: failed});
+        if (selection.action === 'status') result = await connection.status({signal});
+        else if (selection.action === 'inspect') result = await connection.inspect(parameters, {signal});
+        else if (selection.action === 'act') result = await connection.act(parameters, {signal});
+        else {
+            result = await connection.capture(parameters, {signal});
+            const output = path.resolve(cwd, selection.output);
+            await writeFile(output, Buffer.from(result.data, 'base64'), {signal});
+            const {data, ...metadata} = result;
+            result = {...metadata, output};
+        }
+    } catch (error) {
+        failed(error);
+    } finally {
+        if (connection) {
+            try { await connection.close(); } catch (error) { failed(error); }
+        }
+        process.removeListener('SIGINT', interrupted);
+        process.removeListener('SIGTERM', interrupted);
+    }
+    if (failures.length) {
+        const error = failures.length === 1 ? failures[0]
+            : new AggregateError(failures, 'App control completed with errors.');
+        stderr.write(`${JSON.stringify({...(result === undefined ? {} : {result}),
+            error: serializeCoreError(error)}, null, 2)}\n`);
+        return controller.signal.aborted ? 130 : error.exitCode ?? 1;
+    }
+    stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return 0;
+}

package/src/cli/main.mjs

@@ -6,6 +6,7 @@ import {ArcaneError,ERROR_CODES,normalizeError} from '../errors.mjs';
 import {CLI_NAME,SDK_NAME,SDK_VERSION,OUTPUT_MODES} from '../constants.mjs';
 import {loadArcaneNativeProvider} from '../native-provider-loader.mjs';
 import {APP_BUNDLE_EXTENSION} from '../release-bundle.mjs';
+import {runAppControlCli} from './app-control.mjs';
 
 const is = new Is(false);
 
@@ -82,6 +83,7 @@ Usage:
   ${CLI_NAME} run [--target <target>] [--app <id>] [--cert <pem>] [--key <pem>] [--port 8000] [--http-port 0] [--arcane-root <directory>] [--output-root <directory>] [--format <format>] [--signing <mode>]
   ${CLI_NAME} update-check
   ${CLI_NAME} targets
+  ${CLI_NAME} app-control status|inspect|capture|act --endpoint <pipe-or-socket> [--help]
   ${CLI_NAME} repo status|pull|push
   ${CLI_NAME} mail key set [profile] [--secret-stdin]
   ${CLI_NAME} mail key status [profile]
@@ -942,6 +944,9 @@ export async function runCli(argv=process.argv.slice(2),{
     loadNativeProvider=loadArcaneNativeProvider,
     controller=new AbortController()
 }={}){
+    if(argv[0]==='app-control'){
+        return runAppControlCli(argv.slice(1),{cwd,stdout,stderr,controller});
+    }
     let reporter;
     let command='help';
     const onSignal=()=>controller.abort(new Error('Interrupted'));

package/src/core/app-control.mjs

@@ -0,0 +1,23 @@
+import {connectCoreSocket, createCoreSocketConnection} from './socket-connection.mjs';
+
+function reportAppControlError(error) { console.error('Arcane app control failed:', error); }
+
+/** Connect to one explicitly selected running native window without launching it. */
+export async function connectAppControl({endpoint, signal, onError = reportAppControlError} = {}) {
+    if (typeof endpoint !== 'string' || !endpoint) {
+        throw new TypeError('App control requires an explicit local pipe/socket endpoint.');
+    }
+    const socket = await connectCoreSocket(endpoint, signal, onError);
+    const connection = createCoreSocketConnection({socket, endpoint, signal, onError,
+        name: 'app-control', closedMessage: 'The app-control connection closed.'});
+    const {client} = connection;
+    return {
+        endpoint,
+        closed: connection.closed,
+        status(options) { return client.invoke('app.control.status', {}, options); },
+        inspect(parameters = {}, options) { return client.invoke('app.control.inspect', parameters, options); },
+        capture(parameters = {}, options) { return client.invoke('app.control.capture', parameters, options); },
+        act(parameters, options) { return client.invoke('app.control.act', parameters, options); },
+        close() { return connection.close(); }
+    };
+}