@spexcode/session-selflaunch 0.6.8 → 0.7.0-next.1

package/dist/locality.d.ts

@@ -10,11 +10,22 @@ export interface FilesystemClassification {
 export declare function classifyFilesystemType(type: number | bigint): FilesystemClassification;
 export interface LocalityDetector {
     readonly platform: string;
-    statfsType(parentPath: string): number | bigint;
+    readonly classify?: (parentPath: string) => FilesystemClassification;
 }
+export declare const linuxLocalityDetector: (statfsType: (parentPath: string) => number | bigint) => LocalityDetector;
+interface DarwinMountEntry {
+    readonly mountPoint: string;
+    readonly fstype: string;
+    readonly flags: ReadonlySet<string>;
+}
+export declare function parseDarwinMountTable(output: string): DarwinMountEntry[];
+export declare function classifyDarwinMount(mountTable: string, resolvedPath: string): FilesystemClassification;
+export declare const darwinLocalityDetector: (readMountTable: () => string) => LocalityDetector;
 export declare function requireLocalDatabasePathWithDetector(databasePath: string, options: {
     assumeLocal?: boolean;
 }, detector: LocalityDetector): string;
+export declare function localityDetectorForPlatform(platform: string): LocalityDetector;
 export declare function requireLocalDatabasePath(databasePath: string, options?: {
     assumeLocal?: boolean;
 }): string;
+export {};

package/dist/locality.js

@@ -1,4 +1,5 @@
-import { statfsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { realpathSync, statSync, statfsSync } from 'node:fs';
 import { isAbsolute, dirname } from 'node:path';
 import { DatabasePathError } from './path.js';
 export class LocalityError extends Error {
@@ -44,6 +45,54 @@ export function classifyFilesystemType(type) {
         return { locality: 'local', name: local.name };
     return { locality: 'undetermined', name: `0x${magic.toString(16)}` };
 }
+export const linuxLocalityDetector = (statfsType) => ({
+    platform: 'linux',
+    classify: parentPath => classifyFilesystemType(statfsType(parentPath)),
+});
+// Darwin filesystem type names that are network transports even when the mount table omits MNT_LOCAL. `local`
+// wins when present (it is the kernel's own verdict); this list only names the refusal, so the operator reads
+// "smbfs" instead of a bare "undetermined".
+const DARWIN_NETWORK_FILESYSTEM_NAMES = new Set(['nfs', 'smbfs', 'afpfs', 'webdav', 'cifs', 'ftp']);
+// `/sbin/mount` prints one `<device> on <mount point> (<fstype>, <flag>, …)` line per mount. The mount point may
+// contain spaces (`/Volumes/My Disk`); the parenthesised list is always last and never contains `)`.
+const DARWIN_MOUNT_LINE = /^.+ on (.+) \(([^)]*)\)$/;
+export function parseDarwinMountTable(output) {
+    const entries = [];
+    for (const line of output.split('\n')) {
+        const match = DARWIN_MOUNT_LINE.exec(line.trim());
+        if (!match)
+            continue;
+        const [fstype = '', ...flags] = match[2].split(',').map(part => part.trim()).filter(Boolean);
+        entries.push({ mountPoint: match[1], fstype, flags: new Set(flags) });
+    }
+    return entries;
+}
+const mountPointCovers = (mountPoint, path) => mountPoint === '/' || path === mountPoint || path.startsWith(mountPoint.endsWith('/') ? mountPoint : `${mountPoint}/`);
+export function classifyDarwinMount(mountTable, resolvedPath) {
+    let entry;
+    for (const candidate of parseDarwinMountTable(mountTable)) {
+        if (!mountPointCovers(candidate.mountPoint, resolvedPath))
+            continue;
+        if (!entry || candidate.mountPoint.length > entry.mountPoint.length)
+            entry = candidate;
+    }
+    if (!entry)
+        return { locality: 'undetermined', name: 'no mount table entry' };
+    if (entry.flags.has('local'))
+        return { locality: 'local', name: entry.fstype };
+    if (DARWIN_NETWORK_FILESYSTEM_NAMES.has(entry.fstype))
+        return { locality: 'network', name: entry.fstype };
+    return { locality: 'undetermined', name: entry.fstype };
+}
+export const darwinLocalityDetector = (readMountTable) => ({
+    platform: 'darwin',
+    classify: parentPath => {
+        // `mount` never fails for a missing directory, so the parent's absence must be raised here for the resolver
+        // to keep its actionable PROTOCOL_PATH_PARENT_MISSING error.
+        statSync(parentPath);
+        return classifyDarwinMount(readMountTable(), realpathSync(parentPath));
+    },
+});
 export function requireLocalDatabasePathWithDetector(databasePath, options, detector) {
     if (!isAbsolute(databasePath)) {
         throw new DatabasePathError('PROTOCOL_PATH_NOT_ABSOLUTE', 'databasePath must be absolute before locality detection');
@@ -51,12 +100,12 @@ export function requireLocalDatabasePathWithDetector(databasePath, options, dete
     if (options.assumeLocal)
         return databasePath;
     const parent = dirname(databasePath);
-    if (detector.platform !== 'linux') {
+    if (!detector.classify) {
         throw new LocalityError('LOCALITY_DETECTOR_UNAVAILABLE', `no filesystem locality detector for platform ${detector.platform}; pass --assume-local-storage only after auditing ${parent}`);
     }
-    let type;
+    let classification;
     try {
-        type = detector.statfsType(parent);
+        classification = detector.classify(parent);
     }
     catch (error) {
         // @@@missing-parent - Preserve the actionable path error without pretending locality was established.
@@ -65,7 +114,6 @@ export function requireLocalDatabasePathWithDetector(databasePath, options, dete
         }
         throw new LocalityError('LOCALITY_PROBE_FAILED', `could not determine the filesystem of ${parent}`, error);
     }
-    const classification = classifyFilesystemType(type);
     if (classification.locality === 'network') {
         throw new LocalityError('LOCALITY_NETWORK_FILESYSTEM', `${parent} is ${classification.name}; advisory locking is not admitted there`);
     }
@@ -74,10 +122,14 @@ export function requireLocalDatabasePathWithDetector(databasePath, options, dete
     }
     return databasePath;
 }
-const linuxDetector = {
-    platform: process.platform,
-    statfsType: parentPath => statfsSync(parentPath).type,
-};
+const readDarwinMountTable = () => execFileSync('/sbin/mount', [], { encoding: 'utf8', timeout: 5_000, stdio: ['ignore', 'pipe', 'ignore'] });
+export function localityDetectorForPlatform(platform) {
+    if (platform === 'linux')
+        return linuxLocalityDetector(parentPath => statfsSync(parentPath).type);
+    if (platform === 'darwin')
+        return darwinLocalityDetector(readDarwinMountTable);
+    return { platform };
+}
 export function requireLocalDatabasePath(databasePath, options = {}) {
-    return requireLocalDatabasePathWithDetector(databasePath, options, linuxDetector);
+    return requireLocalDatabasePathWithDetector(databasePath, options, localityDetectorForPlatform(process.platform));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-selflaunch",
-  "version": "0.6.8",
+  "version": "0.7.0-next.1",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "A fail-closed self-launch adopter for the SpexCode session protocol.",
@@ -24,8 +24,8 @@
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/session-protocol": "0.6.8",
-    "@spexcode/session-runtime": "0.6.8"
+    "@spexcode/session-protocol": "0.7.0-next.1",
+    "@spexcode/session-runtime": "0.7.0-next.1"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",