hostctl 0.1.36 → 0.1.37

package/dist/index.d.ts

@@ -1282,9 +1282,11 @@ declare namespace k3s {
 interface CopyIdParams {
     public_key: string;
     user?: string;
+    sudo?: boolean;
 }
 interface CopyIdResult {
     success: boolean;
+    changed: boolean;
 }
 declare const _default$w: TaskFn<CopyIdParams, CopyIdResult>;
 
@@ -1309,6 +1311,8 @@ interface GrantNopasswdParams {
 interface GrantNopasswdResult {
     /** True if the operation was successful. */
     success: boolean;
+    /** True if any state was changed. */
+    changed: boolean;
     /** The path to the created sudoers file. */
     filePath: string;
 }

package/dist/index.js

@@ -2552,7 +2552,7 @@ import process3 from "process";
 import * as cmdr from "commander";
 
 // src/version.ts
-var version = "0.1.36";
+var version = "0.1.37";
 
 // src/cli.ts
 import JSON5 from "json5";
@@ -5402,8 +5402,10 @@ async function runFn2(context) {
   }
   const sudoPrefix = sudo ? ["sudo"] : [];
   if (append !== void 0) {
-    const stdin = `${append}${KeySequence.NEWLINE}${KeySequence.CTRL_D}`;
-    const { success } = await exec(["tee", "-a", file], { sudo, stdin });
+    const escapedContent = append.replace(/'/g, "'\\''");
+    const command = `echo '${escapedContent}' >> "${file}"`;
+    info(`Appending with command: ${command}`);
+    const { success } = await exec([...sudoPrefix, "sh", "-c", command], { sudo });
     return { changed: true, success };
   }
   if (block !== void 0) {
@@ -5498,11 +5500,12 @@ ${marker_end}`;
         }
         return { changed: true, success: result.success };
       } else {
-        const stdin = `${line}${KeySequence.NEWLINE}${KeySequence.CTRL_D}`;
-        info(`Appending line with tee: '${stdin}'`);
-        const result = await exec([...sudoPrefix, "tee", "-a", file], { sudo, stdin });
+        const escapedLine = line.replace(/'/g, "'\\''");
+        const command = `echo '${escapedLine}' >> "${file}"`;
+        info(`Appending with command: ${command}`);
+        const result = await exec([...sudoPrefix, "sh", "-c", command], { sudo });
         if (!result.success) {
-          info(`tee command failed. stderr: ${result.stderr}`);
+          info(`Append command failed. stderr: ${result.stderr}`);
         }
         return { changed: true, success: result.success };
       }
@@ -6398,44 +6401,45 @@ var get_username_default = task(run45, { name: "core.user.get_username", descrip
 
 // src/core/ssh/copy_id.ts
 async function run46(context) {
-  const { params, run: runTask, exec, log, info } = context;
-  let { public_key, user } = params;
+  const { params, run: runTask, exec, log, info, error } = context;
+  let { public_key, user, sudo } = params;
   const publicKeyTrimmed = public_key.trim();
+  const sudoPrefix = sudo ? ["sudo"] : [];
   if (!user) {
     const usernameResult = await runTask(get_username_default());
     if (usernameResult instanceof Error) {
       info(`Failed to get current username: ${usernameResult.message}`);
-      return { success: false };
+      return { success: false, changed: false };
     }
     if (typeof usernameResult?.username !== "string") {
       info("Could not determine current username from task result.");
-      return { success: false };
+      return { success: false, changed: false };
     }
     user = usernameResult.username;
   }
   if (!user) {
     info("User for SSH key copy is undefined.");
-    return { success: false };
+    return { success: false, changed: false };
   }
   const userExistsResult = await runTask(exists_default4({ user }));
   if (userExistsResult instanceof Error) {
     info(`Error checking if user '${user}' exists: ${userExistsResult.message}`);
-    return { success: false };
+    return { success: false, changed: false };
   }
   if (!userExistsResult?.exists) {
     const hostnameResult = await runTask(hostname_default());
     const hostname = hostnameResult instanceof Error || !hostnameResult?.hostname ? "current host" : hostnameResult.hostname;
     info(`User '${user}' does not exist on ${hostname}. Cannot copy SSH ID.`);
-    return { success: false };
+    return { success: false, changed: false };
   }
   const homeDirResult = await runTask(home_dir_default({ user }));
   if (homeDirResult instanceof Error) {
     info(`Error getting home directory for user '${user}': ${homeDirResult.message}`);
-    return { success: false };
+    return { success: false, changed: false };
   }
   if (typeof homeDirResult?.path !== "string") {
     info(`Could not determine home directory path for user '${user}'.`);
-    return { success: false };
+    return { success: false, changed: false };
   }
   const userHome = homeDirResult.path;
   const sshDir = path3.join(userHome, ".ssh");
@@ -6444,7 +6448,7 @@ async function run46(context) {
     info(
       `Failed to create or set permissions for ${sshDir}: ${dirCreateResult instanceof Error ? dirCreateResult.message : "Task reported failure"}`
     );
-    return { success: false };
+    return { success: false, changed: false };
   }
   const authorizedKeysFile = path3.join(sshDir, "authorized_keys");
   const touchResult = await runTask(touch_default({ file: authorizedKeysFile, mode: "600", owner: user }));
@@ -6452,30 +6456,28 @@ async function run46(context) {
     info(
       `Failed to touch or set permissions for ${authorizedKeysFile}: ${touchResult instanceof Error ? touchResult.message : "Task reported failure"}`
     );
-    return { success: false };
+    return { success: false, changed: false };
   }
   const checkKeyCommandParts = [];
   checkKeyCommandParts.push("sudo", "-u", user, "grep", "-xqF", publicKeyTrimmed, authorizedKeysFile);
   const checkKeyCmdResult = await exec(checkKeyCommandParts);
   if (checkKeyCmdResult.exitCode === 0) {
     info(`SSH key already exists in ${authorizedKeysFile} for user ${user}.`);
-    return { success: true };
+    return { success: true, changed: false };
   } else if (checkKeyCmdResult.exitCode !== 1) {
     info(`Error checking for existing SSH key: ${checkKeyCmdResult.stderr || checkKeyCmdResult.stdout}`);
-    return { success: false };
+    return { success: false, changed: false };
   }
-  const sudoCmd = `sudo -u ${user}`;
   const escapedPublicKey = publicKeyTrimmed.replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
-  const shellCommand = `echo "${escapedPublicKey}" | ${sudoCmd} tee -a "${authorizedKeysFile}"`;
-  info(`Attempting to add key with command: sh -c '${shellCommand}'`);
-  const addKeyResult = await exec(["sh", "-c", shellCommand]);
+  const command = `echo "${escapedPublicKey}" >> "${authorizedKeysFile}"`;
+  const addKeyResult = await exec([...sudoPrefix, "sh", "-c", command], { sudo });
   if (!addKeyResult.success) {
-    info(
-      `Failed to add SSH key for user ${user}. Exit code: ${addKeyResult.exitCode}, Error: ${addKeyResult.stderr || addKeyResult.stdout}`
-    );
+    error(`Failed to append public key to ${authorizedKeysFile}: ${addKeyResult.stderr}`);
+    return { success: false, changed: false };
   }
   return {
-    success: addKeyResult.success
+    success: true,
+    changed: true
   };
 }
 var copy_id_default = task(run46, { name: "core.ssh.copy_id", description: "Ssh copy id." });
@@ -6500,41 +6502,58 @@ var check_default = task(run47, { name: "core.sudoers.check", description: "Sudo
 
 // src/core/sudoers/grant-nopasswd.ts
 async function run48(context) {
-  const { params, exec, log, error } = context;
+  const { params, exec, log, error, info } = context;
   const { user } = params;
   if (!user) {
     throw new Error("The 'user' parameter is required.");
   }
   const sudoersFileName = params.name || user;
   const sudoersFilePath = `/etc/sudoers.d/${sudoersFileName}`;
-  const sudoersContent = `${user} ALL=(ALL) NOPASSWD: ALL${KeySequence.NEWLINE}${KeySequence.CTRL_D}`;
+  const sudoersContent = `${user} ALL=(ALL) NOPASSWD: ALL`;
   try {
-    const writeCmd = await exec(["sudo", "tee", sudoersFilePath], { stdin: sudoersContent });
-    if (!writeCmd.success) {
-      error(`Failed to write to ${sudoersFilePath}: ${writeCmd.stderr}`);
-      return { success: false, filePath: sudoersFilePath };
-    }
-    const chmodCmd = await exec(["sudo", "chmod", "0440", sudoersFilePath]);
-    if (!chmodCmd.success) {
-      error(`Failed to set permissions on ${sudoersFilePath}: ${chmodCmd.stderr}`);
-      return { success: false, filePath: sudoersFilePath };
-    }
-    const chownCmd = await exec(["sudo", "chown", "root:root", sudoersFilePath]);
-    if (!chownCmd.success) {
-      error(`Failed to set ownership on ${sudoersFilePath}: ${chownCmd.stderr}`);
-      return { success: false, filePath: sudoersFilePath };
+    const editResult = await context.run(
+      core_default.file.edit({
+        file: sudoersFilePath,
+        line: sudoersContent,
+        sudo: true
+      })
+    );
+    if (editResult instanceof Error || !editResult.success) {
+      throw new Error(`Failed to edit sudoers file at ${sudoersFilePath}`);
+    }
+    const chmodResult = await context.run(
+      core_default.file.chmod({
+        path: sudoersFilePath,
+        mode: "0440",
+        sudo: true
+      })
+    );
+    if (chmodResult instanceof Error || !chmodResult.success) {
+      throw new Error(`Failed to set permissions on ${sudoersFilePath}`);
+    }
+    const chownResult = await context.run(
+      core_default.file.chown({
+        path: sudoersFilePath,
+        owner: "root",
+        group: "root",
+        sudo: true
+      })
+    );
+    if (chownResult instanceof Error || !chownResult.success) {
+      throw new Error(`Failed to set ownership on ${sudoersFilePath}`);
     }
     const checkCmd = await exec(["sudo", "visudo", "-cf", sudoersFilePath]);
     if (!checkCmd.success) {
       error(`Syntax check failed for ${sudoersFilePath}: ${checkCmd.stderr}`);
       await exec(["sudo", "rm", "-f", sudoersFilePath]);
-      return { success: false, filePath: sudoersFilePath };
+      return { success: false, changed: false, filePath: sudoersFilePath };
     }
+    const changed = editResult.changed;
     log(Verbosity.INFO, `Successfully granted passwordless sudo to user '${user}' via ${sudoersFilePath}`);
-    return { success: true, filePath: sudoersFilePath };
+    return { success: true, changed, filePath: sudoersFilePath };
   } catch (e) {
     error(`An unexpected error occurred: ${e.message}`);
-    throw e;
+    return { success: false, changed: false, filePath: "" };
   }
 }
 var grant_nopasswd_default = task(run48, {