From 2a437f3db8968b467493a14a81c69b40c4c16376 Mon Sep 17 00:00:00 2001
From: fccview <comm.campione@gmail.com>
Date: Tue, 26 Aug 2025 13:44:08 +0100
Subject: [PATCH] Fix script path bug and add support for pinned versions

---
 .github/workflows/docker-publish.yml         |   4 +-
 README.md                                    |  12 +-
 app/_components/modals/CreateTaskModal.tsx   |   4 +-
 app/_components/modals/SelectScriptModal.tsx |  16 ++-
 app/_server/actions/cronjobs/index.ts        |   4 +-
 app/_server/actions/scripts/index.ts         |  25 ++--
 app/_utils/scripts.ts                        |  19 ++-
 app/_utils/system/hostCrontab.ts             | 139 ++++++++++---------
 docker-compose.yml                           |   7 +-
 9 files changed, 132 insertions(+), 98 deletions(-)

diff --git a/.github/workflows/docker-publish.yml b/.github/workflows/docker-publish.yml
index cf7d6dd..71e0a69 100644
--- a/.github/workflows/docker-publish.yml
+++ b/.github/workflows/docker-publish.yml
@@ -2,8 +2,8 @@ name: Docker
 
 on:
   push:
-    branches: ["main", "legacy", "feature/*", "bugfix/*"]
-    tags: ["v*.*.*"]
+    branches: ["main", "legacy"]
+    tags: ["*"]
   pull_request:
     branches: ["main"]
 
diff --git a/README.md b/README.md
index a566ffd..d03bc2a 100644
--- a/README.md
+++ b/README.md
@@ -49,7 +49,7 @@ If you find my projects helpful and want to fuel my late-night coding sessions w
 ```bash
 services:
   cronjob-manager:
-    image: ghcr.io/fccview/cronmaster:main
+    image: ghcr.io/fccview/cronmaster:1.2.1
     container_name: cronmaster
     user: "root"
     ports:
@@ -59,7 +59,7 @@ services:
       - NODE_ENV=production
       - DOCKER=true
       - NEXT_PUBLIC_CLOCK_UPDATE_INTERVAL=30000
-      - NEXT_PUBLIC_HOST_PROJECT_DIR=/path/to/cronmaster/directory
+      - HOST_PROJECT_DIR=/path/to/cronmaster/directory
       # If docker struggles to find your crontab user, update this variable with it.
       # Obviously replace fccview with your user - find it with: ls -asl /var/spool/cron/crontabs/
       # - HOST_CRONTAB_USER=fccview
@@ -69,7 +69,7 @@ services:
 
       # These are needed if you want to keep your data on the host machine and not wihin the docker volume.
       # DO NOT change the location of ./scripts as all cronjobs that use custom scripts created via the app
-      # will target this foler (thanks to the NEXT_PUBLIC_HOST_PROJECT_DIR variable set above)
+      # will target this foler (thanks to the HOST_PROJECT_DIR variable set above)
       - ./scripts:/app/scripts
       - ./data:/app/data
       - ./snippets:/app/snippets
@@ -132,7 +132,7 @@ The following environment variables can be configured:
 | Variable                            | Default | Description                                                                                 |
 | ----------------------------------- | ------- | ------------------------------------------------------------------------------------------- |
 | `NEXT_PUBLIC_CLOCK_UPDATE_INTERVAL` | `30000` | Clock update interval in milliseconds (30 seconds)                                          |
-| `NEXT_PUBLIC_HOST_PROJECT_DIR`      | `N/A`   | Mandatory variable to make sure cron runs on the right path.                                |
+| `HOST_PROJECT_DIR`                  | `N/A`   | Mandatory variable to make sure cron runs on the right path.                                |
 | `DOCKER`                            | `false` | ONLY set this to true if you are runnign the app via docker, in the docker-compose.yml file |
 
 **Example**: To change the clock update interval to 60 seconds:
@@ -144,14 +144,14 @@ NEXT_PUBLIC_CLOCK_UPDATE_INTERVAL=60000 docker-compose up
 **Example**: Your `docker-compose.yml` file or repository are in `~/homelab/cronmaster/`
 
 ```bash
-NEXT_PUBLIC_HOST_PROJECT_DIR=/home/<your_user_here>/homelab/cronmaster
+HOST_PROJECT_DIR=/home/<your_user_here>/homelab/cronmaster
 ```
 
 ### Important Notes for Docker
 
 - Root user is required for cron operations and direct file access. There is no way around this, if you don't feel comfortable in running it as root feel free to run the app locally with `yarn install`, `yarn build` and `yarn start`
 - Crontab files are accessed directly via file system mounts at `/host/cron/crontabs` and `/host/crontab` for real-time reading and writing
-- `NEXT_PUBLIC_HOST_PROJECT_DIR` is required in order for the scripts created within the app to run properly
+- `HOST_PROJECT_DIR` is required in order for the scripts created within the app to run properly
 - The `DOCKER=true` environment variable enables direct file access mode for crontab operations. This is REQUIRED when running the application in docker mode.
 
 ## Usage
diff --git a/app/_components/modals/CreateTaskModal.tsx b/app/_components/modals/CreateTaskModal.tsx
index 5fc8d18..0f6a686 100644
--- a/app/_components/modals/CreateTaskModal.tsx
+++ b/app/_components/modals/CreateTaskModal.tsx
@@ -58,10 +58,10 @@ export function CreateTaskModal({
     loadScriptContent();
   }, [selectedScript]);
 
-  const handleScriptSelect = (script: Script) => {
+  const handleScriptSelect = async (script: Script) => {
     onFormChange({
       selectedScriptId: script.id,
-      command: getHostScriptPath(script.filename),
+      command: await getHostScriptPath(script.filename),
     });
   };
 
diff --git a/app/_components/modals/SelectScriptModal.tsx b/app/_components/modals/SelectScriptModal.tsx
index a614e9d..c7af499 100644
--- a/app/_components/modals/SelectScriptModal.tsx
+++ b/app/_components/modals/SelectScriptModal.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { useState } from "react";
+import { useEffect, useState } from "react";
 import { Modal } from "../ui/Modal";
 import { Button } from "../ui/Button";
 import { Input } from "../ui/Input";
@@ -27,6 +27,18 @@ export function SelectScriptModal({
   const [searchQuery, setSearchQuery] = useState("");
   const [previewScript, setPreviewScript] = useState<Script | null>(null);
   const [previewContent, setPreviewContent] = useState<string>("");
+  const [hostScriptPath, setHostScriptPath] = useState<string>("");
+
+  useEffect(() => {
+    const fetchHostScriptPath = async () => {
+      const path = await getHostScriptPath(previewScript?.filename || "");
+      setHostScriptPath(path);
+    };
+
+    if (previewScript) {
+      fetchHostScriptPath();
+    }
+  }, [previewScript]);
 
   const filteredScripts = scripts.filter(
     (script) =>
@@ -156,7 +168,7 @@ export function SelectScriptModal({
                     </div>
                     <div className="bg-muted/30 p-3 rounded border border-border/30">
                       <code className="text-sm font-mono text-foreground break-all">
-                        {getHostScriptPath(previewScript.filename)}
+                        {hostScriptPath}
                       </code>
                     </div>
                   </div>
diff --git a/app/_server/actions/cronjobs/index.ts b/app/_server/actions/cronjobs/index.ts
index b2943d4..de4894d 100644
--- a/app/_server/actions/cronjobs/index.ts
+++ b/app/_server/actions/cronjobs/index.ts
@@ -19,8 +19,6 @@ export async function fetchCronJobs(): Promise<CronJob[]> {
   }
 }
 
-
-
 export async function createCronJob(
   formData: FormData
 ): Promise<{ success: boolean; message: string }> {
@@ -42,7 +40,7 @@ export async function createCronJob(
       const selectedScript = scripts.find((s) => s.id === selectedScriptId);
 
       if (selectedScript) {
-        finalCommand = getScriptPath(selectedScript.filename);
+        finalCommand = await getScriptPath(selectedScript.filename);
       } else {
         return { success: false, message: "Selected script not found" };
       }
diff --git a/app/_server/actions/scripts/index.ts b/app/_server/actions/scripts/index.ts
index f05b6d7..fa3e6c4 100644
--- a/app/_server/actions/scripts/index.ts
+++ b/app/_server/actions/scripts/index.ts
@@ -37,29 +37,32 @@ async function generateUniqueFilename(baseName: string): Promise<string> {
 }
 
 async function ensureScriptsDirectory() {
-  if (!existsSync(SCRIPTS_DIR)) {
-    await mkdir(SCRIPTS_DIR, { recursive: true });
+  const scriptsDir = await SCRIPTS_DIR();
+  if (!existsSync(scriptsDir)) {
+    await mkdir(scriptsDir, { recursive: true });
   }
 }
 
 async function ensureHostScriptsDirectory() {
-  const isDocker = process.env.DOCKER === "true";
-  const hostScriptsDir = isDocker
-    ? "/app/scripts"
-    : join(process.cwd(), "scripts");
+  const hostProjectDir = process.env.HOST_PROJECT_DIR || process.cwd();
+
+  const hostScriptsDir = join(hostProjectDir, "scripts");
   if (!existsSync(hostScriptsDir)) {
     await mkdir(hostScriptsDir, { recursive: true });
   }
 }
 
 async function saveScriptFile(filename: string, content: string) {
+  const isDocker = process.env.DOCKER === "true";
+  const scriptsDir = isDocker ? "/app/scripts" : await SCRIPTS_DIR();
   await ensureScriptsDirectory();
-  const scriptPath = join(SCRIPTS_DIR, filename);
+
+  const scriptPath = join(scriptsDir, filename);
   await writeFile(scriptPath, content, "utf8");
 }
 
 async function deleteScriptFile(filename: string) {
-  const scriptPath = join(SCRIPTS_DIR, filename);
+  const scriptPath = join(await SCRIPTS_DIR(), filename);
   if (existsSync(scriptPath)) {
     await unlink(scriptPath);
   }
@@ -226,7 +229,11 @@ export async function cloneScript(
 
 export async function getScriptContent(filename: string): Promise<string> {
   try {
-    const scriptPath = join(SCRIPTS_DIR, filename);
+    const isDocker = process.env.DOCKER === "true";
+    const scriptPath = isDocker
+      ? join("/app/scripts", filename)
+      : join(process.cwd(), "scripts", filename);
+
     if (existsSync(scriptPath)) {
       const content = await readFile(scriptPath, "utf8");
       const lines = content.split("\n");
diff --git a/app/_utils/scripts.ts b/app/_utils/scripts.ts
index c3c7f11..768bce9 100644
--- a/app/_utils/scripts.ts
+++ b/app/_utils/scripts.ts
@@ -1,15 +1,22 @@
+"use server";
+
 import { join } from "path";
 
 const isDocker = process.env.DOCKER === "true";
-const SCRIPTS_DIR = isDocker ? "/app/scripts" : join(process.cwd(), "scripts");
+const SCRIPTS_DIR = async () => {
+  if (isDocker && process.env.HOST_PROJECT_DIR) {
+    return `${process.env.HOST_PROJECT_DIR}/scripts`;
+  }
+  return join(process.cwd(), "scripts");
+};
 
-export function getScriptPath(filename: string): string {
-  return join(SCRIPTS_DIR, filename);
+export async function getScriptPath(filename: string): Promise<string> {
+  return join(await SCRIPTS_DIR(), filename);
 }
 
-export function getHostScriptPath(filename: string): string {
-  const hostProjectDir =
-    process.env.NEXT_PUBLIC_HOST_PROJECT_DIR || process.cwd();
+export async function getHostScriptPath(filename: string): Promise<string> {
+  const hostProjectDir = process.env.HOST_PROJECT_DIR || process.cwd();
+
   const hostScriptsDir = join(hostProjectDir, "scripts");
   return `bash ${join(hostScriptsDir, filename)}`;
 }
diff --git a/app/_utils/system/hostCrontab.ts b/app/_utils/system/hostCrontab.ts
index 5de02a0..5dde5b1 100644
--- a/app/_utils/system/hostCrontab.ts
+++ b/app/_utils/system/hostCrontab.ts
@@ -4,80 +4,89 @@ import { promisify } from "util";
 const execAsync = promisify(exec);
 
 async function execHostCrontab(command: string): Promise<string> {
-    try {
-        const { stdout } = await execAsync(
-            `nsenter -t 1 -m -u -i -n -p sh -c "${command}"`
-        );
-        return stdout;
-    } catch (error: any) {
-        console.error("Error executing host crontab command:", error);
-        throw error;
-    }
+  try {
+    const { stdout } = await execAsync(
+      `nsenter -t 1 -m -u -i -n -p sh -c "${command}"`
+    );
+    return stdout;
+  } catch (error: any) {
+    console.error("Error executing host crontab command:", error);
+    throw error;
+  }
 }
 
 async function getTargetUser(): Promise<string> {
-    try {
-        if (process.env.HOST_CRONTAB_USER) {
-            return process.env.HOST_CRONTAB_USER;
-        }
-
-        const { stdout } = await execAsync('stat -c "%U" /var/run/docker.sock');
-        const dockerSocketOwner = stdout.trim();
-
-        if (dockerSocketOwner === 'root') {
-            try {
-                const projectDir = process.env.NEXT_PUBLIC_HOST_PROJECT_DIR;
-                if (projectDir) {
-                    const dirOwner = await execHostCrontab(`stat -c "%U" "${projectDir}"`);
-                    return dirOwner.trim();
-                }
-            } catch (error) {
-                console.warn("Could not detect user from project directory:", error);
-            }
-
-            try {
-                const users = await execHostCrontab('getent passwd | grep ":/home/" | head -1 | cut -d: -f1');
-                const firstUser = users.trim();
-                if (firstUser) {
-                    return firstUser;
-                }
-            } catch (error) {
-                console.warn("Could not detect user from passwd:", error);
-            }
-
-            return 'root';
-        }
-
-        return dockerSocketOwner;
-    } catch (error) {
-        console.error("Error detecting target user:", error);
-        return 'root';
+  try {
+    if (process.env.HOST_CRONTAB_USER) {
+      return process.env.HOST_CRONTAB_USER;
     }
+
+    const { stdout } = await execAsync('stat -c "%U" /var/run/docker.sock');
+    const dockerSocketOwner = stdout.trim();
+
+    if (dockerSocketOwner === "root") {
+      try {
+        const projectDir = process.env.HOST_PROJECT_DIR;
+
+        if (projectDir) {
+          const dirOwner = await execHostCrontab(
+            `stat -c "%U" "${projectDir}"`
+          );
+          return dirOwner.trim();
+        }
+      } catch (error) {
+        console.warn("Could not detect user from project directory:", error);
+      }
+
+      try {
+        const users = await execHostCrontab(
+          'getent passwd | grep ":/home/" | head -1 | cut -d: -f1'
+        );
+        const firstUser = users.trim();
+        if (firstUser) {
+          return firstUser;
+        }
+      } catch (error) {
+        console.warn("Could not detect user from passwd:", error);
+      }
+
+      return "root";
+    }
+
+    return dockerSocketOwner;
+  } catch (error) {
+    console.error("Error detecting target user:", error);
+    return "root";
+  }
 }
 
 export async function readHostCrontab(): Promise<string> {
-    try {
-        const user = await getTargetUser();
-        return await execHostCrontab(`crontab -l -u ${user} 2>/dev/null || echo ""`);
-    } catch (error) {
-        console.error("Error reading host crontab:", error);
-        return "";
-    }
+  try {
+    const user = await getTargetUser();
+    return await execHostCrontab(
+      `crontab -l -u ${user} 2>/dev/null || echo ""`
+    );
+  } catch (error) {
+    console.error("Error reading host crontab:", error);
+    return "";
+  }
 }
 
 export async function writeHostCrontab(content: string): Promise<boolean> {
-    try {
-        const user = await getTargetUser();
-        let finalContent = content;
-        if (!finalContent.endsWith('\n')) {
-            finalContent += '\n';
-        }
-
-        const base64Content = Buffer.from(finalContent).toString('base64');
-        await execHostCrontab(`echo '${base64Content}' | base64 -d | crontab -u ${user} -`);
-        return true;
-    } catch (error) {
-        console.error("Error writing host crontab:", error);
-        return false;
+  try {
+    const user = await getTargetUser();
+    let finalContent = content;
+    if (!finalContent.endsWith("\n")) {
+      finalContent += "\n";
     }
+
+    const base64Content = Buffer.from(finalContent).toString("base64");
+    await execHostCrontab(
+      `echo '${base64Content}' | base64 -d | crontab -u ${user} -`
+    );
+    return true;
+  } catch (error) {
+    console.error("Error writing host crontab:", error);
+    return false;
+  }
 }
diff --git a/docker-compose.yml b/docker-compose.yml
index 9a66162..d2dc8ab 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -5,12 +5,13 @@ services:
     user: "root"
     ports:
       # Feel free to change port, 3000 is very common so I like to map it to something else
-      - "40124:3000"
+      - "40123:3000"
     environment:
       - NODE_ENV=production
       - DOCKER=true
+      # Legacy used to be NEXT_PUBLIC_HOST_PROJECT_DIR, this was causing issues on runtime.
+      - HOST_PROJECT_DIR=/path/to/cronmaster/directory
       - NEXT_PUBLIC_CLOCK_UPDATE_INTERVAL=30000
-      - NEXT_PUBLIC_HOST_PROJECT_DIR=/path/to/cronmaster/directory
       # If docker struggles to find your crontab user, update this variable with it.
       # Obviously replace fccview with your user - find it with: ls -asl /var/spool/cron/crontabs/
       # - HOST_CRONTAB_USER=fccview
@@ -20,7 +21,7 @@ services:
 
       # These are needed if you want to keep your data on the host machine and not wihin the docker volume.
       # DO NOT change the location of ./scripts as all cronjobs that use custom scripts created via the app
-      # will target this foler (thanks to the NEXT_PUBLIC_HOST_PROJECT_DIR variable set above)
+      # will target this folder (thanks to the HOST_PROJECT_DIR variable set above)
       - ./scripts:/app/scripts
       - ./data:/app/data
       - ./snippets:/app/snippets