@crvouga/dev-fleet 0.0.0-stage → 0.1.0

package/src/platform/ansible.ts

@@ -0,0 +1,62 @@
+import { mkdir, mkdtemp, writeFile, rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
+import macos from '../../ansible/macos/policy.json';
+import type { Runner, CommandOptions, CommandResult } from '../types';
+
+/** Ubuntu provides ansible-core through APT; macOS runs the pinned release through
+ * uv's isolated tool runner so no global Python environment is modified.
+ */
+export function ansibleCommand(
+  path = process.env['PATH'] ?? '',
+  exists: (candidate: string) => boolean = existsSync
+): string[] {
+  const found = path
+    .split(delimiter)
+    .filter(Boolean)
+    .some((directory) => exists(join(directory, 'ansible-playbook')));
+  return found
+    ? ['ansible-playbook']
+    : [
+        'uvx',
+        '--from',
+        `ansible-core==${macos.ansibleCore}`,
+        'ansible-playbook',
+      ];
+}
+
+/** Private fleet state on disk, never /tmp: a worker's /tmp is RAM-backed with a
+ * per-user quota that agent caches can exhaust, and the baseline that bounds it
+ * must still be able to run then.
+ */
+export function variablesDirectory(home = homedir()): string {
+  return join(home, '.local/state/personal/fleet/run');
+}
+
+/** Ansible resolves @file paths before opening them; @/dev/stdin is not portable
+ * across versions when stdin is a pipe. Keep runtime variables in a private,
+ * short-lived directory instead. Never put their values in argv or logs.
+ */
+export async function runAnsible(
+  run: Runner,
+  playbook: string,
+  options: CommandOptions & { input: string },
+  scratch = variablesDirectory()
+): Promise<CommandResult> {
+  if (Buffer.byteLength(options.input) > 256 * 1024)
+    throw new Error('ANSIBLE_VARIABLE_LIMIT');
+  await mkdir(scratch, { recursive: true, mode: 0o700 });
+  const directory = await mkdtemp(join(scratch, 'personal-ansible-'));
+  const path = join(directory, 'variables.json');
+  try {
+    await writeFile(path, options.input, { mode: 0o600, flag: 'wx' });
+    const { input: _input, ...commandOptions } = options;
+    return await run(
+      [...ansibleCommand(), playbook, '--extra-vars', '@' + path],
+      commandOptions
+    );
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}

package/src/platform/darwin.ts

@@ -0,0 +1,203 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import type {
+  NotificationKind,
+  NotifierCapability,
+  NotifierTestResult,
+  Platform,
+  ProcessInfo,
+  ScheduledJob,
+  ScheduledJobStatus,
+} from './types';
+import {
+  installLaunchdJob,
+  launchdJobStatus,
+  removeLaunchdJob,
+} from './launchd';
+import { psProcesses } from './ps';
+
+function appleScriptString(value: string): string {
+  return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\r?\n/g, '\\n')}"`;
+}
+
+export class DarwinPlatform implements Platform {
+  readonly dockerSetupScript = 'bootstrap/docker-desktop.sh';
+  readonly name = 'darwin' as const;
+  readonly label = 'macOS';
+
+  opencodeDir(): string {
+    return join(homedir(), '.config/opencode');
+  }
+
+  cacheDir(): string {
+    return join(homedir(), '.cache');
+  }
+
+  globalBinDir(): string {
+    return join(homedir(), '.local/bin');
+  }
+
+  canBuildSwiftNotifier(): boolean {
+    return (
+      spawnSync('/usr/bin/which', ['swiftc'], { stdio: 'ignore' }).status === 0
+    );
+  }
+
+  shellRcFiles(): readonly string[] {
+    const home = homedir();
+    return [
+      join(home, '.zshrc'),
+      join(home, '.bashrc'),
+      join(home, '.bash_profile'),
+      join(home, '.config/fish/config.fish'),
+    ];
+  }
+
+  notifierCapabilities(): NotifierCapability {
+    return { native: true, sounds: true, clickToFocus: true };
+  }
+
+  async postNotification(input: {
+    title: string;
+    message: string;
+    kind: NotificationKind;
+  }): Promise<NotifierTestResult> {
+    const cli = join(this.opencodeDir(), 'bin/opencode-notifier');
+    try {
+      const { existsSync } = await import('node:fs');
+      if (existsSync(cli)) {
+        const body = JSON.stringify({
+          kind: input.kind,
+          title: input.title,
+          message: input.message,
+          subtitle: 'dev-fleet test',
+          sessionID: 'ses_ws_test',
+          directory: process.cwd(),
+          sessionTitle: 'dev-fleet test',
+          token: '',
+        });
+        const r = spawnSync(cli, ['--post', body], { encoding: 'utf8' });
+        if (r.status === 0) {
+          return { ok: true, detail: 'posted via OpenCodeNotifier daemon' };
+        }
+      }
+    } catch {
+      // Fall through to osascript.
+    }
+    try {
+      const script = `display notification ${appleScriptString(input.message)} with title ${appleScriptString(input.title)}`;
+      execSync(`osascript -e ${JSON.stringify(script)}`, { stdio: 'ignore' });
+      return { ok: true, detail: 'posted via osascript fallback' };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { ok: false, detail: `osascript failed: ${msg}` };
+    }
+  }
+
+  isNotifierDaemonRunning(): boolean {
+    try {
+      const out = execSync('pgrep -fl "OpenCodeNotifier.*daemon"', {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
+      return out.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  restartNotifierDaemon(): void {
+    spawnSync('pkill', ['-f', 'OpenCodeNotifier.*--daemon'], {
+      stdio: 'ignore',
+    });
+  }
+
+  availableSystemSounds(): string[] {
+    const dirs = [
+      '/System/Library/Sounds',
+      '/Library/Sounds',
+      join(homedir(), 'Library/Sounds'),
+    ];
+    const names = new Set<string>();
+    for (const dir of dirs) {
+      let entries: string[] = [];
+      try {
+        entries = readdirSync(dir);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const m = entry.match(/^(.*)\.(aiff?|wav|mp3|m4a|caf)$/i);
+        if (m?.[1]) names.add(m[1]);
+      }
+    }
+    return [...names].sort((a, b) => a.localeCompare(b));
+  }
+
+  async playSystemSound(name: string): Promise<NotifierTestResult> {
+    const trimmed = name.trim();
+    if (trimmed.length === 0) {
+      return { ok: false, detail: 'empty sound name' };
+    }
+    const dirs = [
+      '/System/Library/Sounds',
+      '/Library/Sounds',
+      join(homedir(), 'Library/Sounds'),
+    ];
+    const exts = ['aiff', 'aif', 'wav', 'mp3', 'm4a', 'caf'];
+    for (const dir of dirs) {
+      for (const ext of exts) {
+        const candidate = join(dir, `${trimmed}.${ext}`);
+        if (existsSync(candidate)) {
+          const r = spawnSync('afplay', [candidate], { stdio: 'ignore' });
+          if (r.status === 0) {
+            return { ok: true, detail: `played ${trimmed} via afplay` };
+          }
+          return { ok: false, detail: `afplay failed for ${trimmed}` };
+        }
+      }
+    }
+    return {
+      ok: false,
+      detail: `unknown sound "${trimmed}" (see \`devfleet workstation opencode notifications sounds list\`)`,
+    };
+  }
+
+  listProcesses(): ProcessInfo[] | null {
+    return psProcesses();
+  }
+
+  tailscaleAppBinaries(): readonly string[] {
+    return ['/Applications/Tailscale.app/Contents/MacOS/Tailscale'].filter(
+      (p) => existsSync(p)
+    );
+  }
+
+  vscodeSettingsPath(): string | null {
+    return join(
+      homedir(),
+      'Library/Application Support/Code/User/settings.json'
+    );
+  }
+
+  vscodeCliBinaries(): readonly string[] {
+    return [
+      '/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code',
+    ].filter((p) => existsSync(p));
+  }
+
+  installScheduledJob(job: ScheduledJob): NotifierTestResult {
+    return installLaunchdJob(job);
+  }
+
+  removeScheduledJob(label: string): NotifierTestResult {
+    return removeLaunchdJob(label);
+  }
+
+  scheduledJobStatus(label: string): ScheduledJobStatus {
+    return launchdJobStatus(label);
+  }
+}

package/src/platform/detect.ts

@@ -0,0 +1,11 @@
+import type { PlatformName } from './types';
+
+/** Map `process.platform` onto the dev-fleet platform names. Pure — unit-tested. */
+export function detectPlatformName(
+  platform: NodeJS.Platform = process.platform
+): PlatformName {
+  if (platform === 'darwin') return 'darwin';
+  if (platform === 'linux') return 'linux';
+  if (platform === 'win32') return 'windows';
+  return 'unknown';
+}

package/src/platform/fallback.ts

@@ -0,0 +1,110 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import type {
+  NotificationKind,
+  NotifierCapability,
+  NotifierTestResult,
+  Platform,
+  ProcessInfo,
+  ScheduledJob,
+  ScheduledJobStatus,
+} from './types';
+
+/** Safe default for unrecognized platforms — filesystem converges, notify degrades. */
+export class FallbackPlatform implements Platform {
+  readonly name = 'unknown' as const;
+  readonly label = 'Unknown';
+
+  opencodeDir(): string {
+    return join(homedir(), '.config/opencode');
+  }
+
+  cacheDir(): string {
+    return join(homedir(), '.cache');
+  }
+
+  globalBinDir(): string {
+    return join(homedir(), '.local/bin');
+  }
+
+  canBuildSwiftNotifier(): boolean {
+    return false;
+  }
+
+  shellRcFiles(): readonly string[] {
+    return [join(homedir(), '.profile')];
+  }
+
+  notifierCapabilities(): NotifierCapability {
+    return {
+      native: false,
+      sounds: false,
+      clickToFocus: false,
+      reason: 'unrecognized platform — notifications disabled',
+    };
+  }
+
+  async postNotification(_input: {
+    title: string;
+    message: string;
+    kind: NotificationKind;
+  }): Promise<NotifierTestResult> {
+    return { ok: false, detail: 'notifications unsupported on this platform' };
+  }
+
+  isNotifierDaemonRunning(): boolean {
+    return false;
+  }
+
+  restartNotifierDaemon(): void {
+    // No-op.
+  }
+
+  availableSystemSounds(): string[] {
+    return [];
+  }
+
+  async playSystemSound(name: string): Promise<NotifierTestResult> {
+    void name;
+    return { ok: false, detail: 'sounds unsupported on this platform' };
+  }
+
+  listProcesses(): ProcessInfo[] | null {
+    return null;
+  }
+
+  tailscaleAppBinaries(): readonly string[] {
+    return [];
+  }
+
+  vscodeSettingsPath(): string | null {
+    return null;
+  }
+
+  vscodeCliBinaries(): readonly string[] {
+    return [];
+  }
+
+  installScheduledJob(job: ScheduledJob): NotifierTestResult {
+    return {
+      ok: false,
+      detail: `scheduled jobs are not supported on ${this.label} (${job.label})`,
+    };
+  }
+
+  removeScheduledJob(label: string): NotifierTestResult {
+    return {
+      ok: true,
+      detail: `nothing to remove for ${label} on ${this.label}`,
+    };
+  }
+
+  scheduledJobStatus(label: string): ScheduledJobStatus {
+    return {
+      supported: false,
+      installed: false,
+      detail: `not supported on ${this.label} (${label})`,
+    };
+  }
+}

package/src/platform/index.ts

@@ -0,0 +1,38 @@
+import { DarwinPlatform } from './darwin';
+import { detectPlatformName } from './detect';
+import { FallbackPlatform } from './fallback';
+import { LinuxPlatform } from './linux';
+import { WindowsPlatform } from './windows';
+import type { Platform, PlatformName } from './types';
+
+export type { Platform, PlatformName } from './types';
+export type {
+  NotificationKind,
+  NotifierCapability,
+  NotifierTestResult,
+  GlobalInstallResult,
+} from './types';
+export { detectPlatformName } from './detect';
+
+/** Polymorphic factory — callers never branch on `process.platform` directly. */
+export function getPlatform(name?: PlatformName): Platform {
+  const resolved = name ?? detectPlatformName();
+  switch (resolved) {
+    case 'darwin':
+      return new DarwinPlatform();
+    case 'linux':
+      return new LinuxPlatform();
+    case 'windows':
+      return new WindowsPlatform();
+    case 'unknown':
+      return new FallbackPlatform();
+  }
+}
+
+let cached: Platform | null = null;
+
+/** Memoized current-platform adapter. */
+export function currentPlatform(): Platform {
+  if (cached === null) cached = getPlatform();
+  return cached;
+}

package/src/platform/launchd.ts

@@ -0,0 +1,98 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir, userInfo } from 'node:os';
+import { join } from 'node:path';
+
+import type {
+  NotifierTestResult,
+  ScheduledJob,
+  ScheduledJobStatus,
+} from './types';
+
+function xml(value: string): string {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+export function launchAgentPath(label: string, home = homedir()): string {
+  return join(home, 'Library/LaunchAgents', `${label}.plist`);
+}
+
+/** launchd agent plist for a periodic job. Pure — unit-tested. */
+export function launchdPlist(job: ScheduledJob): string {
+  const args = job.command.map((a) => `    <string>${xml(a)}</string>`);
+  const env = Object.entries(job.env).map(
+    ([k, v]) => `    <key>${xml(k)}</key><string>${xml(v)}</string>`
+  );
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0"><dict>',
+    `  <key>Label</key><string>${xml(job.label)}</string>`,
+    '  <key>ProgramArguments</key><array>',
+    ...args,
+    '  </array>',
+    '  <key>EnvironmentVariables</key><dict>',
+    ...env,
+    '  </dict>',
+    `  <key>StartInterval</key><integer>${job.intervalSeconds}</integer>`,
+    '  <key>RunAtLoad</key><true/>',
+    '  <key>LowPriorityIO</key><true/>',
+    '  <key>Nice</key><integer>10</integer>',
+    `  <key>StandardOutPath</key><string>${xml(join(job.logDir, `${job.label}.out.log`))}</string>`,
+    `  <key>StandardErrorPath</key><string>${xml(join(job.logDir, `${job.label}.err.log`))}</string>`,
+    '</dict></plist>',
+    '',
+  ].join('\n');
+}
+
+function domain(): string {
+  return `gui/${userInfo().uid}`;
+}
+
+export function installLaunchdJob(job: ScheduledJob): NotifierTestResult {
+  const plist = launchAgentPath(job.label);
+  mkdirSync(join(homedir(), 'Library/LaunchAgents'), { recursive: true });
+  mkdirSync(job.logDir, { recursive: true });
+  writeFileSync(plist, launchdPlist(job));
+  spawnSync('launchctl', ['bootout', `${domain()}/${job.label}`], {
+    stdio: 'ignore',
+  });
+  const r = spawnSync('launchctl', ['bootstrap', domain(), plist], {
+    encoding: 'utf8',
+  });
+  return r.status === 0
+    ? { ok: true, detail: `launchd agent ${plist}` }
+    : { ok: false, detail: `launchctl bootstrap failed: ${r.stderr.trim()}` };
+}
+
+export function removeLaunchdJob(label: string): NotifierTestResult {
+  spawnSync('launchctl', ['bootout', `${domain()}/${label}`], {
+    stdio: 'ignore',
+  });
+  rmSync(launchAgentPath(label), { force: true });
+  return { ok: true, detail: `removed launchd agent ${label}` };
+}
+
+export function launchdJobStatus(label: string): ScheduledJobStatus {
+  const r = spawnSync('launchctl', ['print', `${domain()}/${label}`], {
+    encoding: 'utf8',
+  });
+  if (r.status !== 0) {
+    const present = existsSync(launchAgentPath(label));
+    return {
+      supported: true,
+      installed: false,
+      detail: present ? 'plist present but not loaded' : 'not installed',
+    };
+  }
+  const lastExit =
+    /last exit code = (.+)/.exec(r.stdout)?.[1]?.trim() ?? 'unknown';
+  return {
+    supported: true,
+    installed: true,
+    detail: `loaded; last exit code ${lastExit}`,
+  };
+}

package/src/platform/linux.ts

@@ -0,0 +1,139 @@
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import type {
+  NotificationKind,
+  NotifierCapability,
+  NotifierTestResult,
+  Platform,
+  ProcessInfo,
+  ScheduledJob,
+  ScheduledJobStatus,
+} from './types';
+import { existsSync } from 'node:fs';
+import {
+  installSystemdJob,
+  removeSystemdJob,
+  systemdJobStatus,
+} from './systemd-user';
+import { psProcesses } from './ps';
+
+export class LinuxPlatform implements Platform {
+  readonly name = 'linux' as const;
+  readonly label = 'Linux';
+
+  opencodeDir(): string {
+    const base =
+      process.env['XDG_CONFIG_HOME']?.trim() || join(homedir(), '.config');
+    return join(base, 'opencode');
+  }
+
+  cacheDir(): string {
+    const base =
+      process.env['XDG_CACHE_HOME']?.trim() || join(homedir(), '.cache');
+    return base;
+  }
+
+  globalBinDir(): string {
+    return join(homedir(), '.local/bin');
+  }
+
+  canBuildSwiftNotifier(): boolean {
+    return false;
+  }
+
+  shellRcFiles(): readonly string[] {
+    const home = homedir();
+    return [
+      join(home, '.bashrc'),
+      join(home, '.bash_profile'),
+      join(home, '.zshrc'),
+      join(home, '.config/fish/config.fish'),
+    ];
+  }
+
+  notifierCapabilities(): NotifierCapability {
+    return {
+      native: true,
+      sounds: false,
+      clickToFocus: false,
+      reason:
+        'Linux uses notify-send (no sounds, no click-to-focus); the macOS OpenCodeNotifier app is macOS-only.',
+    };
+  }
+
+  async postNotification(input: {
+    title: string;
+    message: string;
+    kind: NotificationKind;
+  }): Promise<NotifierTestResult> {
+    void input.kind;
+    const candidates: ReadonlyArray<{ cmd: string; args: string[] }> = [
+      { cmd: 'notify-send', args: [input.title, input.message] },
+      { cmd: 'zenity', args: ['--notification', `--text=${input.message}`] },
+    ];
+    for (const candidate of candidates) {
+      const r = spawnSync(candidate.cmd, candidate.args, { stdio: 'ignore' });
+      if (r.status === 0) {
+        return { ok: true, detail: `posted via ${candidate.cmd}` };
+      }
+    }
+    return {
+      ok: false,
+      detail: 'no notifier found (install libnotify: notify-send)',
+    };
+  }
+
+  isNotifierDaemonRunning(): boolean {
+    return false;
+  }
+
+  restartNotifierDaemon(): void {
+    // No daemon on Linux — no-op.
+  }
+
+  availableSystemSounds(): string[] {
+    return [];
+  }
+
+  async playSystemSound(name: string): Promise<NotifierTestResult> {
+    void name;
+    return {
+      ok: false,
+      detail: 'sounds unsupported on Linux (notify-send has no sound API)',
+    };
+  }
+
+  listProcesses(): ProcessInfo[] | null {
+    return psProcesses();
+  }
+
+  tailscaleAppBinaries(): readonly string[] {
+    return ['/usr/bin/tailscale', '/usr/sbin/tailscale'].filter((p) =>
+      existsSync(p)
+    );
+  }
+
+  vscodeSettingsPath(): string | null {
+    const base =
+      process.env['XDG_CONFIG_HOME']?.trim() || join(homedir(), '.config');
+    return join(base, 'Code/User/settings.json');
+  }
+
+  vscodeCliBinaries(): readonly string[] {
+    return ['/usr/share/code/bin/code'].filter((p) => existsSync(p));
+  }
+
+  installScheduledJob(job: ScheduledJob): NotifierTestResult {
+    return installSystemdJob(job);
+  }
+
+  removeScheduledJob(label: string): NotifierTestResult {
+    return removeSystemdJob(label);
+  }
+
+  scheduledJobStatus(label: string): ScheduledJobStatus {
+    return systemdJobStatus(label);
+  }
+}