subconscious-cli 6.0.0 → 6.1.0

package/bin/windows/agents.js

@@ -1,83 +1,187 @@
-import path from 'node:path';
 import os from 'node:os';
+import path from 'node:path';
 import readline from 'node:readline';
-import { windowsEnv, windowsBinDirs, windowsPath, resolveWindowsExecutable, readWindowsVersion, runWindows } from './process.js';
-import { windowsInstallSpec, installWindowsAgent } from './install.js';
-import { windowsSetup } from './setup.js';
-import { windowsLaunch, executeWindowsLaunch } from './launch.js';
+import { agentBinary, agentInstallDirs } from '../agent-data.js';
+import { separatorIndex } from '../headless-args.js';
 import { parseOptions } from './common.js';
+import { installWindowsAgent, windowsInstallSpec } from './install.js';
+import { executeWindowsLaunch, windowsLaunch } from './launch.js';
+import {
+  readWindowsVersion,
+  resolveWindowsExecutable,
+  runWindows,
+  windowsBinDirs,
+  windowsEnv,
+  windowsPath,
+} from './process.js';
+import { windowsSetup } from './setup.js';
 
-const askInstall = name => new Promise(resolve => {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  rl.question(`  ${name} isn't installed. Install it now? [Y/n] `, answer => { rl.close(); resolve(['', 'y', 'yes'].includes(answer.trim().toLowerCase())); });
-});
+const askInstall = (name) =>
+  new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(
+      `  ${name} isn't installed. Install it now? [Y/n] `,
+      (answer) => {
+        rl.close();
+        resolve(['', 'y', 'yes'].includes(answer.trim().toLowerCase()));
+      },
+    );
+  });
 
 export async function runWindowsAgent(agent, argv, dependencies) {
-  const { profile, parseAgentAction, extractModel, requireApiKey, resolvedModelsForLaunch, selectLaunchModel, runbookEnv } = dependencies;
+  const {
+    profile,
+    parseAgentAction,
+    extractModel,
+    requireApiKey,
+    resolvedModelsForLaunch,
+    selectLaunchModel,
+    runbookEnv,
+  } = dependencies;
   const parsed = parseAgentAction(agent, argv);
-  let args = parsed.action !== 'launch' && parsed.action === argv[0] ? argv.slice(1) : argv;
+  let args =
+    !['launch', 'headless'].includes(parsed.action) && parsed.action === argv[0]
+      ? argv.slice(1)
+      : argv;
   const environment = windowsEnv(profile?.values, process.env);
-  const preferredDirs = agent.runbook?.installDir
-    ? [path.resolve(environment[agent.runbook.installDirEnv] || path.join(os.homedir(), agent.runbook.installDir))] : [];
-  environment.PATH = windowsPath([...preferredDirs, ...(environment.PATH || '').split(';'), ...windowsBinDirs(environment)]);
+  const preferredDirs = agentInstallDirs(agent, environment, os.homedir());
+  const bin = agentBinary(agent);
+  environment.PATH = windowsPath([
+    ...preferredDirs,
+    ...(environment.PATH || '').split(';'),
+    ...windowsBinDirs(environment),
+  ]);
   if (agent.id === 'subconscious-code' && parsed.action === 'install') {
     if (args.length) throw new Error('Usage: subc marathon install');
     return finish(await installWindowsAgent(agent.id, environment));
   }
   if (['status', 'uninstall'].includes(parsed.action)) {
-    return finish(await windowsSetup(agent.id, parsed.action, args, environment));
+    return finish(
+      await windowsSetup(agent.id, parsed.action, args, environment),
+    );
   }
 
   // Honor -- after which all arguments belong to the underlying agent.
-  const boundary = args.indexOf('--');
+  const boundary = separatorIndex(args);
   const tail = boundary < 0 ? [] : args.slice(boundary);
-  const extracted = extractModel(boundary < 0 ? args : args.slice(0, boundary), profile);
+  const extracted = extractModel(
+    boundary < 0 ? args : args.slice(0, boundary),
+    profile,
+  );
   args = [...extracted.rest, ...tail];
   let explicit = {};
   if (parsed.action === 'install' || agent.id === 'claude-code') {
-    const handled = parseOptions(boundary < 0 ? args : args.slice(0, args.indexOf('--')), { '--api-key': 1, '--gateway-url': 1 });
+    const handled = parseOptions(
+      boundary < 0 ? args : args.slice(0, boundary),
+      { '--api-key': 1, '--gateway-url': 1 },
+    );
     explicit = handled.options;
   }
-  const key = explicit['--api-key'] || await requireApiKey(profile, agent);
+  const key = explicit['--api-key'] || (await requireApiKey(profile, agent));
   if (!key) return finish(1);
-  const catalogProfile = explicit['--gateway-url'] ? { ...profile, values: { ...profile?.values, GATEWAY_URL: explicit['--gateway-url'] } } : profile;
-  const catalog = await resolvedModelsForLaunch(catalogProfile, key, extracted.model);
-  const model = selectLaunchModel(extracted.model, extracted.modelSource, catalog);
-  if (extracted.model && model !== extracted.model) console.error(`Configured model ${extracted.model} is not in the live catalog; using ${model}.`);
+  const catalogProfile = explicit['--gateway-url']
+    ? {
+        ...profile,
+        values: { ...profile?.values, GATEWAY_URL: explicit['--gateway-url'] },
+      }
+    : profile;
+  const catalog = await resolvedModelsForLaunch(
+    catalogProfile,
+    key,
+    extracted.model,
+  );
+  const model = selectLaunchModel(
+    extracted.model,
+    extracted.modelSource,
+    catalog,
+  );
+  if (extracted.model && model !== extracted.model)
+    console.error(
+      `Configured model ${extracted.model} is not in the live catalog; using ${model}.`,
+    );
+  const headless = dependencies.headless ?? parsed.action === 'headless';
   let executable;
-  if (parsed.action === 'launch') {
-    executable = resolveWindowsExecutable(agent.bin, { env: environment, preferredDirs });
+  if (parsed.action === 'launch' || headless) {
+    executable = resolveWindowsExecutable(bin, {
+      env: environment,
+      preferredDirs,
+    });
     if (!executable) {
       const installer = windowsInstallSpec(agent.id, environment);
-      if (!installer || !process.stdin.isTTY || !process.stdout.isTTY || !await askInstall(agent.name)) {
-        console.error(`${agent.name} isn't installed. ${installer ? `Install it with: ${installer.display}` : 'Install it separately, then rerun subc.'}`);
+      if (
+        !installer ||
+        headless ||
+        !process.stdin.isTTY ||
+        !process.stdout.isTTY ||
+        !(await askInstall(agent.name))
+      ) {
+        console.error(
+          `${agent.name} isn't installed. ${installer ? `Install it with: ${installer.display}` : 'Install it separately, then rerun subc.'}`,
+        );
         return finish(127);
       }
       const installed = await installWindowsAgent(agent.id, environment);
       if (installed) return finish(installed);
-      executable = resolveWindowsExecutable(agent.bin, { env: environment, preferredDirs });
+      executable = resolveWindowsExecutable(bin, {
+        env: environment,
+        preferredDirs,
+      });
       if (!executable) {
-        console.error(`Installed ${agent.name}, but ${agent.bin} was not found. Add its installation directory to PATH or restart your terminal.`);
+        console.error(
+          `Installed ${agent.name}, but ${bin} was not found. Add its installation directory to PATH or restart your terminal.`,
+        );
         return finish(127);
       }
     }
     if (agent.id === 'claude-code') {
-      const version = dependencies.parseClaudeVersion(readWindowsVersion(executable, environment));
-      if (dependencies.claudeVersionNeedsUpgrade(version)) console.error(`Minimum supported Claude Code version is ${dependencies.minimumClaudeVersion}; installed version is ${version}. Please upgrade Claude Code.`);
+      const version = dependencies.parseClaudeVersion(
+        readWindowsVersion(executable, environment),
+      );
+      if (dependencies.claudeVersionNeedsUpgrade(version))
+        console.error(
+          `Minimum supported Claude Code version is ${dependencies.minimumClaudeVersion}; installed version is ${version}. Please upgrade Claude Code.`,
+        );
     }
   }
   // Reuse profile/catalog semantics, but use Windows path and environment rules.
-  const env = windowsEnv(runbookEnv(key, model, executable && path.dirname(executable), catalogProfile, agent, catalog.models), { PATH: windowsPath(executable ? [path.dirname(executable)] : [], environment.PATH) });
+  const env = windowsEnv(
+    runbookEnv(
+      key,
+      model,
+      executable && path.dirname(executable),
+      catalogProfile,
+      agent,
+      catalog.models,
+    ),
+    {
+      PATH: windowsPath(
+        executable ? [path.dirname(executable)] : [],
+        environment.PATH,
+      ),
+    },
+  );
   if (explicit['--gateway-url']) env.GATEWAY_URL = explicit['--gateway-url'];
-  if (parsed.action === 'install') return finish(await windowsSetup(agent.id, 'install', args, env));
+  if (parsed.action === 'install')
+    return finish(await windowsSetup(agent.id, 'install', args, env));
   if (agent.id === 'pi') await windowsSetup('pi', 'install', [], env);
   if (agent.id === 'codex') {
-    try { await windowsSetup('codex', 'install', [], env, { log: () => {} }); }
-    catch (error) { console.error(`Could not refresh Codex hooks (launch will continue): ${error.message}`); }
+    try {
+      await windowsSetup('codex', 'install', [], env, { log: () => {} });
+    } catch (error) {
+      console.error(
+        `Could not refresh Codex hooks (launch will continue): ${error.message}`,
+      );
+    }
   }
   const spec = await windowsLaunch(agent.id, args, env);
-  if (spec.command === agent.bin) spec.command = executable;
-  console.log(`  Launching ${agent.name} on Subconscious (${model})\n`);
+  if (spec.command === bin) spec.command = executable;
+  // Headless stdout belongs to the agent alone.
+  (headless ? console.error : console.log)(
+    `  Launching ${agent.name} on Subconscious (${model})\n`,
+  );
   return finish(await executeWindowsLaunch(spec, runWindows));
 }
 

package/bin/windows/common.js

@@ -1,58 +1,69 @@
+import { randomUUID } from 'node:crypto';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { readFileSync } from 'node:fs';
 
-export const defaults = JSON.parse(readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8')).defaults;
+export { DEFAULTS as defaults } from '../agent-data.js';
+export { modelIds, positiveInteger } from '../launch-values.js';
 export const value = (env, key, fallback = '') => env[key]?.trim() || fallback;
-export const origin = url => url.replace(/\/+$/, '').replace(/\/v1(?:\/(?:messages|responses|chat\/completions))?$/, '');
-export function positiveInteger(input, name) {
-  if (!/^[1-9][0-9]*$/.test(String(input)) || !Number.isSafeInteger(Number(input))) throw new Error(`${name} must be a positive integer`);
-  return Number(input);
-}
-export function modelIds(env) {
-  const models = [...new Set([value(env, 'MODEL', defaults.model), ...value(env, 'SUBCONSCIOUS_MODELS', defaults.models.join('\n')).split(/\r?\n/)].filter(Boolean))];
-  for (const model of models) if (!/^[-A-Za-z0-9._:/+]+$/.test(model)) throw new Error(`Invalid model id: ${model}`);
-  return models;
-}
+export const origin = (url) =>
+  url
+    .replace(/\/+$/, '')
+    .replace(/\/v1(?:\/(?:messages|responses|chat\/completions))?$/, '');
 export function parseOptions(argv, schema, { strict = false } = {}) {
-  const options = {}, rest = [];
+  const options = {},
+    rest = [];
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === '--') {
-      if (strict && i + 1 < argv.length) throw new Error(`Unexpected setup argument: ${argv[i + 1]}`);
-      rest.push(...argv.slice(i + 1)); break;
+      if (strict && i + 1 < argv.length)
+        throw new Error(`Unexpected setup argument: ${argv[i + 1]}`);
+      rest.push(...argv.slice(i + 1));
+      break;
     }
     const [flag, ...equals] = argv[i].split('=');
     if (!Object.hasOwn(schema, flag)) {
       if (strict) throw new Error(`Unknown setup option: ${argv[i]}`);
-      rest.push(argv[i]); continue;
+      rest.push(argv[i]);
+      continue;
     }
     if (schema[flag] === true) {
       if (equals.length) throw new Error(`${flag} does not take a value`);
-      options[flag] = true; continue;
+      options[flag] = true;
+      continue;
     }
     const next = equals.length ? equals.join('=') : argv[++i];
-    if (!next || next.startsWith('--')) throw new Error(`${flag} requires a value`);
+    if (!next || next.startsWith('--'))
+      throw new Error(`${flag} requires a value`);
     options[flag] = next;
   }
   return { options, rest };
 }
 export async function readJson(file, fallback) {
-  try { return JSON.parse((await fs.readFile(file, 'utf8')).replace(/^\uFEFF/, '')); }
-  catch (error) {
+  try {
+    return JSON.parse((await fs.readFile(file, 'utf8')).replace(/^\uFEFF/, ''));
+  } catch (error) {
     if (error.code === 'ENOENT') return fallback;
-    throw new Error(`Cannot read ${file}; leaving it unchanged: ${error.message}`);
+    throw new Error(
+      `Cannot read ${file}; leaving it unchanged: ${error.message}`,
+    );
   }
 }
 export function object(value, description) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${description} must be a JSON object; leaving it unchanged`);
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new Error(
+      `${description} must be a JSON object; leaving it unchanged`,
+    );
   return value;
 }
 export async function writeJson(file, data) {
   await fs.mkdir(path.dirname(file), { recursive: true });
   const temp = `${file}.${randomUUID()}.tmp`;
   try {
-    await fs.writeFile(temp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+    await fs.writeFile(temp, `${JSON.stringify(data, null, 2)}\n`, {
+      mode: 0o600,
+      flag: 'wx',
+    });
     await fs.rename(temp, file);
-  } finally { await fs.rm(temp, { force: true }); }
+  } finally {
+    await fs.rm(temp, { force: true });
+  }
 }

package/bin/windows/install.js

@@ -1,26 +1,36 @@
+import { createHash, randomUUID } from 'node:crypto';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { createHash, randomUUID } from 'node:crypto';
-import { readFileSync } from 'node:fs';
+import { agentById, installCommands } from '../agent-data.js';
 import { powershellCommand, runWindows } from './process.js';
 
-const registry = JSON.parse(readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8'));
-const repository = 'subconscious-systems/subconscious-code';
+const marathon = agentById('subconscious-code').install;
+const repository = marathon.repository;
 
 function npmInstall(command) {
-  const match = /^npm (?:i|install) -g ([@a-zA-Z0-9/._-]+)$/.exec(command || '');
+  const match = /^npm (?:i|install) -g ([@a-zA-Z0-9/._-]+)$/.exec(
+    command || '',
+  );
   return match ? { command: 'npm', args: ['install', '-g', match[1]] } : null;
 }
 
 export function windowsInstallSpec(id, env = process.env) {
-  const install = registry.agents.find(agent => agent.id === id)?.install;
-  const command = typeof install === 'object' ? install.win32 : undefined;
-  if (id === 'subconscious-code') return { nativeRelease: true, display: 'subc marathon install' };
+  const install = installCommands(agentById(id)) || {};
+  const command = install.win32;
+  if (id === 'subconscious-code')
+    return { nativeRelease: true, display: 'subc marathon install' };
   if (!command) return null; // Never fall back to a Linux installer.
   if (id === 'claude-code') {
-    const primary = powershellCommand("$ErrorActionPreference = 'Stop'; Invoke-RestMethod 'https://claude.ai/install.ps1' | Invoke-Expression; if (-not $?) { exit 1 }", env);
-    return { ...primary, display: command, fallback: npmInstall(install.fallback) };
+    const primary = powershellCommand(
+      "$ErrorActionPreference = 'Stop'; Invoke-RestMethod 'https://claude.ai/install.ps1' | Invoke-Expression; if (-not $?) { exit 1 }",
+      env,
+    );
+    return {
+      ...primary,
+      display: command,
+      fallback: npmInstall(install.fallback),
+    };
   }
   const spec = npmInstall(command);
   if (!spec) throw new Error(`No safe Windows installer is defined for ${id}`);
@@ -28,38 +38,93 @@ export function windowsInstallSpec(id, env = process.env) {
 }
 
 export function windowsReleaseAsset(release, arch = process.arch) {
-  const target = { x64: 'x86_64-pc-windows-msvc', arm64: 'aarch64-pc-windows-msvc' }[arch];
-  if (!target) throw new Error(`Subconscious Code does not support Windows architecture ${arch}`);
+  const target = marathon.windows_targets.find((triple) =>
+    triple.startsWith({ x64: 'x86_64-', arm64: 'aarch64-' }[arch] ?? '-'),
+  );
+  if (!target)
+    throw new Error(
+      `Subconscious Code does not support Windows architecture ${arch}`,
+    );
   // Pinned older releases are installed under the new executable name too.
   // Never resolve or overwrite Windows' own sc.exe.
-  const names = [`marathon-${target}.zip`, `marathon-${target}.exe`, `sc-${target}.zip`, `sc-${target}.exe`];
-  const asset = names.map(name => release.assets?.find(asset => asset.name === name)).find(Boolean);
-  if (!asset) throw new Error(`Marathon ${release.tag_name || 'latest'} has no published native Windows ${arch} binary for subc marathon install.`);
-  const checksum = release.assets.find(candidate => candidate.name === `${asset.name}.sha256`);
-  if (!checksum) throw new Error(`The Windows release is missing ${asset.name}.sha256; refusing an unverified installation.`);
+  const names = marathon.windows_assets.map((name) =>
+    name.replaceAll('{target}', target),
+  );
+  const asset = names
+    .map((name) => release.assets?.find((asset) => asset.name === name))
+    .find(Boolean);
+  if (!asset)
+    throw new Error(
+      `Marathon ${release.tag_name || 'latest'} has no published native Windows ${arch} binary for subc marathon install.`,
+    );
+  const checksum = release.assets.find(
+    (candidate) => candidate.name === `${asset.name}.sha256`,
+  );
+  if (!checksum)
+    throw new Error(
+      `The Windows release is missing ${asset.name}.sha256; refusing an unverified installation.`,
+    );
   return { asset, checksum };
 }
 
-export async function installWindowsSC(env, { fetchImpl = fetch, run = runWindows, home = os.homedir(), arch = process.arch, log = console.log } = {}) {
+export async function installWindowsSC(
+  env,
+  {
+    fetchImpl = fetch,
+    run = runWindows,
+    home = os.homedir(),
+    arch = process.arch,
+    log = console.log,
+  } = {},
+) {
   const version = env.SC_CODE_VERSION?.replace(/^v/, '');
-  const endpoint = version ? `tags/${encodeURIComponent('v' + version)}` : 'latest';
-  const response = await fetchImpl(`https://api.github.com/repos/${repository}/releases/${endpoint}`, { headers: { Accept: 'application/vnd.github+json' }, signal: AbortSignal.timeout(15000) });
-  if (!response.ok) throw new Error(`Could not find a Subconscious Code release (HTTP ${response.status}).`);
+  const endpoint = version
+    ? `tags/${encodeURIComponent(`v${version}`)}`
+    : 'latest';
+  const response = await fetchImpl(
+    `https://api.github.com/repos/${repository}/releases/${endpoint}`,
+    {
+      headers: { Accept: 'application/vnd.github+json' },
+      signal: AbortSignal.timeout(15000),
+    },
+  );
+  if (!response.ok)
+    throw new Error(
+      `Could not find a Subconscious Code release (HTTP ${response.status}).`,
+    );
   const release = await response.json();
   const { asset, checksum } = windowsReleaseAsset(release, arch);
-  const download = async asset => {
+  const download = async (asset) => {
     const url = new URL(asset.browser_download_url);
-    if (url.origin !== 'https://github.com' || !url.pathname.startsWith(`/${repository}/releases/download/`)) throw new Error('Unexpected release download URL');
-    const response = await fetchImpl(url.href, { signal: AbortSignal.timeout(120000) });
-    if (!response.ok) throw new Error(`Download failed (HTTP ${response.status}): ${asset.name}`);
+    if (
+      url.origin !== 'https://github.com' ||
+      !url.pathname.startsWith(`/${repository}/releases/download/`)
+    )
+      throw new Error('Unexpected release download URL');
+    const response = await fetchImpl(url.href, {
+      signal: AbortSignal.timeout(120000),
+    });
+    if (!response.ok)
+      throw new Error(
+        `Download failed (HTTP ${response.status}): ${asset.name}`,
+      );
     return Buffer.from(await response.arrayBuffer());
   };
   log(`Downloading Marathon ${release.tag_name} for Windows ${arch}...`);
-  const [binary, checksumText] = await Promise.all([download(asset), download(checksum)]);
+  const [binary, checksumText] = await Promise.all([
+    download(asset),
+    download(checksum),
+  ]);
   const expected = checksumText.toString('utf8').trim().split(/\s+/)[0];
-  if (!/^[a-f0-9]{64}$/i.test(expected) || createHash('sha256').update(binary).digest('hex') !== expected.toLowerCase()) throw new Error('Subconscious Code checksum verification failed');
+  if (
+    !/^[a-f0-9]{64}$/i.test(expected) ||
+    createHash('sha256').update(binary).digest('hex') !== expected.toLowerCase()
+  )
+    throw new Error('Subconscious Code checksum verification failed');
   const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'subc-sc-install-'));
-  const installDir = path.resolve(env.SC_INSTALL_DIR || path.join(home, '.local', 'bin'));
+  const installDir = path.resolve(
+    env.SC_INSTALL_DIR || path.join(home, '.local', 'bin'),
+  );
   const destination = path.join(installDir, 'marathon.exe');
   const staging = path.join(installDir, `marathon-${randomUUID()}.tmp`);
   try {
@@ -68,11 +133,24 @@ export async function installWindowsSC(env, { fetchImpl = fetch, run = runWindow
       const archive = path.join(dir, 'release.zip');
       await fs.writeFile(archive, binary, { flag: 'wx' });
       // Extract only the exact root executable. No archive-controlled paths.
-      const executable = asset.name.startsWith('marathon-') ? 'marathon.exe' : 'sc.exe';
-      const spec = powershellCommand("$ErrorActionPreference = 'Stop'; Add-Type -AssemblyName System.IO.Compression.FileSystem; $z = [IO.Compression.ZipFile]::OpenRead($env:SUBC_ARCHIVE); try { $e = $z.GetEntry($env:SUBC_EXECUTABLE); if ($null -eq $e) { throw 'Archive has no expected root executable' }; [IO.Compression.ZipFileExtensions]::ExtractToFile($e, $env:SUBC_EXTRACTED, $false) } finally { $z.Dispose() }", { ...env, SUBC_ARCHIVE: archive, SUBC_EXTRACTED: extracted, SUBC_EXECUTABLE: executable });
-      if (await run(spec.command, spec.args, { env: spec.env })) throw new Error('Could not extract the Windows release');
+      const executable = asset.name.startsWith('marathon-')
+        ? 'marathon.exe'
+        : 'sc.exe';
+      const spec = powershellCommand(
+        "$ErrorActionPreference = 'Stop'; Add-Type -AssemblyName System.IO.Compression.FileSystem; $z = [IO.Compression.ZipFile]::OpenRead($env:SUBC_ARCHIVE); try { $e = $z.GetEntry($env:SUBC_EXECUTABLE); if ($null -eq $e) { throw 'Archive has no expected root executable' }; [IO.Compression.ZipFileExtensions]::ExtractToFile($e, $env:SUBC_EXTRACTED, $false) } finally { $z.Dispose() }",
+        {
+          ...env,
+          SUBC_ARCHIVE: archive,
+          SUBC_EXTRACTED: extracted,
+          SUBC_EXECUTABLE: executable,
+        },
+      );
+      if (await run(spec.command, spec.args, { env: spec.env }))
+        throw new Error('Could not extract the Windows release');
     } else await fs.writeFile(extracted, binary, { flag: 'wx' });
-    const magic = (await fs.readFile(extracted)).subarray(0, 2).toString('ascii');
+    const magic = (await fs.readFile(extracted))
+      .subarray(0, 2)
+      .toString('ascii');
     if (magic !== 'MZ') throw new Error('Release is not a Windows executable');
     await fs.mkdir(installDir, { recursive: true });
     await fs.copyFile(extracted, staging);
@@ -90,8 +168,12 @@ export async function installWindowsAgent(id, env, run = runWindows) {
   if (!spec) throw new Error('Install this agent separately, then rerun subc.');
   if (spec.nativeRelease) return installWindowsSC(env, { run });
   let code;
-  try { code = await run(spec.command, spec.args, { env: spec.env || env }); }
-  catch (error) { if (!spec.fallback) throw error; code = 1; }
+  try {
+    code = await run(spec.command, spec.args, { env: spec.env || env });
+  } catch (error) {
+    if (!spec.fallback) throw error;
+    code = 1;
+  }
   if (code && spec.fallback) {
     console.error('Native installer failed; trying the npm package.');
     code = await run(spec.fallback.command, spec.fallback.args, { env });