arcane-os 0.55.0 → 0.57.0

package/src/process.mjs

@@ -33,8 +33,8 @@ function platformArguments(command,args,platform=process.platform){
     return [cliPath,...args];
 }
 
-function appendOutput(current,chunk){
-    return current+chunk.toString('utf8');
+function appendOutput(current,text){
+    return current+text;
 }
 
 async function emitLines(events,type,text){
@@ -45,9 +45,9 @@ async function emitLines(events,type,text){
     }
 }
 
-function deliverChunk(stream,events,type,chunk){
+function deliverChunk(stream,events,type,text){
     stream.pause();
-    return emitLines(events,type,chunk.toString('utf8')).catch(()=>{
+    return emitLines(events,type,text).catch(()=>{
         // The queue owns and propagates the first callback failure.
     }).finally(()=>{
         if(!stream.destroyed){
@@ -124,12 +124,16 @@ export async function runProcess(command,args=[],{
     heartbeatMs=5000,
     terminationGraceMs=DEFAULT_TERMINATION_GRACE_MS,
     allowNonzero=false,
-    input
+    input,
+    cancellationMode='terminate-tree'
 }={}){
     throwIfAborted(signal);
     if(!is.array(args)||args.some(argument=>!is.string(argument))){
         throw new ArcaneError(ERROR_CODES.usage,'Process arguments must be a fixed array of strings.');
     }
+    if(cancellationMode!=='terminate-tree'&&cancellationMode!=='close-input'){
+        throw new ArcaneError(ERROR_CODES.usage,'Unknown process cancellation mode.');
+    }
     if(!is.integer(terminationGraceMs)||terminationGraceMs<100||terminationGraceMs>30_000){
         throw new ArcaneError(
             ERROR_CODES.usage,
@@ -153,12 +157,15 @@ export async function runProcess(command,args=[],{
     return new Promise((resolve,reject)=>{
         let stdout='';
         let stderr='';
+        let childClosed=false;
+        let closedResult=null;
         let settlementStarted=false;
         let cancellationRequested=false;
         let cancellationError=null;
         let terminationRequested=false;
         let escalation=null;
         let spawnError=null;
+        let inputError=null;
         let child;
         let heartbeat=null;
         const deliveries=new Set();
@@ -184,9 +191,37 @@ export async function runProcess(command,args=[],{
             clearTimeout(escalation);
             signal?.removeEventListener('abort',abort);
             void (async()=>{
+                let callbackFailure=null;
                 try{
                     await events.drain();
-                }catch(callbackFailure){
+                }catch(error){
+                    callbackFailure=error;
+                }
+                if(cancellationMode==='close-input'&&closedResult){
+                    const failures=[...new Set([
+                        callback===reject?value:null,
+                        callbackFailure,inputError,cancellationError,spawnError
+                    ].filter(error=>error!==null))];
+                    if(failures.length>0){
+                        const primary=failures[0];
+                        // Owned cancellation/exit errors already carry this exact
+                        // result. Other errors retain their identity and cause in
+                        // the complete failure record instead of being rewritten.
+                        if(failures.length===1&&primary?.details===closedResult){
+                            reject(primary);
+                            return;
+                        }
+                        const failure=new ArcaneError(
+                            primary?.code??ERROR_CODES.operationFailed,
+                            primary?.message??`Could not complete ${command}.`,
+                            {cause:primary,details:closedResult,exitCode:primary?.exitCode}
+                        );
+                        failure.errors=failures;
+                        reject(failure);
+                        return;
+                    }
+                }
+                if(callbackFailure){
                     reject(callbackFailure);
                     return;
                 }
@@ -195,10 +230,16 @@ export async function runProcess(command,args=[],{
         };
 
         const stopTree=()=>{
-            if(terminationRequested||settlementStarted){
+            if(terminationRequested||settlementStarted||childClosed){
                 return;
             }
             terminationRequested=true;
+            if(cancellationMode==='close-input'){
+                // The selected host owns shutdown after EOF. Keep observing its
+                // complete output and exit; accepted durable work may outlive UI.
+                child?.stdin.end();
+                return;
+            }
             terminateProcessTree(child);
             escalation=setTimeout(()=>{
                 if(childIsRunning(child)){
@@ -214,7 +255,7 @@ export async function runProcess(command,args=[],{
         };
 
         const abort=()=>{
-            if(cancellationRequested||settlementStarted){
+            if(cancellationRequested||settlementStarted||childClosed){
                 return;
             }
             cancellationRequested=true;
@@ -225,7 +266,9 @@ export async function runProcess(command,args=[],{
             );
             void events.enqueue({
                 type:'process.cancellation.requested',
-                message:`Stopping ${command} and its child processes.`,
+                message:cancellationMode==='close-input'
+                    ?`Closing ${command} input and waiting for its owned shutdown.`
+                    :`Stopping ${command} and its child processes.`,
                 data:{command,pid:child?.pid??null}
             });
             stopTree();
@@ -263,6 +306,10 @@ export async function runProcess(command,args=[],{
             return;
         }
 
+        // Each readable retains split UTF-8 sequences and flushes at EOF.
+        // Capture and events consume the same decoded text.
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
         child.stdout.on('data',chunk=>{
             stdout=appendOutput(stdout,chunk);
             ownDelivery(child.stdout,'process.stdout',chunk);
@@ -282,6 +329,10 @@ export async function runProcess(command,args=[],{
             }
         });
         child.on('close',(code,terminationSignal)=>{
+            // The child lifetime has ended even while its output/event callbacks
+            // are still draining. A later abort cannot cancel that completed work.
+            childClosed=true;
+            signal?.removeEventListener('abort',abort);
             clearInterval(heartbeat);
             void (async()=>{
                 await drainDeliveries();
@@ -295,10 +346,11 @@ export async function runProcess(command,args=[],{
                     stdout,
                     stderr
                 };
+                closedResult=result;
                 if(terminationRequested){
                     // The direct child has exited. Make one final tree-wide attempt so
                     // a descendant that ignored the graceful request cannot outlive it.
-                    terminateProcessTree(child,{force:true});
+                    if(cancellationMode!=='close-input')terminateProcessTree(child,{force:true});
                     if(cancellationRequested){
                         await events.enqueue({
                             type:'process.cancelled',
@@ -306,7 +358,8 @@ export async function runProcess(command,args=[],{
                             data:{command,code:result.code,signal:terminationSignal}
                         });
                     }
-                    finish(reject,events.error??cancellationError??new ArcaneError(
+                    if(cancellationError)cancellationError.details=result;
+                    finish(reject,events.error??inputError??cancellationError??new ArcaneError(
                         ERROR_CODES.operationFailed,
                         `Stopped ${command} after its event callback failed.`
                     ));
@@ -320,6 +373,12 @@ export async function runProcess(command,args=[],{
                     ));
                     return;
                 }
+                if(inputError){
+                    finish(reject,new ArcaneError(ERROR_CODES.operationFailed,
+                        `Could not write ${command} input: ${inputError.message}`,
+                        {cause:inputError,details:result}));
+                    return;
+                }
                 await events.enqueue({
                     type:'process.completed',
                     message:`${command} exited with code ${String(result.code)}.`,
@@ -342,7 +401,10 @@ export async function runProcess(command,args=[],{
             abort();
         }
 
-        if(input!==undefined){
+        if(cancellationMode==='close-input'){
+            child.stdin.on('error',error=>{inputError=error;stopTree();});
+            if(input!==undefined&&!terminationRequested)child.stdin.write(input);
+        }else if(input!==undefined){
             child.stdin.end(input);
         }else{
             child.stdin.end();

package/src/toolchain.mjs

@@ -1,6 +1,6 @@
 import Is from 'strong-type';
 import path from 'node:path';
-import {resolvePackageOutputRoot} from './app-layout.mjs';
+import {resolveAppRoot,resolvePackageOutputRoot} from './app-layout.mjs';
 import {readdir,lstat,realpath,mkdir,readFile,writeFile} from 'node:fs/promises';
 import {createWorkspace,initWorkspace} from './scaffold.mjs';
 import {
@@ -17,6 +17,8 @@ import {createPwaArtifacts} from './pwa.mjs';
 import {readInstalledSdkLayout} from './sdk-runtime-layout.mjs';
 import {withWorkspaceOperationLock} from './workspace-operation-lock.mjs';
 import {refreshAppPackageProjection} from './app-descriptor.mjs';
+import {configureDevelopmentLocalAI} from './local-ai/config.mjs';
+import {createDevelopmentLocalAI} from './local-ai/dev.mjs';
 import {
     discoverApps as discoverPackagerApps,
     inspectApp as inspectPackagedApp,
@@ -566,6 +568,11 @@ export async function developApplication(options = {}) {
             onEvent: options.onEvent
         },
         async function refreshDevelopmentWorkspace(workspaceOperationLease) {
+            await configureDevelopmentLocalAI({
+                appRoot: resolveAppRoot(profile.workspaceRoot, profile.config, appId),
+                runtimes: options.localAI,
+                signal: options.signal
+            });
             await refreshAppPackageProjection(
                 {
                     workspaceRoot: profile.workspaceRoot,
@@ -589,7 +596,19 @@ export async function developApplication(options = {}) {
             return current;
         }
     );
-    const server=await startDevServer({
+    const localAIConfig = prepared.descriptor?.native?.localAI;
+    const localAI = localAIConfig?.runtimes.length ? createDevelopmentLocalAI({
+        config: localAIConfig,
+        appRoot: prepared.appRoot,
+        directory: path.join(prepared.appRoot, '.arcane', 'local-ai', 'runtimes'),
+        application: prepared.descriptor,
+        version: prepared.descriptor.version,
+        signal: options.signal,
+        onEvent: options.onEvent
+    }) : undefined;
+    let server;
+    try {
+        server=await startDevServer({
         workspaceRoot:prepared.workspaceRoot,
         appId:prepared.appId,
         mode:'source',
@@ -605,10 +624,19 @@ export async function developApplication(options = {}) {
         tls:options.tls,
         certPath:options.certPath,
         keyPath:options.keyPath,
+        localAI,
         signal:options.signal,
         onEvent:options.onEvent
-    });
-    return {...server,appId:prepared.appId,mode:'source'};
+        });
+    } catch (error) {
+        try {
+            await localAI?.close(error);
+        } catch (closeError) {
+            throw new AggregateError([error, closeError], 'Development startup and local AI shutdown failed.');
+        }
+        throw error;
+    }
+    return {...server,appId:prepared.appId,mode:'source',...(localAI ? {localAI} : {})};
 }
 
 export async function packageApplication(options={}){
@@ -840,7 +868,7 @@ export function assertIntegratedNativeToolchain({
     workspaceMode,workspaceRoot,toolchainRoot,target,providerSource='arcane-checkout'
 }={}){
     if(workspaceMode!=='integrated')return;
-    if(providerSource==='sdk-package'&&target==='portable')return;
+    if(providerSource==='sdk-package'&&(target==='portable'||target==='windows-x64'))return;
     if(!is.string(toolchainRoot)||!sameCanonicalPath(workspaceRoot,toolchainRoot)){
         throw new ArcaneError(
             ERROR_CODES.policyDenied,
@@ -996,12 +1024,14 @@ function pathsOverlap(left,right){
 async function packageNativeRelease(prepared,app,{
     workspaceOperationLease,
     selectedSdk,
+    target,
     signal,
     onEvent
 }={}){
     const release=await packageApp({
         workspaceRoot:prepared.workspaceRoot,
         appId:app.appId,
+        target,
         browserPwa:false,
         workspaceOperationLease,
         signal,
@@ -1065,7 +1095,7 @@ async function executePairedNativeBuild(options,adapter,{
     const packageOutputs=[];
     for(const app of [prepared.validation.app,...dependencyApps]){
         const releaseRoot=resolvePackageOutputRoot(
-            prepared.workspaceRoot,prepared.validation.config,app.manifest
+            prepared.workspaceRoot,prepared.validation.config,app.manifest,{target}
         );
         if(pathsOverlap(releaseRoot,outputRoot)
             ||packageOutputs.some(existing=>pathsOverlap(existing,releaseRoot))){
@@ -1084,13 +1114,13 @@ async function executePairedNativeBuild(options,adapter,{
         descriptorSource:prepared.validation.app.descriptorSource,
         descriptorPath:prepared.validation.app.descriptorPath,
         validation:prepared.validation
-    },{workspaceOperationLease,selectedSdk,signal,onEvent});
+    },{workspaceOperationLease,selectedSdk,target,signal,onEvent});
     const dependencyReleases=[];
     for(const dependency of dependencyApps){
         dependencyReleases.push(await packageNativeRelease(
             prepared,
             dependency,
-            {workspaceOperationLease,selectedSdk,signal,onEvent}
+            {workspaceOperationLease,selectedSdk,target,signal,onEvent}
         ));
     }
     const toolchain=await adapter.prepare({