@webstir-io/webstir 0.1.1 → 0.1.3

package/src/workspace-lock.ts

@@ -0,0 +1,207 @@
+import path from 'node:path';
+import { lstat, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+
+export interface WorkspaceWatchLockHandle {
+  readonly path: string;
+  release(): Promise<void>;
+}
+
+interface WorkspaceWatchLockOwner {
+  readonly kind: 'watch';
+  readonly pid: number;
+  readonly workspaceRoot: string;
+  readonly createdAt: string;
+}
+
+interface WorkspaceWatchLockState {
+  readonly exists: boolean;
+  readonly active: boolean;
+  readonly lockPath: string;
+  readonly owner?: WorkspaceWatchLockOwner;
+}
+
+const WEBSTIR_DIR = '.webstir';
+const WATCH_LOCK_DIR = 'watch.lock';
+const OWNER_FILE = 'owner.json';
+const UNKNOWN_OWNER_GRACE_MS = 30_000;
+
+export class WorkspaceWatchLockConflictError extends Error {
+  public constructor(
+    workspaceRoot: string,
+    command: 'build' | 'publish' | 'watch',
+    owner?: WorkspaceWatchLockOwner,
+  ) {
+    const ownerDetails = owner ? ` (pid ${owner.pid})` : '';
+    const action = command === 'watch' ? 'start webstir watch' : `run webstir ${command}`;
+    super(
+      `Cannot ${action} because webstir watch is active for this workspace${ownerDetails}. Stop the watch process before running another build pipeline against ${workspaceRoot}.`,
+    );
+    this.name = 'WorkspaceWatchLockConflictError';
+  }
+}
+
+export async function acquireWorkspaceWatchLock(
+  workspaceRoot: string,
+): Promise<WorkspaceWatchLockHandle> {
+  const resolvedRoot = path.resolve(workspaceRoot);
+  const lockPath = getWorkspaceWatchLockPath(resolvedRoot);
+  await mkdir(path.dirname(lockPath), { recursive: true });
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      await mkdir(lockPath);
+      try {
+        await writeOwner(lockPath, resolvedRoot);
+      } catch (error) {
+        await removeLockDirectory(lockPath);
+        throw error;
+      }
+      return createLockHandle(lockPath);
+    } catch (error) {
+      if (!isErrno(error, 'EEXIST')) {
+        throw error;
+      }
+
+      const state = await readWorkspaceWatchLockState(resolvedRoot);
+      if (state.active) {
+        throw new WorkspaceWatchLockConflictError(resolvedRoot, 'watch', state.owner);
+      }
+
+      await removeLockDirectory(state.lockPath);
+    }
+  }
+
+  const state = await readWorkspaceWatchLockState(resolvedRoot);
+  throw new WorkspaceWatchLockConflictError(resolvedRoot, 'watch', state.owner);
+}
+
+export async function assertNoActiveWorkspaceWatch(
+  workspaceRoot: string,
+  command: 'build' | 'publish',
+): Promise<void> {
+  const resolvedRoot = path.resolve(workspaceRoot);
+  const state = await readWorkspaceWatchLockState(resolvedRoot);
+  if (!state.exists) {
+    return;
+  }
+
+  if (state.active) {
+    throw new WorkspaceWatchLockConflictError(resolvedRoot, command, state.owner);
+  }
+
+  await removeLockDirectory(state.lockPath);
+}
+
+function getWorkspaceWatchLockPath(workspaceRoot: string): string {
+  return path.join(workspaceRoot, WEBSTIR_DIR, WATCH_LOCK_DIR);
+}
+
+function createLockHandle(lockPath: string): WorkspaceWatchLockHandle {
+  let released = false;
+
+  return {
+    path: lockPath,
+    async release() {
+      if (released) {
+        return;
+      }
+
+      released = true;
+      const owner = await readOwner(lockPath);
+      if (owner?.pid !== process.pid) {
+        return;
+      }
+
+      await removeLockDirectory(lockPath);
+    },
+  };
+}
+
+async function readWorkspaceWatchLockState(
+  workspaceRoot: string,
+): Promise<WorkspaceWatchLockState> {
+  const lockPath = getWorkspaceWatchLockPath(workspaceRoot);
+  let modifiedAtMs = 0;
+
+  try {
+    const stats = await lstat(lockPath);
+    modifiedAtMs = stats.mtimeMs;
+  } catch (error) {
+    if (isErrno(error, 'ENOENT')) {
+      return { exists: false, active: false, lockPath };
+    }
+
+    throw error;
+  }
+
+  const owner = await readOwner(lockPath);
+  if (!owner) {
+    return {
+      exists: true,
+      active: Date.now() - modifiedAtMs < UNKNOWN_OWNER_GRACE_MS,
+      lockPath,
+    };
+  }
+
+  return {
+    exists: true,
+    active: isProcessActive(owner.pid),
+    lockPath,
+    owner,
+  };
+}
+
+async function writeOwner(lockPath: string, workspaceRoot: string): Promise<void> {
+  const owner: WorkspaceWatchLockOwner = {
+    kind: 'watch',
+    pid: process.pid,
+    workspaceRoot,
+    createdAt: new Date().toISOString(),
+  };
+  await writeFile(path.join(lockPath, OWNER_FILE), `${JSON.stringify(owner, null, 2)}\n`, 'utf8');
+}
+
+async function readOwner(lockPath: string): Promise<WorkspaceWatchLockOwner | undefined> {
+  try {
+    const raw = await readFile(path.join(lockPath, OWNER_FILE), 'utf8');
+    const parsed = JSON.parse(raw) as Partial<WorkspaceWatchLockOwner>;
+    if (
+      parsed.kind !== 'watch' ||
+      typeof parsed.pid !== 'number' ||
+      typeof parsed.workspaceRoot !== 'string' ||
+      typeof parsed.createdAt !== 'string'
+    ) {
+      return undefined;
+    }
+
+    return {
+      kind: 'watch',
+      pid: parsed.pid,
+      workspaceRoot: parsed.workspaceRoot,
+      createdAt: parsed.createdAt,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function isProcessActive(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !isErrno(error, 'ESRCH');
+  }
+}
+
+async function removeLockDirectory(lockPath: string): Promise<void> {
+  await rm(lockPath, { recursive: true, force: true });
+}
+
+function isErrno(error: unknown, code: string): boolean {
+  return Boolean(error && typeof error === 'object' && 'code' in error && error.code === code);
+}

package/src/workspace-watcher.ts

@@ -30,10 +30,7 @@ export class WorkspaceWatcher {
 
   public constructor(options: WorkspaceWatcherOptions) {
     this.workspaceRoot = path.resolve(options.workspaceRoot);
-    this.treeRoots = [
-      path.join(this.workspaceRoot, 'src'),
-      path.join(this.workspaceRoot, 'types'),
-    ];
+    this.treeRoots = [path.join(this.workspaceRoot, 'src'), path.join(this.workspaceRoot, 'types')];
     this.onEvent = options.onEvent;
     this.debounceMs = options.debounceMs ?? 75;
   }
@@ -112,7 +109,11 @@ export class WorkspaceWatcher {
     }
 
     for (const watchedDirectory of Array.from(this.treeWatchers.keys())) {
-      if (watchedDirectory !== root && watchedDirectory.startsWith(`${root}${path.sep}`) && !current.has(watchedDirectory)) {
+      if (
+        watchedDirectory !== root &&
+        watchedDirectory.startsWith(`${root}${path.sep}`) &&
+        !current.has(watchedDirectory)
+      ) {
         this.treeWatchers.get(watchedDirectory)?.close();
         this.treeWatchers.delete(watchedDirectory);
       }
@@ -234,7 +235,10 @@ async function collectDirectories(root: string): Promise<readonly string[]> {
   const stack = [path.resolve(root)];
 
   while (stack.length > 0) {
-    const current = stack.pop()!;
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
     directories.push(current);
 
     const entries = await readdir(current, { withFileTypes: true });

package/src/workspace.ts

@@ -25,7 +25,7 @@ export function parseWorkspaceMode(value: unknown): WorkspaceMode {
   }
 
   throw new Error(
-    `Unsupported webstir.mode "${value}". Expected one of: ${SUPPORTED_WORKSPACE_MODES.join(', ')}.`
+    `Unsupported webstir.mode "${value}". Expected one of: ${SUPPORTED_WORKSPACE_MODES.join(', ')}.`,
   );
 }
 
@@ -44,7 +44,9 @@ export async function readWorkspaceDescriptor(workspacePath: string): Promise<Wo
   try {
     packageJson = JSON.parse(rawPackageJson) as WorkspacePackageJson;
   } catch (error) {
-    throw new Error(`Workspace package.json at ${packageJsonPath} is not valid JSON.`, { cause: error });
+    throw new Error(`Workspace package.json at ${packageJsonPath} is not valid JSON.`, {
+      cause: error,
+    });
   }
 
   return {

package/src/watch-daemon-client.ts

@@ -1,171 +0,0 @@
-import path from 'node:path';
-import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
-import { createInterface, type Interface as ReadLineInterface } from 'node:readline';
-import { fileURLToPath } from 'node:url';
-
-import { createWorkspaceRuntimeEnv, resolveRuntimeCommand } from './runtime.ts';
-import { parseStructuredDiagnosticLine, type StructuredDiagnosticPayload } from './watch-events.ts';
-import { ensureLocalPackageArtifacts } from './providers.ts';
-
-type WatchDaemonCommand =
-  | { readonly type: 'start' }
-  | { readonly type: 'change'; readonly path: string }
-  | { readonly type: 'reload' }
-  | { readonly type: 'shutdown' };
-
-export interface FrontendWatchDaemonClientOptions {
-  readonly workspaceRoot: string;
-  readonly verbose?: boolean;
-  readonly hmrVerbose?: boolean;
-  readonly env?: Record<string, string | undefined>;
-  readonly onLine?: (line: string) => void;
-  readonly onErrorLine?: (line: string) => void;
-  readonly onDiagnostic?: (payload: StructuredDiagnosticPayload) => void;
-}
-
-export class FrontendWatchDaemonClient {
-  private readonly workspaceRoot: string;
-  private readonly verbose: boolean;
-  private readonly hmrVerbose: boolean;
-  private readonly env?: Record<string, string | undefined>;
-  private readonly onLine?: (line: string) => void;
-  private readonly onErrorLine?: (line: string) => void;
-  private readonly onDiagnostic?: (payload: StructuredDiagnosticPayload) => void;
-  private child?: ChildProcessWithoutNullStreams;
-  private stdoutReader?: ReadLineInterface;
-  private stderrReader?: ReadLineInterface;
-  private exitPromise?: Promise<number | null>;
-  private isStopping = false;
-
-  public constructor(options: FrontendWatchDaemonClientOptions) {
-    this.workspaceRoot = path.resolve(options.workspaceRoot);
-    this.verbose = options.verbose ?? false;
-    this.hmrVerbose = options.hmrVerbose ?? false;
-    this.env = options.env;
-    this.onLine = options.onLine;
-    this.onErrorLine = options.onErrorLine;
-    this.onDiagnostic = options.onDiagnostic;
-  }
-
-  public async start(): Promise<void> {
-    if (this.child) {
-      return;
-    }
-
-    await ensureLocalPackageArtifacts();
-    const frontendCliPath = fileURLToPath(import.meta.resolve('@webstir-io/webstir-frontend/cli'));
-    const args = [
-      frontendCliPath,
-      'watch-daemon',
-      '--workspace',
-      this.workspaceRoot,
-      '--no-auto-start',
-    ];
-
-    if (this.verbose) {
-      args.push('--verbose');
-    }
-
-    if (this.hmrVerbose) {
-      args.push('--hmr-verbose');
-    }
-
-    const child = spawn(resolveRuntimeCommand(), args, {
-      cwd: this.workspaceRoot,
-      env: createWorkspaceRuntimeEnv(this.workspaceRoot, 'build', this.env),
-      stdio: 'pipe',
-    });
-
-    this.child = child;
-    this.exitPromise = new Promise<number | null>((resolve, reject) => {
-      child.once('error', reject);
-      child.once('close', (code) => resolve(code));
-    });
-
-    this.stdoutReader = createInterface({ input: child.stdout, crlfDelay: Infinity });
-    this.stdoutReader.on('line', (line) => {
-      const diagnostic = parseStructuredDiagnosticLine(line);
-      if (diagnostic) {
-        this.onDiagnostic?.(diagnostic);
-        return;
-      }
-
-      this.onLine?.(line);
-    });
-
-    this.stderrReader = createInterface({ input: child.stderr, crlfDelay: Infinity });
-    this.stderrReader.on('line', (line) => {
-      this.onErrorLine?.(line);
-    });
-  }
-
-  public async sendStart(): Promise<void> {
-    await this.send({ type: 'start' });
-  }
-
-  public async sendChange(filePath: string): Promise<void> {
-    await this.send({ type: 'change', path: filePath });
-  }
-
-  public async sendReload(): Promise<void> {
-    await this.send({ type: 'reload' });
-  }
-
-  public async stop(): Promise<number | null> {
-    if (!this.child || !this.exitPromise) {
-      return 0;
-    }
-
-    if (!this.isStopping) {
-      this.isStopping = true;
-      try {
-        await this.send({ type: 'shutdown' });
-      } catch {
-        // Fall through to best-effort teardown.
-      }
-
-      this.child.stdin.end();
-    }
-
-    const code = await this.exitPromise;
-    this.cleanup();
-    return code;
-  }
-
-  public async waitForExit(): Promise<number | null> {
-    if (!this.exitPromise) {
-      throw new Error('Frontend watch daemon has not started.');
-    }
-
-    const code = await this.exitPromise;
-    this.cleanup();
-    return code;
-  }
-
-  private async send(command: WatchDaemonCommand): Promise<void> {
-    if (!this.child || !this.child.stdin.writable) {
-      throw new Error('Frontend watch daemon is not running.');
-    }
-
-    await new Promise<void>((resolve, reject) => {
-      this.child!.stdin.write(`${JSON.stringify(command)}\n`, (error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-
-        resolve();
-      });
-    });
-  }
-
-  private cleanup(): void {
-    this.stdoutReader?.close();
-    this.stderrReader?.close();
-    this.stdoutReader = undefined;
-    this.stderrReader = undefined;
-    this.child = undefined;
-    this.exitPromise = undefined;
-    this.isStopping = false;
-  }
-}