@notis_ai/cli 0.2.17 → 0.2.19

package/src/runtime/app-changelog.js

@@ -1,79 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-export const APP_CHANGELOG_FILE = 'CHANGELOG.md';
-export const CHANGELOG_MERGE_DATE = '{PR_MERGE_DATE}';
-
-const ENTRY_HEADING = /^##\s+\[([^\]]+)]\s+-\s+(\{PR_MERGE_DATE\}|\d{4}-\d{2}-\d{2})\s*$/;
-
-function validCalendarDate(value) {
-  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
-  const date = new Date(`${value}T00:00:00Z`);
-  return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
-}
-
-export function parseAppChangelog(markdown, { sourcePath = APP_CHANGELOG_FILE } = {}) {
-  const lines = String(markdown || '').replace(/\r\n?/g, '\n').split('\n');
-  const entries = [];
-  const errors = [];
-  let current = null;
-
-  function finishCurrent() {
-    if (!current) return;
-    entries.push({
-      title: current.title,
-      date: current.date,
-      body: current.body.join('\n').trim(),
-    });
-  }
-
-  for (const [index, line] of lines.entries()) {
-    // Only a level-2 heading (`## ...`, not `###`/`####`) can start a release
-    // entry; deeper sub-section headings are legitimate release-body content.
-    if (!/^##(?!#)/.test(line)) {
-      if (current) current.body.push(line);
-      continue;
-    }
-
-    const match = line.match(ENTRY_HEADING);
-    if (!match) {
-      errors.push(
-        `${sourcePath}:${index + 1} must use \`## [Release title] - YYYY-MM-DD\` or \`## [Release title] - {PR_MERGE_DATE}\`.`,
-      );
-      continue;
-    }
-
-    finishCurrent();
-    const title = match[1].trim();
-    const date = match[2];
-    if (!title) {
-      errors.push(`${sourcePath}:${index + 1} must include a release title inside square brackets.`);
-    }
-    if (date !== CHANGELOG_MERGE_DATE && !validCalendarDate(date)) {
-      errors.push(`${sourcePath}:${index + 1} contains an invalid calendar date.`);
-    }
-    current = { title, date, body: [] };
-  }
-  finishCurrent();
-
-  if (entries.length === 0 && errors.length === 0) {
-    errors.push(
-      `${sourcePath} must include at least one \`## [Release title] - YYYY-MM-DD\` entry.`,
-    );
-  }
-
-  return { source_path: sourcePath, entries, errors, exists: true };
-}
-
-export function readAppChangelog(projectDir) {
-  const path = join(projectDir, APP_CHANGELOG_FILE);
-  if (!existsSync(path)) {
-    return {
-      source_path: APP_CHANGELOG_FILE,
-      entries: [],
-      errors: [`${APP_CHANGELOG_FILE} is required for Store publication.`],
-      exists: false,
-    };
-  }
-  return parseAppChangelog(readFileSync(path, 'utf-8'));
-}

package/src/runtime/app-dev-consumers.js

@@ -1,154 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-
-export const DEFAULT_APP_DEV_CONSUMERS_FILE = join(homedir(), '.notis', 'app-dev-consumers.json');
-export const APP_DEV_CONSUMER_EXPIRES_AFTER_MS = 10_000;
-const waitArray = new Int32Array(new SharedArrayBuffer(4));
-const CONSUMER_LOCK_STALE_AFTER_MS = 30_000;
-
-function processIsRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code !== 'ESRCH';
-  }
-}
-
-function reclaimConsumerLock(lockPath) {
-  const stat = lstatSync(lockPath);
-  if (!stat.isDirectory() || stat.isSymbolicLink()) {
-    throw new Error(`Refusing unsafe app development consumer lock: ${lockPath}`);
-  }
-  let ownerPid = null;
-  try {
-    const owner = readFileSync(join(lockPath, 'owner'), 'utf8').trim();
-    const parsed = Number.parseInt(owner.split('.')[0] || '', 10);
-    ownerPid = Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
-  } catch {
-    // An interrupted owner write is reclaimed after the bounded stale window.
-  }
-  if (ownerPid !== null) return !processIsRunning(ownerPid);
-  return Date.now() - stat.mtimeMs >= CONSUMER_LOCK_STALE_AFTER_MS;
-}
-
-function withLock(filePath, callback) {
-  mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
-  const lockPath = `${filePath}.lock`;
-  const owner = `${process.pid}.${randomUUID()}`;
-  const startedAt = Date.now();
-  while (true) {
-    try {
-      mkdirSync(lockPath, { mode: 0o700 });
-      writeFileSync(join(lockPath, 'owner'), owner, { mode: 0o600 });
-      break;
-    } catch (error) {
-      if (error?.code !== 'EEXIST') throw error;
-      try {
-        if (reclaimConsumerLock(lockPath)) {
-          rmSync(lockPath, { recursive: true, force: true });
-          continue;
-        }
-      } catch (lockError) {
-        if (lockError?.code === 'ENOENT') continue;
-        throw lockError;
-      }
-      if (Date.now() - startedAt > 2_000) {
-        throw new Error('App development consumer registry is busy.');
-      }
-      Atomics.wait(waitArray, 0, 0, 10);
-    }
-  }
-  try {
-    return callback();
-  } finally {
-    try {
-      if (readFileSync(join(lockPath, 'owner'), 'utf8').trim() === owner) {
-        rmSync(lockPath, { recursive: true, force: true });
-      }
-    } catch {
-      // A replaced lock belongs to another writer.
-    }
-  }
-}
-
-function normalize(value, now) {
-  const raw = value && typeof value === 'object' && Array.isArray(value.consumers)
-    ? value.consumers
-    : [];
-  return raw.filter((lease) => {
-    const heartbeat = Date.parse(String(lease?.lastHeartbeatAt || ''));
-    return typeof lease?.instanceId === 'string'
-      && typeof lease?.userId === 'string'
-      && typeof lease?.apiBase === 'string'
-      && Number.isSafeInteger(lease?.pid)
-      && Number.isFinite(heartbeat)
-      && now - heartbeat <= APP_DEV_CONSUMER_EXPIRES_AFTER_MS;
-  });
-}
-
-export function readAppDevConsumers(filePath = DEFAULT_APP_DEV_CONSUMERS_FILE, now = Date.now()) {
-  if (!existsSync(filePath)) return [];
-  try {
-    return normalize(JSON.parse(readFileSync(filePath, 'utf8')), now);
-  } catch {
-    return [];
-  }
-}
-
-function writeAppDevConsumers(filePath, consumers) {
-  mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
-  const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-  writeFileSync(temporary, JSON.stringify({ version: 1, consumers }, null, 2), { mode: 0o600 });
-  renameSync(temporary, filePath);
-}
-
-export function heartbeatAppDevConsumer(
-  lease,
-  filePath = DEFAULT_APP_DEV_CONSUMERS_FILE,
-) {
-  return withLock(filePath, () => {
-    const now = Date.now();
-    const next = readAppDevConsumers(filePath, now)
-      .filter((entry) => entry.instanceId !== lease.instanceId);
-    next.push({
-      ...lease,
-      apiBase: lease.apiBase.replace(/\/$/, ''),
-      lastHeartbeatAt: new Date(now).toISOString(),
-    });
-    writeAppDevConsumers(filePath, next);
-    return next;
-  });
-}
-
-export function removeAppDevConsumer(
-  instanceId,
-  filePath = DEFAULT_APP_DEV_CONSUMERS_FILE,
-) {
-  return withLock(filePath, () => {
-    const next = readAppDevConsumers(filePath)
-      .filter((entry) => entry.instanceId !== instanceId);
-    writeAppDevConsumers(filePath, next);
-    return next;
-  });
-}
-
-export function hasAppDevConsumer(consumers, { mode, userId, apiBase }) {
-  if (mode === 'machine') return consumers.length > 0;
-  if (mode !== 'environment') return true;
-  const normalizedApiBase = String(apiBase || '').replace(/\/$/, '');
-  return consumers.some((consumer) => (
-    consumer.userId === userId
-    && consumer.apiBase.replace(/\/$/, '') === normalizedApiBase
-  ));
-}

package/src/runtime/app-dev-host-lock.js

@@ -1,80 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-
-const DEFAULT_LOCK_ROOT = join(homedir(), '.notis', 'app-dev-host-locks');
-const OWNER_FILE = 'owner.json';
-
-function processIsRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code !== 'ESRCH';
-  }
-}
-
-function lockName(identity, apiBase, projectDir) {
-  return createHash('sha256').update(`${identity}\0${apiBase}\0${projectDir}`).digest('hex');
-}
-
-function readOwner(path) {
-  try {
-    const value = JSON.parse(readFileSync(join(path, OWNER_FILE), 'utf8'));
-    return Number.isSafeInteger(value?.pid) && typeof value?.ownerId === 'string'
-      ? { pid: value.pid, ownerId: value.ownerId }
-      : null;
-  } catch {
-    return null;
-  }
-}
-
-function reclaimable(path, now, staleAfterMs) {
-  const stat = lstatSync(path);
-  if (!stat.isDirectory() || stat.isSymbolicLink()) {
-    throw new Error(`Refusing unsafe app development host lock: ${path}`);
-  }
-  const owner = readOwner(path);
-  if (owner) return !processIsRunning(owner.pid);
-  return now - stat.mtimeMs >= staleAfterMs;
-}
-
-export function tryAcquireAppDevHostLock(options) {
-  const lockRoot = options.lockRoot || DEFAULT_LOCK_ROOT;
-  mkdirSync(lockRoot, { recursive: true, mode: 0o700 });
-  const path = join(lockRoot, lockName(options.identity, options.apiBase, options.projectDir));
-  const ownerId = `${process.pid}.${randomUUID()}`;
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      mkdirSync(path, { mode: 0o700 });
-      try {
-        writeFileSync(join(path, OWNER_FILE), JSON.stringify({ pid: process.pid, ownerId }), {
-          mode: 0o600,
-        });
-      } catch (error) {
-        rmSync(path, { recursive: true, force: true });
-        throw error;
-      }
-      return { path, ownerId };
-    } catch (error) {
-      if (error?.code !== 'EEXIST') throw error;
-      if (reclaimable(path, options.now ?? Date.now(), options.staleAfterMs ?? 60_000)) {
-        rmSync(path, { recursive: true, force: true });
-        continue;
-      }
-      return null;
-    }
-  }
-  return null;
-}
-
-export function releaseAppDevHostLock(lock) {
-  try {
-    if (readOwner(lock.path)?.ownerId === lock.ownerId) {
-      rmSync(lock.path, { recursive: true, force: true });
-    }
-  } catch {
-    // A replaced lock belongs to another process.
-  }
-}

package/src/runtime/app-dev-process-identity.js

@@ -1,111 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { readlinkSync, realpathSync } from 'node:fs';
-
-export const NOTIS_APP_BUILD_COMMAND_FINGERPRINT = 'npm:run-build:watch:v1';
-export const NOTIS_APPS_DEV_HOST_COMMAND_FINGERPRINT = 'notis:apps-dev:v1';
-
-function normalizePath(value) {
-  if (typeof value !== 'string' || !value.trim()) return null;
-  try {
-    return realpathSync(value.trim());
-  } catch {
-    return null;
-  }
-}
-
-export function isExpectedNotisBuildCommand(command) {
-  if (typeof command !== 'string') return false;
-  return /(?:^|[/\s])npm(?:\s|$)/.test(command)
-    && /\brun\s+build\b/.test(command)
-    && /(?:^|\s)--watch(?:\s|$)/.test(command);
-}
-
-export function isExpectedNotisAppsDevHostCommand(command) {
-  return typeof command === 'string'
-    && /(?:notis(?:\.js)?|@notis_ai[/\\]cli)/.test(command)
-    && /\bapps\s+dev\b/.test(command);
-}
-
-function readDarwinProcessCwd(pid, execute) {
-  const output = execute('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn'], {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'ignore'],
-  });
-  const line = output.split('\n').find((entry) => entry.startsWith('n'));
-  return line ? line.slice(1) : null;
-}
-
-export function inspectAppDevWatcherProcess(pid, {
-  platform = process.platform,
-  execute = execFileSync,
-  readLink = readlinkSync,
-} = {}) {
-  if (!Number.isSafeInteger(pid) || pid <= 0 || platform === 'win32') return null;
-  try {
-    const ps = (field) => execute('ps', ['-o', `${field}=`, '-p', String(pid)], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim();
-    const processGroupPid = Number.parseInt(ps('pgid'), 10);
-    const startIdentity = ps('lstart').replace(/\s+/g, ' ').trim();
-    const command = ps('command');
-    const cwd = platform === 'linux'
-      ? readLink(`/proc/${pid}/cwd`)
-      : readDarwinProcessCwd(pid, execute);
-    const projectDir = normalizePath(cwd);
-    if (!Number.isSafeInteger(processGroupPid) || processGroupPid <= 0) return null;
-    if (!startIdentity || !command || !projectDir) return null;
-    return { pid, processGroupPid, startIdentity, command, projectDir };
-  } catch {
-    return null;
-  }
-}
-
-export function captureDesktopWatcherOwnership({
-  pid,
-  projectDir,
-  desktopOwnerId,
-  desktopOwnerScope,
-  inspect = inspectAppDevWatcherProcess,
-} = {}) {
-  const owner = typeof desktopOwnerId === 'string' ? desktopOwnerId.trim() : '';
-  const ownerScope = typeof desktopOwnerScope === 'string' ? desktopOwnerScope.trim() : '';
-  const expectedProjectDir = normalizePath(projectDir);
-  if (!owner || !ownerScope || !expectedProjectDir) return null;
-  const identity = inspect(pid);
-  if (
-    !identity
-    || identity.processGroupPid !== pid
-    || identity.projectDir !== expectedProjectDir
-    || !isExpectedNotisBuildCommand(identity.command)
-  ) {
-    return null;
-  }
-  return {
-    desktopOwnerId: owner,
-    desktopOwnerScope: ownerScope,
-    watcherProcessGroupPid: identity.processGroupPid,
-    watcherStartIdentity: identity.startIdentity,
-    watcherProjectDir: identity.projectDir,
-    watcherCommandFingerprint: NOTIS_APP_BUILD_COMMAND_FINGERPRINT,
-  };
-}
-
-export function captureDesktopHostOwnership({
-  pid = process.pid,
-  desktopOwnerId,
-  desktopOwnerScope,
-  inspect = inspectAppDevWatcherProcess,
-} = {}) {
-  const owner = typeof desktopOwnerId === 'string' ? desktopOwnerId.trim() : '';
-  const ownerScope = typeof desktopOwnerScope === 'string' ? desktopOwnerScope.trim() : '';
-  if (!owner || !ownerScope) return null;
-  const identity = inspect(pid);
-  if (!identity || !isExpectedNotisAppsDevHostCommand(identity.command)) return null;
-  return {
-    desktopOwnerId: owner,
-    desktopOwnerScope: ownerScope,
-    desktopHostStartIdentity: identity.startIdentity,
-    desktopHostCommandFingerprint: NOTIS_APPS_DEV_HOST_COMMAND_FINGERPRINT,
-  };
-}

package/src/runtime/app-dev-roots.js

@@ -1,284 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readFileSync,
-  readdirSync,
-  realpathSync,
-  renameSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join, parse as parsePath, resolve } from 'node:path';
-
-import { usageError } from './errors.js';
-import { CONFIG_DIR } from './profiles.js';
-
-export const APP_DEV_ROOTS_VERSION = 1;
-export const DEFAULT_APP_DEV_ROOT = join(homedir(), '.notis', 'apps');
-export const DEFAULT_APP_DEV_ROOTS_FILE = join(CONFIG_DIR, 'app-dev-roots.json');
-const CONFIG_FILENAMES = ['notis.config.ts', 'notis.config.js', 'notis.config.mjs'];
-const LOCK_TIMEOUT_MS = 5_000;
-const lockWait = new Int32Array(new SharedArrayBuffer(4));
-
-function rootsFile(filePath) {
-  if (filePath) return resolve(filePath);
-  const envPath = process.env.NOTIS_APP_DEV_ROOTS_FILE;
-  return typeof envPath === 'string' && envPath.trim()
-    ? resolve(envPath.trim())
-    : DEFAULT_APP_DEV_ROOTS_FILE;
-}
-
-function legacyProjectsFile(filePath) {
-  const sessionsFile = filePath
-    || join(CONFIG_DIR, 'app-dev-sessions.json');
-  const parsed = parsePath(resolve(sessionsFile));
-  return join(parsed.dir, `${parsed.name}-projects${parsed.ext || '.json'}`);
-}
-
-function readLockOwner(lockPath) {
-  try {
-    return readFileSync(join(lockPath, 'owner'), 'utf8').trim();
-  } catch {
-    return null;
-  }
-}
-
-function withLock(filePath, callback) {
-  mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
-  const lockPath = `${filePath}.lock`;
-  const owner = `${process.pid}.${randomUUID()}`;
-  const startedAt = Date.now();
-  while (true) {
-    try {
-      mkdirSync(lockPath, { mode: 0o700 });
-      writeFileSync(join(lockPath, 'owner'), owner, { mode: 0o600 });
-      break;
-    } catch (error) {
-      if (error?.code !== 'EEXIST') throw error;
-      try {
-        const stat = lstatSync(lockPath);
-        if (!stat.isDirectory() || stat.isSymbolicLink()) {
-          throw new Error(`Refusing unsafe app development roots lock: ${lockPath}`);
-        }
-        const existingOwner = readLockOwner(lockPath);
-        const pid = Number.parseInt(String(existingOwner || '').split('.')[0] || '', 10);
-        if (Number.isInteger(pid) && pid > 0) {
-          try {
-            process.kill(pid, 0);
-          } catch (ownerError) {
-            if (ownerError?.code === 'ESRCH') {
-              rmSync(lockPath, { recursive: true, force: true });
-              continue;
-            }
-          }
-        }
-      } catch (statError) {
-        if (statError?.code === 'ENOENT') continue;
-        throw statError;
-      }
-      if (Date.now() - startedAt >= LOCK_TIMEOUT_MS) {
-        throw new Error(`Timed out waiting for app development roots lock: ${filePath}`);
-      }
-      Atomics.wait(lockWait, 0, 0, 10);
-    }
-  }
-  try {
-    return callback();
-  } finally {
-    if (readLockOwner(lockPath) === owner) {
-      rmSync(lockPath, { recursive: true, force: true });
-    }
-  }
-}
-
-function canonicalExistingDirectory(inputPath) {
-  const absolute = resolve(String(inputPath || ''));
-  let stat;
-  try {
-    stat = statSync(absolute);
-  } catch {
-    throw usageError(`App development root does not exist: ${absolute}`);
-  }
-  if (!stat.isDirectory()) {
-    throw usageError(`App development root is not a directory: ${absolute}`);
-  }
-  return realpathSync(absolute);
-}
-
-function normalizeRegistry(raw) {
-  const roots = Array.isArray(raw?.roots) ? raw.roots : [];
-  const seen = new Set();
-  return roots
-    .map((entry) => typeof entry === 'string' ? { path: entry } : entry)
-    .filter((entry) => entry && typeof entry.path === 'string' && entry.path.trim())
-    .map((entry) => ({
-      path: resolve(entry.path),
-      registeredAt: typeof entry.registeredAt === 'string'
-        ? entry.registeredAt
-        : new Date(0).toISOString(),
-    }))
-    .filter((entry) => {
-      if (seen.has(entry.path)) return false;
-      seen.add(entry.path);
-      return true;
-    });
-}
-
-function readRaw(filePath) {
-  if (!existsSync(filePath)) return { version: APP_DEV_ROOTS_VERSION, roots: [] };
-  try {
-    return {
-      version: APP_DEV_ROOTS_VERSION,
-      roots: normalizeRegistry(JSON.parse(readFileSync(filePath, 'utf8'))),
-    };
-  } catch {
-    return { version: APP_DEV_ROOTS_VERSION, roots: [] };
-  }
-}
-
-function writeRaw(registry, filePath) {
-  mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
-  const normalized = {
-    version: APP_DEV_ROOTS_VERSION,
-    roots: normalizeRegistry(registry),
-  };
-  const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-  writeFileSync(temporary, JSON.stringify(normalized, null, 2), { mode: 0o600 });
-  renameSync(temporary, filePath);
-  return normalized;
-}
-
-function migrateLegacyProjectsUnlocked(registry, options) {
-  const path = legacyProjectsFile(options.legacySessionsFilePath);
-  if (!existsSync(path)) return registry;
-  let projects = [];
-  try {
-    const raw = JSON.parse(readFileSync(path, 'utf8'));
-    projects = Array.isArray(raw?.projects) ? raw.projects : [];
-  } catch {
-    return registry;
-  }
-  const byPath = new Map(registry.roots.map((entry) => [entry.path, entry]));
-  for (const project of projects) {
-    if (typeof project?.projectDir !== 'string' || !project.projectDir.trim()) continue;
-    try {
-      const path = canonicalExistingDirectory(project.projectDir);
-      if (path === realpathIfExists(DEFAULT_APP_DEV_ROOT)) continue;
-      if (!byPath.has(path)) {
-        byPath.set(path, {
-          path,
-          registeredAt: typeof project.lastMountedAt === 'string'
-            ? project.lastMountedAt
-            : new Date().toISOString(),
-        });
-      }
-    } catch {
-      // Deleted or inaccessible legacy projects are intentionally not migrated.
-    }
-  }
-  rmSync(path, { force: true });
-  return { version: APP_DEV_ROOTS_VERSION, roots: [...byPath.values()] };
-}
-
-function realpathIfExists(path) {
-  try {
-    return realpathSync(path);
-  } catch {
-    return resolve(path);
-  }
-}
-
-export function readAppDevRoots(options = {}) {
-  const filePath = rootsFile(options.filePath);
-  let registry = readRaw(filePath);
-  if (options.migrateLegacy !== false) {
-    registry = withLock(filePath, () => {
-      const before = readRaw(filePath);
-      const after = migrateLegacyProjectsUnlocked(before, options);
-      const changed = JSON.stringify(before.roots) !== JSON.stringify(after.roots);
-      return changed ? writeRaw(after, filePath) : before;
-    });
-  }
-  const implicit = realpathIfExists(options.defaultRoot || DEFAULT_APP_DEV_ROOT);
-  const roots = [
-    { path: implicit, registeredAt: null, implicit: true },
-    ...registry.roots
-      .filter((entry) => entry.path !== implicit)
-      .map((entry) => ({ ...entry, implicit: false })),
-  ];
-  return { version: APP_DEV_ROOTS_VERSION, roots };
-}
-
-export function registerAppDevRoot(inputPath, options = {}) {
-  const path = canonicalExistingDirectory(inputPath);
-  const implicit = realpathIfExists(options.defaultRoot || DEFAULT_APP_DEV_ROOT);
-  if (path === implicit) return readAppDevRoots(options);
-  const filePath = rootsFile(options.filePath);
-  withLock(filePath, () => {
-    const registry = readRaw(filePath);
-    if (!registry.roots.some((entry) => entry.path === path)) {
-      registry.roots.push({ path, registeredAt: new Date().toISOString() });
-      writeRaw(registry, filePath);
-    }
-  });
-  return readAppDevRoots({ ...options, migrateLegacy: false });
-}
-
-export function removeAppDevRoot(inputPath, options = {}) {
-  const path = realpathIfExists(resolve(String(inputPath || '')));
-  const implicit = realpathIfExists(options.defaultRoot || DEFAULT_APP_DEV_ROOT);
-  if (path === implicit) {
-    throw usageError(`The default app development root cannot be removed: ${implicit}`);
-  }
-  const filePath = rootsFile(options.filePath);
-  let removed = false;
-  withLock(filePath, () => {
-    const registry = readRaw(filePath);
-    const next = registry.roots.filter((entry) => entry.path !== path);
-    removed = next.length !== registry.roots.length;
-    if (removed) writeRaw({ ...registry, roots: next }, filePath);
-  });
-  return { removed, path, registry: readAppDevRoots({ ...options, migrateLegacy: false }) };
-}
-
-function hasConfig(path) {
-  return CONFIG_FILENAMES.some((name) => existsSync(join(path, name)));
-}
-
-function childAppDirs(parent) {
-  if (!existsSync(parent)) return [];
-  let entries = [];
-  try {
-    entries = readdirSync(parent, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  return entries
-    .filter((entry) => entry.isDirectory())
-    .filter((entry) => !entry.name.startsWith('.') && !entry.name.startsWith('_'))
-    .filter((entry) => entry.name !== 'node_modules')
-    .map((entry) => join(parent, entry.name))
-    .filter(hasConfig);
-}
-
-export function discoverAppProjectsInRoot(inputRoot) {
-  const root = realpathIfExists(resolve(inputRoot));
-  const candidates = [];
-  if (hasConfig(root)) candidates.push(root);
-  candidates.push(...childAppDirs(root));
-  candidates.push(...childAppDirs(join(root, 'apps')));
-  return [...new Set(candidates.map(realpathIfExists))].sort();
-}
-
-export function discoverRegisteredAppProjects(options = {}) {
-  const roots = readAppDevRoots(options).roots;
-  return [...new Set(roots.flatMap((entry) => discoverAppProjectsInRoot(entry.path)))].sort();
-}
-
-export function getAppDevRootsFile(filePath) {
-  return rootsFile(filePath);
-}