@grainulation/wheat 1.0.2 → 1.0.4

package/lib/connect.js

@@ -6,10 +6,10 @@
  * Zero npm dependencies.
  */
 
-import http from 'node:http';
-import https from 'node:https';
-import fs from 'node:fs';
-import path from 'node:path';
+import http from "node:http";
+import https from "node:https";
+import fs from "node:fs";
+import path from "node:path";
 
 // ─── Constants ─────────────────────────────────────────────────────────────
 
@@ -18,12 +18,12 @@ const DETECT_TIMEOUT_MS = 2000;
 const VERIFY_TIMEOUT_MS = 5000;
 const LOCK_RETRY_MS = 200;
 const LOCK_MAX_RETRIES = 10;
-const SETTINGS_FILENAME = '.claude/settings.local.json';
+const SETTINGS_FILENAME = ".claude/settings.local.json";
 
 const HOOK_ENDPOINTS = {
-  permission:   '/hooks/permission',
-  activity:     '/hooks/activity',
-  notification: '/hooks/notification',
+  permission: "/hooks/permission",
+  activity: "/hooks/activity",
+  notification: "/hooks/notification",
 };
 
 // ─── Argument parsing ──────────────────────────────────────────────────────
@@ -31,17 +31,19 @@ const HOOK_ENDPOINTS = {
 function parseArgs(args) {
   const flags = {};
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--url' && args[i + 1]) {
-      flags.url = args[i + 1]; i++;
-    } else if (args[i] === '--port' && args[i + 1]) {
-      flags.port = parseInt(args[i + 1], 10); i++;
-    } else if (args[i] === '--dry-run') {
+    if (args[i] === "--url" && args[i + 1]) {
+      flags.url = args[i + 1];
+      i++;
+    } else if (args[i] === "--port" && args[i + 1]) {
+      flags.port = parseInt(args[i + 1], 10);
+      i++;
+    } else if (args[i] === "--dry-run") {
       flags.dryRun = true;
-    } else if (args[i] === '--force') {
+    } else if (args[i] === "--force") {
       flags.force = true;
-    } else if (args[i] === '--json') {
+    } else if (args[i] === "--json") {
       flags.json = true;
-    } else if (args[i] === '--help' || args[i] === '-h') {
+    } else if (args[i] === "--help" || args[i] === "-h") {
       flags.help = true;
     }
   }
@@ -51,28 +53,43 @@ function parseArgs(args) {
 // ─── HTTP helpers (zero-dep) ───────────────────────────────────────────────
 
 function httpRequest(url, options = {}) {
-  return new Promise(resolve => {
+  return new Promise((resolve) => {
     const parsed = new URL(url);
-    const client = parsed.protocol === 'https:' ? https : http;
+    const client = parsed.protocol === "https:" ? https : http;
     const timeout = options.timeout || DETECT_TIMEOUT_MS;
 
-    const req = client.request(parsed, {
-      method: options.method || 'GET',
-      headers: options.headers || {},
-      timeout,
-    }, res => {
-      let body = '';
-      res.on('data', chunk => { body += chunk; });
-      res.on('end', () => {
-        resolve({ status: res.statusCode, body, error: null });
-      });
+    const req = client.request(
+      parsed,
+      {
+        method: options.method || "GET",
+        headers: options.headers || {},
+        timeout,
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          resolve({ status: res.statusCode, body, error: null });
+        });
+      }
+    );
+
+    req.on("error", (err) =>
+      resolve({ status: 0, body: "", error: err.message })
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      resolve({ status: 0, body: "", error: "timeout" });
     });
 
-    req.on('error', err => resolve({ status: 0, body: '', error: err.message }));
-    req.on('timeout', () => { req.destroy(); resolve({ status: 0, body: '', error: 'timeout' }); });
-
     if (options.body) {
-      req.write(typeof options.body === 'string' ? options.body : JSON.stringify(options.body));
+      req.write(
+        typeof options.body === "string"
+          ? options.body
+          : JSON.stringify(options.body)
+      );
     }
     req.end();
   });
@@ -82,38 +99,53 @@ function httpRequest(url, options = {}) {
 
 async function probeFarmer(baseUrl) {
   // Primary detection: hit /api/state which is the canonical farmer endpoint
-  const stateResp = await httpRequest(baseUrl + '/api/state', { timeout: DETECT_TIMEOUT_MS });
+  const stateResp = await httpRequest(baseUrl + "/api/state", {
+    timeout: DETECT_TIMEOUT_MS,
+  });
   if (stateResp.error) return { found: false, error: stateResp.error };
 
   if (stateResp.status !== 200) {
     // Fallback: try root to see if it's farmer at all
-    const rootResp = await httpRequest(baseUrl + '/', { timeout: DETECT_TIMEOUT_MS });
+    const rootResp = await httpRequest(baseUrl + "/", {
+      timeout: DETECT_TIMEOUT_MS,
+    });
     if (rootResp.error || rootResp.status !== 200) {
-      return { found: false, error: `Port responds (HTTP ${stateResp.status}) but /api/state not available` };
+      return {
+        found: false,
+        error: `Port responds (HTTP ${stateResp.status}) but /api/state not available`,
+      };
     }
-    const looksLikeFarmer = rootResp.body.includes('farmer') || rootResp.body.includes('Farmer');
+    const looksLikeFarmer =
+      rootResp.body.includes("farmer") || rootResp.body.includes("Farmer");
     if (!looksLikeFarmer) {
-      return { found: false, error: `Port responds but does not look like Farmer` };
+      return {
+        found: false,
+        error: `Port responds but does not look like Farmer`,
+      };
     }
   }
 
   // Hook probe: verify the permission endpoint accepts POSTs
   const probePayload = {
-    hook_event_name: 'PreToolUse',
-    tool_name: '__wheat_connect_probe__',
-    tool_input: '{}',
-    session_id: 'wheat-connect-probe',
+    hook_event_name: "PreToolUse",
+    tool_name: "__wheat_connect_probe__",
+    tool_input: "{}",
+    session_id: "wheat-connect-probe",
   };
 
   const hookResp = await httpRequest(baseUrl + HOOK_ENDPOINTS.permission, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
     body: probePayload,
     timeout: VERIFY_TIMEOUT_MS,
   });
 
   if (hookResp.error) {
-    return { found: true, verified: false, error: `Farmer found but hook probe failed: ${hookResp.error}` };
+    return {
+      found: true,
+      verified: false,
+      error: `Farmer found but hook probe failed: ${hookResp.error}`,
+    };
   }
 
   let isVerified = false;
@@ -125,20 +157,30 @@ async function probeFarmer(baseUrl) {
     found: true,
     verified: isVerified,
     status: hookResp.status,
-    error: isVerified ? null : `Hook endpoint returned unexpected response (HTTP ${hookResp.status})`,
+    error: isVerified
+      ? null
+      : `Hook endpoint returned unexpected response (HTTP ${hookResp.status})`,
   };
 }
 
 async function verifySse(baseUrl) {
-  return new Promise(resolve => {
-    const parsed = new URL(baseUrl + '/events');
-    const req = http.request(parsed, { method: 'GET', timeout: VERIFY_TIMEOUT_MS }, res => {
-      const isSSE = res.headers['content-type']?.includes('text/event-stream');
-      res.destroy(); // We only need to confirm it opens
-      resolve({ ok: isSSE, status: res.statusCode });
+  return new Promise((resolve) => {
+    const parsed = new URL(baseUrl + "/events");
+    const req = http.request(
+      parsed,
+      { method: "GET", timeout: VERIFY_TIMEOUT_MS },
+      (res) => {
+        const isSSE =
+          res.headers["content-type"]?.includes("text/event-stream");
+        res.destroy(); // We only need to confirm it opens
+        resolve({ ok: isSSE, status: res.statusCode });
+      }
+    );
+    req.on("error", (err) => resolve({ ok: false, error: err.message }));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve({ ok: false, error: "timeout" });
     });
-    req.on('error', err => resolve({ ok: false, error: err.message }));
-    req.on('timeout', () => { req.destroy(); resolve({ ok: false, error: 'timeout' }); });
     req.end();
   });
 }
@@ -150,46 +192,78 @@ async function detectFarmer(preferredPort) {
     const result = await probeFarmer(baseUrl);
     if (result.found) return { ...result, url: baseUrl, port };
   }
-  return { found: false, url: null, port: null, error: 'No farmer server found on default ports' };
+  return {
+    found: false,
+    url: null,
+    port: null,
+    error: "No farmer server found on default ports",
+  };
 }
 
 // ─── Settings file management ──────────────────────────────────────────────
 
 function hookCommand(farmerUrl, endpoint) {
+  if (process.platform === "win32") {
+    // PowerShell: read stdin via [Console]::In, POST via Invoke-RestMethod
+    const url = `${farmerUrl}${endpoint}`;
+    return `powershell -NoProfile -Command "$b=[Console]::In.ReadToEnd(); try{Invoke-RestMethod -Uri '${url}' -Method Post -ContentType 'application/json' -Body $b}catch{}"`;
+  }
   return `cat | curl -s -X POST ${farmerUrl}${endpoint} -H 'Content-Type: application/json' --data-binary @- 2>/dev/null || true`;
 }
 
 function buildHooksConfig(farmerUrl) {
   return {
-    PreToolUse: [{
-      matcher: '',
-      hooks: [{ type: 'command', command: hookCommand(farmerUrl, HOOK_ENDPOINTS.permission) }],
-    }],
-    PostToolUse: [{
-      matcher: '',
-      hooks: [{ type: 'command', command: hookCommand(farmerUrl, HOOK_ENDPOINTS.activity) }],
-    }],
-    Notification: [{
-      matcher: '',
-      hooks: [{ type: 'command', command: hookCommand(farmerUrl, HOOK_ENDPOINTS.notification) }],
-    }],
+    PreToolUse: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: hookCommand(farmerUrl, HOOK_ENDPOINTS.permission),
+          },
+        ],
+      },
+    ],
+    PostToolUse: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: hookCommand(farmerUrl, HOOK_ENDPOINTS.activity),
+          },
+        ],
+      },
+    ],
+    Notification: [
+      {
+        matcher: "",
+        hooks: [
+          {
+            type: "command",
+            command: hookCommand(farmerUrl, HOOK_ENDPOINTS.notification),
+          },
+        ],
+      },
+    ],
   };
 }
 
 function readSettings(settingsPath) {
   try {
-    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    return JSON.parse(fs.readFileSync(settingsPath, "utf8"));
   } catch (err) {
-    if (err.code === 'ENOENT') return {};
+    if (err.code === "ENOENT") return {};
     throw new Error(`Cannot parse ${settingsPath}: ${err.message}`);
   }
 }
 
 function isFarmerHookEntry(entry) {
   if (!entry.hooks || !Array.isArray(entry.hooks)) return false;
-  return entry.hooks.some(h =>
-    (h.type === 'command' && h.command && h.command.includes('/hooks/'))
-    || (h.type === 'url' && h.url && h.url.includes('/hooks/'))
+  return entry.hooks.some(
+    (h) =>
+      (h.type === "command" && h.command && h.command.includes("/hooks/")) ||
+      (h.type === "url" && h.url && h.url.includes("/hooks/"))
   );
 }
 
@@ -199,33 +273,40 @@ function mergeHooks(existing, farmerHooks) {
 
   for (const hookType of Object.keys(farmerHooks)) {
     const existingHooks = merged.hooks[hookType] || [];
-    const nonFarmerHooks = existingHooks.filter(entry => !isFarmerHookEntry(entry));
+    const nonFarmerHooks = existingHooks.filter(
+      (entry) => !isFarmerHookEntry(entry)
+    );
     merged.hooks[hookType] = [...nonFarmerHooks, ...farmerHooks[hookType]];
   }
   return merged;
 }
 
 async function writeSettingsAtomic(settingsPath, settings) {
-  const lockPath = settingsPath + '.lock';
-  const backupPath = settingsPath + '.backup';
-  const tmpPath = settingsPath + '.tmp';
+  const lockPath = settingsPath + ".lock";
+  const backupPath = settingsPath + ".backup";
+  const tmpPath = settingsPath + ".tmp";
 
   let lockAcquired = false;
   for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
     try {
-      const fd = fs.openSync(lockPath, 'wx');
+      const fd = fs.openSync(lockPath, "wx");
       fs.writeSync(fd, String(process.pid));
       fs.closeSync(fd);
       lockAcquired = true;
       break;
     } catch (err) {
-      if (err.code === 'EEXIST') {
+      if (err.code === "EEXIST") {
         try {
-          const holderPid = parseInt(fs.readFileSync(lockPath, 'utf8').trim(), 10);
+          const holderPid = parseInt(
+            fs.readFileSync(lockPath, "utf8").trim(),
+            10
+          );
           process.kill(holderPid, 0);
-          await new Promise(r => setTimeout(r, LOCK_RETRY_MS));
+          await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
         } catch {
-          try { fs.unlinkSync(lockPath); } catch {}
+          try {
+            fs.unlinkSync(lockPath);
+          } catch {}
         }
       } else {
         throw err;
@@ -234,17 +315,21 @@ async function writeSettingsAtomic(settingsPath, settings) {
   }
 
   if (!lockAcquired) {
-    throw new Error('Cannot acquire file lock — another process is writing to settings');
+    throw new Error(
+      "Cannot acquire file lock — another process is writing to settings"
+    );
   }
 
   try {
     if (fs.existsSync(settingsPath)) {
       fs.copyFileSync(settingsPath, backupPath);
     }
-    fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + '\n');
+    fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + "\n");
     fs.renameSync(tmpPath, settingsPath);
   } finally {
-    try { fs.unlinkSync(lockPath); } catch {}
+    try {
+      fs.unlinkSync(lockPath);
+    } catch {}
   }
 }
 
@@ -252,49 +337,53 @@ async function writeSettingsAtomic(settingsPath, settings) {
 
 function printSuccess(farmerUrl, settingsPath, dryRun) {
   console.log();
-  console.log('  \x1b[32m\u2713\x1b[0m \x1b[1mFarmer connected\x1b[0m');
-  console.log('  \u2500'.repeat(40));
+  console.log("  \x1b[32m\u2713\x1b[0m \x1b[1mFarmer connected\x1b[0m");
+  console.log("  \u2500".repeat(40));
   console.log(`  Server:   ${farmerUrl}`);
   console.log(`  Settings: ${settingsPath}`);
   console.log();
-  console.log('  Hooks configured:');
+  console.log("  Hooks configured:");
   console.log(`    PreToolUse   \u2192 ${farmerUrl}/hooks/permission`);
   console.log(`    PostToolUse  \u2192 ${farmerUrl}/hooks/activity`);
   console.log(`    Notification \u2192 ${farmerUrl}/hooks/notification`);
   console.log();
   if (dryRun) {
-    console.log('  \x1b[33m(dry run \u2014 no files were modified)\x1b[0m');
+    console.log("  \x1b[33m(dry run \u2014 no files were modified)\x1b[0m");
     console.log();
   }
-  console.log('  What this means:');
-  console.log('    Every Claude Code tool call in this project now routes');
-  console.log('    through Farmer. You can approve, deny, or monitor');
-  console.log('    from your phone or desktop.');
+  console.log("  What this means:");
+  console.log("    Every Claude Code tool call in this project now routes");
+  console.log("    through Farmer. You can approve, deny, or monitor");
+  console.log("    from your phone or desktop.");
   console.log();
-  console.log('  What was verified:');
-  console.log('    - Farmer is running and responding to hook probes');
-  console.log('    - SSE event stream is available for live monitoring');
-  console.log('    - Hooks were merged without overwriting existing settings');
-  console.log('    - Slash commands installed/updated');
-  console.log('    - .farmer-config.json written with sprint paths');
+  console.log("  What was verified:");
+  console.log("    - Farmer is running and responding to hook probes");
+  console.log("    - SSE event stream is available for live monitoring");
+  console.log("    - Hooks were merged without overwriting existing settings");
+  console.log("    - Slash commands installed/updated");
+  console.log("    - .farmer-config.json written with sprint paths");
   console.log();
-  console.log('  What to do next:');
-  console.log('    Open Claude Code in this directory. If Farmer goes down,');
-  console.log('    hooks fail silently (|| true) so your workflow is never blocked.');
+  console.log("  What to do next:");
+  console.log("    Open Claude Code in this directory. If Farmer goes down,");
+  console.log(
+    "    hooks fail silently (|| true) so your workflow is never blocked."
+  );
   console.log();
 }
 
 function printNotFound(triedPorts) {
   console.log();
-  console.log('  \x1b[31m\u2717\x1b[0m \x1b[1mFarmer not detected\x1b[0m');
-  console.log('  \u2500'.repeat(40));
-  console.log(`  Tried ports: ${triedPorts.join(', ')}`);
+  console.log("  \x1b[31m\u2717\x1b[0m \x1b[1mFarmer not detected\x1b[0m");
+  console.log("  \u2500".repeat(40));
+  console.log(`  Tried ports: ${triedPorts.join(", ")}`);
   console.log();
-  console.log('  To start Farmer:');
-  console.log('    npx @grainulation/farmer start');
+  console.log("  To start Farmer:");
+  console.log("    npx @grainulation/farmer start");
   console.log();
-  console.log('  Or connect to a remote Farmer:');
-  console.log('    wheat connect farmer --url https://your-tunnel.trycloudflare.com');
+  console.log("  Or connect to a remote Farmer:");
+  console.log(
+    "    wheat connect farmer --url https://your-tunnel.trycloudflare.com"
+  );
   console.log();
 }
 
@@ -334,20 +423,24 @@ export async function run(dir, args) {
   let detection;
 
   if (flags.url) {
-    farmerUrl = flags.url.replace(/\/+$/, '');
+    farmerUrl = flags.url.replace(/\/+$/, "");
     console.log(`\n  Connecting to ${farmerUrl}...`);
     detection = await probeFarmer(farmerUrl);
     if (!detection.found) {
       if (flags.json) {
         console.log(JSON.stringify({ success: false, error: detection.error }));
       } else {
-        console.log(`\n  \x1b[31m\u2717\x1b[0m Cannot reach Farmer at ${farmerUrl}: ${detection.error}\n`);
+        console.log(
+          `\n  \x1b[31m\u2717\x1b[0m Cannot reach Farmer at ${farmerUrl}: ${detection.error}\n`
+        );
       }
       process.exit(1);
     }
   } else {
     const ports = flags.port ? [flags.port] : DEFAULT_PORTS;
-    console.log(`\n  Detecting Farmer on localhost (ports: ${ports.join(', ')})...`);
+    console.log(
+      `\n  Detecting Farmer on localhost (ports: ${ports.join(", ")})...`
+    );
     detection = await detectFarmer(flags.port);
     if (!detection.found) {
       if (flags.json) {
@@ -361,8 +454,10 @@ export async function run(dir, args) {
   }
 
   if (!detection.verified) {
-    console.log(`  \x1b[33m!\x1b[0m Farmer found but hook verification failed.`);
-    console.log(`    ${detection.error || 'Unknown verification error'}`);
+    console.log(
+      `  \x1b[33m!\x1b[0m Farmer found but hook verification failed.`
+    );
+    console.log(`    ${detection.error || "Unknown verification error"}`);
     console.log(`    Proceeding with configuration anyway...`);
   } else {
     console.log(`  \x1b[32m\u2713\x1b[0m Farmer detected at ${farmerUrl}`);
@@ -371,25 +466,43 @@ export async function run(dir, args) {
   // Verify SSE endpoint is available
   const sseResult = await verifySse(farmerUrl);
   if (sseResult.ok) {
-    console.log(`  \x1b[32m\u2713\x1b[0m SSE event stream verified at ${farmerUrl}/events`);
+    console.log(
+      `  \x1b[32m\u2713\x1b[0m SSE event stream verified at ${farmerUrl}/events`
+    );
   } else {
-    console.log(`  \x1b[33m!\x1b[0m SSE endpoint not confirmed (${sseResult.error || 'unexpected response'})`);
+    console.log(
+      `  \x1b[33m!\x1b[0m SSE endpoint not confirmed (${
+        sseResult.error || "unexpected response"
+      })`
+    );
     console.log(`    Live monitoring may not work until Farmer restarts.`);
   }
 
   // Step 2: Read existing settings, merge, write
   const existing = readSettings(settingsPath);
 
-  const hasExistingFarmerHooks = existing.hooks && Object.values(existing.hooks).some(
-    entries => Array.isArray(entries) && entries.some(entry => isFarmerHookEntry(entry))
-  );
+  const hasExistingFarmerHooks =
+    existing.hooks &&
+    Object.values(existing.hooks).some(
+      (entries) =>
+        Array.isArray(entries) &&
+        entries.some((entry) => isFarmerHookEntry(entry))
+    );
 
   if (hasExistingFarmerHooks && !flags.force) {
     if (flags.json) {
-      console.log(JSON.stringify({ success: true, alreadyConfigured: true, url: farmerUrl }));
+      console.log(
+        JSON.stringify({
+          success: true,
+          alreadyConfigured: true,
+          url: farmerUrl,
+        })
+      );
     } else {
-      console.log(`  \x1b[33m!\x1b[0m Farmer hooks already configured in ${SETTINGS_FILENAME}`);
-      console.log('    Use --force to overwrite.');
+      console.log(
+        `  \x1b[33m!\x1b[0m Farmer hooks already configured in ${SETTINGS_FILENAME}`
+      );
+      console.log("    Use --force to overwrite.");
     }
     return;
   }
@@ -399,9 +512,16 @@ export async function run(dir, args) {
 
   if (flags.dryRun) {
     if (flags.json) {
-      console.log(JSON.stringify({ success: true, dryRun: true, url: farmerUrl, settings: merged }));
+      console.log(
+        JSON.stringify({
+          success: true,
+          dryRun: true,
+          url: farmerUrl,
+          settings: merged,
+        })
+      );
     } else {
-      console.log('\n  Would write to: ' + settingsPath);
+      console.log("\n  Would write to: " + settingsPath);
       console.log();
       console.log(JSON.stringify(merged, null, 2));
       printSuccess(farmerUrl, settingsPath, true);
@@ -414,22 +534,27 @@ export async function run(dir, args) {
 
   // Install/update slash commands
   try {
-    const updateModule = await import(new URL('./update.js', import.meta.url).href);
-    await updateModule.run(targetDir, ['--force']);
+    const updateModule = await import(
+      new URL("./update.js", import.meta.url).href
+    );
+    await updateModule.run(targetDir, ["--force"]);
   } catch (err) {
-    console.log(`  \x1b[33m!\x1b[0m Could not install slash commands: ${err.message}`);
+    console.log(
+      `  \x1b[33m!\x1b[0m Could not install slash commands: ${err.message}`
+    );
   }
 
   // Write sprint paths to .farmer-config.json so farmer auto-discovers them
-  const farmerConfigPath = path.join(targetDir, '.farmer-config.json');
+  const farmerConfigPath = path.join(targetDir, ".farmer-config.json");
   try {
     let farmerConfig = {};
     if (fs.existsSync(farmerConfigPath)) {
-      farmerConfig = JSON.parse(fs.readFileSync(farmerConfigPath, 'utf8'));
+      farmerConfig = JSON.parse(fs.readFileSync(farmerConfigPath, "utf8"));
     }
-    const claimsPath = path.join(targetDir, 'claims.json');
-    const compilationPath = path.join(targetDir, 'compilation.json');
-    if (fs.existsSync(claimsPath) || true) {  // Always write paths, claims may come later
+    const claimsPath = path.join(targetDir, "claims.json");
+    const compilationPath = path.join(targetDir, "compilation.json");
+    if (fs.existsSync(claimsPath) || true) {
+      // Always write paths, claims may come later
       farmerConfig.claimsPath = claimsPath;
       farmerConfig.compilationPath = compilationPath;
     }
@@ -439,14 +564,28 @@ export async function run(dir, args) {
     if (!farmerConfig.registeredProjects.includes(targetDir)) {
       farmerConfig.registeredProjects.push(targetDir);
     }
-    fs.writeFileSync(farmerConfigPath, JSON.stringify(farmerConfig, null, 2) + '\n');
-    console.log(`  \x1b[32m+\x1b[0m .farmer-config.json (sprint paths registered)`);
+    fs.writeFileSync(
+      farmerConfigPath,
+      JSON.stringify(farmerConfig, null, 2) + "\n"
+    );
+    console.log(
+      `  \x1b[32m+\x1b[0m .farmer-config.json (sprint paths registered)`
+    );
   } catch (err) {
-    console.log(`  \x1b[33m!\x1b[0m Could not write .farmer-config.json: ${err.message}`);
+    console.log(
+      `  \x1b[33m!\x1b[0m Could not write .farmer-config.json: ${err.message}`
+    );
   }
 
   if (flags.json) {
-    console.log(JSON.stringify({ success: true, url: farmerUrl, settingsPath, verified: detection.verified }));
+    console.log(
+      JSON.stringify({
+        success: true,
+        url: farmerUrl,
+        settingsPath,
+        verified: detection.verified,
+      })
+    );
   } else {
     printSuccess(farmerUrl, settingsPath, false);
   }