@agimon-ai/doompi-web 0.0.1-alpha.0

package/src/adapters/serverSpawner.ts

@@ -0,0 +1,181 @@
+import { spawn } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { sessionRecordPath } from '../services/registryStore.ts';
+import { type BundledServerLaunch, defaultServerLaunch } from './bundledServer.ts';
+
+/** Names the server in messages; the resolved command is a node path nobody would recognise. */
+const SERVER_LABEL = 'doompi-server';
+const SPAWNED_SEGMENT = 'spawned';
+const SOCKET_FILE = 's.sock';
+const TOKEN_FILE = 'token';
+const LOG_FILE = 'server.log';
+const DIR_NAME_PREFIX_LENGTH = 8;
+const OWNER_ONLY_FILE = 0o600;
+const OWNER_ONLY_DIR = 0o700;
+const TOKEN_BYTES = 32;
+// macOS caps sun_path around 104 bytes; failing here beats a cryptic bind error.
+const MAX_SOCKET_PATH = 103;
+const RECORD_WAIT_MS = 10_000;
+const RECORD_POLL_MS = 100;
+const LOG_TAIL_CHARS = 400;
+
+export type SpawnOutcome =
+  | { ok: true; sessionId: string }
+  | { ok: false; code: 'invalid_request' | 'spawn_failed'; error: string };
+
+export interface SpawnSessionInput {
+  cwd: string;
+  name?: string;
+}
+
+/** Launches doompi-server processes for sessions created from the page. */
+export interface SessionSpawner {
+  spawn(input: SpawnSessionInput): Promise<SpawnOutcome>;
+}
+
+export interface ServerSpawnerOptions {
+  registryDir: string;
+  /** Overridable so tests can stand in a fake server; defaults to the installation's own doompi-server. */
+  command?: string;
+  onNotice?: (message: string) => void;
+}
+
+function logTail(logPath: string): string {
+  try {
+    return fs.readFileSync(logPath, 'utf8').slice(-LOG_TAIL_CHARS).trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Creates sessions the way a terminal would: by starting a doompi-server.
+ *
+ * The spawned server is detached and owns its own lifetime; it registers
+ * itself like any other, which is why success is defined as "its record
+ * appeared", not as anything about the child process. The hub stopping later
+ * does not take created sessions down with it.
+ *
+ * Without an explicit command the server comes from this installation rather
+ * than from PATH, so the cockpit needs no flag to launch the build it belongs
+ * to. The resolution happens per session because it reads the session's own
+ * working directory.
+ */
+export function createServerSpawner(options: ServerSpawnerOptions): SessionSpawner {
+  return {
+    spawn(input) {
+      let stats: fs.Stats;
+      try {
+        stats = fs.statSync(input.cwd);
+      } catch {
+        return Promise.resolve({ ok: false, code: 'invalid_request', error: `No such directory: ${input.cwd}` });
+      }
+      if (!path.isAbsolute(input.cwd) || !stats.isDirectory()) {
+        return Promise.resolve({
+          ok: false,
+          code: 'invalid_request',
+          error: `The working directory must be an absolute path to a directory, received "${input.cwd}".`,
+        });
+      }
+
+      // Resolved before anything is written, so a broken installation fails
+      // without leaving a session directory nobody will ever use.
+      let launch: BundledServerLaunch;
+      try {
+        launch = options.command
+          ? { command: options.command, args: [], environment: process.env }
+          : defaultServerLaunch(input.cwd, process.env);
+      } catch (error) {
+        return Promise.resolve({
+          ok: false,
+          code: 'spawn_failed',
+          error: `Could not locate ${SERVER_LABEL}: ${error instanceof Error ? error.message : String(error)}`,
+        });
+      }
+      const command = options.command ?? SERVER_LABEL;
+
+      const sessionId = crypto.randomUUID();
+      // The directory borrows only a prefix of the id: sun_path is capped
+      // around 104 bytes and every byte of the session dir counts against it.
+      const spawnedRoot = path.join(options.registryDir, SPAWNED_SEGMENT);
+      let dirName = sessionId.slice(0, DIR_NAME_PREFIX_LENGTH);
+      while (fs.existsSync(path.join(spawnedRoot, dirName)) && dirName.length < sessionId.length) {
+        dirName = sessionId.slice(0, dirName.length + DIR_NAME_PREFIX_LENGTH);
+      }
+      const sessionDir = path.join(spawnedRoot, dirName);
+      const socketPath = path.join(sessionDir, SOCKET_FILE);
+      if (socketPath.length > MAX_SOCKET_PATH) {
+        return Promise.resolve({
+          ok: false,
+          code: 'spawn_failed',
+          error: `The socket path would exceed the unix limit (${socketPath.length} > ${MAX_SOCKET_PATH}); use a shorter --registry-dir.`,
+        });
+      }
+      const tokenFile = path.join(sessionDir, TOKEN_FILE);
+      const logPath = path.join(sessionDir, LOG_FILE);
+      fs.mkdirSync(sessionDir, { recursive: true, mode: OWNER_ONLY_DIR });
+      fs.writeFileSync(tokenFile, crypto.randomBytes(TOKEN_BYTES).toString('hex'), { mode: OWNER_ONLY_FILE });
+
+      const log = fs.openSync(logPath, 'a', OWNER_ONLY_FILE);
+      const args = [
+        '--listen',
+        socketPath,
+        '--auth-token-file',
+        tokenFile,
+        '--session-id',
+        sessionId,
+        '--name',
+        input.name ?? 'untitled',
+        '--registry-dir',
+        options.registryDir,
+      ];
+      const child = spawn(launch.command, [...launch.args, ...args], {
+        cwd: input.cwd,
+        detached: true,
+        stdio: ['ignore', log, log],
+        env: launch.environment,
+      });
+      fs.closeSync(log);
+
+      return new Promise((resolve) => {
+        let settled = false;
+        const finish = (outcome: SpawnOutcome): void => {
+          if (settled) return;
+          settled = true;
+          clearInterval(pollTimer);
+          clearTimeout(deadline);
+          if (outcome.ok) options.onNotice?.(`created session ${sessionId} in ${input.cwd}`);
+          resolve(outcome);
+        };
+
+        child.once('error', (error) =>
+          finish({ ok: false, code: 'spawn_failed', error: `Could not start ${command}: ${error.message}` }),
+        );
+        child.once('exit', (code) => {
+          const tail = logTail(logPath);
+          finish({
+            ok: false,
+            code: 'spawn_failed',
+            error: `${command} exited with code ${code ?? 'unknown'} before registering.${tail ? ` Log: ${tail}` : ''}`,
+          });
+        });
+        child.unref();
+
+        const recordFile = sessionRecordPath(options.registryDir, sessionId);
+        const pollTimer = setInterval(() => {
+          if (fs.existsSync(recordFile)) finish({ ok: true, sessionId });
+        }, RECORD_POLL_MS);
+        const deadline = setTimeout(() => {
+          const tail = logTail(logPath);
+          finish({
+            ok: false,
+            code: 'spawn_failed',
+            error: `${command} did not register within ${RECORD_WAIT_MS / 1000}s.${tail ? ` Log: ${tail}` : ''}`,
+          });
+        }, RECORD_WAIT_MS);
+      });
+    },
+  };
+}

package/src/adapters/sessionFiles.ts

@@ -0,0 +1,99 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { rankFileMatches } from '../services/fileMatch.ts';
+
+const execFileAsync = promisify(execFile);
+
+const GIT_TIMEOUT_MS = 2000;
+const GIT_MAX_BUFFER = 8 * 1024 * 1024;
+/** The walk fallback stops collecting past this many entries. */
+const WALK_LIMIT = 4000;
+const WALK_DEPTH = 6;
+const SKIPPED_DIRECTORIES = new Set(['.git', 'node_modules', 'dist', 'coverage', '.next', '.pnpm']);
+
+async function gitFiles(cwd: string): Promise<string[] | undefined> {
+  try {
+    // Tracked plus untracked-but-not-ignored: what a person means by "the files".
+    const { stdout } = await execFileAsync('git', ['ls-files', '-co', '--exclude-standard'], {
+      cwd,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER,
+    });
+    const files = stdout.split('\n').filter((line) => line !== '');
+    return files.length > 0 ? files : undefined;
+  } catch {
+    return undefined; // Not a repository, or git is unavailable; the walk covers it.
+  }
+}
+
+function walkFiles(cwd: string): string[] {
+  const files: string[] = [];
+  const visit = (dir: string, depth: number): void => {
+    if (files.length >= WALK_LIMIT || depth > WALK_DEPTH) return;
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= WALK_LIMIT) return;
+      if (entry.name.startsWith('.') && entry.name !== '.doom') continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!SKIPPED_DIRECTORIES.has(entry.name)) visit(full, depth + 1);
+      } else if (entry.isFile()) {
+        files.push(path.relative(cwd, full));
+      }
+    }
+  };
+  visit(cwd, 0);
+  return files;
+}
+
+/**
+ * Repository-relative files under a session's working directory matching a
+ * query, for the composer's @ completion. Git's index is the source when
+ * available (it already understands ignores); a bounded walk covers plain
+ * directories.
+ */
+export async function listSessionFiles(cwd: string, query: string, limit: number): Promise<string[]> {
+  const files = (await gitFiles(cwd)) ?? walkFiles(cwd);
+  return rankFileMatches(files, query, limit);
+}
+
+export type SessionFileResult =
+  | { status: 'ok'; body: Buffer }
+  | { status: 'not-found' }
+  | { status: 'forbidden' }
+  | { status: 'too-large' };
+
+function isInside(root: string, candidate: string): boolean {
+  return candidate === root || candidate.startsWith(`${root}${path.sep}`);
+}
+
+/**
+ * One file under a session's working directory, for the timeline's mention
+ * previews. Containment is checked on the real path as well as the lexical
+ * one, so a symlink inside the tree cannot hand out something beyond it.
+ */
+export async function readSessionFile(cwd: string, relativePath: string, maxBytes: number): Promise<SessionFileResult> {
+  if (!relativePath || relativePath.includes('\0') || path.isAbsolute(relativePath)) return { status: 'forbidden' };
+  const root = path.resolve(cwd);
+  const candidate = path.resolve(root, relativePath);
+  if (!isInside(root, candidate)) return { status: 'forbidden' };
+  let real: string;
+  let stats: fs.Stats;
+  try {
+    real = await fs.promises.realpath(candidate);
+    stats = await fs.promises.stat(real);
+  } catch {
+    return { status: 'not-found' };
+  }
+  if (!isInside(await fs.promises.realpath(root), real)) return { status: 'forbidden' };
+  if (!stats.isFile()) return { status: 'not-found' };
+  if (stats.size > maxBytes) return { status: 'too-large' };
+  return { status: 'ok', body: await fs.promises.readFile(real) };
+}