dataset rename and add rules

ui/src/app/api/datasets/rename/route.ts

@@ -0,0 +1,60 @@
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import { getDatasetsRoot } from '@/server/settings';
+
+const sanitizeSegment = (value: string): string => {
+  if (!value || typeof value !== 'string') {
+    return '';
+  }
+
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '');
+};
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { currentName, newName } = body ?? {};
+
+    if (!currentName || typeof currentName !== 'string') {
+      return NextResponse.json({ error: 'Current dataset name is required' }, { status: 400 });
+    }
+
+    if (!newName || typeof newName !== 'string') {
+      return NextResponse.json({ error: 'New dataset name is required' }, { status: 400 });
+    }
+
+    const datasetsRoot = await getDatasetsRoot();
+
+    const sanitizedCurrent = sanitizeSegment(currentName);
+    const currentPath = path.join(datasetsRoot, sanitizedCurrent);
+
+    if (!fs.existsSync(currentPath)) {
+      return NextResponse.json({ error: `Dataset '${currentName}' not found` }, { status: 404 });
+    }
+
+    const sanitizedNew = sanitizeSegment(newName);
+    if (!sanitizedNew) {
+      return NextResponse.json({ error: 'New dataset name is invalid' }, { status: 400 });
+    }
+
+    if (sanitizedCurrent === sanitizedNew) {
+      return NextResponse.json({ success: true, name: sanitizedCurrent, path: currentPath });
+    }
+
+    const newPath = path.join(datasetsRoot, sanitizedNew);
+    if (fs.existsSync(newPath)) {
+      return NextResponse.json({ error: `Dataset '${sanitizedNew}' already exists` }, { status: 409 });
+    }
+
+    fs.renameSync(currentPath, newPath);
+
+    return NextResponse.json({ success: true, name: sanitizedNew, path: newPath });
+  } catch (error: any) {
+    console.error('Dataset rename error:', error);
+    return NextResponse.json({ error: error?.message || 'Failed to rename dataset' }, { status: 500 });
+  }
+}

ui/src/app/jobs/new/SimplifiedJob.tsx

@@ -12,7 +12,7 @@ import HFJobsWorkflow from '@/components/HFJobsWorkflow';
 import { Button } from '@headlessui/react';
 import { ChevronDown, ChevronUp, Upload } from 'lucide-react';
 import { apiClient } from '@/utils/api';
-import { addUserDataset, updateUserDatasetPath } from '@/utils/storage/datasetStorage';
+import { addUserDataset, updateUserDatasetPath, renameUserDataset } from '@/utils/storage/datasetStorage';
 import DatasetPreviewGrid from '@/components/DatasetPreviewGrid';
 
 type DatasetMode = 'upload' | 'existing';
@@ -54,6 +54,13 @@ const buildDatasetName = (base: string, suffix: string) => {
   return `${slug}${suffix}`;
 };
 
+const sanitizeDatasetName = (value: string) =>
+  value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, 128);
+
 type SimplifiedJobProps = {
   jobConfig: JobConfig;
   setJobConfig: (value: any, key: string) => void;
@@ -155,6 +162,8 @@ export default function SimplifiedJob({
   const [controlUploadError, setControlUploadError] = useState<string | null>(null);
   const [trainPreviewRefresh, setTrainPreviewRefresh] = useState(0);
   const [controlPreviewRefresh, setControlPreviewRefresh] = useState(0);
+  const [isRenamingTrainDataset, setIsRenamingTrainDataset] = useState(false);
+  const [isRenamingControlDataset, setIsRenamingControlDataset] = useState(false);
 
   const modelArch = useMemo(() => {
     return modelArchs.find(arch => arch.name === process.model.arch);
@@ -382,12 +391,10 @@ export default function SimplifiedJob({
       controlDatasetPath,
       controlDatasetResolvedName,
       ensureDataset,
-      setControlPreviewRefresh,
       setJobConfig,
       trainDatasetName,
       trainDatasetPath,
       trainDatasetResolvedName,
-      setTrainPreviewRefresh,
     ],
   );
 
@@ -498,7 +505,7 @@ export default function SimplifiedJob({
       return;
     }
     const currentFolder = dataset.folder_path;
-    if (!currentFolder) {
+    if (!currentFolder || currentFolder === defaultDatasetConfig.folder_path) {
       return;
     }
     const match = existingOptions.find(option => option.value === currentFolder);
@@ -521,6 +528,116 @@ export default function SimplifiedJob({
     }
   }, [existingOptions, dataset.control_path, controlDatasetResolvedName]);
 
+  const handleDatasetRename = useCallback(
+    async (target: 'train' | 'control') => {
+      const isTrain = target === 'train';
+      const resolvedName = isTrain ? trainDatasetResolvedName : controlDatasetResolvedName;
+      const desiredName = (isTrain ? trainDatasetName : controlDatasetName) || '';
+      const datasetPath = isTrain ? trainDatasetPath : controlDatasetPath;
+
+      if (!resolvedName || !datasetPath) {
+        return;
+      }
+
+      const trimmedDesired = desiredName.trim();
+      const sanitizedDesired = sanitizeDatasetName(trimmedDesired);
+
+      if (!trimmedDesired || !sanitizedDesired) {
+        if (isTrain) {
+          setTrainDatasetName(resolvedName);
+        } else {
+          setControlDatasetName(resolvedName);
+        }
+        return;
+      }
+
+      if (sanitizedDesired === resolvedName) {
+        if (isTrain && sanitizedDesired !== trainDatasetName) {
+          setTrainDatasetName(sanitizedDesired);
+        }
+        if (!isTrain && sanitizedDesired !== controlDatasetName) {
+          setControlDatasetName(sanitizedDesired);
+        }
+        return;
+      }
+
+      if ((isTrain && isRenamingTrainDataset) || (!isTrain && isRenamingControlDataset)) {
+        return;
+      }
+
+      try {
+        if (isTrain) {
+          setIsRenamingTrainDataset(true);
+        } else {
+          setIsRenamingControlDataset(true);
+        }
+
+        const response = await apiClient
+          .post('/api/datasets/rename', {
+            currentName: resolvedName,
+            newName: sanitizedDesired,
+          })
+          .then(res => res.data);
+
+        if (!response?.success) {
+          throw new Error(response?.error || 'Rename failed');
+        }
+
+        const updatedName = response.name as string;
+        const updatedPath = response.path as string;
+
+        if (isTrain) {
+          renameUserDataset(resolvedName, updatedName, updatedPath);
+          updateUserDatasetPath(updatedName, updatedPath);
+          setTrainDatasetResolvedName(updatedName);
+          setTrainDatasetPath(updatedPath);
+          setTrainDatasetName(updatedName);
+          setJobConfig(updatedPath, 'config.process[0].datasets[0].folder_path');
+          setTrainPreviewRefresh(prev => prev + 1);
+          setTrainUploadInfo(`Renamed dataset to ${updatedName}`);
+          setTrainUploadError(null);
+        } else {
+          renameUserDataset(resolvedName, updatedName, updatedPath);
+          updateUserDatasetPath(updatedName, updatedPath);
+          setControlDatasetResolvedName(updatedName);
+          setControlDatasetPath(updatedPath);
+          setControlDatasetName(updatedName);
+          setJobConfig(updatedPath, 'config.process[0].datasets[0].control_path');
+          setControlPreviewRefresh(prev => prev + 1);
+          setControlUploadInfo(`Renamed dataset to ${updatedName}`);
+          setControlUploadError(null);
+        }
+      } catch (error: any) {
+        console.error('Dataset rename failed:', error);
+        const message = error?.response?.data?.error || error?.message || 'Failed to rename dataset';
+        if (isTrain) {
+          setTrainDatasetName(resolvedName);
+          setTrainUploadError(message);
+        } else {
+          setControlDatasetName(resolvedName);
+          setControlUploadError(message);
+        }
+      } finally {
+        if (isTrain) {
+          setIsRenamingTrainDataset(false);
+        } else {
+          setIsRenamingControlDataset(false);
+        }
+      }
+    },
+    [
+      controlDatasetName,
+      controlDatasetPath,
+      controlDatasetResolvedName,
+      isRenamingControlDataset,
+      isRenamingTrainDataset,
+      setJobConfig,
+      trainDatasetName,
+      trainDatasetPath,
+      trainDatasetResolvedName,
+    ],
+  );
+
   return (
     <form onSubmit={handleSubmit} className="space-y-8">
       <Card title="Training Setup">
@@ -675,6 +792,7 @@ export default function SimplifiedJob({
                 setTrainDatasetNameTouched(true);
               }}
               placeholder="my-training-dataset"
+              onBlur={() => handleDatasetRename('train')}
             />
             <div
               {...trainDropzone.getRootProps({
@@ -765,15 +883,16 @@ export default function SimplifiedJob({
 
             {controlDatasetMode === 'upload' ? (
               <div className="space-y-4">
-                <TextInput
-                  label="Control Dataset Name"
-                  value={controlDatasetName}
-                  onChange={value => {
-                    setControlDatasetName(value);
-                    setControlDatasetNameTouched(true);
-                  }}
-                  placeholder="my-control-data"
-                />
+            <TextInput
+              label="Control Dataset Name"
+              value={controlDatasetName}
+              onChange={value => {
+                setControlDatasetName(value);
+                setControlDatasetNameTouched(true);
+              }}
+              placeholder="my-control-data"
+              onBlur={() => handleDatasetRename('control')}
+            />
                 <div
                   {...controlDropzone.getRootProps({
                     className:

ui/src/components/DatasetImageCard.tsx

@@ -210,6 +210,7 @@ const DatasetImageCard: React.FC<DatasetImageCardProps> = ({
               className="w-full bg-transparent resize-none outline-none focus:ring-0 focus:outline-none"
               value={caption}
               rows={3}
+              placeholder="Type your caption"
               onChange={e => setCaption(e.target.value)}
               onKeyDown={handleKeyDown}
             />

ui/src/components/DatasetPreviewGrid.tsx

@@ -88,10 +88,10 @@ export default function DatasetPreviewGrid({
         return (
           <div
             className={classNames(
-              'grid gap-4',
+              'grid gap-3 sm:gap-4',
               compact
-                ? 'grid-cols-1 sm:grid-cols-2'
-                : 'grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4',
+                ? 'grid-cols-2 sm:grid-cols-3 lg:grid-cols-4 xl:grid-cols-5'
+                : 'grid-cols-2 sm:grid-cols-3 md:grid-cols-4 xl:grid-cols-5 2xl:grid-cols-6',
             )}
           >
             {items.map(item => (

ui/src/components/HFJobsWorkflow.tsx

@@ -157,7 +157,7 @@ export default function HFJobsWorkflow({ jobConfig, onComplete, hackathonEligibl
   const [hardware, setHardware] = useState(settings.HF_JOBS_DEFAULT_HARDWARE || 'a100-large');
   const [namespace, setNamespace] = useState(settings.HF_JOBS_NAMESPACE || '');
   const [autoUpload, setAutoUpload] = useState(true);
-  const [participateHackathon, setParticipateHackathon] = useState(() => hackathonEligible);
+  const [participateHackathon, setParticipateHackathon] = useState(true);
   const [participationTouched, setParticipationTouched] = useState(false);
 
   const requiresControlImages = (() => {
@@ -479,30 +479,37 @@ export default function HFJobsWorkflow({ jobConfig, onComplete, hackathonEligibl
           <Card title="Validate HF Token">
             <div className="space-y-4">
               {hackathonEligible && (
-                <Checkbox
-                  label={
-                    <span>
-                      Participating in LoRA Frenzi? If so, keep your training at 5,000 steps or fewer and join this
-                      <a
-                        href="https://huggingface.co/organizations/lora-training-frenzi/share/kEyyVNQXBPWqmARdwHFVdIiFqqONHZPOtz"
-                        target="_blank"
-                        rel="noopener noreferrer"
-                        className="text-blue-400 underline mx-1"
-                      >
-                        organization
-                      </a>
-                      before starting your job.
-                    </span>
-                  }
-                  checked={participateHackathon}
-                  onChange={value => {
-                    setParticipationTouched(true);
-                    setParticipateHackathon(value);
-                  }}
-                />
+                <div className="space-y-3">
+                  <Checkbox
+                    label="Participate in LoRA Frenzi"
+                    checked={participateHackathon}
+                    onChange={value => {
+                      setParticipationTouched(true);
+                      setParticipateHackathon(value);
+                    }}
+                  />
+                  <ul className="text-xs text-gray-400 space-y-1 pl-4 list-disc">
+                    <li>Maximum 5,000 training steps per run</li>
+                    <li>Jobs longer than 6 hours will time out</li>
+                    <li>Train only one LoRA simultaneously</li>
+                    <li>Do not train on likenesses without consent or NSFW content</li>
+                  </ul>
+                  <p className="text-xs text-gray-400">
+                    Join the
+                    <a
+                      href="https://huggingface.co/organizations/lora-training-frenzi/share/kEyyVNQXBPWqmARdwHFVdIiFqqONHZPOtz"
+                      target="_blank"
+                      rel="noopener noreferrer"
+                      className="text-blue-400 underline mx-1"
+                    >
+                      LoRA Frenzi organization
+                    </a>
+                    before submitting your job.
+                  </p>
+                </div>
               )}
               <p className="text-sm text-gray-400">
-                First, let's validate your Hugging Face token and get your username for dataset uploads.
+                To continue, accept the rules above and we'll validate your Hugging Face token.
               </p>
               
               {validationResult && (
@@ -515,10 +522,14 @@ export default function HFJobsWorkflow({ jobConfig, onComplete, hackathonEligibl
 
               <Button
                 onClick={validateToken}
-                disabled={loading || !(authToken || settings.HF_TOKEN)}
+                disabled={
+                  loading ||
+                  !(authToken || settings.HF_TOKEN) ||
+                  (hackathonEligible && !participateHackathon)
+                }
                 className="w-full px-4 py-2 bg-blue-600 hover:bg-blue-700 text-white rounded disabled:opacity-50"
               >
-                {loading ? 'Validating...' : 'Validate Token'}
+                {loading ? 'Validating...' : 'I accept the rules, get started'}
               </Button>
             </div>
           </Card>

ui/src/components/formInputs.tsx

@@ -28,10 +28,22 @@ export interface TextInputProps extends InputProps {
   onChange: (value: string) => void;
   type?: 'text' | 'password';
   disabled?: boolean;
+  onBlur?: () => void;
 }
 
 export const TextInput = forwardRef<HTMLInputElement, TextInputProps>((props: TextInputProps, ref) => {
-  const { label, value, onChange, placeholder, required, disabled, type = 'text', className, docKey = null } = props;
+  const {
+    label,
+    value,
+    onChange,
+    placeholder,
+    required,
+    disabled,
+    onBlur,
+    type = 'text',
+    className,
+    docKey = null,
+  } = props;
   let { doc } = props;
   if (!doc && docKey) {
     doc = getDoc(docKey);
@@ -55,6 +67,7 @@ export const TextInput = forwardRef<HTMLInputElement, TextInputProps>((props: Te
         onChange={e => {
           if (!disabled) onChange(e.target.value);
         }}
+        onBlur={onBlur}
         className={`${inputClasses} ${disabled ? 'opacity-30 cursor-not-allowed' : ''}`}
         placeholder={placeholder}
         required={required}

ui/src/utils/storage/datasetStorage.ts

@@ -128,6 +128,37 @@ export const updateUserDatasetPath = (datasetName: string, datasetPath: string)
   writeDatasets(updated);
 };
 
+export const renameUserDataset = (currentName: string, newName: string, datasetPath: string) => {
+  if (!usingBrowserDb) {
+    return;
+  }
+  const normalizedCurrent = sanitizeName(currentName);
+  const normalizedNew = sanitizeName(newName);
+  if (!normalizedCurrent || !normalizedNew) {
+    return;
+  }
+
+  const entries = listUserDatasetEntries();
+  const updated = entries
+    .map(entry => {
+      if (sanitizeName(entry.name) === normalizedCurrent) {
+        return {
+          name: newName,
+          path: datasetPath || entry.path,
+        };
+      }
+      return entry;
+    })
+    .filter(entry => Boolean(entry?.name));
+
+  const hasNew = updated.some(entry => sanitizeName(entry.name) === normalizedNew);
+  if (!hasNew) {
+    updated.push({ name: newName, path: datasetPath || '' });
+  }
+
+  writeDatasets(updated);
+};
+
 export const removeUserDataset = (datasetName: string) => {
   if (!usingBrowserDb) {
     return;