arcane-os 0.66.0 → 0.68.0

package/src/local-ai/onnx.mjs

@@ -95,7 +95,7 @@ export function createONNXRuntime({modulePath,onEvent,signal}={}){
 
     function current(){
         return {sessions:[...sessions.values()].map(function sessionState(entry){
-            return structuredClone(entry.state);
+            return {...structuredClone(entry.state), stopping:entry.stopping, exited:entry.exited};
         }),closed};
     }
 
@@ -157,20 +157,31 @@ export function createONNXRuntime({modulePath,onEvent,signal}={}){
         entry.stopping=true;
         if(failed)entry.terminalError??=reason;
         entry.stopTask=Promise.resolve().then(async function releaseSession(){
-            if(active||failed||entry.terminalError){
-                entry.terminationRequested=true;
-                await worker.terminate();
-            }else{
-                try{worker.postMessage({operation:'unload',requestId:++nextRequestId});}
-                catch(error){
-                    entry.releaseError=error;
+            let terminationError;
+            try{
+                if(active||failed||entry.terminalError){
                     entry.terminationRequested=true;
                     await worker.terminate();
+                }else{
+                    try{worker.postMessage({operation:'unload',requestId:++nextRequestId});}
+                    catch(error){
+                        entry.releaseError=error;
+                        entry.terminationRequested=true;
+                        await worker.terminate();
+                    }
                 }
+            }catch(error){
+                terminationError=error;
+                reportBackgroundError(error);
             }
+            // Failed termination is not actual worker exit. Keep native file
+            // ownership until exit and complete output delivery have settled.
             await entry.exit;
-            await Promise.all(entry.outputTasks);
-            if(entry.releaseError)throw entry.releaseError;
+            const outputResults=await Promise.allSettled(entry.outputTasks);
+            const failures=[entry.releaseError,terminationError].filter(function present(error){return error!==null&&error!==undefined;});
+            for(const result of outputResults)if(result.status==='rejected')failures.push(result.reason);
+            if(failures.length>1)throw new AggregateError(failures,'Releasing the ONNX worker failed.');
+            if(failures.length)throw failures[0];
             return structuredClone(entry.state);
         });
         // A native call has no AbortSignal. Stop delivery immediately, retain
@@ -262,7 +273,7 @@ export function createONNXRuntime({modulePath,onEvent,signal}={}){
         finally{entry.resolveExit(code);}
     }
 
-    async function load({id,model,sessionOptions,signal:operationSignal}={}){
+    async function load({id,model,sessionOptions,executionPreference,signal:operationSignal}={}){
         assertOpen(operationSignal);
         if(!is.string(id)||!is.string(model))throw new TypeError('ONNX load requires a session id and model path.');
         const previous=sessions.get(id);
@@ -312,7 +323,7 @@ export function createONNXRuntime({modulePath,onEvent,signal}={}){
         }
         // Queue load before publishing readiness so a synchronous subscriber
         // can enqueue inference or request release without racing ownership.
-        const task=enqueue(entry,'load',{model,sessionOptions},operationSignal,true);
+        const task=enqueue(entry,'load',{model,sessionOptions,executionPreference},operationSignal,true);
         publish(entry);
         dispatchNext(entry);
         return task;

package/src/native/portable-layout.mjs

@@ -153,6 +153,9 @@ 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';
+    }) ?? false);
     const whisperSelected = localAI?.runtimes?.some(function selectedWhisper(requirement) {
         return (typeof requirement === 'string' ? requirement : requirement.id) === 'whisper.cpp';
     }) ?? false;
@@ -175,10 +178,12 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         imports.push("import {createLocalAIService} from 'arcane-os/core/local-ai';");
         definitions.push(`    createLocalAIService(JSON.parse(${JSON.stringify(JSON.stringify(chatConfiguration))}), context)`);
     }
-    if (imageSelected) {
-        imports.push("import {createLocalImageService} from 'arcane-os/core/image';");
+    if (modelAssetsSelected) {
         imports.push("import {createModelAssetService} from 'arcane-os/core/model-assets';");
         definitions.push('    modelAssets');
+    }
+    if (imageSelected) {
+        imports.push("import {createLocalImageService} from 'arcane-os/core/image';");
         definitions.push(`    createLocalImageService(JSON.parse(${JSON.stringify(JSON.stringify(localAI))}), {...context, modelAssets})`);
     }
     if (whisperSelected) {
@@ -239,7 +244,7 @@ export function coreEntrySource(application, version, services, {localAI, runtim
         '    ...await readCoreLaunchContext()',
         '};',
         '',
-        ...(imageSelected ? ['const modelAssets = createModelAssetService({appRoot: context.appRoot});', ''] : []),
+        ...(modelAssetsSelected ? ['const modelAssets = createModelAssetService({appRoot: context.appRoot});', ''] : []),
         ...(whisperSelected ? [
             'const stt = createWhisperRuntime(',
             '    {',

package/src/repository.mjs

@@ -1,10 +1,142 @@
 import {runProcess} from './process.mjs';
 import {ArcaneError,ERROR_CODES,throwIfAborted} from './errors.mjs';
+import path from 'node:path';
+import Is from 'strong-type';
+
+const is = new Is(false);
 
 async function git(args,{run=runProcess,...options}){
     return run('git',args,options);
 }
 
+/** Private shared reader for Git text protocols, retaining native diagnostics. */
+export async function readGitText(args, {
+    cwd, signal, onEvent, run = runProcess, allowNonzero = false,
+    notTextCode = 'ARCANE_GIT_CONFIGURATION_NOT_TEXT', label = 'Git configuration'
+} = {}) {
+    const chunks = [];
+    try {
+        const result = await run('git', args, {
+            cwd, signal, onEvent, allowNonzero,
+            outputEncoding: {stdout: null}, captureOutput: {stdout: false}, emitOutputEvents: {stdout: false},
+            onOutput: function observeOutput({stream, chunk}) {
+                if (stream === 'stdout') chunks.push(chunk);
+            }
+        });
+        try { throwIfAborted(signal); }
+        catch (error) { error.details = result; throw error; }
+        const rawStdout = Buffer.concat(chunks);
+        let output = null;
+        if (result.code === 0) {
+            try { output = new TextDecoder('utf-8', {fatal: true, ignoreBOM: true}).decode(rawStdout); }
+            catch (cause) {
+                throw new ArcaneError(notTextCode, `${label} cannot be represented as UTF-8 text.`, {cause, details: result});
+            }
+        }
+        return {result, output, rawStdout};
+    } catch (error) {
+        const rawStdout = Buffer.concat(chunks);
+        let attached = false;
+        let attachmentError;
+        try {
+            if (error !== null && (is.object(error) || is.function(error)) && !('rawStdout' in error)) {
+                Object.defineProperty(error, 'rawStdout', {
+                    value: rawStdout, writable: true, enumerable: true, configurable: true
+                });
+                attached = true;
+            }
+        } catch (cause) { attachmentError = cause; }
+        if (attached) throw error;
+        const failure = new ArcaneError(error?.code ?? ERROR_CODES.operationFailed,
+            error instanceof Error ? error.message : String(error),
+            {cause: error, details: error?.details, exitCode: error?.exitCode});
+        failure.rawStdout = rawStdout;
+        if (attachmentError) failure.attachmentError = attachmentError;
+        throw failure;
+    }
+}
+
+/** Capture a caller-selected operation target without changing its strings. */
+export function captureRepositoryTarget(target) {
+    if (target === undefined) return undefined;
+    const {remote, ref} = 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};
+}
+
+export function repositoryPushArguments(target) {
+    return target === undefined ? ['push'] : ['push', '--no-follow-tags', '--', target.remote, `HEAD:${target.ref}`];
+}
+
+/** Observe an existing workspace without initializing or refreshing it. */
+export async function repositoryConfiguration({workspaceRoot = process.cwd(), signal, onEvent, run = runProcess} = {}) {
+    const repositoryRoot = path.resolve(workspaceRoot);
+    const options = {cwd: repositoryRoot, signal, onEvent, run, allowNonzero: true};
+    throwIfAborted(signal);
+
+    function processFailure(observation, message) {
+        const failure = new ArcaneError(ERROR_CODES.operationFailed, message, {details: observation.result});
+        failure.rawStdout = observation.rawStdout;
+        return failure;
+    }
+
+    async function configuration(pattern) {
+        const observation = await readGitText(['config', '--includes', '--null', '--get-regexp', pattern], options);
+        const values = new Map();
+        if (observation.result.code === 1) return values;
+        if (observation.result.code !== 0) throw processFailure(observation, 'Git configuration observation failed.');
+        for (const record of observation.output.split('\0')) {
+            if (record === '') continue;
+            const separator = record.indexOf('\n');
+            const key = separator === -1 ? record : record.slice(0, separator);
+            const value = separator === -1 ? '' : record.slice(separator + 1);
+            const entries = values.get(key) ?? [];
+            entries.push(value);
+            values.set(key, entries);
+        }
+        return values;
+    }
+
+    function literalPattern(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    }
+
+    const root = await readGitText(['rev-parse', '--is-inside-work-tree', '--show-prefix'], options);
+    if (root.result.code !== 0) throw processFailure(root, 'Git working repository observation failed.');
+    if (root.output !== 'true\n\n' && root.output !== 'true\r\n\r\n') {
+        const failure = new ArcaneError('ARCANE_REPOSITORY_DIRECTORY_INVALID',
+            'The selected directory is not a Git working repository root.', {details: root.result});
+        failure.rawStdout = root.rawStdout;
+        throw failure;
+    }
+    const head = await readGitText(['symbolic-ref', '--quiet', 'HEAD'], options);
+    if (head.result.code !== 0 && head.result.code !== 1) throw processFailure(head, 'Git symbolic HEAD observation failed.');
+    const headRef = head.result.code === 1 ? null : head.output.replace(/\r?\n$/u, '');
+    let upstream = null;
+    let remoteName;
+    if (headRef?.startsWith('refs/heads/')) {
+        const key = `branch.${headRef.slice('refs/heads/'.length)}`;
+        const branch = await configuration(`^${literalPattern(key)}[.](remote|merge)$`);
+        const remoteNames = branch.get(`${key}.remote`) ?? [];
+        remoteName = remoteNames.at(-1);
+        upstream = {remoteNames, mergeRefs: branch.get(`${key}.merge`) ?? [], urls: [], pushUrls: []};
+    }
+    const selectedNames = ['origin'];
+    if (remoteName !== undefined && remoteName !== '.' && remoteName !== 'origin') selectedNames.push(remoteName);
+    const names = selectedNames.map(literalPattern).join('|');
+    const remotes = await configuration(`^remote[.](${names})[.](url|pushurl)$`);
+    const origin = {urls: remotes.get('remote.origin.url') ?? [], pushUrls: remotes.get('remote.origin.pushurl') ?? []};
+    if (upstream && remoteName !== undefined && remoteName !== '.') {
+        upstream.urls = remotes.get(`remote.${remoteName}.url`) ?? [];
+        upstream.pushUrls = remotes.get(`remote.${remoteName}.pushurl`) ?? [];
+    }
+    return {repositoryRoot, headRef, origin, upstream};
+}
+
 export async function repositoryStatus({
     workspaceRoot=process.cwd(),
     signal,
@@ -28,11 +160,13 @@ export async function repositoryStatus({
 
 export async function repositoryPull({
     workspaceRoot=process.cwd(),
+    target,
     signal,
     onEvent,
     run=runProcess
 }={}){
     throwIfAborted(signal);
+    const selectedTarget=captureRepositoryTarget(target);
     const before=await repositoryStatus({workspaceRoot,signal,onEvent,run});
     if(!before.clean){
         throw new ArcaneError(
@@ -41,22 +175,27 @@ export async function repositoryPull({
             {details:before}
         );
     }
-    const result=await git(['pull','--ff-only'],{cwd:workspaceRoot,signal,onEvent,run});
+    const args=selectedTarget===undefined?['pull','--ff-only']
+        :['pull','--ff-only','--',selectedTarget.remote,`${selectedTarget.ref}:`];
+    const result=await git(args,{cwd:workspaceRoot,signal,onEvent,run});
     return {
         action:'pull',
         repositoryRoot:before.repositoryRoot,
         branch:before.branch,
-        output:result.stdout.trim()
+        output:result.stdout.trim(),
+        ...(selectedTarget===undefined?{}:{target:selectedTarget,stdout:result.stdout,stderr:result.stderr})
     };
 }
 
 export async function repositoryPush({
     workspaceRoot=process.cwd(),
+    target,
     signal,
     onEvent,
     run=runProcess
 }={}){
     throwIfAborted(signal);
+    const selectedTarget=captureRepositoryTarget(target);
     const before=await repositoryStatus({workspaceRoot,signal,onEvent,run});
     if(!before.branch){
         throw new ArcaneError(
@@ -64,12 +203,13 @@ export async function repositoryPush({
             'Refusing to push from a detached HEAD.'
         );
     }
-    const result=await git(['push'],{cwd:workspaceRoot,signal,onEvent,run});
+    const result=await git(repositoryPushArguments(selectedTarget),{cwd:workspaceRoot,signal,onEvent,run});
     return {
         action:'push',
         repositoryRoot:before.repositoryRoot,
         branch:before.branch,
-        output:(result.stdout||result.stderr).trim()
+        output:(result.stdout||result.stderr).trim(),
+        ...(selectedTarget===undefined?{}:{target:selectedTarget,stdout:result.stdout,stderr:result.stderr})
     };
 }