arcane-os 0.95.0 → 0.96.0

package/src/native/portable-provider.mjs

@@ -1,9 +1,10 @@
-import {mkdir, mkdtemp, readFile, realpath, rm, stat} from 'node:fs/promises';
+import {readFile, rm, stat} from 'node:fs/promises';
 import path from 'node:path';
 import Is from 'strong-type';
-import {createCoreClassicSource} from '../core-classic-source.mjs';
 import {ArcaneError, ERROR_CODES, throwIfAborted} from '../errors.mjs';
-import {SDK_ROOT, CORE_FILES, outputFile, writeOutput, copyRelease, copyCoreRuntime, coreEntrySource} from './portable-layout.mjs';
+import {SDK_ROOT, CORE_FILES, outputFile} from './portable-layout.mjs';
+import {assemblePortable} from './portable-assembly.mjs';
+import {publishNativeOutput} from './publish-output.mjs';
 
 const is = new Is(false);
 const PROTOCOL = 'arcane-native-builder/1';
@@ -20,66 +21,6 @@ async function emit(onEvent, event) {
     if (is.function(onEvent)) await onEvent(event);
 }
 
-function contains(root, candidate) {
-    const relative = path.relative(root, candidate);
-    return relative === '' || (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`));
-}
-
-async function futureRealPath(location) {
-    try { return await realpath(location); }
-    catch (error) {
-        if (error.code !== 'ENOENT') throw error;
-        const parent = path.dirname(location);
-        if (parent === location) throw error;
-        return path.join(await futureRealPath(parent), path.basename(location));
-    }
-}
-
-async function outputDirectory(request) {
-    if (!is.string(request.outputRoot) || !request.outputRoot) {
-        throw new ArcaneError(ERROR_CODES.usage, 'Portable assembly requires an outputRoot.');
-    }
-    const output = await futureRealPath(path.resolve(request.outputRoot));
-    const protectedRoots = [SDK_ROOT, request.appReleaseRoot,
-        ...(request.dependencies?.map(function dependencyRoot(item) { return item.releaseRoot; }) ?? []),
-        ...(request.protectedRoots ?? [])];
-    for (const location of protectedRoots) {
-        if (!location) continue;
-        const root = await futureRealPath(path.resolve(location));
-        // SDK/release roots must never be replaced by generated output. A
-        // caller may select its ordinary project-local dist descendant.
-        if (contains(output, root) || (location !== SDK_ROOT && contains(root, output))) {
-            throw new ArcaneError(ERROR_CODES.usage, `Portable output overlaps selected source: ${location}.`);
-        }
-    }
-    await mkdir(output, {recursive: true});
-    return output;
-}
-
-function serviceSelection(services, release) {
-    return services.map(function selectService(service) {
-        if (!is.string(service?.module) || !release.files.includes(service.module)) {
-            throw new ArcaneError(ERROR_CODES.prerequisiteMissing, `The selected release does not contain service module ${String(service?.module)}.`);
-        }
-        return {...service, options: service.options === undefined ? {} : service.options};
-    });
-}
-
-function eventOwnerPath(release) {
-    const paths = release.files.filter(function sdkEventModule(relative) {
-        return relative === 'sdk/event-manager.mjs' || relative.endsWith('/sdk/event-manager.mjs')
-            || /^node_modules\/(?:@[^/]+\/)?[^/]+\/browser-runtime\/event-manager\.mjs$/u.test(relative);
-    });
-    if (paths.length !== 1) {
-        throw new ArcaneError(ERROR_CODES.prerequisiteMissing,
-            'The portable app release must select one shared SDK event-manager module.',
-            {details: {paths}});
-    }
-    // Native hosts mount the complete app directory at one local URL origin.
-    // An origin-root URL keeps nested navigable documents on the same owner.
-    return '/' + paths[0].split('/').map(encodeURIComponent).join('/');
-}
-
 /** Package-owned assembly; never imports an OS checkout or application service. */
 export function createPortableNativeProvider({services, packagedWeb = false, webKitDocumentLifecycle = false} = {}) {
     return {
@@ -117,108 +58,23 @@ export function createPortableNativeProvider({services, packagedWeb = false, web
             return result;
         },
         async build(request = {}) {
-            const {appDescriptor, release, signal, onEvent} = request;
-            throwIfAborted(signal);
-            const target = portableTarget(request.targetRequest);
-            const localAI = appDescriptor.native?.localAI;
-            const selectedServices = serviceSelection(services ?? appDescriptor.native?.services ?? [], release);
-            const eventOwnerModuleURL = eventOwnerPath(release);
-            const output = await outputDirectory(request);
-            throwIfAborted(signal);
-            // Unique assembly directories preserve earlier outputs and avoid
-            // overwriting an app's files or a concurrent packaging operation.
-            const root = await mkdtemp(path.join(output, 'arcane-portable-'));
-            const files = [];
+            throwIfAborted(request.signal);
+            portableTarget(request.targetRequest);
+            const artifact = await assemblePortable(request, {services, packagedWeb, webKitDocumentLifecycle});
+            const sourceRoot = artifact.target.rootDir;
             try {
-                await emit(onEvent, {type: 'native.payload.started', appId: appDescriptor.id, outputRoot: root});
-                async function bundleSelectedRuntimes() {
-                    if (localAI === undefined) return {runtimes: [], files: []};
-                    const {bundleLocalAIRuntimes} = await import('../local-ai/install.mjs');
-                    return bundleLocalAIRuntimes({
-                        runtimes: localAI.runtimes,
-                        directory: path.join(output, 'local-ai-runtimes'),
-                        outputRoot: root,
-                        platform: target.platform === 'windows' ? 'win32' : target.platform === 'macos' ? 'darwin' : target.platform,
-                        architecture: target.architecture,
-                        signal,
-                        onEvent
-                    });
-                }
-                // These outputs have separate directories. Join both owners
-                // before cleanup so neither can keep writing a removed assembly.
-                const preparation = await Promise.allSettled([
-                    copyRelease({...request, releaseRoot: request.appReleaseRoot}, 'app', root, files, signal),
-                    bundleSelectedRuntimes()
-                ]);
-                const failures = preparation.filter(function failedPreparation(result) { return result.status === 'rejected'; });
-                if (failures.length === 1) throw failures[0].reason;
-                if (failures.length > 1) {
-                    throw new AggregateError(failures.map(function preparationError(result) { return result.reason; }),
-                        'Portable application and local runtime preparation failed.');
-                }
-                const bundled = preparation[1].value;
-                files.push(...bundled.files);
-                const dependencies = [];
-                for (const [index, dependency] of (request.dependencies ?? []).entries()) {
-                    const directory = `dependencies/${index}`;
-                    await copyRelease(dependency, directory, root, files, signal);
-                    dependencies.push({appId: dependency.appId, root: directory, release: dependency.release});
-                }
-                const sdk = await copyCoreRuntime(root, files, signal);
-                const selectedSdk = request.selectedSdk;
-                let appSdk;
-                if (selectedSdk && release.files.some(function selectedPackageFile(relative) {
-                    return relative.startsWith(`${selectedSdk.packageSource}/`);
-                })) {
-                    const destination = `app/${selectedSdk.packageSource}`;
-                    let metadata;
-                    if (release.files.includes(`${selectedSdk.packageSource}/package.json`)) {
-                        metadata = JSON.parse(await readFile(outputFile(root, `${destination}/package.json`), 'utf8'));
-                    } else {
-                        metadata = await copyCoreRuntime(root, files, signal, {
-                            sourceRoot: selectedSdk.packageRoot, sdkDestination: destination
-                        });
+                const root = await publishNativeOutput({
+                    sourceRoot, outputRoot: path.dirname(sourceRoot), appId: artifact.app.id,
+                    signal: request.signal,
+                    async onPublished(outputRoot) {
+                        await emit(request.onEvent, {type: 'native.payload.completed', appId: artifact.app.id, outputRoot});
                     }
-                    appSdk = {name: metadata.name, version: metadata.version, root: destination};
-                }
-                await writeOutput(root, 'package.json', '{"type":"module"}\n', files, signal);
-                await writeOutput(root, 'runtime/arcane-core.mjs', coreEntrySource(appDescriptor, sdk.version, selectedServices,
-                    {localAI, runtimes: bundled.runtimes, packagedWeb}), files, signal);
-                await writeOutput(root, 'runtime/arcane-api.js', await createCoreClassicSource({
-                    eventOwnerModuleURL, replayRuntimeState: true, webKitDocumentLifecycle
-                }), files, signal);
-                const manifest = {
-                    schemaVersion: 1,
-                    kind: 'arcane-portable-native',
-                    sdk: {name: sdk.name, version: sdk.version},
-                    ...(appSdk ? {appSdk} : {}),
-                    app: appDescriptor,
-                    target,
-                    webRoot: 'app',
-                    start: release.manifest?.app?.start ?? './index.html',
-                    ...(appDescriptor.native?.window === undefined ? {} : {window: {...appDescriptor.native.window}}),
-                    ...(appDescriptor.native?.launchContext === undefined ? {} : {launchContext: appDescriptor.native.launchContext}),
-                    core: {
-                        entry: 'runtime/arcane-core.mjs', transport: 'stdio', protocol: 'arcane/1', services: selectedServices,
-                        ...(localAI === undefined ? {} : {localAIRuntimes: bundled.runtimes})
-                    },
-                    client: {
-                        source: 'runtime/arcane-api.js', injection: 'document-created', eventOwnerModuleURL, replayRuntimeState: true,
-                        ...(webKitDocumentLifecycle ? {webKitDocumentLifecycle: true} : {})
-                    },
-                    dependencies,
-                    minimumCoreVersion: request.minimumCoreVersion ?? null,
-                    files: [...files, MANIFEST]
-                };
-                await writeOutput(root, MANIFEST, JSON.stringify(manifest, null, 2) + '\n', files, signal);
-                throwIfAborted(signal);
-                await emit(onEvent, {type: 'native.payload.completed', appId: appDescriptor.id, outputRoot: root});
-                throwIfAborted(signal);
-                return {app: appDescriptor, target: {...target, rootDir: root}, manifest};
+                });
+                return {...artifact, target: {...artifact.target, rootDir: root}};
             } catch (error) {
-                try { await rm(root, {recursive: true, force: true}); }
+                try { await rm(sourceRoot, {recursive: true, force: true}); }
                 catch (cleanupError) {
-                    throw new AggregateError([error, cleanupError], `Portable assembly failed; its incomplete output remains at ${root}.`);
+                    throw new AggregateError([error, cleanupError], `Portable publication failed; its assembly remains at ${sourceRoot}.`);
                 }
                 throw error;
             }

package/src/native/publish-output.mjs

@@ -0,0 +1,101 @@
+import {lstat, mkdir, readFile, rename, rm, writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {ArcaneError, ERROR_CODES, throwIfAborted} from '../errors.mjs';
+import {outputFile} from './portable-layout.mjs';
+
+/** Publish only a complete native artifact, retaining the previous app until acceptance. */
+export async function publishNativeOutput({sourceRoot, outputRoot, appId, bundle = false, signal, onPublished}) {
+    const parent = path.resolve(outputRoot);
+    const source = path.resolve(sourceRoot);
+    const name = bundle ? `${appId}.app` : appId;
+    // Keep valid application IDs usable on Windows without changing their
+    // descriptor identity, including when another platform assembles the app.
+    const outputName = /^(?:con|prn|aux|nul|com[1-9¹²³]|lpt[1-9¹²³])(?:\.|$)/iu.test(name) ? `_${name}` : name;
+    const destination = outputFile(parent, outputName);
+    if (path.dirname(destination) !== parent || source === destination) {
+        throw new ArcaneError(ERROR_CODES.usage, 'Native publication requires a separate app-specific output child.');
+    }
+    const reservation = path.join(parent, `.arcane-publish-${path.basename(destination)}`);
+    const backup = path.join(reservation, 'previous');
+    const state = {sourceRoot: source, outputRoot: destination, reservation, backup, promoted: false, committed: false};
+    throwIfAborted(signal);
+    try { await mkdir(reservation); }
+    catch (error) {
+        if (error.code !== 'EEXIST') throw error;
+        throw new ArcaneError(ERROR_CODES.operationFailed,
+            `Native output publication is already reserved at ${reservation}. Finish or recover that publication before retrying.`,
+            {cause: error, details: state});
+    }
+    let previous = false;
+    let failure;
+    let retainReservation = false;
+    try {
+        // This short filesystem reservation protects only final replacement,
+        // including across processes. Assembly and other apps stay independent.
+        const acquiredAt = new Date();
+        const ttlMs = 5 * 60 * 1000;
+        await writeFile(path.join(reservation, 'owner.json'), JSON.stringify({
+            pid: process.pid, acquiredAt: acquiredAt.toISOString(), expiresAt: new Date(acquiredAt.getTime() + ttlMs).toISOString(), ttlMs,
+            sourceRoot: source, outputRoot: destination, reservation, backup,
+            recovery: 'Expiry is informational and never permits automatic takeover. After the owning build has stopped, inspect both outputs. Restore previous if publication did not finish; preserve the current output if it did. Remove this reservation only after recovery.'
+        }, null, 2) + '\n', {flag: 'wx'});
+        throwIfAborted(signal);
+        let existing;
+        try { existing = await lstat(destination); }
+        catch (error) { if (error.code !== 'ENOENT') throw error; }
+        if (existing) {
+            // Replacement is scoped to this app's generated artifact, never a
+            // cache, source directory, linked folder or unrelated user data.
+            if (!existing.isDirectory() || existing.isSymbolicLink()) {
+                throw new ArcaneError(ERROR_CODES.usage, `Native output is not a replaceable app directory: ${destination}.`);
+            }
+            const manifestRoot = bundle ? path.join(destination, 'Contents', 'Resources') : destination;
+            const manifest = JSON.parse(await readFile(path.join(manifestRoot, 'arcane-native.json'), 'utf8'));
+            if (manifest.app?.id !== appId || !['arcane-portable-native', 'arcane-windows-native', 'arcane-macos-native'].includes(manifest.kind)) {
+                throw new ArcaneError(ERROR_CODES.usage, `Native output belongs to a different artifact: ${destination}.`);
+            }
+            throwIfAborted(signal);
+            await rename(destination, backup);
+            previous = true;
+        }
+        throwIfAborted(signal);
+        await rename(source, destination);
+        state.promoted = true;
+        throwIfAborted(signal);
+        // Completion observers see the actual final paths. Their ordinary
+        // rejection/cancellation still rolls back before the build is accepted.
+        await onPublished?.(destination);
+        throwIfAborted(signal);
+        state.committed = true;
+    } catch (error) {
+        const failures = [error];
+        if (state.promoted) {
+            try {
+                await rename(destination, source);
+                state.promoted = false;
+            } catch (restoreError) { failures.push(restoreError); }
+        }
+        if (previous && !state.promoted) {
+            try {
+                await rename(backup, destination);
+                previous = false;
+            } catch (restoreError) { failures.push(restoreError); }
+        }
+        retainReservation = failures.length > 1;
+        failure = retainReservation
+            ? new ArcaneError(ERROR_CODES.operationFailed,
+                `Native output recovery is incomplete. Preserve and inspect ${destination}, ${source} and ${reservation}.`,
+                {cause: new AggregateError(failures, 'Native publication and recovery failed.'), details: state})
+            : error;
+    }
+    if (!retainReservation) {
+        try { await rm(reservation, {recursive: true, force: true}); }
+        catch (cleanupError) {
+            failure = new ArcaneError(ERROR_CODES.operationFailed,
+                `Native output ${state.committed ? 'was published' : 'was not accepted'}, and publication cleanup failed at ${reservation}.`,
+                {cause: failure ? new AggregateError([failure, cleanupError], 'Native publication cleanup failed.') : cleanupError, details: state});
+        }
+    }
+    if (failure) throw failure;
+    return destination;
+}

package/src/native/windows-provider.mjs

@@ -7,6 +7,8 @@ import Is from 'strong-type';
 import {ArcaneError, ERROR_CODES, throwIfAborted} from '../errors.mjs';
 import {runProcess} from '../process.mjs';
 import {createPortableNativeProvider} from './portable-provider.mjs';
+import {assemblePortable} from './portable-assembly.mjs';
+import {publishNativeOutput} from './publish-output.mjs';
 import {outputFile, writeOutput} from './portable-layout.mjs';
 import {createWindowsApplicationIcon} from './windows-icon.mjs';
 
@@ -275,13 +277,13 @@ export function createWindowsNativeProvider({services, hostDirectory} = {}) {
             const target = windowsTarget(request.targetRequest);
             const selected = hostDirectory ?? request.toolchain?.hostDirectory;
             const selectedHost = selected === undefined ? null : await requireHostDirectory(selected);
-            const artifact = await portable.build({
+            const artifact = await assemblePortable({
                 ...request,
                 targetRequest: portableRequest(target),
                 async onEvent(event) {
-                    if (event.type !== 'native.payload.completed') await emit(onEvent, {...event, target: 'windows-x64'});
+                    await emit(onEvent, {...event, target: 'windows-x64'});
                 }
-            });
+            }, {services});
             const root = artifact.target.rootDir;
             try {
                 const host = selectedHost ?? await releasedHostDirectory(path.resolve(request.outputRoot), artifact.manifest.sdk.version, {signal, onEvent});
@@ -304,9 +306,13 @@ export function createWindowsNativeProvider({services, hostDirectory} = {}) {
                 };
                 await writeFile(path.join(root, MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`, {signal});
                 throwIfAborted(signal);
-                await emit(onEvent, {type: 'native.payload.completed', target: 'windows-x64', appId: request.appDescriptor.id, outputRoot: root});
-                throwIfAborted(signal);
-                return {...artifact, target: {...target, rootDir: root}, manifest};
+                const output = await publishNativeOutput({
+                    sourceRoot: root, outputRoot: path.dirname(root), appId: request.appDescriptor.id, signal,
+                    async onPublished(outputRoot) {
+                        await emit(onEvent, {type: 'native.payload.completed', target: 'windows-x64', appId: request.appDescriptor.id, outputRoot});
+                    }
+                });
+                return {...artifact, target: {...target, rootDir: output}, manifest};
             } catch (error) {
                 return removeOwnedDirectory(root, error);
             }