fix commits later

Author: monyarm

packages/mcl/src/main.d

@@ -16,7 +16,8 @@ alias supportedCommands = imported!`std.traits`.AliasSeq!(
     cmds.shard_matrix,
     cmds.host_info,
     cmds.ci,
-    cmds.machine
+    cmds.machine,
+    cmds.config
 );
 
 int main(string[] args)

packages/mcl/src/src/mcl/commands/config.d

@@ -1,11 +1,17 @@
 module mcl.commands.config;
 
-import std.stdio : writeln;
+import std.stdio : writeln, write;
 import std.conv : to;
 import std.json : JSONValue;
 import std.format : fmt = format;
 import std.exception : enforce;
 import std.range : front;
+import std.string : indexOf, strip;
+import std.logger: errorf;
+import core.stdc.stdlib: exit;
+import std.algorithm : each;
+import std.array : array;
+import std.process : Redirect, ProcessPipes, wait;
 
 import mcl.utils.env : optional, parseEnv;
 import mcl.utils.fetch : fetchJson;
@@ -15,46 +21,78 @@ import mcl.utils.process : execute;
 
 export void config(string[] args)
 {
-    const params = parseEnv!Params;
+    if (args.length == 0)
+    {
+
+        errorf("Usage: mcl config <subcommand> [args]");
+        exit(1);
+    }
+    if (!checkRepo())
+    {
+        errorf("This command must be run from a repository containing a NixOS machine configuration");
+        exit(1);
+    }
     switch (args.front) {
         case "sys":
-            sys(params, args);
+            sys(args[1..$]);
             break;
         case "home":
-            home(params, args);
+            home(args[1..$]);
             break;
         case "start-vm":
-            startVM(params, args);
+            startVM(args[1..$]);
             break;
         default:
-            assert(false, "Unknown config subcommand" ~ args.front);
+            errorf("Unknown config subcommand" ~ args.front ~ ". Supported subcommands: sys, home, start-vm");
     }
 }
 
-void sys(Params params, string[] args)
+bool checkRepo()
 {
+    string remoteOriginUrl = execute(["git", "config", "--get", "remote.origin.url"], false);
+    return remoteOriginUrl.indexOf("nixos-machine-config") != -1 || remoteOriginUrl.indexOf("infra-lido") != -1;
 }
 
-void home(Params params, string[] args)
+void sys(string[] args)
 {
+    if ((args.length < 1 || args.length > 2) && args.front != "apply")
+    {
+        errorf("Usage: mcl config sys apply or mcl config sys apply <machine-name>");
+        exit(1);
+    }
+    else {
+        string machineName = args.length > 1 ? args[1] : "";
+        writeln("Applying system configuration from: ", machineName);
+        auto exec = execute!ProcessPipes( "just switch-system " ~ machineName, true, false, Redirect.stderrToStdout);
+        wait(exec.pid);
+    };
 }
 
-void startVM(Params params, string[] args)
+void home(string[] args)
 {
-    if (args.length < 2 || args.length > 2)
-        assert(false, "Usage: mcl config start-vm <vm-name>");
+    if ((args.length != 2) && args.front != "apply")
+    {
+        errorf("Usage: mcl config home apply <desktop/server>");
+        exit(1);
+    }
     else {
-        string vmName = args[1];
-        writeln("Starting VM: ", vmName);
-        execute(["just", "start-vm", vmName]);
-    };
+        auto type = args[1];
+        writeln("Applying home configuration from: ", type);
+        auto exec = execute!ProcessPipes( ["just", "switch-home", type], true, false, Redirect.stderrToStdout);
+        wait(exec.pid);
+    }
 }
 
-struct Params
+void startVM(string[] args)
 {
-
-    void setup()
+    if (args.length < 1 || args.length > 1)
     {
-
+        errorf("Usage: mcl config start-vm <vm-name>");
+        exit(1);
     }
+    else {
+        string vmName = args.front;
+        writeln("Starting VM: ", vmName);
+        execute(["just", "start-vm", vmName]);
+    };
 }

packages/mcl/src/src/mcl/commands/shard_matrix.d

@@ -18,7 +18,7 @@ import mcl.utils.json : toJSON;
 import mcl.utils.nix : nix;
 import mcl.utils.path : createResultDirs, resultDir, rootDir;
 
-export void shard_matrix()
+export void shard_matrix(string[] args)
 {
     const params = parseEnv!Params;
     auto matrix = generateShardMatrix();

packages/mcl/src/src/mcl/utils/process.d

@@ -4,22 +4,22 @@ import mcl.utils.test;
 
 import mcl.utils.tui : bold;
 
-import std.process : ProcessPipes;
+import std.process : ProcessPipes, Redirect;
 import std.string : split, strip;
 import core.sys.posix.unistd : geteuid;
 import std.json : JSONValue, parseJSON;
 
 bool isRoot() => geteuid() == 0;
 
-T execute(T = string)(string args, bool printCommand = true, bool returnErr = false) if (is(T == string) || is(T == ProcessPipes) || is(T == JSONValue))
+T execute(T = string)(string args, bool printCommand = true, bool returnErr = false, Redirect redirect = Redirect.all) if (is(T == string) || is(T == ProcessPipes) || is(T == JSONValue))
 {
-    return execute!T(args.split(" "), printCommand, returnErr);
+    return execute!T(args.strip.split(" "), printCommand, returnErr, redirect);
 }
-T execute(T = string)(string[] args, bool printCommand = true, bool returnErr = false) if (is(T == string) || is(T == ProcessPipes) || is(T == JSONValue))
+T execute(T = string)(string[] args, bool printCommand = true, bool returnErr = false, Redirect redirect = Redirect.all) if (is(T == string) || is(T == ProcessPipes) || is(T == JSONValue))
 {
     import std.exception : enforce;
     import std.format : format;
-    import std.process : pipeShell, wait, Redirect, escapeShellCommand;
+    import std.process : pipeShell, wait, escapeShellCommand;
     import std.logger : tracef, errorf, infof;
     import std.array : join;
     import std.algorithm : map;
@@ -31,7 +31,7 @@ T execute(T = string)(string[] args, bool printCommand = true, bool returnErr =
     {
         infof("\n$ `%s`", cmd.bold);
     }
-    auto res = pipeShell(cmd, Redirect.all);
+    auto res = pipeShell(cmd, redirect);
     static if (is(T == ProcessPipes))
     {
         return res;