@notis_ai/cli 0.2.14 → 0.2.16

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

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,284 @@
+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);
+}