@crvouga/dev-fleet 0.0.0-stage → 0.2.0

package/bootstrap/global-config.ts

@@ -0,0 +1,171 @@
+/** Publish one managed global mise config without clobbering unrelated configuration. */
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const MARKER = '# Managed by dev-fleet bootstrap/setup.ts\n';
+/**
+ * Where agent harnesses create a fresh checkout per task. Every new path would
+ * need its own `mise trust`, and an untrusted mise.toml makes every mise shim
+ * (claude, codex, bun, ...) exit before the agent starts. mise honours this
+ * setting only in the global config, so it is added at publish time and never
+ * written into the repository's mise.toml.
+ */
+export const AGENT_WORKTREE_ROOTS = ['~/.t3/worktrees'];
+const MANAGED = /^# Managed by \S+ \S*setup\.ts\n/;
+export const workspaceRoot = join(import.meta.dirname, '..');
+
+export function globalConfigDir(): string {
+  if (process.env['MISE_GLOBAL_CONFIG_FILE']) {
+    throw new Error(
+      'Unset MISE_GLOBAL_CONFIG_FILE before applying the shared toolchain.'
+    );
+  }
+  return (
+    process.env['MISE_CONFIG_DIR'] ??
+    join(process.env['XDG_CONFIG_HOME'] ?? join(homedir(), '.config'), 'mise')
+  );
+}
+
+export function assertManagedConfig(dir: string): void {
+  const config = join(dir, 'config.toml');
+  const lock = join(dir, 'mise.lock');
+  // Any earlier owner name counts: the marker text identifies the file as
+  // managed, never the repository or path it was published from.
+  const managed =
+    existsSync(config) && MANAGED.test(readFileSync(config, 'utf8'));
+  if ((existsSync(config) && !managed) || (existsSync(lock) && !managed)) {
+    throw new Error(
+      `Existing mise configuration at ${dir}. Back up and move config.toml and mise.lock, then rerun. Nothing was overwritten.`
+    );
+  }
+}
+
+/** What `publishGlobalConfig` writes to config.toml, given what is there. */
+function publishedConfig(root: string, previous: string | undefined): string {
+  return (
+    MARKER +
+    withTrustedPaths(
+      readFileSync(join(root, 'mise.toml'), 'utf8'),
+      trustedPaths(previous)
+    )
+  );
+}
+
+export function publishGlobalConfig(dir: string, root = workspaceRoot): void {
+  assertManagedConfig(dir);
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, 'config.toml');
+  const previous = existsSync(path) ? readFileSync(path, 'utf8') : undefined;
+  const config = publishedConfig(root, previous);
+  if (previous !== config) writeFileSync(path, config);
+  cpSync(join(root, 'mise.lock'), join(dir, 'mise.lock'), {
+    filter: changedFile,
+  });
+  const sidecars = join(root, '.mise/locks');
+  if (existsSync(sidecars))
+    cpSync(sidecars, join(dir, '.mise/locks'), {
+      recursive: true,
+      filter: changedFile,
+    });
+}
+
+/**
+ * How the global mise configuration stands against what this revision
+ * publishes. On a fleet machine it belongs to dev-fleet: a project pins its
+ * tools in its own mise.toml and never publishes a global one.
+ *
+ * - `published`: dev-fleet's marker, this revision's pins and lock
+ * - `missing`: there is no global config.toml
+ * - `replaced`: another owner (or nobody's marker) wrote it
+ * - `changed`: dev-fleet's marker, but not this revision's content
+ */
+export type GlobalConfigStanding =
+  'published' | 'missing' | 'replaced' | 'changed';
+
+export function globalConfigStanding(
+  dir: string,
+  root = workspaceRoot
+): GlobalConfigStanding {
+  const path = join(dir, 'config.toml');
+  if (!existsSync(path)) return 'missing';
+  const current = readFileSync(path, 'utf8');
+  if (!current.startsWith(MARKER)) return 'replaced';
+  const same = (source: string, target: string): boolean =>
+    existsSync(target) && readFileSync(source).equals(readFileSync(target));
+  const sidecars = join(root, '.mise/locks');
+  const locks = existsSync(sidecars)
+    ? (readdirSync(sidecars, { recursive: true }) as string[])
+        .map((name) => join('.mise/locks', name))
+        .filter((name) => statSync(join(root, name)).isFile())
+    : [];
+  // Paths trusted on the machine are kept by every publish, in any order;
+  // the agent worktree roots must be among them.
+  const TRUSTED = /^trusted_config_paths\s*=.*\n/m;
+  const trusted = trustedPaths(current);
+  let listed: unknown;
+  try {
+    listed = (Bun.TOML.parse(current) as { settings?: Record<string, unknown> })
+      .settings?.['trusted_config_paths'];
+  } catch {
+    listed = undefined;
+  }
+  const unchanged =
+    Array.isArray(listed) &&
+    trusted.every((path) => listed.includes(path)) &&
+    current.replace(TRUSTED, '') ===
+      publishedConfig(root, current).replace(TRUSTED, '') &&
+    ['mise.lock', ...locks].every((name) =>
+      same(join(root, name), join(dir, name))
+    );
+  return unchanged ? 'published' : 'changed';
+}
+
+/**
+ * The managed roots plus any entries already in the published config, so a
+ * local `mise settings add trusted_config_paths ...` survives the next publish.
+ */
+export function trustedPaths(previous: string | undefined): string[] {
+  let local: unknown;
+  try {
+    local = previous
+      ? (Bun.TOML.parse(previous) as { settings?: Record<string, unknown> })
+          .settings?.['trusted_config_paths']
+      : undefined;
+  } catch {
+    local = undefined;
+  }
+  const extra = Array.isArray(local)
+    ? local.filter((path): path is string => typeof path === 'string')
+    : [];
+  return [...new Set([...AGENT_WORKTREE_ROOTS, ...extra])];
+}
+
+/** Adds trusted_config_paths to the [settings] table, creating it if absent. */
+export function withTrustedPaths(config: string, paths: string[]): string {
+  const line = `trusted_config_paths = [${paths.map((path) => JSON.stringify(path)).join(', ')}]`;
+  if (/^trusted_config_paths\s*=/m.test(config))
+    throw new Error(
+      'mise.toml sets trusted_config_paths; mise ignores it outside the global config. Add roots to AGENT_WORKTREE_ROOTS instead.'
+    );
+  const header = /^\[settings\][^\S\n]*\n/m;
+  return header.test(config)
+    ? config.replace(header, (match) => `${match}${line}\n`)
+    : `${config.replace(/\n*$/, '\n')}\n[settings]\n${line}\n`;
+}
+
+function changedFile(source: string, destination: string): boolean {
+  return (
+    statSync(source).isDirectory() ||
+    !existsSync(destination) ||
+    !readFileSync(source).equals(readFileSync(destination))
+  );
+}

package/bootstrap/install-launcher.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+# Links ~/.local/bin/devfleet to this checkout (or the one given). Idempotent.
+set -eu
+root=${1:-$(cd "$(dirname "$0")/.." && pwd)}
+[ -x "$root/bootstrap/devfleet" ] || exit 1
+# Only ever a checkout: an installed package sits wherever a package manager
+# put it and may be gone tomorrow.
+[ -e "$root/.git" ] || { echo 'The devfleet launcher links to a checkout of dev-fleet; fleet-sync installs it.' >&2; exit 1; }
+mkdir -p "$HOME/.local/bin"
+ln -sfn "$root/bootstrap/devfleet" "$HOME/.local/bin/devfleet"

package/bootstrap/native-aws.ts

@@ -0,0 +1,86 @@
+/** AWS v2's official Windows MSI; aqua only packages AWS for Unix. */
+import { createHash } from 'node:crypto';
+import { appendFileSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { workspaceRoot } from './global-config';
+
+type AwsConfig = {
+  tools: { aws: { version: string } };
+  vars: { aws_windows_msi_sha256: string };
+};
+export function awsWindowsArtifact(config: AwsConfig): {
+  url: string;
+  sha256: string;
+  version: string;
+} {
+  const version = config.tools.aws.version;
+  const sha256 = config.vars.aws_windows_msi_sha256;
+  if (!/^2\.\d+\.\d+$/.test(version) || !/^[a-f0-9]{64}$/.test(sha256))
+    throw new Error('Invalid pinned AWS Windows artifact.');
+  return {
+    version,
+    url: `https://awscli.amazonaws.com/AWSCLIV2-${version}.msi`,
+    sha256,
+  };
+}
+
+export async function installNativeAws(): Promise<void> {
+  if (process.platform !== 'win32') return;
+  const config = Bun.TOML.parse(
+    readFileSync(join(workspaceRoot, 'mise.toml'), 'utf8')
+  ) as AwsConfig;
+  const artifact = awsWindowsArtifact(config);
+  const bin = join(
+    process.env['ProgramFiles'] ?? 'C:\\Program Files',
+    'Amazon',
+    'AWSCLIV2'
+  );
+  const executable = join(bin, 'aws.exe');
+  const probe = () =>
+    spawnSync(executable, ['--version'], { encoding: 'utf8', timeout: 30_000 });
+  if (!probe().stdout?.includes(`aws-cli/${artifact.version} `)) {
+    const directory = mkdtempSync(join(tmpdir(), 'workspace-aws-'));
+    try {
+      const response = await fetch(artifact.url);
+      if (!response.ok)
+        throw new Error(`AWS MSI download failed (${response.status}).`);
+      const bytes = Buffer.from(await response.arrayBuffer());
+      if (createHash('sha256').update(bytes).digest('hex') !== artifact.sha256)
+        throw new Error('AWS MSI checksum mismatch.');
+      const msi = join(directory, 'aws.msi');
+      await Bun.write(msi, bytes);
+      const script = String.raw`$arguments = @('/i', ('"' + $env:WORKSPACE_AWS_MSI + '"'), '/qn', '/norestart'); $options = @{FilePath='msiexec.exe'; ArgumentList=$arguments; Wait=$true; PassThru=$true}; if ($env:WORKSPACE_AWS_ELEVATE -eq '1') { $options.Verb = 'RunAs' }; $p = Start-Process @options; exit $p.ExitCode`;
+      const result = spawnSync(
+        'powershell.exe',
+        ['-NoProfile', '-Command', script],
+        {
+          stdio: 'inherit',
+          env: {
+            ...process.env,
+            WORKSPACE_AWS_MSI: msi,
+            WORKSPACE_AWS_ELEVATE:
+              process.argv.includes('--non-interactive') || process.env['CI']
+                ? '0'
+                : '1',
+          },
+        }
+      );
+      if (result.status !== 0 && result.status !== 3010)
+        throw new Error(
+          `AWS MSI installation failed (exit ${result.status}, signal ${result.signal}, error ${result.error?.message ?? 'none'}); check for a conflicting installed version or run the reviewed bootstrap as Administrator.`
+        );
+    } finally {
+      rmSync(directory, { recursive: true, force: true });
+    }
+  }
+  if (!probe().stdout?.includes(`aws-cli/${artifact.version} `))
+    throw new Error(
+      `Expected AWS CLI ${artifact.version}; resolve the existing installation before retrying.`
+    );
+  process.env['PATH'] = `${bin};${process.env['PATH'] ?? ''}`;
+  // Persist across subsequent hosted-runner steps; normal users reopen the shell.
+  if (process.env['GITHUB_PATH'])
+    appendFileSync(process.env['GITHUB_PATH'], `${bin}\n`);
+}

package/bootstrap/native-t3.ts

@@ -0,0 +1,154 @@
+/** Pinned Ubuntu T3 distribution. Shared tool installation owns artifacts;
+ * Workstation owns services. Never touches ~/.t3 or replaces an existing launcher.
+ */
+import { createHash } from 'node:crypto';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { workspaceRoot } from './global-config';
+interface Configuration {
+  vars: {
+    t3_version: string;
+    t3_linux_x64_sha256: string;
+    t3_linux_arm64_sha256: string;
+    t3_desktop_amd64_sha256: string;
+    t3_desktop_arm64_sha256: string;
+  };
+}
+/** Pinned desktop .deb for Ubuntu workers. The GUI app is the worker's only T3
+ * process and embeds the server; the CLI tarball stays for policy commands. */
+export function desktopT3Artifact(config: Configuration, architecture: string) {
+  const deb = { x64: 'amd64', arm64: 'arm64' }[architecture];
+  if (!deb) throw new Error('Unsupported T3 architecture.');
+  const version = config.vars.t3_version;
+  const sha256 =
+    deb === 'amd64'
+      ? config.vars.t3_desktop_amd64_sha256
+      : config.vars.t3_desktop_arm64_sha256;
+  if (
+    !/^\d+\.\d+\.\d+(?:-nightly\.\d{8}\.\d+)?$/.test(version) ||
+    !/^[a-f0-9]{64}$/.test(sha256)
+  )
+    throw new Error('Invalid T3 desktop pin.');
+  const name = `T3-Code-${version}-${deb}.deb`;
+  return {
+    version,
+    sha256,
+    name,
+    url: `https://github.com/pingdotgg/t3code/releases/download/v${version}/${name}`,
+  };
+}
+export function managedT3Desktop() {
+  const config = Bun.TOML.parse(
+    readFileSync(join(workspaceRoot, 'mise.toml'), 'utf8')
+  ) as Configuration;
+  return desktopT3Artifact(config, process.arch);
+}
+export function nativeT3Artifact(config: Configuration, architecture: string) {
+  if (!['x64', 'arm64'].includes(architecture))
+    throw new Error('Unsupported T3 architecture.');
+  const version = config.vars.t3_version;
+  const sha256 =
+    architecture === 'x64'
+      ? config.vars.t3_linux_x64_sha256
+      : config.vars.t3_linux_arm64_sha256;
+  if (
+    !/^\d+\.\d+\.\d+(?:-nightly\.\d{8}\.\d+)?$/.test(version) ||
+    !/^[a-f0-9]{64}$/.test(sha256)
+  )
+    throw new Error('Invalid T3 pin.');
+  const name = `t3-${version}-linux-${architecture}`;
+  return {
+    version,
+    sha256,
+    name,
+    url: `https://github.com/pingdotgg/t3code/releases/download/v${version}/${name}.tar.gz`,
+  };
+}
+export function managedT3(): { path: string; version: string } {
+  const config = Bun.TOML.parse(
+    readFileSync(join(workspaceRoot, 'mise.toml'), 'utf8')
+  ) as Configuration;
+  const artifact = nativeT3Artifact(config, process.arch);
+  return {
+    path: join(homedir(), '.local/share/personal/tools', artifact.name, 't3'),
+    version: artifact.version,
+  };
+}
+export async function installNativeT3(): Promise<void> {
+  if (process.platform !== 'linux') return;
+  const config = Bun.TOML.parse(
+    readFileSync(join(workspaceRoot, 'mise.toml'), 'utf8')
+  ) as Configuration;
+  const artifact = nativeT3Artifact(config, process.arch);
+  const root = join(homedir(), '.local/share/personal/tools');
+  const archive = join(root, `${artifact.name}.tar.gz`);
+  mkdirSync(root, { recursive: true, mode: 0o700 });
+  if (!existsSync(archive)) {
+    const response = await fetch(artifact.url, {
+      signal: AbortSignal.timeout(120_000),
+    });
+    if (!response.ok) throw new Error('Pinned T3 artifact unavailable.');
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (createHash('sha256').update(bytes).digest('hex') !== artifact.sha256)
+      throw new Error('T3 artifact checksum mismatch.');
+    writeFileSync(`${archive}.partial`, bytes, { mode: 0o600 });
+    renameSync(`${archive}.partial`, archive);
+  }
+  if (
+    createHash('sha256').update(readFileSync(archive)).digest('hex') !==
+    artifact.sha256
+  )
+    throw new Error(
+      'T3 cached artifact drift; preserve running service and review maintenance recovery.'
+    );
+  const directory = join(root, artifact.name);
+  if (!existsSync(directory)) {
+    const staging = join(root, `${artifact.name}.staging`);
+    mkdirSync(staging, { recursive: true, mode: 0o700 });
+    try {
+      if (
+        spawnSync(
+          'tar',
+          ['--same-permissions', '-xzf', archive, '-C', staging],
+          { timeout: 120_000 }
+        ).status !== 0
+      )
+        throw new Error('T3 extraction failed.');
+      verifyArchive(archive, staging);
+      renameSync(join(staging, artifact.name), directory);
+    } finally {
+      rmSync(staging, { recursive: true, force: true });
+    }
+  } else verifyArchive(archive, root);
+  const version = spawnSync(join(directory, 't3'), ['--version'], {
+    encoding: 'utf8',
+    timeout: 30_000,
+  });
+  if (
+    version.status !== 0 ||
+    version.stdout.trim() !== `t3 v${artifact.version}`
+  )
+    throw new Error('Pinned T3 executable verification failed.');
+}
+
+function verifyArchive(archive: string, root: string): void {
+  if (
+    spawnSync(
+      'python3',
+      [join(workspaceRoot, 'bootstrap/verify-t3-archive.py'), archive, root],
+      { timeout: 120_000 }
+    ).status !== 0
+  )
+    throw new Error(
+      'Managed T3 files differ from the pinned artifact; maintenance is required.'
+    );
+}