diff --git a/package.json b/package.json
index 71c49ec..36a7c4c 100644
--- a/package.json
+++ b/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "scheduler-ui-by-moda20",
+  "name": "type-scheduler-ui-by-moda20",
   "description": "The frontend for the scheduler backend",
   "private": false,
   "version": "0.0.0-pre-alpha",
@@ -24,19 +24,22 @@
     "@icons-pack/react-simple-icons": "^13.8.0",
     "@melloware/react-logviewer": "^6.3.5",
     "@monaco-editor/react": "^4.7.0",
+    "@radix-ui/primitive": "1.1.2",
     "@radix-ui/react-accordion": "^1.2.12",
     "@radix-ui/react-alert-dialog": "^1.1.2",
     "@radix-ui/react-avatar": "^1.1.10",
     "@radix-ui/react-checkbox": "^1.1.3",
+    "@radix-ui/react-compose-refs": "1.1.2",
     "@radix-ui/react-dialog": "^1.1.6",
     "@radix-ui/react-dropdown-menu": "^2.1.2",
     "@radix-ui/react-icons": "^1.3.2",
     "@radix-ui/react-label": "^2.1.4",
     "@radix-ui/react-popover": "^1.1.6",
+    "@radix-ui/react-primitive": "2.1.2",
     "@radix-ui/react-scroll-area": "^1.2.2",
     "@radix-ui/react-select": "^2.1.4",
     "@radix-ui/react-separator": "^1.1.8",
-    "@radix-ui/react-slot": "^1.2.4",
+    "@radix-ui/react-slot": "^1.3.0",
     "@radix-ui/react-switch": "^1.2.6",
     "@radix-ui/react-tabs": "^1.1.3",
     "@radix-ui/react-toast": "^1.2.2",
@@ -47,6 +50,7 @@
     "@tanstack/react-query": "^5.90.21",
     "@tanstack/react-table": "^8.20.5",
     "@tanstack/react-virtual": "^3.13.18",
+    "@types/lodash-es": "^4.17.12",
     "ansi-colors": "^4.1.3",
     "axios": "^1.10.0",
     "class-variance-authority": "^0.7.1",
@@ -58,6 +62,7 @@
     "fuse.js": "^7.4.0",
     "history": "^5.3.0",
     "js-cookie": "^3.0.5",
+    "lodash-es": "^4.18.1",
     "lucide": "^0.474.0",
     "lucide-react": "^0.453.0",
     "moment": "^2.30.1",
diff --git a/src/components/custom/DrawerMenuConfigurator.tsx b/src/components/custom/DrawerMenuConfigurator.tsx
index a736b3a..9b20465 100644
--- a/src/components/custom/DrawerMenuConfigurator.tsx
+++ b/src/components/custom/DrawerMenuConfigurator.tsx
@@ -16,6 +16,7 @@ import { verifyUserConnection } from "@/utils/authUtils"
 import { ButtonWithTooltip } from "@/components/custom/general/ButtonWithTooltip"
 
 export default function DrawerMenuConfigurator() {
+  const [open, setOpen] = useState(false)
   useHotkeys(
     ["ctrl+l", "meta+l"],
     () => {
@@ -25,6 +26,7 @@ export default function DrawerMenuConfigurator() {
     },
     {
       preventDefault: true,
+      enabled: open,
     },
   )
 
@@ -69,6 +71,7 @@ export default function DrawerMenuConfigurator() {
     {
       enableOnFormTags: true,
       enableOnContentEditable: true,
+      enabled: open,
     },
   )
 
@@ -88,6 +91,7 @@ export default function DrawerMenuConfigurator() {
       side={"right"}
       title={"Configuration"}
       description={"Update server configuration"}
+      onOpenChange={setOpen}
       trigger={
         <Button
           variant={"outline"}
diff --git a/src/components/custom/ManagedSelect.tsx b/src/components/custom/ManagedSelect.tsx
index 516ba3f..9916bb2 100644
--- a/src/components/custom/ManagedSelect.tsx
+++ b/src/components/custom/ManagedSelect.tsx
@@ -7,9 +7,18 @@ import {
   SelectValue,
 } from "@/components/ui/select"
 import useDialogueManager from "@/hooks/useDialogManager"
-import { useEffect, useState } from "react"
+import {
+  forwardRef,
+  useEffect,
+  useState,
+  type ElementRef,
+  useCallback,
+  useImperativeHandle,
+  useRef,
+} from "react"
 import { safeStringCast } from "@/utils/generalUtils"
 import { cn } from "@/lib/utils"
+import { useHotkeys } from "react-hotkeys-hook"
 
 export type ManagedSelectInputValue = {
   value?: string | boolean
@@ -32,11 +41,34 @@ export interface ManagedSelectProps {
   itemClassName?: string
 }
 
-export default function ManagedSelect(props: ManagedSelectProps) {
+const ManagedSelect = forwardRef<
+  ElementRef<typeof SelectTrigger>,
+  ManagedSelectProps
+>((props, ref) => {
   const { isDialogOpen, setDialogState } = useDialogueManager()
   const [parsedInputs, setParsedInputs] = useState<
     Array<ParsedManagedSelectInputValue>
   >([])
+  const innerRef = useRef<HTMLButtonElement>(null)
+  useImperativeHandle(ref, () => innerRef.current)
+  const hotkeyRef = useHotkeys(
+    ["enter"],
+    () => {
+      handleDialogState(!isDialogOpen)
+    },
+    {
+      ignoreModifiers: false,
+      preventDefault: true,
+    },
+  )
+
+  const refCallback = useCallback(
+    (elem: HTMLButtonElement) => {
+      innerRef.current = elem
+      hotkeyRef(elem)
+    },
+    [hotkeyRef],
+  )
 
   useEffect(() => {
     setParsedInputs(
@@ -49,24 +81,43 @@ export default function ManagedSelect(props: ManagedSelectProps) {
     )
   }, [props.inputOptions])
 
+  const handleDialogState = useCallback(
+    (open: boolean) => {
+      if (open) {
+        if (!props.disabled) {
+          setDialogState(true)
+        }
+      } else {
+        setDialogState(false)
+      }
+    },
+    [props.disabled, setDialogState],
+  )
+
   return (
     <Select
       open={isDialogOpen}
-      onOpenChange={v => setDialogState(v)}
+      onOpenChange={v => handleDialogState(v)}
       onValueChange={v => {
         const targetValue = props.inputOptions.find(
           e => safeStringCast(e.value) === v,
         )
         props.onChange(props.exportOnlyValue ? targetValue?.value : targetValue)
-        setDialogState(false)
+        handleDialogState(false)
       }}
       defaultValue={safeStringCast(props.defaultValue)}
       disabled={props.disabled}
     >
       <SelectTrigger
+        ref={refCallback}
+        onKeyDownCapture={e => {
+          if (e.key === "Enter") {
+            e.preventDefault()
+          }
+        }}
         onClick={v => {
           v.preventDefault()
-          setDialogState(true)
+          handleDialogState(true)
         }}
         className={cn(props.className)}
       >
@@ -91,4 +142,8 @@ export default function ManagedSelect(props: ManagedSelectProps) {
       </SelectContent>
     </Select>
   )
-}
+})
+
+ManagedSelect.displayName = "ManagedSelect"
+
+export default ManagedSelect
diff --git a/src/components/custom/SearchBar.tsx b/src/components/custom/SearchBar.tsx
index a370064..a65cf78 100644
--- a/src/components/custom/SearchBar.tsx
+++ b/src/components/custom/SearchBar.tsx
@@ -29,6 +29,7 @@ import {
 } from "@/app/reducers/uiReducer"
 import { useNavigate } from "react-router"
 import { useAppDispatch, useAppSelector } from "@/app/hooks"
+import { cn } from "@/lib/utils"
 
 export interface SearchBarProps {
   trigger?: ReactNode
@@ -36,7 +37,7 @@ export interface SearchBarProps {
 
 export default function SearchBar({ trigger }: SearchBarProps) {
   const inputRef = useRef<HTMLInputElement>(null)
-  const { isDialogOpen, setDialogState } = useDialogueManager()
+  const { isDialogOpen, setDialogState, isTopOfTheStack } = useDialogueManager()
   const navigate = useNavigate()
   const dispatch = useAppDispatch()
   const routesList = useAppSelector(routes)
@@ -248,7 +249,12 @@ export default function SearchBar({ trigger }: SearchBarProps) {
                 inputGroup="commandActions"
                 modal={true}
               >
-                <CommandItem asChild className="rounded">
+                <CommandItem
+                  asChild
+                  className={cn("rounded", {
+                    "pointer-events-none": !isTopOfTheStack,
+                  })}
+                >
                   <div className="flex items-center justify-between">
                     <div className="flex flex-col gap-1">
                       <span>{job.name}</span>
diff --git a/src/components/custom/jobsTable/actionDropdown.tsx b/src/components/custom/jobsTable/actionDropdown.tsx
index 1d75d8f..b34fb0f 100644
--- a/src/components/custom/jobsTable/actionDropdown.tsx
+++ b/src/components/custom/jobsTable/actionDropdown.tsx
@@ -17,6 +17,7 @@ import {
   EllipsisVertical,
   EyeIcon,
   FileSliders,
+  LinkIcon,
   LogsIcon,
   Settings,
   Trash2Icon,
@@ -42,6 +43,11 @@ import { JobExecutionDialog } from "@/components/job-execution-dialog"
 import DrawerJobEvents from "@/components/custom/DrawerJobEvents"
 import DrawerFilePreview from "@/components/custom/DrawerFilePreview"
 import JobEventNotificationsDrawer from "@/components/custom/jobsTable/JobEvents/JobEventNotificationsDrawer"
+import { JobProxyLinkDialog } from "@/components/custom/system/JobProxyLinkDialog"
+import { cn } from "@/lib/utils"
+import { set, unset } from "lodash-es"
+import { safeJsonParse } from "@/utils/generalUtils"
+import { toast } from "@/hooks/use-toast"
 
 export interface ActionDropdownProps {
   columnsProps: tableColumnsProps
@@ -167,6 +173,29 @@ export default function ActionDropdown({
     return columnsProps.takeAction(row, jobActions.REFRESH)
   }, [row])
 
+  const updateProxyStrategy = useCallback(
+    (newStrategy?: string, specificProxyId?: string) => {
+      const { data: oldParam, error } = safeJsonParse(row.param || "{}")
+      if (error) {
+        toast({
+          title: "Failed to parse Job params. this is a JSON parsing issue.",
+          description: oldParam?.toString(),
+          variant: "destructive",
+        })
+      }
+      set(oldParam, "proxyConfig.proxyStrategy", newStrategy)
+      if (specificProxyId) {
+        set(oldParam, "proxyConfig.targetProxyId", specificProxyId)
+      } else {
+        unset(oldParam, "proxyConfig.targetProxyId")
+      }
+      return columnsProps.takeAction(row, jobActions.UPDATE, {
+        param: JSON.stringify(oldParam),
+      })
+    },
+    [row],
+  )
+
   const eventHandlers = useMemo(() => {
     try {
       const params = JSON.parse(row.param || "{}")
@@ -194,7 +223,10 @@ export default function ActionDropdown({
         )}
       </DropdownMenuTrigger>
       <DropdownMenuContent
-        className="bg-background w-auto"
+        tabIndex={!isTopOfTheStack ? -1 : 0}
+        className={cn("bg-background w-auto", {
+          "pointer-events-none": !isTopOfTheStack,
+        })}
         onEscapeKeyDown={handleEscapeDirectTrigger}
         {...dropdownContentProps}
       >
@@ -271,7 +303,7 @@ export default function ActionDropdown({
             >
               <DockIcon />
               <span>Custom run</span>
-              <DropdownMenuShortcut>⌘+⇧+E</DropdownMenuShortcut>
+              <DropdownMenuShortcut>⌘⇧E</DropdownMenuShortcut>
             </DropdownMenuItemExtended>
           </JobExecutionDialog>
           <DropdownMenuItemExtended
@@ -323,6 +355,22 @@ export default function ActionDropdown({
             modal={modal}
           />
         </DropdownMenuGroup>
+        <DropdownMenuGroup>
+          <JobProxyLinkDialog
+            jobDetails={row}
+            onProxyStrategyChange={updateProxyStrategy}
+          >
+            <DropdownMenuItemExtended
+              keyBinding="meta+shift+p"
+              onSelect={handleEventPrevention}
+              disabled={!isTopOfTheStack}
+            >
+              <LinkIcon />
+              <span>Linked Proxies</span>
+              <DropdownMenuShortcut>⌘⇧P</DropdownMenuShortcut>
+            </DropdownMenuItemExtended>
+          </JobProxyLinkDialog>
+        </DropdownMenuGroup>
         <DropdownMenuGroup>
           <DrawerLokiLogs
             jobName={row.name}
diff --git a/src/components/custom/system/JobProxyLinkDialog.tsx b/src/components/custom/system/JobProxyLinkDialog.tsx
new file mode 100644
index 0000000..367b8b0
--- /dev/null
+++ b/src/components/custom/system/JobProxyLinkDialog.tsx
@@ -0,0 +1,306 @@
+import { Button } from "@/components/ui/button"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "@/components/ui/dialog"
+import { z } from "zod"
+import { zodResolver } from "@hookform/resolvers/zod"
+import { useForm } from "react-hook-form"
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from "@/components/ui/form"
+import { LinkIcon } from "lucide-react"
+import { ComboBox } from "@/components/ui/combo-box"
+import { cn } from "@/lib/utils"
+import useDialogueManager from "@/hooks/useDialogManager"
+import {
+  JobProxyLinkUpdateSchema,
+  JobProxyLinkUpdateType,
+  ProxyActions,
+  ProxyStrategyOptionEnum,
+  ProxyStrategyOptions,
+} from "@/models/proxies"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import ConfirmationDialogAction from "@/components/confirmationDialogAction"
+import { MinusIcon } from "@radix-ui/react-icons"
+import type { jobsTableData } from "@/features/jobsTable/interfaces"
+import { useProxies } from "@/hooks/useProxies"
+import { useQuery } from "@tanstack/react-query"
+import { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import ButtonWithStrCut from "@/components/custom/general/ButtonWithStrCut"
+import ManagedSelect from "@/components/custom/ManagedSelect"
+import { Separator } from "@/components/ui/separator"
+
+import {
+  InputBase,
+  InputBaseAdornment,
+  InputBaseControl,
+  InputBaseInput,
+} from "@/components/ui/input-base"
+
+export interface ProxyLinkDialogProps {
+  children: React.ReactNode
+  jobDetails?: jobsTableData
+  onChange?: (value: JobProxyLinkUpdateType) => void
+  onProxyStrategyChange?: (value: string, proxyId?: string) => void
+  triggerClassName?: string
+}
+
+export function JobProxyLinkDialog({
+  children,
+  jobDetails,
+  onChange,
+  onProxyStrategyChange,
+  triggerClassName,
+}: ProxyLinkDialogProps) {
+  const { isDialogOpen, setDialogState } = useDialogueManager()
+  const strategySelectRef = useRef<HTMLButtonElement>(null)
+  const proxyConfig = useMemo(() => {
+    const jobParams = JSON.parse(jobDetails?.param ?? "{}")
+    return jobParams["proxyConfig"]
+  }, [jobDetails])
+
+  const { proxyItems, jobProxies, proxyActions } = useProxies()
+  const { data: jobProxyList, isLoading } = useQuery({
+    queryKey: ["proxies", jobDetails?.id],
+    queryFn: () => jobProxies(Number(jobDetails?.id)),
+    placeholderData: [],
+    select: data => {
+      form.setValue(
+        "proxies",
+        data.map(e => String(e.proxy_id)),
+      )
+      return data
+    },
+  })
+  const form = useForm<z.infer<typeof JobProxyLinkUpdateSchema>>({
+    resolver: zodResolver(JobProxyLinkUpdateSchema),
+    defaultValues: {
+      id: jobDetails?.id ?? "",
+      proxies: jobProxyList?.map(e => String(e.proxy_id)) ?? [],
+      strategy: proxyConfig?.proxyStrategy,
+      proxyId: proxyConfig?.targetProxyId,
+    },
+  })
+
+  const handlePickingStrategy = useCallback(
+    (newStrategy: ProxyStrategyOptionEnum) => {
+      form.setValue("strategy", newStrategy)
+      if (newStrategy !== ProxyStrategyOptionEnum.SPECIFIC) {
+        form.setValue("proxyId", "")
+      }
+      strategySelectRef.current?.blur()
+    },
+    [],
+  )
+  const handleSubmit = useCallback(
+    async (inputValue: JobProxyLinkUpdateType) => {
+      onChange?.(inputValue)
+      return proxyActions(
+        ProxyActions.LINK_TO_JOBS,
+        undefined,
+        undefined,
+        inputValue,
+      )
+        .then(() => {
+          if (
+            inputValue.strategy !== proxyConfig?.proxyStrategy ||
+            (inputValue.strategy === ProxyStrategyOptionEnum.SPECIFIC &&
+              inputValue.proxyId !== proxyConfig?.targetProxyId)
+          ) {
+            return onProxyStrategyChange?.(
+              inputValue.strategy,
+              inputValue.proxyId,
+            )
+          } else {
+            return Promise.resolve()
+          }
+        })
+        .then(() => {
+          setDialogState(false)
+        })
+    },
+    [onChange, isDialogOpen, proxyConfig],
+  )
+
+  return (
+    <Dialog open={isDialogOpen} onOpenChange={v => setDialogState(v)}>
+      <DialogTrigger
+        className={cn(triggerClassName)}
+        onClick={v => {
+          v.preventDefault()
+          setDialogState(true)
+        }}
+        asChild
+      >
+        {children}
+      </DialogTrigger>
+      <DialogContent
+        className="sm:max-w-[425px] text-foreground bg-background"
+        onEscapeKeyDown={e => {
+          e.preventDefault()
+          setDialogState(false)
+        }}
+      >
+        <DialogTitle>Update proxy Links</DialogTitle>
+        <DialogHeader>
+          <DialogDescription>
+            Proxies linked to {jobDetails?.name}
+          </DialogDescription>
+        </DialogHeader>
+        <Form {...form}>
+          <form
+            onSubmit={form.handleSubmit(
+              (v, event) => {
+                event.preventDefault()
+                handleSubmit(v)
+              },
+              err => {
+                console.log(err)
+              },
+            )}
+            className="space-y-8"
+          >
+            <div className="space-y-4">
+              <div className="flex justify-between gap-2 items-center">
+                <div className="flex flex-col gap-1 w-8/12">
+                  <h4 className="text-lg font-bold">Pick strategy</h4>
+                  <p className="text-muted-foreground italic text-sm">
+                    Strategy for default proxy choice.
+                  </p>
+                </div>
+                <div className="flex flex-col gap-1 justify-start">
+                  <FormField
+                    control={form.control}
+                    name="strategy"
+                    render={({ field }) => (
+                      <div>
+                        <ManagedSelect
+                          ref={strategySelectRef}
+                          exportOnlyValue={true}
+                          onChange={handlePickingStrategy}
+                          inputOptions={ProxyStrategyOptions}
+                          defaultValue={field.value}
+                        />
+                      </div>
+                    )}
+                  />
+
+                  {form.watch("strategy") ===
+                    ProxyStrategyOptionEnum.SPECIFIC && (
+                    <FormField
+                      control={form.control}
+                      name="proxyId"
+                      render={({ field }) => (
+                        <InputBase>
+                          <InputBaseAdornment>id</InputBaseAdornment>
+                          <InputBaseControl>
+                            <InputBaseInput
+                              value={field.value}
+                              onChange={e => field.onChange(e.target.value)}
+                            />
+                          </InputBaseControl>
+                        </InputBase>
+                      )}
+                    />
+                  )}
+                </div>
+              </div>
+              <Separator orientation="horizontal" className="my-2 h-1" />
+              <Card className="border-transparent">
+                <CardHeader className="flex flex-row items-center justify-between space-y-0 p-0 pb-2 text-foreground bg-background border-transparent rounded-t-xl">
+                  <CardTitle className="text-lg font-bold">
+                    Proxy links
+                  </CardTitle>
+                  <ConfirmationDialogAction
+                    title={"Unlink All proxies"}
+                    description={"Unlink all proxies from this job"}
+                    takeAction={() =>
+                      form.setValue("proxies", [], {
+                        shouldTouch: true,
+                        shouldDirty: true,
+                        shouldValidate: true,
+                      })
+                    }
+                    confirmText={"Unlink all jobs"}
+                  >
+                    <Button
+                      variant={"destructive"}
+                      size="sm"
+                      className="btn-rounded"
+                    >
+                      <MinusIcon />
+                      Unlink all
+                    </Button>
+                  </ConfirmationDialogAction>
+                </CardHeader>
+                <CardContent className="p-0 pt-0 flex flex-col gap-2">
+                  <FormField
+                    control={form.control}
+                    name="proxies"
+                    render={({ field }) => (
+                      <div>
+                        <FormItem>
+                          <FormLabel>
+                            Select the Proxies to link to this job
+                          </FormLabel>
+                          <br />
+                          <FormControl ref={field.ref}>
+                            <ComboBox
+                              selectedItemValue={field.value}
+                              itemList={proxyItems}
+                              {...field}
+                              noFieldsFoundText={"No Proxies found"}
+                              searchFieldPlaceholder={"Search saved proxies..."}
+                              inputFieldsText={
+                                "Select proxy to link with this job ..."
+                              }
+                              className="w-[--radix-popover-trigger-width]"
+                              triggerClassName={"w-full"}
+                              multiSelect={true}
+                              managed={true}
+                              maxSelectedItemsToShowOnMainTrigger={3}
+                            />
+                          </FormControl>
+                          <FormDescription>
+                            The selected proxy will be part of the job's linked
+                            proxies. The proxies are going to be injected to the
+                            job based on a strategy
+                          </FormDescription>
+                          <FormMessage />
+                        </FormItem>
+                      </div>
+                    )}
+                  />
+                </CardContent>
+              </Card>
+            </div>
+            <DialogFooter>
+              <ButtonWithStrCut
+                disabled={form.formState.isSubmitting}
+                keyBinding={"meta+enter"}
+                useInForm={true}
+                variant={"default"}
+                type="submit"
+              >
+                <LinkIcon />
+                Update proxy links
+              </ButtonWithStrCut>
+            </DialogFooter>
+          </form>
+        </Form>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/src/components/custom/system/ProxyConfigDialog.tsx b/src/components/custom/system/ProxyConfigDialog.tsx
index 5d1cb48..16c4cca 100644
--- a/src/components/custom/system/ProxyConfigDialog.tsx
+++ b/src/components/custom/system/ProxyConfigDialog.tsx
@@ -27,7 +27,7 @@ import { ComboBox } from "@/components/ui/combo-box"
 import { cn, parseCron } from "@/lib/utils"
 import useDialogueManager from "@/hooks/useDialogManager"
 import { useHotkeys } from "react-hotkeys-hook"
-import type { ProxyTableData } from "@/models/proxies"
+import { ProxyTableData, ProxyUpdateSchema } from "@/models/proxies"
 import { proxyProtocolOptions, ProxyStatus } from "@/models/proxies"
 import { Checkbox } from "@/components/ui/checkbox"
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
@@ -35,7 +35,7 @@ import { PasswordInput } from "@/components/ui/password-input"
 import ManagedSelect from "@/components/custom/ManagedSelect"
 import ButtonWithStrCut from "@/components/custom/general/ButtonWithStrCut"
 
-export interface ProxyConffigDialogProps {
+export interface ProxyConfigDialogProps {
   children: React.ReactNode
   isCreateDialog?: boolean
   proxyDetails?: ProxyTableData
@@ -44,27 +44,13 @@ export interface ProxyConffigDialogProps {
   triggerClassName?: string
 }
 
-const ProxyUpdateSchema = z.object({
-  id: z.union([z.number(), z.string()]).optional(),
-  proxy_ip: z.string(),
-  proxy_port: z.coerce.number().positive().max(65535),
-  description: z.string().optional(),
-  status: z.union([z.nativeEnum(ProxyStatus), z.number()]).optional(),
-  username: z.string().optional(),
-  password: z.string().optional(),
-  protocol: z.string().optional(),
-  jobs: z.array(z.number()).optional(),
-})
-
-export type ProxyConfigUpdateType = z.infer<typeof ProxyUpdateSchema>
-
 export function ProxyConfigDialog({
   children,
   isCreateDialog,
   proxyDetails,
   onChange,
   triggerClassName,
-}: ProxyConffigDialogProps) {
+}: ProxyConfigDialogProps) {
   const form = useForm<z.infer<typeof ProxyUpdateSchema>>({
     resolver: zodResolver(ProxyUpdateSchema),
     defaultValues: {
diff --git a/src/components/ui/input-base.tsx b/src/components/ui/input-base.tsx
new file mode 100644
index 0000000..1e3618c
--- /dev/null
+++ b/src/components/ui/input-base.tsx
@@ -0,0 +1,213 @@
+"use client"
+
+import { composeEventHandlers } from "@radix-ui/primitive"
+import { useComposedRefs } from "@radix-ui/react-compose-refs"
+import { Primitive } from "@radix-ui/react-primitive"
+import { Slot } from "@radix-ui/react-slot"
+import * as React from "react"
+
+import { Button } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+
+export type InputBaseContextProps = Pick<
+  InputBaseProps,
+  "autoFocus" | "disabled"
+> & {
+  controlRef: React.RefObject<HTMLElement | null>
+  onFocusedChange: (focused: boolean) => void
+}
+
+const InputBaseContext = React.createContext<InputBaseContextProps>({
+  autoFocus: false,
+  controlRef: { current: null },
+  disabled: false,
+  onFocusedChange: () => {},
+})
+
+function useInputBase() {
+  const context = React.useContext(InputBaseContext)
+  if (!context) {
+    throw new Error("useInputBase must be used within a <InputBase />.")
+  }
+
+  return context
+}
+
+export interface InputBaseProps
+  extends React.ComponentProps<typeof Primitive.div> {
+  autoFocus?: boolean
+  disabled?: boolean
+  error?: boolean
+}
+
+function InputBase({
+  autoFocus,
+  disabled,
+  className,
+  onClick,
+  error,
+  ...props
+}: InputBaseProps) {
+  const [focused, setFocused] = React.useState(false)
+  const controlRef = React.useRef<HTMLElement>(null)
+
+  return (
+    <InputBaseContext.Provider
+      value={{
+        autoFocus,
+        controlRef,
+        disabled,
+        onFocusedChange: setFocused,
+      }}
+    >
+      <Primitive.div
+        data-slot="input-base"
+        // Based on MUI's <InputBase /> implementation.
+        // https://github.com/mui/material-ui/blob/master/packages/mui-material/src/InputBase/InputBase.js#L458~L460
+        onClick={composeEventHandlers(onClick, event => {
+          if (controlRef.current && event.currentTarget === event.target) {
+            controlRef.current.focus()
+          }
+        })}
+        className={cn(
+          "border-input selection:bg-primary selection:text-primary-foreground dark:bg-input/30 flex min-h-9 cursor-text items-center gap-2 rounded-md border bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none md:text-sm",
+          disabled && "pointer-events-none cursor-not-allowed opacity-50",
+          focused && "border-ring ring-ring/50 ring-[3px]",
+          error &&
+            "ring-destructive/20 dark:ring-destructive/40 border-destructive",
+          className,
+        )}
+        {...props}
+      />
+    </InputBaseContext.Provider>
+  )
+}
+
+function InputBaseFlexWrapper({
+  className,
+  ...props
+}: React.ComponentProps<typeof Primitive.div>) {
+  return (
+    <Primitive.div
+      data-slot="input-base-flex-wrapper"
+      className={cn("flex flex-1 flex-wrap", className)}
+      {...props}
+    />
+  )
+}
+
+function InputBaseControl({
+  ref,
+  onFocus,
+  onBlur,
+  ...props
+}: React.ComponentProps<typeof Slot>) {
+  const { controlRef, autoFocus, disabled, onFocusedChange } = useInputBase()
+
+  const composedRefs = useComposedRefs(controlRef, ref)
+
+  return (
+    <Slot
+      data-slot="input-base-control"
+      ref={composedRefs}
+      autoFocus={autoFocus}
+      onFocus={composeEventHandlers(onFocus, () => onFocusedChange(true))}
+      onBlur={composeEventHandlers(onBlur, () => onFocusedChange(false))}
+      {...{ disabled }}
+      {...props}
+    />
+  )
+}
+
+export interface InputBaseAdornmentProps extends React.ComponentProps<"div"> {
+  asChild?: boolean
+}
+
+function InputBaseAdornment({
+  className,
+  asChild,
+  children,
+  ...props
+}: InputBaseAdornmentProps) {
+  const Comp = asChild ? Slot : typeof children === "string" ? "p" : "div"
+
+  return (
+    <Comp
+      data-slot="input-base-adornment"
+      className={cn(
+        "text-muted-foreground flex items-center [&_svg:not([class*='size-'])]:size-4",
+        "[&:not(:has(button))]:pointer-events-none",
+        className,
+      )}
+      {...props}
+    >
+      {children}
+    </Comp>
+  )
+}
+
+function InputBaseAdornmentButton({
+  type = "button",
+  variant = "ghost",
+  size = "icon",
+  disabled: disabledProp,
+  className,
+  ...props
+}: React.ComponentProps<typeof Button>) {
+  const { disabled } = useInputBase()
+
+  return (
+    <Button
+      data-slot="input-base-adornment-button"
+      type={type}
+      variant={variant}
+      size={size}
+      disabled={disabled || disabledProp}
+      className={cn("size-6", className)}
+      {...props}
+    />
+  )
+}
+
+function InputBaseInput({
+  className,
+  ...props
+}: React.ComponentProps<typeof Primitive.input>) {
+  return (
+    <Primitive.input
+      data-slot="input-base-input"
+      className={cn(
+        "placeholder:text-muted-foreground file:text-foreground w-full flex-1 bg-transparent file:border-0 file:bg-transparent file:text-sm file:font-medium focus:outline-none disabled:pointer-events-none",
+        className,
+      )}
+      {...props}
+    />
+  )
+}
+
+function InputBaseTextarea({
+  className,
+  ...props
+}: React.ComponentProps<"textarea">) {
+  return (
+    <textarea
+      data-slot="input-base-textarea"
+      className={cn(
+        "placeholder:text-muted-foreground min-h-16 flex-1 bg-transparent focus:outline-none disabled:pointer-events-none",
+        className,
+      )}
+      {...props}
+    />
+  )
+}
+
+export {
+  InputBase,
+  InputBaseFlexWrapper,
+  InputBaseControl,
+  InputBaseAdornment,
+  InputBaseAdornmentButton,
+  InputBaseInput,
+  InputBaseTextarea,
+  useInputBase,
+}
diff --git a/src/hooks/useProxies.tsx b/src/hooks/useProxies.tsx
index 6b60392..082d2c1 100644
--- a/src/hooks/useProxies.tsx
+++ b/src/hooks/useProxies.tsx
@@ -1,9 +1,14 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
 import systemService from "@/services/SystemService"
-import { ProxyActions, type ProxyTableData } from "@/models/proxies"
+import {
+  JobProxyLinkUpdateType,
+  ProxyActions,
+  ProxyConfigUpdateType,
+  type ProxyTableData,
+} from "@/models/proxies"
 import { Row } from "@tanstack/react-table"
-import { ProxyConfigUpdateType } from "@/components/custom/system/ProxyConfigDialog"
 import { toast } from "@/hooks/use-toast"
+import { useCallback, useMemo } from "react"
 
 export interface UseProxyProps {
   filters?: {
@@ -28,6 +33,19 @@ export function useProxies(props?: UseProxyProps) {
     placeholderData: [],
   })
 
+  const proxyItems = useMemo(() => {
+    return data?.map((item: any) => {
+      return {
+        value: item.id?.toString(),
+        label: `${item.proxy_ip}:${item.proxy_port}`,
+      }
+    })
+  }, [data])
+
+  const jobProxies = useCallback((jobId: number) => {
+    return systemService.getJobProxies(jobId)
+  }, [])
+
   const createMutation = useMutation({
     mutationFn: systemService.addProxy,
     onSuccess: async (data, variables) => {
@@ -106,6 +124,27 @@ export function useProxies(props?: UseProxyProps) {
     },
   })
 
+  const jobLinkMutation = useMutation({
+    mutationFn: (d: any) =>
+      systemService.addProxiesToASingleJob(d.id, d.proxies),
+    onSuccess: async (data, vars) => {
+      toast({
+        title: `${vars.proxies.length} proxies linked to a job`,
+        duration: 2000,
+      })
+      await queryClient.invalidateQueries({
+        queryKey: ["proxies"],
+      })
+    },
+    onError: (error, variables) => {
+      toast({
+        title: "Error linking proxies to job",
+        description: error.message,
+        variant: "destructive",
+      })
+    },
+  })
+
   const testMutation = useMutation({
     mutationFn: systemService.testProxy,
     onMutate: (id, _context) => {
@@ -133,6 +172,7 @@ export function useProxies(props?: UseProxyProps) {
     action: ProxyActions,
     row?: Row<ProxyTableData>,
     proxyData?: ProxyConfigUpdateType,
+    jobProxyLinkData?: JobProxyLinkUpdateType,
   ) => {
     switch (action) {
       case ProxyActions.UPDATE:
@@ -152,6 +192,11 @@ export function useProxies(props?: UseProxyProps) {
           id: proxyData!.id!,
           jobs: proxyData!.jobs!.map(e => Number(e)),
         })
+      case ProxyActions.LINK_TO_JOBS:
+        return jobLinkMutation.mutateAsync({
+          id: Number(jobProxyLinkData!.id),
+          proxies: jobProxyLinkData!.proxies.map(e => Number(e)),
+        })
       case ProxyActions.TEST:
         return testMutation.mutateAsync(Number(row?.original?.id))
       default:
@@ -161,7 +206,9 @@ export function useProxies(props?: UseProxyProps) {
 
   return {
     proxies: data,
+    proxyItems,
     isLoading,
     proxyActions,
+    jobProxies,
   }
 }
diff --git a/src/models/proxies.ts b/src/models/proxies.ts
index 78f1702..943dbff 100644
--- a/src/models/proxies.ts
+++ b/src/models/proxies.ts
@@ -1,3 +1,5 @@
+import { z } from "zod/v4"
+
 export interface ProxyTableData {
   id: string
   proxy_ip: string
@@ -19,6 +21,7 @@ export enum ProxyActions {
   CREATE,
   LINK,
   TEST,
+  LINK_TO_JOBS,
 }
 
 export enum ProxyStatus {
@@ -44,3 +47,40 @@ export const proxyProtocolOptions = [
     label: "SOCKS5",
   },
 ]
+
+export enum ProxyStrategyOptionEnum {
+  RANDOM = "RANDOM",
+  ROUND_ROBIN = "ROUND_ROBIN",
+  SPECIFIC = "SPECIFIC",
+  LEAST_USED = "LEAST_USED",
+}
+export const ProxyStrategyOptions = [
+  { value: ProxyStrategyOptionEnum.RANDOM, label: "Random" },
+  { value: ProxyStrategyOptionEnum.ROUND_ROBIN, label: "Round Robin" },
+  { value: ProxyStrategyOptionEnum.SPECIFIC, label: "Specific" },
+  { value: ProxyStrategyOptionEnum.LEAST_USED, label: "Least Used" },
+  { value: undefined, label: "First linked (default)" },
+]
+
+export const ProxyUpdateSchema = z.object({
+  id: z.union([z.number(), z.string()]).optional(),
+  proxy_ip: z.string(),
+  proxy_port: z.coerce.number().positive().max(65535),
+  description: z.string().optional(),
+  status: z.union([z.nativeEnum(ProxyStatus), z.number()]).optional(),
+  username: z.string().optional(),
+  password: z.string().optional(),
+  protocol: z.string().optional(),
+  jobs: z.array(z.number()).optional(),
+})
+
+export type ProxyConfigUpdateType = z.infer<typeof ProxyUpdateSchema>
+
+export const JobProxyLinkUpdateSchema = z.object({
+  id: z.union([z.number(), z.string()]),
+  proxies: z.array(z.any()).optional(),
+  strategy: z.string().optional(),
+  proxyId: z.string().optional(),
+})
+
+export type JobProxyLinkUpdateType = z.infer<typeof JobProxyLinkUpdateSchema>
diff --git a/src/services/SystemService.ts b/src/services/SystemService.ts
index f6e17a5..972563a 100644
--- a/src/services/SystemService.ts
+++ b/src/services/SystemService.ts
@@ -1,6 +1,6 @@
 import axios from "@/lib/httpUtils"
 import type { ProxyTableData } from "@/models/proxies"
-import type { ProxyConfigUpdateType } from "@/components/custom/system/ProxyConfigDialog"
+import type { ProxyConfigUpdateType } from "@/models/proxies"
 import { downloadFile } from "@/utils/serviceUtils"
 
 const systemService = {
@@ -49,6 +49,13 @@ const systemService = {
       },
     })
   },
+  getJobProxies(jobId: number): Promise<any> {
+    return axios.get("/proxies/getJobProxies", {
+      params: {
+        jobId,
+      },
+    })
+  },
   updateProxy(id: number, proxyData: ProxyConfigUpdateType): Promise<any> {
     return axios.put("/proxies/updateProxy", {
       id,
@@ -64,6 +71,12 @@ const systemService = {
       job_ids: jobIds,
     })
   },
+  addProxiesToASingleJob(jobId: number, proxyIds: Array<number>): Promise<any> {
+    return axios.post("/proxies/addProxiesToJob", {
+      job_id: jobId,
+      proxy_ids: proxyIds,
+    })
+  },
   deleteProxy(id: number | string): Promise<any> {
     return axios.delete("/proxies/deleteProxy", {
       params: {
diff --git a/src/utils/generalUtils.ts b/src/utils/generalUtils.ts
index 78f84cb..fce9beb 100644
--- a/src/utils/generalUtils.ts
+++ b/src/utils/generalUtils.ts
@@ -1,6 +1,8 @@
 import c from "ansi-colors"
 import { useLocation } from "react-router"
 import React from "react"
+import { attempt, isError } from "lodash-es"
+
 c.enabled = true
 export const debounce = (fn: Function, ms = 300) => {
   let timeoutId: ReturnType<typeof setTimeout>
@@ -164,3 +166,8 @@ export function isReactFragment(variableToInspect) {
   }
   return variableToInspect === React.Fragment
 }
+
+export function safeJsonParse(input?: string) {
+  const result = attempt(() => JSON.parse(input))
+  return { error: isError(result), data: result }
+}