@volter/supercode-teams 0.3.184 → 0.3.187

package/mail/upgrade-state.mjs

@@ -0,0 +1,78 @@
+import { connect } from 'node:net';
+import { copyFile, lstat, mkdir, readFile, readdir, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const json = async path => { try { return JSON.parse(await readFile(path, 'utf8')); } catch (error) { if (error.code === 'ENOENT') return null; throw error; } };
+const present = async path => { try { return await lstat(path); } catch (error) { if (error.code === 'ENOENT') return null; throw error; } };
+const answers = socket => new Promise(done => {
+  if (typeof socket !== 'string') return done(false);
+  const probe = connect(socket), timer = setTimeout(() => { probe.destroy(); done(false); }, 200);
+  probe.once('connect', () => { clearTimeout(timer); probe.destroy(); done(true); });
+  probe.once('error', () => { clearTimeout(timer); done(false); });
+});
+
+export async function checkpoint(home, directory) {
+  const path = join(home, 'mail.sqlite');
+  let database = false;
+  if (await present(path)) {
+    const { DatabaseSync } = await import('node:sqlite');
+    const reader = new DatabaseSync(path, { readOnly: true });
+    try { reader.prepare('VACUUM INTO ?').run(join(directory, 'mail.sqlite')); database = true; }
+    finally { reader.close(); }
+  }
+  const legacy = await present(join(home, 'mail'));
+  if (legacy && !legacy.isDirectory()) throw new Error('startup checkpoint requires a regular original Maildir');
+  const before = { database, legacy: legacy ? { device: legacy.dev, inode: legacy.ino } : null };
+  await writeFile(join(directory, 'before.json'), JSON.stringify(before) + '\n', { mode: 0o600 });
+  return before;
+}
+
+async function mergeLegacy(source, target) {
+  // Older writers can recreate the path during startup. Merge only records
+  // that do not conflict; keep both complete trees if a choice is required.
+  for (const item of await readdir(source, { withFileTypes: true })) {
+    const from = join(source, item.name), to = join(target, item.name), saved = await present(to);
+    if (item.isDirectory()) {
+      if (saved && !saved.isDirectory()) throw new Error('startup recovery found conflicting legacy record types');
+      if (!saved) await mkdir(to, { mode: 0o700 });
+      await mergeLegacy(from, to);
+    } else if (item.isFile()) {
+      if (!saved) await copyFile(from, to);
+      else if (!saved.isFile() || !(await readFile(from)).equals(await readFile(to))) throw new Error('startup recovery found conflicting legacy record bytes; both originals are retained');
+    } else throw new Error('startup recovery found a non-regular legacy record');
+  }
+}
+
+export async function restore(home, directory, before, teamsHome) {
+  const serving = await json(join(teamsHome, 'machine.json'));
+  if (serving && await answers(serving.socket)) throw new Error('startup recovery refused: another daemon is serving this home');
+  const path = join(home, 'mail.sqlite');
+  if (before.legacy) {
+    const root = join(home, 'mail'), current = await present(root);
+    const original = item => item?.isDirectory() && item.dev === before.legacy.device && item.ino === before.legacy.inode;
+    if (!original(current)) {
+      const archives = join(home, 'mail-retired');
+      let matches = [];
+      if (await present(archives)) for (const name of await readdir(archives)) {
+        const path = join(archives, name);
+        if (original(await present(path))) matches.push(path);
+      }
+      // Locate the pre-start inode even if a failed candidate's database cannot
+      // be opened or its metadata transaction never committed.
+      if (matches.length !== 1) throw new Error('startup recovery cannot locate its retained original Maildir');
+      if (current) {
+        if (!current.isDirectory()) throw new Error('startup recovery found a replaced Maildir path');
+        await mergeLegacy(root, matches[0]);
+        await rename(root, join(directory, 'recreated-mail'));
+      }
+      await rename(matches[0], root);
+    }
+  }
+  // Startup failure never served a caller. Preserve the failed candidate's
+  // database bytes for diagnosis before restoring the previous schema snapshot.
+  for (const suffix of ['', '-wal', '-shm']) {
+    if (await present(path + suffix)) await rename(path + suffix, join(directory, 'failed-mail.sqlite' + suffix));
+  }
+  if (before.database) await copyFile(join(directory, 'mail.sqlite'), path);
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.184",
+  "version": "0.3.187",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",

package/session-index-owner.mjs

@@ -270,8 +270,13 @@ export class SessionIndexOwner extends EventEmitter {
     if (!source) return;
     const path = name == null ? null : join(directory, name);
     if (path?.endsWith('-shm')) return;
+    // Lifecycle parents cover replacement of the selected root, not every
+    // sibling below that parent. Only selected physical directory bindings
+    // extend file-source admission beyond its logical aliases.
+    const parents = new Set([dirname(source.root), ...[...source.aliases].map(dirname)]);
+    const selectedTargets = source.kind === 'stores' ? targets : targets.filter((target) => !parents.has(target));
     if (path != null && !pathUnder(source.root, path) && !pathUnder(path, source.root)
-      && !(source.kind === 'stores' ? targets : [...source.aliases]).some((target) => pathUnder(path, target) || pathUnder(target, path))
+      && ![...selectedTargets, ...source.aliases].some((target) => pathUnder(path, target) || pathUnder(target, path))
       && !(source.registryPath && (pathUnder(source.registryPath, path) || pathUnder(path, source.registryPath)))
       && ![source.namesPath, source.historyPath].includes(path)) return;
     if (path == null || pathUnder(path, source.root) || path === source.registryPath
@@ -306,8 +311,10 @@ export class SessionIndexOwner extends EventEmitter {
     finally { this.running = null; if (!this.closed && this.pending.size) this.#schedule(this.pending.keys().next().value, null); }
   }
 
-  async #watch(source, path) {
-    const directory = await this.watches.want(source.id, path);
+  async #watch(source, path, tree = false) {
+    const directory = await this.watches.want(source.id, path, {
+      tree, physicalParent: tree && !pathUnder(source.root, path),
+    });
     source.wanted.add(path);
     if (!this.closed) {
       this.store.clearFailure(source.id, path, 'watch');
@@ -320,7 +327,7 @@ export class SessionIndexOwner extends EventEmitter {
     this.metrics.reconciliations = (this.metrics.reconciliations ?? 0) + 1;
     for (const root of new Set([source.root, ...source.aliases])) {
       await this.#watch(source, dirname(root));
-      await this.#watch(source, root);
+      await this.#watch(source, root, source.kind === 'files');
     }
     for (const failure of this.store.failures([source.id])) if (failure.kind === 'registry-selection') {
       try {
@@ -338,14 +345,14 @@ export class SessionIndexOwner extends EventEmitter {
     }
     if (source.harness === 'codex') await this.#codexLedgers(source);
     const listing = await listSessionParts(source.harness, source.root, {
-      folder, metrics: this.metrics, beforeDirectory: (path) => this.#watch(source, path),
+      folder, metrics: this.metrics, beforeDirectory: (path) => this.#watch(source, path, true),
     });
     if (this.closed) return;
-    for (const part of source.parts.values()) if (part.kind === 'file' && pathUnder(folder, part.path) && !listing.parts.has(part.path)) this.#remove(source, part.path);
+    for (const part of source.parts.values()) if (part.kind === 'file' && (folder === source.root || pathUnder(folder, part.path)) && !listing.parts.has(part.path)) this.#remove(source, part.path);
     for (const path of listing.parts) { if (this.closed) return; await this.#file(source, path); }
     if (this.closed) return;
     this.store.clearFailure(source.id, folder, 'folder');
-    for (const directory of source.directories) if (pathUnder(folder, directory)) source.directories.delete(directory);
+    for (const directory of source.directories) if (folder === source.root || pathUnder(folder, directory)) source.directories.delete(directory);
     for (const directory of listing.directories) source.directories.add(directory);
     const wanted = new Set([...source.aliases, ...[...source.aliases].map(dirname), source.root, dirname(source.root), ...source.directories,
       ...(source.registryPath ? [source.registryPath, dirname(source.registryPath)] : []),
@@ -539,7 +546,12 @@ export class SessionIndexOwner extends EventEmitter {
     const part = await sessionPartFor(source.harness, source.root, path);
     if (part != null) return this.#file(source, part);
     if (path === source.root || !pathUnder(source.root, path)) return this.#reconcile(source);
-    if ((await sourceStat(path))?.isDirectory() || source.directories.has(path)) return this.#reconcile(source, path);
+    // Directory topology belongs to the whole selection: canonical transcript
+    // paths can sit outside a logical symlink's subtree. A removed alias no
+    // longer has stat metadata and is absent from the physical directory set,
+    // but must still retire those rows and their watch bindings.
+    const info = await sourceStat(path);
+    if (!info || info.isDirectory() || source.directories.has(path)) return this.#reconcile(source);
   }
 
   #retryTimer() {

package/session-index-watches.mjs

@@ -1,8 +1,11 @@
 import { watch } from 'node:fs';
-import { dirname } from 'node:path';
-import { normalizedSourcePath, sourceStat } from '@volter/supercode-interchange';
+import { basename, dirname, resolve } from 'node:path';
+import { normalizedSourcePath, pathUnder, sourceStat } from '@volter/supercode-interchange';
 
-/** One directory watch per physical directory, shared by all selected homes.
+const NATIVE_RECURSIVE = ['darwin', 'win32'].includes(process.platform);
+
+/** Native recursive trees on macOS/Windows, shared by physical coverage.
+ * Linux retains directory watches over its shared inotify descriptor.
  * Missing paths keep an ancestor watch. Reconciliation installs closer
  * watches before listing newly created directories. */
 export class SessionIndexWatches {
@@ -11,7 +14,7 @@ export class SessionIndexWatches {
     this.directories = new Map(); this.closed = false;
   }
 
-  async want(source, path) {
+  async want(source, path, { tree = false, physicalParent = false } = {}) {
     if (this.closed) return;
     let at = path;
     for (;;) {
@@ -21,27 +24,42 @@ export class SessionIndexWatches {
       if (parent === at) throw new Error(`no existing directory can watch ${path}`);
       at = parent;
     }
-    const directory = await normalizedSourcePath(at);
+    const target = await normalizedSourcePath(at);
+    let recursive = NATIVE_RECURSIVE && tree && at === path;
+    let directory = recursive && physicalParent ? dirname(target) : target;
+    // Descendants (including a symlink's physical tree) share an existing
+    // native stream. Shallow lifecycle/registry watches need no new stream
+    // when a selected tree already covers them.
+    for (const [root, value] of this.directories) if (value.recursive && pathUnder(root, target)) {
+      directory = root; recursive = true; break;
+    }
     const info = await sourceStat(directory);
     if (this.closed) return;
     if (!info?.isDirectory()) throw new Error(`directory changed while binding a watch for ${path}`);
     let held = this.directories.get(directory);
-    const renew = !held || held.dev !== info.dev || held.ino !== info.ino;
+    const renew = !held || held.dev !== info.dev || held.ino !== info.ino || recursive && !held.recursive;
     if (renew) {
       // A pathname can now name another filesystem object. Preserve every
       // source binding while replacing the watch attached to the old object.
       const old = held;
-      const value = { sources: old?.sources ?? new Map(), watcher: null, dev: info.dev, ino: info.ino };
+      const value = { sources: old?.sources ?? new Map(), watcher: null, dev: info.dev, ino: info.ino, recursive: recursive || old?.recursive || false };
       // Register before returning to the caller's first listing. A nameless
       // event and a watcher error both request a reconciliation, never removals.
-      value.watcher = watch(directory, { persistent: false, encoding: 'buffer' }, (event, filename) => {
+      value.watcher = watch(directory, { persistent: false, encoding: 'buffer', recursive: value.recursive }, (event, filename) => {
         if (this.closed || this.directories.get(directory) !== value) return;
         let name = null;
         if (filename != null) {
           try { name = new TextDecoder('utf-8', { fatal: true }).decode(filename); }
           catch { /* an undecodable path requires a whole directory read */ }
         }
-        for (const [id, targets] of value.sources) this.changed(id, { directory, name, event, targets: [...targets] });
+        const changed = name == null ? null : resolve(directory, name);
+        // Recursive filenames name a path below the tree. Keep the owner's
+        // directory/basename contract, and reconcile an undecodable event.
+        const known = changed != null && pathUnder(directory, changed);
+        for (const [id, targets] of value.sources) this.changed(id, {
+          directory: known ? dirname(changed) : directory,
+          name: known ? basename(changed) : null, event, targets: [...targets],
+        });
       });
       value.watcher.on('error', (error) => {
         this.#refuse(directory, value, error);
@@ -74,7 +92,7 @@ export class SessionIndexWatches {
     // Parent first closes the replacement/creation gap around root's stat.
     const parent = dirname(root);
     if (parent !== root) await this.want(source, parent);
-    await this.want(source, root);
+    await this.want(source, root, { tree: true });
   }
 
   /** Successful reconciliation supplies the complete wanted directory set.