arcane-os 0.4.1 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",

package/runtime/arcane/components/chat.html

@@ -2053,6 +2053,21 @@
         }
 
         function determinateProgress(){
+            const totalBytes=role?.progress?.totalBytes;
+            const loadedBytes=role?.progress?.loadedBytes;
+            if(
+                Number.isFinite(totalBytes)
+                &&totalBytes>0
+                &&Number.isFinite(loadedBytes)
+                &&loadedBytes>=0
+            ){
+                return {
+                    completed:Math.min(loadedBytes,totalBytes),
+                    total:totalBytes,
+                    unit:'bytes',
+                    byteTelemetry:true
+                };
+            }
             const total=Number(role?.progress?.total);
             const completed=Number(role?.progress?.completed);
             const unit=typeof role?.progress?.unit==='string'&&role.progress.unit
@@ -2068,23 +2083,162 @@
             return {
                 completed,
                 total,
-                unit
+                unit,
+                byteTelemetry:false
             };
         }
 
+        function formatBytes(value){
+            if(!Number.isFinite(value)||value<0){
+                return '';
+            }
+            const bytes=value;
+            const units=['B','KB','MB','GB'];
+            let unitIndex=0;
+            let amount=bytes;
+            while(amount>=1000&&unitIndex<units.length-1){
+                amount/=1000;
+                unitIndex+=1;
+            }
+            const decimals=unitIndex===0||amount>=100
+                ?0
+                :amount>=10
+                ?1
+                :2;
+            return `${Number(amount.toFixed(decimals))} ${units[unitIndex]}`;
+        }
+
+        function formatPercentage(loadedBytes,totalBytes){
+            const percentage=Math.min(100,Math.max(0,loadedBytes/totalBytes*100));
+            if(loadedBytes<=0){
+                return '0%';
+            }
+            if(loadedBytes>=totalBytes){
+                return '100%';
+            }
+            return `${Math.min(99.9,percentage).toFixed(1)}%`;
+        }
+
+        function approximateDuration(value){
+            if(!Number.isFinite(value)||value<0){
+                return '';
+            }
+            const suppliedSeconds=value;
+            const seconds=Math.ceil(suppliedSeconds);
+            if(seconds<1){
+                return '<1s';
+            }
+            if(seconds<60){
+                return `${seconds}s`;
+            }
+            const minutes=Math.floor(seconds/60);
+            const remainingSeconds=seconds%60;
+            if(minutes<60){
+                return `${minutes}m ${String(remainingSeconds).padStart(2,'0')}s`;
+            }
+            const hours=Math.floor(minutes/60);
+            const remainingMinutes=minutes%60;
+            return `${hours}h ${String(remainingMinutes).padStart(2,'0')}m`;
+        }
+
+        function activeTransferText(){
+            const active=role?.progress?.activeTransfers;
+            const limit=role?.progress?.transferLimit;
+            const mode=typeof role?.progress?.transferMode==='string'
+                ?role.progress.transferMode.trim().toLowerCase()
+                :'';
+            if(
+                !Number.isSafeInteger(active)
+                ||active<0
+                ||!Number.isSafeInteger(limit)
+                ||limit<1
+                ||!mode
+            ){
+                return '';
+            }
+            if(mode==='single'){
+                return active>0?'single transfer active':'single transfer idle';
+            }
+            if(mode==='probing'){
+                return 'checking parallel Range support';
+            }
+            const noun=['range','ranges'].includes(mode)
+                ?'range transfer worker'
+                :['shard','shards'].includes(mode)
+                ?'shard transfer worker'
+                :['file','files'].includes(mode)
+                ?'file transfer worker'
+                :['single','single-file','monolith'].includes(mode)
+                ?'single-file transfer worker'
+                :`${mode.replaceAll('-',' ')} transfer worker`;
+            return `${active} of ${limit} ${noun}${limit===1?'':'s'} active`;
+        }
+
+        function progressElapsedText(){
+            const elapsedMilliseconds=Number(role?.progress?.elapsedMs);
+            if(!Number.isFinite(elapsedMilliseconds)||elapsedMilliseconds<0){
+                return '';
+            }
+            const elapsedSeconds=Math.floor(elapsedMilliseconds/1000);
+            const hours=Math.floor(elapsedSeconds/3600);
+            const minutes=Math.floor(elapsedSeconds%3600/60);
+            const seconds=elapsedSeconds%60;
+            if(hours>0){
+                return `${hours}h ${minutes}m elapsed`;
+            }
+            if(minutes>0){
+                return `${minutes}m ${String(seconds).padStart(2,'0')}s elapsed`;
+            }
+            return `${seconds}s elapsed`;
+        }
+
         function progressMessage(){
             const measured=determinateProgress();
-            const phase=typeof role?.progress?.phase==='string'&&role.progress.phase
+            const phaseValue=typeof role?.progress?.phase==='string'&&role.progress.phase
                 ?role.progress.phase
                 :'loading';
+            const phase=phaseValue.replaceAll('-',' ');
             const parts=[
                 `Loading ${modelDisplayName()} through the Arcane SDK`,
                 phase
             ];
-            if(measured){
-                parts.push(`${measured.completed} of ${measured.total} ${measured.unit}`);
+            if(measured?.byteTelemetry){
+                const remainingBytes=Math.max(0,measured.total-measured.completed);
+                parts.push(formatPercentage(measured.completed,measured.total));
+                parts.push(
+                    `${formatBytes(measured.completed)} of ${formatBytes(measured.total)} downloaded`
+                );
+                parts.push(`${formatBytes(remainingBytes)} remaining`);
+                const bytesPerSecond=role?.progress?.bytesPerSecond;
+                if(Number.isFinite(bytesPerSecond)&&bytesPerSecond>=0){
+                    parts.push(`${formatBytes(bytesPerSecond)}/s`);
+                }else{
+                    parts.push('Calculating speed');
+                }
+                if(remainingBytes>0){
+                    const eta=approximateDuration(role?.progress?.etaSeconds);
+                    parts.push(eta?`About ${eta} remaining`:'Estimating time remaining');
+                }
+            }else if(measured){
+                const suffix=phaseValue==='download'&&measured.unit==='files'
+                    ?'files complete'
+                    :measured.unit;
+                parts.push(`${measured.completed} of ${measured.total} ${suffix}`);
+            }
+            const transfers=activeTransferText();
+            if(transfers){
+                parts.push(transfers);
+            }
+            const elapsed=progressElapsedText();
+            if(elapsed){
+                parts.push(elapsed);
+                if(role?.progress?.heartbeat===true){
+                    parts.push('Still working');
+                }
+            }
+            if(!measured?.byteTelemetry){
+                parts.push('The first activation can take several minutes; keep this tab open');
             }
-            parts.push('The first activation can take several minutes; keep this tab open');
             return parts.join(' · ');
         }
 
@@ -2094,16 +2248,19 @@
             if(!visible){
                 progress.removeAttribute('value');
                 progress.removeAttribute('max');
+                progress.removeAttribute('aria-valuetext');
                 return;
             }
             const measured=determinateProgress();
             if(!measured){
                 progress.removeAttribute('value');
                 progress.removeAttribute('max');
+                progress.setAttribute('aria-valuetext',progressMessage());
                 return;
             }
             progress.max=measured.total;
             progress.value=measured.completed;
+            progress.setAttribute('aria-valuetext',progressMessage());
         }
 
         function render(){

package/runtime/arcane/components/local-ai-status.html

@@ -278,9 +278,9 @@
         summary.setAttribute('role','alert');
         summary.textContent=userManaged
             ?guidanceMessage
-                ||'Review the unavailable user-managed Android service, then Retry or open Profile and switch the affected option to OpenAI.'
+                ||'Review the unavailable user-managed Android service, then Retry or open Profile and switch the language-model option to TWiN Cloud.'
             :browser
-            ?'Start the unavailable local service yourself and Retry, or open Profile, switch each affected option to OpenAI, and enter your OpenAI API key.'
+            ?'Start the unavailable local service yourself and Retry, or open Profile, switch the language-model option to TWiN Cloud, and enter your TWiN access key.'
             :'Arcane could not recover every selected managed local service. Retry or open Arcane Settings > Local AI.';
         return report;
     }

package/runtime/arcane/modules/AI.js

@@ -917,7 +917,9 @@ class AI {
     // This is the enum section for inference configuration
     #service = {
         baseURL: {
-            OPENAI: 'https://api.openai.com/v1'
+            // OPENAI remains the legacy route identifier for compatibility;
+            // remote LLM chat is provided by TWiN Cloud.
+            OPENAI: 'https://inference.do-ai.run/v1'
         },
         sttURL: {
             LOCAL_SPEACH: 'http://127.0.0.1:8011/v1',
@@ -944,7 +946,7 @@ class AI {
     }
 
     #models = {
-        OPENAI:'gpt-4o'
+        OPENAI:'openai-gpt-oss-120b'
     }
 
     #sttModels = {
@@ -1155,11 +1157,14 @@ class AI {
 
     // Browser-delivered framework code must not contain provider credentials.
     // The selected host, application, or user profile supplies one at runtime.
-    get license(){
-        return this.#license || globalThis.arcane?.config?.openAI?.apiKey || '';
+    get twinKey(){
+        return this.#license
+            ||globalThis.arcane?.config?.twinCloud?.accessKey
+            ||globalThis.arcane?.config?.openAI?.apiKey
+            ||'';
     }
-    
-    set license(value){
+
+    set twinKey(value){
         this.#license=typeof value==='string' ? value.trim():'';
         this.#retainLegacyLLMReadiness(
             this.#reconcileLegacyLLMReadiness()
@@ -1170,6 +1175,17 @@ class AI {
         return this.#license;
     }
 
+    // Retain the established credential property while consumers move their
+    // user-facing profile field to the TWiN key name.
+    get license(){
+        return this.twinKey;
+    }
+
+    set license(value){
+        this.twinKey=value;
+        return this.#license;
+    }
+
     #legacyLLMCapability(providerId){
         if(providerId==='OPENAI'){
             return this.llmService==='OPENAI'

package/runtime/arcane/modules/LocalAIReadiness.js

@@ -718,12 +718,18 @@ function guidance(mode,slots){
 
     const services=recoveryServices(slots);
     const profileSettings=affectedSlots.map(slot=>slot+'Provider');
+    const twinCloudOption=affectedSlots.includes('llm')
+        ?' Alternatively, switch the Profile language-model setting to TWiN Cloud and enter a TWiN access key.'
+        :'';
     const message=mode==='browser'
         ?browserManualInstruction(services)
-            +' Alternatively, switch the affected Profile setting to OpenAI and enter an OpenAI API/license key. Arcane will not switch providers automatically.'
+            +twinCloudOption
+            +' Arcane will not switch providers automatically.'
         :mode===USER_MANAGED_LOOPBACK_PROVIDER_MODE
             ?userManagedLoopbackInstruction(services)
-                +' Arcane does not install, start, repair, pull, or otherwise manage this service or its models. Alternatively, switch the affected Profile setting to OpenAI. Arcane will not switch providers automatically.'
+                +' Arcane does not install, start, repair, pull, or otherwise manage this service or its models.'
+                +twinCloudOption
+                +' Arcane will not switch providers automatically.'
             :'Arcane could not recover the selected local AI service. Retry or review Local AI in Arcane Settings. Arcane will not switch providers automatically.';
 
     return completeResult({