homeio

1import yaml from "js-yaml";
2
3import type { AppComposeData } from "@/modules/apps/hooks/useAppCompose";
4import type { StoreAppDetail } from "@/lib/shared/contracts/apps";
5
6export type ConfiguratorView = "classic" | "compose" | "docker_run";
7
8export type PortProtocol = "TCP" | "UDP" | "TCP + UDP";
9
10export type PortRow = {
11  id: string;
12  host: string;
13  container: string;
14  protocol: PortProtocol;
15};
16
17export type VolumeRow = {
18  id: string;
19  host: string;
20  container: string;
21};
22
23export type EnvRow = {
24  id: string;
25  key: string;
26  value: string;
27};
28
29export type WebUiState = {
30  protocol: "http" | "https";
31  host: string;
32  port: string;
33  path: string;
34};
35
36export type ClassicConfigState = {
37  dockerImage: string;
38  title: string;
39  iconUrl: string;
40  webUi: WebUiState;
41  /**
42   * Operator-set link for the app tile. Empty means "build it automatically".
43   * Kept apart from webUi, which composes the container's APP_URL.
44   */
45  webUiLink: string;
46  network: string;
47  ports: PortRow[];
48  volumes: VolumeRow[];
49  envVars: EnvRow[];
50  privileged: boolean;
51  restartPolicy: string;
52  capabilities: string;
53  hostname: string;
54  devices: string[];
55  containerCommands: string[];
56};
57
58export type DockerRunState = {
59  name: string;
60  iconUrl: string;
61  repositoryUrl: string;
62  source: string;
63};
64
65type ComposeLike = {
66  services?: Record<string, Record<string, unknown>>;
67  [key: string]: unknown;
68};
69
70type PrimaryServiceSelectionInput = {
71  compose: ComposeLike;
72  appId?: string;
73  primaryServiceName?: string;
74};
75
76const INFRA_SERVICE_TOKEN_PATTERN =
77  /(?:^|[-_.])(db|database|postgres|postgresql|mariadb|mysql|redis|cache|broker|queue|rabbitmq|kafka|zookeeper|mongo|mongodb|elasticsearch|minio)(?:$|[-_.])/i;
78const APP_ALIAS_PATTERN = /^(app|main|server|web|frontend|backend)$/i;
79
80function nextId(prefix: string) {
81  return `${prefix}-${Math.random().toString(36).slice(2, 8)}`;
82}
83
84function parsePortValue(port: string) {
85  if (!port.trim()) return undefined;
86  const parsed = Number.parseInt(port, 10);
87  if (!Number.isFinite(parsed) || parsed < 1 || parsed > 65535) {
88    return undefined;
89  }
90  return parsed;
91}
92
93function toWebUiUrl(webUi: WebUiState) {
94  const host = webUi.host.trim();
95  const port = webUi.port.trim();
96  if (!host || !port) return undefined;
97
98  const normalizedPath = webUi.path.trim();
99  const path = normalizedPath
100    ? normalizedPath.startsWith("/")
101      ? normalizedPath
102      : `/${normalizedPath}`
103    : "";
104
105  return `${webUi.protocol}://${host}:${port}${path}`;
106}
107
108function isLoopbackHost(host: string) {
109  const normalized = host.trim().toLowerCase();
110  return (
111    normalized === "localhost" ||
112    normalized === "127.0.0.1" ||
113    normalized === "::1" ||
114    normalized === "[::1]"
115  );
116}
117
118function resolveWebUiHost(host: string | undefined, fallbackHost?: string) {
119  const trimmedHost = host?.trim();
120  const trimmedFallback = fallbackHost?.trim();
121
122  if (!trimmedHost) {
123    return trimmedFallback || "localhost";
124  }
125
126  if (trimmedFallback && isLoopbackHost(trimmedHost)) {
127    return trimmedFallback;
128  }
129
130  return trimmedHost;
131}
132
133function parseEnvironment(environment: unknown): Record<string, string> {
134  if (Array.isArray(environment)) {
135    const map: Record<string, string> = {};
136    for (const item of environment) {
137      if (typeof item !== "string") continue;
138      const [key, ...rest] = item.split("=");
139      if (!key) continue;
140      map[key] = rest.join("=");
141    }
142    return map;
143  }
144
145  if (environment && typeof environment === "object") {
146    return Object.fromEntries(
147      Object.entries(environment as Record<string, unknown>).map(
148        ([key, value]) => [key, typeof value === "string" ? value : String(value ?? "")],
149      ),
150    );
151  }
152
153  return {};
154}
155
156function parseWebUi(
157  appUrl: string | undefined,
158  fallbackPort: string,
159  fallbackHost?: string,
160): WebUiState {
161  if (!appUrl) {
162    return {
163      protocol: "http" as const,
164      host: resolveWebUiHost(undefined, fallbackHost),
165      port: fallbackPort,
166      path: "",
167    };
168  }
169
170  try {
171    const parsed = new URL(appUrl);
172    const protocol: WebUiState["protocol"] =
173      parsed.protocol.replace(":", "") === "https" ? "https" : "http";
174    return {
175      protocol,
176      host: resolveWebUiHost(parsed.hostname, fallbackHost),
177      port: parsed.port || fallbackPort,
178      path: parsed.pathname === "/" ? "" : parsed.pathname,
179    };
180  } catch {
181    return {
182      protocol: "http" as const,
183      host: resolveWebUiHost(undefined, fallbackHost),
184      port: fallbackPort,
185      path: "",
186    };
187  }
188}
189
190function parsePortMapping(value: string): Omit<PortRow, "id"> | null {
191  const trimmed = value.trim().replace(/^['"]|['"]$/g, "");
192  if (!trimmed) return null;
193
194  const [mappingPart, protocolPart] = trimmed.split("/");
195  const protocol = protocolPart?.toLowerCase() === "udp" ? "UDP" : "TCP";
196  const segments = mappingPart.split(":").filter(Boolean);
197
198  let host = "";
199  let container = "";
200  if (segments.length === 1) {
201    host = segments[0] || "";
202    container = segments[0] || "";
203  } else if (segments.length >= 2) {
204    host = segments[segments.length - 2] || "";
205    container = segments[segments.length - 1] || "";
206  }
207
208  if (!host || !container) return null;
209
210  return {
211    host,
212    container,
213    protocol,
214  } satisfies Omit<PortRow, "id">;
215}
216
217function parsePorts(ports: unknown): PortRow[] {
218  if (!Array.isArray(ports)) return [];
219
220  return ports
221    .map((item, index) => {
222      let parsed: Omit<PortRow, "id"> | null = null;
223
224      if (typeof item === "string") {
225        parsed = parsePortMapping(item);
226      } else if (item && typeof item === "object") {
227        const candidate = item as {
228          published?: unknown;
229          target?: unknown;
230          protocol?: unknown;
231        };
232        const host =
233          candidate.published === undefined || candidate.published === null
234            ? ""
235            : String(candidate.published).trim();
236        const container =
237          candidate.target === undefined || candidate.target === null
238            ? ""
239            : String(candidate.target).trim();
240        const protocol =
241          typeof candidate.protocol === "string" &&
242          candidate.protocol.toLowerCase() === "udp"
243            ? "UDP"
244            : "TCP";
245
246        if (host && container) {
247          parsed = {
248            host,
249            container,
250            protocol,
251          };
252        }
253      }
254
255      if (!parsed) return null;
256      return {
257        id: nextId(`port-${index}`),
258        ...parsed,
259      } satisfies PortRow;
260    })
261    .filter((item): item is PortRow => item !== null);
262}
263
264function parseVolumeMapping(value: string) {
265  const trimmed = value.trim().replace(/^['"]|['"]$/g, "");
266  if (!trimmed) return null;
267
268  const segments = trimmed.split(":");
269  if (segments.length < 2) return null;
270
271  const host = segments[0] || "";
272  const container = segments[1] || "";
273
274  if (!host || !container) return null;
275
276  return {
277    host,
278    container,
279  } satisfies Omit<VolumeRow, "id">;
280}
281
282function parseVolumes(volumes: unknown): VolumeRow[] {
283  if (!Array.isArray(volumes)) return [];
284
285  return volumes
286    .map((item, index) => {
287      let parsed: Omit<VolumeRow, "id"> | null = null;
288
289      if (typeof item === "string") {
290        parsed = parseVolumeMapping(item);
291      } else if (item && typeof item === "object") {
292        const candidate = item as {
293          source?: unknown;
294          target?: unknown;
295        };
296        const host =
297          candidate.source === undefined || candidate.source === null
298            ? ""
299            : String(candidate.source).trim();
300        const container =
301          candidate.target === undefined || candidate.target === null
302            ? ""
303            : String(candidate.target).trim();
304
305        if (container) {
306          parsed = {
307            host,
308            container,
309          };
310        }
311      }
312
313      if (!parsed) return null;
314      return {
315        id: nextId(`volume-${index}`),
316        ...parsed,
317      } satisfies VolumeRow;
318    })
319    .filter((item): item is VolumeRow => item !== null);
320}
321
322function parseStringArray(input: unknown): string[] {
323  if (!Array.isArray(input)) return [];
324  return input.filter((entry): entry is string => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
325}
326
327function parseCommand(input: unknown): string[] {
328  if (Array.isArray(input)) {
329    return input
330      .filter((entry): entry is string => typeof entry === "string")
331      .map((entry) => entry.trim())
332      .filter(Boolean);
333  }
334
335  if (typeof input === "string" && input.trim().length > 0) {
336    return [input.trim()];
337  }
338
339  return [];
340}
341
342function hasPublishedPorts(input: Record<string, unknown>): boolean {
343  const ports = input.ports;
344  if (!Array.isArray(ports)) {
345    return false;
346  }
347
348  return ports.some((entry) => {
349    if (typeof entry === "string") {
350      return entry.trim().length > 0;
351    }
352    if (!entry || typeof entry !== "object") {
353      return false;
354    }
355
356    const candidate = entry as { target?: unknown; published?: unknown };
357    return Boolean(candidate.target ?? candidate.published);
358  });
359}
360
361function scorePrimaryServiceCandidate(input: {
362  name: string;
363  service: Record<string, unknown>;
364  appId?: string;
365}): number {
366  const name = input.name.toLowerCase();
367  const appId = input.appId?.toLowerCase().trim();
368  const image =
369    typeof input.service.image === "string" ? input.service.image.toLowerCase() : "";
370
371  let score = 0;
372  if (hasPublishedPorts(input.service)) {
373    score += 40;
374  }
375
376  if (name === "app") {
377    score += 60;
378  } else if (APP_ALIAS_PATTERN.test(name)) {
379    score += 30;
380  }
381  if (name.includes("server")) {
382    score += 20;
383  }
384
385  if (appId) {
386    if (name === appId) {
387      score += 100;
388    } else if (name.startsWith(`${appId}-`) || name.endsWith(`-${appId}`)) {
389      score += 45;
390    } else if (name.includes(appId)) {
391      score += 25;
392    }
393
394    if (image.includes(appId)) {
395      score += 20;
396    }
397  }
398
399  if (INFRA_SERVICE_TOKEN_PATTERN.test(name)) {
400    score -= 80;
401  }
402
403  return score;
404}
405
406function getPrimaryService(
407  input: PrimaryServiceSelectionInput,
408): { name: string; service: Record<string, unknown> } {
409  const { compose, appId, primaryServiceName } = input;
410  const services = compose.services ?? {};
411  const names = Object.keys(services);
412  if (names.length === 0) {
413    return {
414      name: "app",
415      service: {},
416    };
417  }
418
419  if (primaryServiceName && services[primaryServiceName]) {
420    return {
421      name: primaryServiceName,
422      service: services[primaryServiceName] ?? {},
423    };
424  }
425
426  if (appId) {
427    const normalizedAppId = appId.toLowerCase();
428    const exactMatch = names.find((name) => name.toLowerCase() === normalizedAppId);
429    if (exactMatch) {
430      return {
431        name: exactMatch,
432        service: services[exactMatch] ?? {},
433      };
434    }
435  }
436
437  const rankedServices = names
438    .map((name, index) => ({
439      name,
440      index,
441      score: scorePrimaryServiceCandidate({
442        name,
443        service: services[name] ?? {},
444        appId,
445      }),
446    }))
447    .sort((a, b) => b.score - a.score || a.index - b.index);
448
449  const name = rankedServices[0]?.name ?? names[0];
450  return {
451    name,
452    service: services[name] ?? {},
453  };
454}
455
456function toEnvRows(environment: Record<string, string>) {
457  return Object.entries(environment)
458    .filter(([key]) => key !== "APP_URL" && key !== "VOLUMES")
459    .map(([key, value], index) => ({
460      id: nextId(`env-${index}`),
461      key,
462      value,
463    } satisfies EnvRow));
464}
465
466function toEnvPayload(state: ClassicConfigState) {
467  const env = Object.fromEntries(
468    state.envVars
469      .filter((row) => row.key.trim().length > 0)
470      .map((row) => [row.key.trim(), row.value]),
471  );
472
473  const appUrl = toWebUiUrl(state.webUi);
474  if (appUrl) {
475    env.APP_URL = appUrl;
476  }
477
478  return env;
479}
480
481function composeFromObject(compose: ComposeLike) {
482  return yaml.dump(compose, {
483    lineWidth: -1,
484    noRefs: true,
485    sortKeys: false,
486  });
487}
488
489export function toAppId(value: string) {
490  return value
491    .trim()
492    .toLowerCase()
493    .replace(/[^a-z0-9]+/g, "-")
494    .replace(/-{2,}/g, "-")
495    .replace(/^-+|-+$/g, "");
496}
497
498function toHostname(value: string) {
499  const normalized = toAppId(value);
500  return normalized.length > 0 ? normalized : "app";
501}
502
503export function createDefaultClassicState(seed: {
504  title: string;
505  iconUrl: string;
506  fallbackPort?: number | null;
507  fallbackHost?: string;
508  webUiLink?: string | null;
509}): ClassicConfigState {
510  const fallbackPort = seed.fallbackPort ? String(seed.fallbackPort) : "";
511
512  return {
513    dockerImage: "nginx:latest",
514    title: seed.title,
515    iconUrl: seed.iconUrl,
516    webUi: {
517      protocol: "http",
518      host: resolveWebUiHost(undefined, seed.fallbackHost),
519      port: fallbackPort,
520      path: "",
521    },
522    webUiLink: seed.webUiLink?.trim() ?? "",
523    network: "bridge",
524    ports: fallbackPort
525      ? [
526          {
527            id: nextId("port-0"),
528            host: fallbackPort,
529            container: fallbackPort,
530            protocol: "TCP",
531          },
532        ]
533      : [],
534    volumes: [],
535    envVars: [],
536    privileged: false,
537    restartPolicy: "always",
538    capabilities: "",
539    hostname: toHostname(seed.title || "app"),
540    devices: [],
541    containerCommands: [],
542  };
543}
544
545export function buildInitialComposeDraft(input: {
546  appId: string;
547  template?: StoreAppDetail;
548  composeData?: AppComposeData;
549  dockerImageFallback?: string;
550}) {
551  const { composeData, template, appId, dockerImageFallback } = input;
552  const installed = template?.installedConfig;
553
554  const baseEnv = installed?.env ?? {};
555  const service: Record<string, unknown> = {
556    image:
557      composeData?.image ||
558      baseEnv.DOCKER_IMAGE ||
559      baseEnv.IMAGE ||
560      dockerImageFallback ||
561      `${appId}/${appId}:latest`,
562  };
563
564  if (composeData?.ports && composeData.ports.length > 0) {
565    service.ports = composeData.ports;
566  } else if (template?.webUiPort) {
567    service.ports = [`${template.webUiPort}:${template.webUiPort}`];
568  }
569
570  if (composeData?.volumes && composeData.volumes.length > 0) {
571    service.volumes = composeData.volumes;
572  }
573
574  const environment = {
575    ...(composeData?.environment ?? {}),
576    ...baseEnv,
577  };
578  if (Object.keys(environment).length > 0) {
579    service.environment = environment;
580  }
581
582  if (composeData?.networkMode || baseEnv.NETWORK_MODE) {
583    service.network_mode = composeData?.networkMode ?? baseEnv.NETWORK_MODE;
584  }
585
586  if (composeData?.restart || baseEnv.RESTART_POLICY) {
587    service.restart = composeData?.restart ?? baseEnv.RESTART_POLICY;
588  }
589
590  if (typeof composeData?.privileged === "boolean") {
591    service.privileged = composeData.privileged;
592  } else if (baseEnv.PRIVILEGED) {
593    service.privileged = ["true", "1", "yes"].includes(baseEnv.PRIVILEGED.toLowerCase());
594  }
595
596  if (composeData?.capAdd && composeData.capAdd.length > 0) {
597    service.cap_add = composeData.capAdd;
598  } else if (baseEnv.CAP_ADD) {
599    service.cap_add = baseEnv.CAP_ADD.split(",").map((entry) => entry.trim()).filter(Boolean);
600  }
601
602  if (composeData?.hostname || installed?.stackName) {
603    service.hostname = composeData?.hostname ?? installed?.stackName;
604  }
605
606  if (composeData?.devices && composeData.devices.length > 0) {
607    service.devices = composeData.devices;
608  }
609
610  if (composeData?.command) {
611    service.command = composeData.command;
612  }
613
614  return composeFromObject({
615    services: {
616      app: service,
617    },
618  });
619}
620
621export function composeToClassicState(input: {
622  composeDraft: string;
623  seed: {
624    title: string;
625    iconUrl: string;
626    fallbackPort?: number | null;
627    fallbackHost?: string;
628    webUiLink?: string | null;
629  };
630  appId?: string;
631  primaryServiceName?: string;
632}): ClassicConfigState {
633  const parsed = yaml.load(input.composeDraft) as ComposeLike;
634  if (!parsed || typeof parsed !== "object") {
635    throw new Error("Compose is empty or invalid");
636  }
637
638  const { service } = getPrimaryService({
639    compose: parsed,
640    appId: input.appId,
641    primaryServiceName: input.primaryServiceName,
642  });
643  const environment = parseEnvironment(service.environment);
644  const ports = parsePorts(service.ports);
645
646  const fallbackPort =
647    ports[0]?.host ||
648    (input.seed.fallbackPort ? String(input.seed.fallbackPort) : "");
649  const webUi = parseWebUi(environment.APP_URL, fallbackPort, input.seed.fallbackHost);
650
651  return {
652    dockerImage:
653      typeof service.image === "string" && service.image.length > 0
654        ? service.image
655        : "",
656    title: input.seed.title,
657    iconUrl: input.seed.iconUrl,
658    webUi,
659    webUiLink: input.seed.webUiLink?.trim() ?? "",
660    network:
661      typeof service.network_mode === "string" && service.network_mode.length > 0
662        ? service.network_mode
663        : "bridge",
664    ports,
665    volumes: parseVolumes(service.volumes),
666    envVars: toEnvRows(environment),
667    privileged: Boolean(service.privileged),
668    restartPolicy:
669      typeof service.restart === "string" && service.restart.length > 0
670        ? service.restart
671        : "always",
672    capabilities: parseStringArray(service.cap_add).join(","),
673    hostname:
674      typeof service.hostname === "string" && service.hostname.length > 0
675        ? service.hostname
676        : toHostname(input.seed.title || "app"),
677    devices: parseStringArray(service.devices),
678    containerCommands: parseCommand(service.command),
679  };
680}
681
682export function safeComposeToClassicState(input: {
683  composeDraft: string;
684  seed: {
685    title: string;
686    iconUrl: string;
687    fallbackPort?: number | null;
688    fallbackHost?: string;
689    webUiLink?: string | null;
690  };
691  appId?: string;
692  primaryServiceName?: string;
693}): {
694  state: ClassicConfigState | null;
695  error: string | null;
696} {
697  try {
698    return {
699      state: composeToClassicState(input),
700      error: null,
701    };
702  } catch (error) {
703    return {
704      state: null,
705      error: error instanceof Error ? error.message : "Invalid docker compose",
706    };
707  }
708}
709
710export function classicStateToCompose(
711  state: ClassicConfigState,
712  previousComposeDraft?: string,
713  options?: {
714    appId?: string;
715    primaryServiceName?: string;
716  },
717) {
718  let compose: ComposeLike = {
719    services: {
720      app: {},
721    },
722  };
723
724  if (previousComposeDraft) {
725    try {
726      const parsed = yaml.load(previousComposeDraft) as ComposeLike;
727      if (parsed && typeof parsed === "object") {
728        compose = parsed;
729      }
730    } catch {
731      // Keep fallback skeleton when old compose is invalid.
732    }
733  }
734
735  if (!compose.services) {
736    compose.services = {};
737  }
738
739  const serviceInfo = getPrimaryService({
740    compose,
741    appId: options?.appId,
742    primaryServiceName: options?.primaryServiceName,
743  });
744  const previousService = serviceInfo.service;
745  const nextService: Record<string, unknown> = {
746    ...previousService,
747    image: state.dockerImage,
748    environment: toEnvPayload(state),
749    network_mode: state.network,
750    restart: state.restartPolicy,
751    privileged: state.privileged,
752    hostname: state.hostname,
753  };
754
755  const normalizedPorts =
756    state.network.trim().toLowerCase() === "host"
757      ? []
758      : state.ports
759          .filter((row) => row.host.trim() && row.container.trim())
760          .map((row) =>
761            row.protocol === "UDP"
762              ? `${row.host}:${row.container}/udp`
763              : `${row.host}:${row.container}`,
764          );
765  if (normalizedPorts.length > 0) {
766    nextService.ports = normalizedPorts;
767  } else {
768    delete nextService.ports;
769  }
770
771  const normalizedVolumes = state.volumes
772    .filter((row) => row.host.trim() && row.container.trim())
773    .map((row) => `${row.host}:${row.container}`);
774  if (normalizedVolumes.length > 0) {
775    nextService.volumes = normalizedVolumes;
776  } else {
777    delete nextService.volumes;
778  }
779
780  const capAdd = state.capabilities
781    .split(",")
782    .map((entry) => entry.trim())
783    .filter(Boolean);
784  if (capAdd.length > 0) {
785    nextService.cap_add = capAdd;
786  } else {
787    delete nextService.cap_add;
788  }
789
790  const devices = state.devices.map((entry) => entry.trim()).filter(Boolean);
791  if (devices.length > 0) {
792    nextService.devices = devices;
793  } else {
794    delete nextService.devices;
795  }
796
797  const command = state.containerCommands.map((entry) => entry.trim()).filter(Boolean);
798  if (command.length === 1) {
799    nextService.command = command[0];
800  } else if (command.length > 1) {
801    nextService.command = command;
802  } else {
803    delete nextService.command;
804  }
805
806  compose.services[serviceInfo.name] = nextService;
807
808  return composeFromObject(compose);
809}
810
811export function buildInstallPayloadFromClassic(input: {
812  appId: string;
813  state: ClassicConfigState;
814  composeSource?: string;
815}) {
816  const payload = {
817    appId: input.appId,
818    displayName: input.state.title.trim() || undefined,
819    env: toEnvPayload(input.state),
820    webUiPort: parsePortValue(input.state.webUi.port),
821    composeSource: input.composeSource,
822  };
823
824  return payload;
825}
826
827export function buildSettingsPayloadFromClassic(input: {
828  appId: string;
829  current: ClassicConfigState;
830  initial: ClassicConfigState;
831  composeSource?: string;
832  initialComposeSource?: string;
833}) {
834  const payload: {
835    appId: string;
836    displayName: string;
837    iconUrl: string | null;
838    env?: Record<string, string>;
839    webUiPort?: number;
840    webUiUrl?: string | null;
841    composeSource?: string;
842  } = {
843    appId: input.appId,
844    displayName: input.current.title,
845    iconUrl: input.current.iconUrl.trim() || null,
846  };
847
848  const nextCompose = input.composeSource?.trim();
849  const initialCompose = input.initialComposeSource?.trim();
850  if (nextCompose && nextCompose.length > 0 && nextCompose !== initialCompose) {
851    payload.composeSource = input.composeSource;
852  }
853
854  const currentEnv = toEnvPayload(input.current);
855  const initialEnv = toEnvPayload(input.initial);
856  if (JSON.stringify(currentEnv) !== JSON.stringify(initialEnv)) {
857    payload.env = currentEnv;
858  }
859
860  const currentPort = parsePortValue(input.current.webUi.port);
861  const initialPort = parsePortValue(input.initial.webUi.port);
862  if (currentPort !== undefined && currentPort !== initialPort) {
863    payload.webUiPort = currentPort;
864  }
865
866  // The link override only changes what we render, never the compose file, so
867  // it travels on its own and does not trigger a redeploy.
868  const currentLink = input.current.webUiLink.trim();
869  if (currentLink !== input.initial.webUiLink.trim()) {
870    // Null clears the override and restores the automatic link.
871    payload.webUiUrl = currentLink.length > 0 ? currentLink : null;
872  }
873
874  return payload;
875}
876
877export function buildInitialDockerRunState(input: {
878  title: string;
879  iconUrl: string;
880  port: string;
881}) {
882  const appName = input.title.trim() || "my-app";
883  const webUiPort = input.port.trim() || "8080";
884
885  return {
886    name: appName,
887    iconUrl: input.iconUrl,
888    repositoryUrl: "",
889    source: `docker run --name ${toAppId(appName)} -p ${webUiPort}:80 nginx:latest`,
890  } satisfies DockerRunState;
891}
892