arcane-os 0.88.1 → 0.90.0

package/src/local-ai/server.mjs

@@ -4,6 +4,7 @@ import Is from 'strong-type';
 import {ArcaneError,ERROR_CODES,errorRecord,normalizeError,throwIfAborted} from '../errors.mjs';
 import {createEventQueue} from '../event-queue.mjs';
 import {runProcess} from '../process.mjs';
+import {resolveLlamaExecution} from './llama-execution.mjs';
 
 const is=new Is(false);
 
@@ -48,17 +49,21 @@ async function probeServer(id,url,signal){
     return observed;
 }
 
-export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,onEvent,onState}={}){
+export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,onEvent,onState,onExit,executionDevices,requireManaged=false}={}){
     if(!['llama.cpp','ollama'].includes(id)){
         throw new ArcaneError(ERROR_CODES.usage,`Unsupported local AI server: ${String(id)}.`);
     }
     const url=localAIServerURL(id,configuration);
     const endpoint=new URL(url);
+    const managedSelection=requireManaged||(id==='llama.cpp'&&(configuration.executionTarget!==undefined
+        ||(runtime?.requestedBackend&&runtime.requestedBackend!=='auto')));
     const controller=new AbortController();
     const operationSignal=signal?AbortSignal.any([signal,controller.signal]):controller.signal;
     const events=createEventQueue(onEvent,{onFailure:fail});
     let current={id,url,state:'starting',available:false,owned:false};
     let owned=false;
+    let external=false;
+    let execution;
     let processTask=null;
     let processObservation=null;
     let startupTask=null;
@@ -70,6 +75,8 @@ export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,
     let terminalFailure=null;
     let resolveReady;
     let rejectReady;
+    let resolveManagement;
+    const management=new Promise(function discoverManagement(resolve){resolveManagement=resolve;});
     const output={stdout:'',stderr:''};
     const ready=new Promise(function createReadiness(resolve,reject){
         resolveReady=resolve;
@@ -80,7 +87,9 @@ export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,
     void ready.catch(function observeReadinessFailure(){return undefined;});
 
     async function publishState(state,error){
-        current={id,url,state,available:state==='ready',owned,...(error?{error:errorRecord(error)}:{})};
+        current={id,url,state,available:state==='ready',owned,
+            managed:!external&&Boolean(runtime?.executable),
+            ...(id==='llama.cpp'?{execution:execution??null}:{}),...(error?{error:errorRecord(error)}:{})};
         await onState?.(current);
         await events.send({
             type:`local-ai.server.${state}`,
@@ -147,6 +156,8 @@ export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,
             // endpoint at this actual launch boundary rather than presenting
             // that earlier installation-selection snapshot as current health.
             const observed=await probeServer(id,url,operationSignal);
+            external=true;
+            resolveManagement(false);
             if(runtime?.requestedVersion&&runtime.requestedVersion!=='latest'){
                 const requested=runtime.requestedVersion.replace(/^v/u,'');
                 if(!is.string(observed.version)||observed.version.replace(/^v/u,'')!==requested){
@@ -158,10 +169,18 @@ export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,
             throwIfAborted(operationSignal);
             // An HTTP error is an existing service's state. Only a refused
             // connection allows starting the selected local executable.
-            if(!localAIConnectionRefused(error))throw error;
+            if(!localAIConnectionRefused(error)){
+                external=true;
+                resolveManagement(false);
+                throw error;
+            }
             if(!localHostname(endpoint.hostname))throw error;
         }
         if(existing){
+            external=true;
+            if(managedSelection){
+                throw new ArcaneError('LOCAL_AI_EXTERNAL_SELECTION_UNSUPPORTED','The existing llama.cpp server owns its model and device selection. Use an available listener for SDK-managed model loading.');
+            }
             await publishState('ready');
             throwIfAborted(operationSignal);
             settleReady();
@@ -170,6 +189,7 @@ export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,
         if(!runtime?.executable){
             throw new ArcaneError(ERROR_CODES.prerequisiteMissing,`No installed ${id} executable was supplied.`);
         }
+        resolveManagement(true);
         if(endpoint.protocol!=='http:'){
             throw new ArcaneError(ERROR_CODES.usage,`${id} managed startup requires its direct HTTP listener URL.`);
         }
@@ -187,12 +207,19 @@ export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,
         throwIfAborted(operationSignal);
         const host=endpoint.hostname.replace(/^\[|\]$/gu,'');
         const port=endpoint.port||'80';
+        const selected=id==='llama.cpp'?await resolveLlamaExecution({
+            executionTarget:configuration.executionTarget,executionDevices,runtime,signal:operationSignal,onEvent:events.send
+        }):null;
+        if(selected)execution=selected.execution;
         const arguments_=id==='ollama'?['serve',...args]:[
             '--host',host,'--port',port,'--jinja',
+            ...(managedSelection?args:[]),
             ...(configuration.model?['--model',path.resolve(appRoot,configuration.model)]:['--models-dir',modelsDirectory]),
-            ...args
+            ...(!managedSelection?args:[]),
+            ...(configuration.alias?['--alias',configuration.alias]:[]),
+            ...selected.args
         ];
-        const env=id==='ollama'?{OLLAMA_HOST:endpoint.origin,OLLAMA_MODELS:modelsDirectory}:undefined;
+        const env=id==='ollama'?{OLLAMA_HOST:endpoint.origin,OLLAMA_MODELS:modelsDirectory}:selected.env;
         owned=true;
         await publishState('starting');
         throwIfAborted(operationSignal);
@@ -215,7 +242,7 @@ export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,
                 return;
             }
             await fail(error);
-        });
+        }).finally(async function releaseProcessResources(){await onExit?.();});
         void processObservation.catch(function observeProcessCallbackFailure(error){
             current={...current,state:'error',available:false,error:errorRecord(error)};
             settleReady(error);
@@ -250,7 +277,10 @@ export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,
         });
     }
 
-    startupTask=start().catch(fail);
+    startupTask=start().catch(fail).finally(async function releaseUnstartedResources(){
+        resolveManagement(false);
+        if(!processTask)await onExit?.();
+    });
     void startupTask.catch(function observeStartupCallbackFailure(error){
         current={...current,state:'error',available:false,error:errorRecord(error)};
         settleReady(error);
@@ -258,5 +288,5 @@ export function createLocalAIServer({id,configuration={},runtime,appRoot,signal,
     operationSignal.addEventListener('abort',observeLifetimeAbort,{once:true});
     if(operationSignal.aborted)observeLifetimeAbort();
 
-    return {ready,url,close,get owned(){return owned;},get current(){return current;}};
+    return {ready,management,url,close,get owned(){return owned;},get external(){return external;},get current(){return current;}};
 }

package/src/native/portable-layout.mjs

@@ -155,8 +155,8 @@ export function coreEntrySource(application, version, services, {localAI, runtim
     const imageSelected = localAI?.runtimes?.some(function selectedImage(requirement) {
         return (typeof requirement === 'string' ? requirement : requirement.id) === 'stable-diffusion.cpp';
     }) ?? false;
-    const modelAssetsSelected = imageSelected || (localAI?.runtimes?.some(function selectedONNX(requirement) {
-        return (typeof requirement === 'string' ? requirement : requirement.id) === 'onnx';
+    const modelAssetsSelected = imageSelected || (localAI?.runtimes?.some(function selectedProjectedRuntime(requirement) {
+        return ['onnx', 'llama.cpp'].includes(typeof requirement === 'string' ? requirement : requirement.id);
     }) ?? false);
     const whisperSelected = localAI?.runtimes?.some(function selectedWhisper(requirement) {
         return (typeof requirement === 'string' ? requirement : requirement.id) === 'whisper.cpp';
@@ -199,13 +199,21 @@ export function coreEntrySource(application, version, services, {localAI, runtim
             '    register(packagedWeb);');
     }
     return [
-        "import {fileURLToPath} from 'node:url';",
+        "import {fileURLToPath, pathToFileURL} from 'node:url';",
         "import path from 'node:path';",
         "import {isSea} from 'node:sea';",
         ...(launchDefaults === undefined ? [] : ["import {mkdir} from 'node:fs/promises';"]),
         "import {readCoreLaunchContext, startCoreHost, startCoreListener, runSharedCoreHost, startSharedCoreBridge} from 'arcane-os/core/host';",
         "import {createModelObservationService} from 'arcane-os/core/model-observation';",
         '',
+        "const appEntryFlag = process.argv.indexOf('--arcane-app-entry', 2);",
+        'if (appEntryFlag !== -1) {',
+        '    const appEntry = process.argv[appEntryFlag + 1];',
+        "    if (appEntry === undefined || appEntry === '') throw new TypeError('--arcane-app-entry requires an app-relative module path.');",
+        "    const appRoot = fileURLToPath(new URL('../app/', import.meta.url));",
+        '    await import(pathToFileURL(path.resolve(appRoot, appEntry)).href);',
+        '} else {',
+        ...[
         ...(localAI === undefined ? [] : [
             '// Bundled runtime paths are artifact-root-relative POSIX paths.',
             'function runtimePath(relative) {',
@@ -366,6 +374,8 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         '    }',
         "    process.off('SIGINT', closeCore);",
         "    process.off('SIGTERM', closeCore);",
+        '}'
+        ].map(function indentOrdinaryCore(line) { return line ? `    ${line}` : line; }),
         '}',
         ''
     ].join('\n');

package/src/repository.mjs

@@ -56,20 +56,33 @@ export async function readGitText(args, {
     }
 }
 
-/** Capture a caller-selected operation target without changing its strings. */
+/** Derive a Git argument only when the caller explicitly selects a local base. */
+export function captureRepositoryRemote(remote, remoteBase) {
+    if (remoteBase === undefined) return remote;
+    if (!is.string(remoteBase) || !remoteBase.isWellFormed() || remoteBase.includes('\0')) {
+        throw new TypeError('remoteBase must be text representable as a native filesystem path.');
+    }
+    return remote === undefined ? undefined : path.resolve(remoteBase, remote);
+}
+
+/** Keep original selection text separate from the accepted command argument. */
 export function captureRepositoryTarget(target) {
     if (target === undefined) return undefined;
-    const {remote, ref} = target;
+    const {remote, ref, remoteBase} = target;
     for (const [name, value] of Object.entries({remote, ref})) {
         if (!is.string(value) || value === '' || !value.isWellFormed() || value.includes('\0')) {
             throw new TypeError(`target.${name} must be nonempty text representable as a native process argument.`);
         }
     }
-    return {remote, ref};
+    return {
+        target: {remote, ref, ...(remoteBase === undefined ? {} : {remoteBase})},
+        remoteArgument: captureRepositoryRemote(remote, remoteBase)
+    };
 }
 
-export function repositoryPushArguments(target) {
-    return target === undefined ? ['push'] : ['push', '--no-follow-tags', '--', target.remote, `HEAD:${target.ref}`];
+export function repositoryPushArguments(selection) {
+    return selection === undefined ? ['push']
+        : ['push', '--no-follow-tags', '--', selection.remoteArgument, `HEAD:${selection.target.ref}`];
 }
 
 /** Observe an existing workspace without initializing or refreshing it. */
@@ -167,6 +180,12 @@ export async function repositoryPull({
 }={}){
     throwIfAborted(signal);
     const selectedTarget=captureRepositoryTarget(target);
+    return pullRepositoryTarget(selectedTarget,{workspaceRoot,signal,onEvent,run});
+}
+
+/** Internal workspace path: its target was already captured before queueing. */
+export async function pullRepositoryTarget(selectedTarget,{workspaceRoot,signal,onEvent,run=runProcess}){
+    throwIfAborted(signal);
     const before=await repositoryStatus({workspaceRoot,signal,onEvent,run});
     if(!before.clean){
         throw new ArcaneError(
@@ -176,14 +195,14 @@ export async function repositoryPull({
         );
     }
     const args=selectedTarget===undefined?['pull','--ff-only']
-        :['pull','--ff-only','--',selectedTarget.remote,`${selectedTarget.ref}:`];
+        :['pull','--ff-only','--',selectedTarget.remoteArgument,`${selectedTarget.target.ref}:`];
     const result=await git(args,{cwd:workspaceRoot,signal,onEvent,run});
     return {
         action:'pull',
         repositoryRoot:before.repositoryRoot,
         branch:before.branch,
         output:result.stdout.trim(),
-        ...(selectedTarget===undefined?{}:{target:selectedTarget,stdout:result.stdout,stderr:result.stderr})
+        ...(selectedTarget===undefined?{}:{target:selectedTarget.target,stdout:result.stdout,stderr:result.stderr})
     };
 }
 
@@ -196,6 +215,12 @@ export async function repositoryPush({
 }={}){
     throwIfAborted(signal);
     const selectedTarget=captureRepositoryTarget(target);
+    return pushRepositoryTarget(selectedTarget,{workspaceRoot,signal,onEvent,run});
+}
+
+/** Internal workspace path: its target was already captured before queueing. */
+export async function pushRepositoryTarget(selectedTarget,{workspaceRoot,signal,onEvent,run=runProcess}){
+    throwIfAborted(signal);
     const before=await repositoryStatus({workspaceRoot,signal,onEvent,run});
     if(!before.branch){
         throw new ArcaneError(
@@ -209,7 +234,7 @@ export async function repositoryPush({
         repositoryRoot:before.repositoryRoot,
         branch:before.branch,
         output:(result.stdout||result.stderr).trim(),
-        ...(selectedTarget===undefined?{}:{target:selectedTarget,stdout:result.stdout,stderr:result.stderr})
+        ...(selectedTarget===undefined?{}:{target:selectedTarget.target,stdout:result.stdout,stderr:result.stderr})
     };
 }
 

package/src/workspace-runtime.mjs

@@ -85,15 +85,96 @@ async function removeTemporaryTree(location){
     await rm(location,{recursive:true,force:true}).catch(()=>{});
 }
 
+async function materializeBrowserDecisions(destination, signal, onEvent) {
+    const transformers = 'https://cdn.jsdelivr.net/npm/@huggingface/transformers@4.3.0/';
+    const onnx = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.31.0-dev.20260914-8d85527a0/';
+    const files = [
+        {name: 'transformers.min.js', url: `${transformers}dist/transformers.min.js`},
+        {name: 'ort-wasm-simd-threaded.asyncify.mjs', url: `${onnx}dist/ort-wasm-simd-threaded.asyncify.mjs`},
+        {name: 'ort-wasm-simd-threaded.asyncify.wasm', url: `${onnx}dist/ort-wasm-simd-threaded.asyncify.wasm`},
+        {name: 'TRANSFORMERS-LICENSE', url: `${transformers}LICENSE`},
+        {name: 'ONNX-RUNTIME-LICENSE', url: `${onnx}LICENSE`}
+    ];
+    const controller = new AbortController();
+    function cancelDistribution() {
+        controller.abort(signal.reason);
+    }
+    signal?.addEventListener('abort', cancelDistribution, {once: true});
+    if (signal?.aborted) cancelDistribution();
+    let completed = 0;
+    try {
+        throwIfAborted(controller.signal);
+        await emit(
+            onEvent,
+            {type: 'workspace.decisions.started', completed, total: files.length}
+        );
+        throwIfAborted(controller.signal);
+        await mkdir(destination, {recursive: true});
+        async function acquireDistributionFile(file) {
+            try {
+                throwIfAborted(controller.signal);
+                const response = await fetch(file.url, {signal: controller.signal});
+                const content = new Uint8Array(await response.arrayBuffer());
+                if (!response.ok) {
+                    const error = new Error(`Browser decision distribution returned HTTP ${response.status} ${response.statusText}.`);
+                    error.code = 'ARCANE_DECISION_DISTRIBUTION_DOWNLOAD_FAILED';
+                    error.response = {
+                        url: response.url,
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: [...response.headers],
+                        content
+                    };
+                    throw error;
+                }
+                throwIfAborted(controller.signal);
+                // Upstream distribution content is opaque, including its own
+                // imports and license text. No SDK source rewriting applies.
+                await writeFile(path.join(destination, file.name), content);
+                throwIfAborted(controller.signal);
+                completed += 1;
+                await emit(
+                    onEvent,
+                    {type: 'workspace.decisions.progress', file: file.name, url: file.url, completed, total: files.length}
+                );
+            } catch (error) {
+                controller.abort(error);
+                throw error;
+            }
+        }
+        // One fixed distribution, acquired once for the selected projection;
+        // no model/app/architecture multiplier or installation script.
+        const outcomes = await Promise.allSettled(files.map(acquireDistributionFile));
+        const failures = new Set();
+        for (const outcome of outcomes) {
+            if (outcome.status === 'rejected') failures.add(outcome.reason);
+        }
+        if (failures.size === 1) throw [...failures][0];
+        if (failures.size > 1) {
+            throw new AggregateError([...failures], 'Browser decision distribution acquisition failed.');
+        }
+        throwIfAborted(controller.signal);
+    } finally {
+        signal?.removeEventListener('abort', cancelDistribution);
+    }
+    return {
+        transformersVersion: '4.3.0',
+        onnxRuntimeVersion: '1.31.0-dev.20260914-8d85527a0',
+        files: files.map(function distributionFilename(file) { return file.name; })
+    };
+}
+
 export async function materializeWorkspaceRuntimeContent({
     workspaceRoot,
     runtimeRoot=path.join(getSdkRoot(),'runtime'),
     browserRuntimeRoot=getSdkBrowserRuntimeRoot(),
     sdkVersion=SDK_VERSION,
+    browserDecisions=false,
     signal,
     onEvent
 }={}){
     if(!workspaceRoot)fail('workspaceRoot is required to materialize a workspace runtime.');
+    if(!is.boolean(browserDecisions))throw new TypeError('browserDecisions must be a boolean.');
     throwIfAborted(signal);
     const workspace=await realDirectory(workspaceRoot,'Workspace root');
     const runtime=await realDirectory(runtimeRoot,'SDK runtime root');
@@ -109,6 +190,7 @@ export async function materializeWorkspaceRuntimeContent({
     const backupRoot=path.join(workspace,`${BACKUP_PREFIX}${token}`);
     let backedUp=false;
     let promoted=false;
+    let decisionDistribution;
 
     await mkdir(stagingRoot);
     try{
@@ -134,6 +216,14 @@ export async function materializeWorkspaceRuntimeContent({
             );
         }
 
+        if (browserDecisions) {
+            decisionDistribution = await materializeBrowserDecisions(
+                path.join(sdkDestination, 'ai', 'decisions-runtime'),
+                signal,
+                onEvent
+            );
+        }
+
         throwIfAborted(signal);
         try{
             const existing=await lstat(destinationRoot);
@@ -160,7 +250,13 @@ export async function materializeWorkspaceRuntimeContent({
         return {
             kind:'arcane-workspace-runtime-content',
             workspaceRoot:workspace,
-            runtimeRoot:destinationRoot
+            runtimeRoot:destinationRoot,
+            ...(decisionDistribution ? {
+                browserDecisions: {
+                    ...decisionDistribution,
+                    directory: path.join(destinationRoot, 'sdk', 'ai', 'decisions-runtime')
+                }
+            } : {})
         };
     }catch(error){
         if(promoted)await removeTemporaryTree(destinationRoot);