spinuptui 0.24.4 → 0.26.0

package/src/lib/localSetup.ts

@@ -0,0 +1,164 @@
+// Set up a brand-new local working copy for a remote SpinupWP site — the
+// missing first step before dbSync (`p`) and mediaFallback (`m`) can run.
+//
+// Gets the CODE down (git clone for git-deployed sites, an rsync pull over SSH
+// for everything else — excluding uploads/ and the server-specific caching
+// drop-ins, object-cache.php/advanced-cache.php: they're wired to production's
+// Redis/disk cache, and object-cache.php doesn't just no-op without it, it
+// fatals) and runs `composer install` locally when the checkout turns out to
+// be Bedrock/Radicle. Deliberately stops there: it never touches the local
+// database or webserver config, and never links the site itself — the caller
+// does that (reusing `linkSite`) once this succeeds, then hands off to the
+// existing dbSync (`p`) and mediaFallback (`m`) flows unchanged.
+//
+// For a public/-style webroot, wp-config.php lives ONE level above it (see
+// CLAUDE.md's WordPress layout rules) — so the rsync path always pulls the
+// site's whole files root, not just the detected webroot, so wp-config.php
+// (and anything else living beside it) comes down too. `public_folder` is a
+// SETTING, not a fact (SpinupWP never enforces it), so the real webroot is
+// detected on the source via `detectWpDirScript` rather than trusted.
+
+import { existsSync, mkdirSync, readdirSync } from "node:fs"
+import { dirname } from "node:path"
+import type { Server, Site } from "../api/types.ts"
+import { expandPath, resolveLocalLink } from "./local.ts"
+import { SSH_OPTS, sshPort, runProcess, meaningfulError } from "./dbBackup.ts"
+import { detectWpDirScript } from "./serverClone.ts"
+
+export interface LocalSetupPlan {
+  domain: string
+  isGit: boolean
+  repoUrl: string | null // git clone source, when isGit
+  user: string // SSH user — only needed for the non-git rsync path
+  host: string
+  port: number | null
+  filesRoot: string // remote /sites/{domain}/files — rsync source root
+  publicFolder: string | null // as configured; the real webroot is still detected, not trusted
+  destPath: string // expanded local destination (must not exist, or be empty)
+  destUrl: string
+}
+
+export type LocalSetupPlanResult = { ok: true; plan: LocalSetupPlan } | { ok: false; error: string }
+
+export function planLocalSetup(
+  site: Site,
+  server: Server | undefined,
+  sshUser: string | null,
+  destPath: string,
+  destUrl: string,
+): LocalSetupPlanResult {
+  const path = destPath.trim()
+  if (!path) return { ok: false, error: "Enter a local path." }
+  const dir = expandPath(path)
+  if (existsSync(dir) && readdirSync(dir).length > 0) return { ok: false, error: "That path already exists and isn't empty." }
+
+  const isGit = !!site.git?.repo
+  const host = server?.ip_address
+  const user = site.site_user ?? sshUser
+  // Non-git sites are pulled over SSH, so they need a reachable server + user.
+  // Git sites clone straight from the repo and never touch the server.
+  if (!isGit && (!host || !user)) return { ok: false, error: "Missing site user or server IP — can't reach the site." }
+
+  return {
+    ok: true,
+    plan: {
+      domain: site.domain,
+      isGit,
+      repoUrl: site.git?.repo ?? null,
+      user: user ?? "",
+      host: host ?? "",
+      port: server?.ssh_port ?? null,
+      filesRoot: `/sites/${site.domain}/files`,
+      publicFolder: site.public_folder,
+      destPath: dir,
+      destUrl: destUrl.trim(),
+    },
+  }
+}
+
+export type LocalSetupStage = "fetch" | "build" | "done" | "error"
+
+export interface LocalSetupProgress {
+  stage: LocalSetupStage
+  domain: string
+  destPath?: string
+  error?: string
+  failedStage?: LocalSetupStage
+  ranComposer?: boolean
+}
+
+export function isLocalSetupInFlight(p: LocalSetupProgress | undefined): boolean {
+  return p != null && p.stage !== "done" && p.stage !== "error"
+}
+
+// rsync the source's whole files root down, excluding uploads wherever they
+// land (relative to the detected webroot, not assumed at the files root).
+async function fetchByRsync(plan: LocalSetupPlan): Promise<{ code: number; stderr: string }> {
+  const target = `${plan.user}@${plan.host}`
+  const probeScript = `${detectWpDirScript(plan.filesRoot, plan.publicFolder ?? undefined)}; echo "D:$D"; echo "W:$W"`
+  const probe = await runProcess(["ssh", ...SSH_OPTS, ...sshPort(plan.port), target, probeScript], 30_000)
+  if (probe.code !== 0) return { code: probe.code, stderr: probe.stderr }
+  const d = probe.stdout.match(/^D:(.*)$/m)?.[1]?.trim()
+  const w = probe.stdout.match(/^W:(.*)$/m)?.[1]?.trim()
+  if (!d) return { code: 1, stderr: "couldn't determine the site's files root on the server." }
+  if (!w) return { code: 1, stderr: "couldn't find a WordPress install under this site on the server." }
+
+  // Paths relative to the files root we're about to rsync, e.g.
+  // "public/wp-content/uploads" when the webroot sits below the files root, or
+  // bare "wp-content/uploads" when it doesn't.
+  const webrootRel = w === d ? "" : w.slice(d.length).replace(/^\/+/, "")
+  const contentRel = (name: string) => (webrootRel ? `${webrootRel}/wp-content/${name}` : `wp-content/${name}`)
+  // object-cache.php (and advanced-cache.php, same family) are server drop-ins
+  // wired to production's Redis/disk cache — they don't just no-op without it,
+  // they fatal (confirmed: SpinupWP's object-cache drop-in 500s on a cache MISS
+  // when Redis is unreachable). Local dev doesn't want production caching
+  // anyway, so these are excluded outright rather than copied and hoping.
+  const excludes = ["uploads", "object-cache.php", "advanced-cache.php"].map((name) => `--exclude=${contentRel(name)}`)
+
+  const sshCmd = ["ssh", ...SSH_OPTS, ...sshPort(plan.port)].join(" ")
+  return runProcess(["rsync", "-az", "-e", sshCmd, ...excludes, `${target}:${d}/`, `${plan.destPath}/`], 600_000)
+}
+
+export async function runLocalSetup(plan: LocalSetupPlan, onProgress: (p: LocalSetupProgress) => void): Promise<LocalSetupProgress> {
+  const domain = plan.domain
+  const fail = (error: string, failedStage: LocalSetupStage = "fetch"): LocalSetupProgress => {
+    const p: LocalSetupProgress = { stage: "error", domain, error, failedStage }
+    onProgress(p)
+    return p
+  }
+  const stageFail = (label: string, stderr: string, fallback: string, failedStage: LocalSetupStage) =>
+    fail(`${label} — ${meaningfulError(stderr, fallback)}`, failedStage)
+
+  onProgress({ stage: "fetch", domain })
+  try {
+    mkdirSync(dirname(plan.destPath), { recursive: true })
+  } catch {
+    // best-effort — the actual clone/rsync surfaces a real error if this truly can't be created
+  }
+
+  if (plan.isGit) {
+    if (!plan.repoUrl) return fail("This site has no git repo configured in SpinupWP.", "fetch")
+    const cl = await runProcess(["git", "clone", plan.repoUrl, plan.destPath], 300_000)
+    if (cl.code !== 0) return stageFail("git clone failed", cl.stderr, `exit ${cl.code}.`, "fetch")
+  } else {
+    mkdirSync(plan.destPath, { recursive: true })
+    const rs = await fetchByRsync(plan)
+    if (rs.code !== 0) return stageFail("File pull failed", rs.stderr, `exit ${rs.code}.`, "fetch")
+  }
+
+  // Bedrock/Radicle needs `composer install` to build vendor/ + web/wp before
+  // anything (wp-cli included) can find a WordPress install in the checkout.
+  // Standard WP ships its core in the tree already, so this is a no-op there.
+  const kind = resolveLocalLink({ domain, path: plan.destPath, localUrl: plan.destUrl }).kind
+  let ranComposer = false
+  if (kind === "bedrock" || kind === "radicle") {
+    onProgress({ stage: "build", domain })
+    const ci = await runProcess(["bash", "-lc", "composer install"], 300_000, plan.destPath)
+    if (ci.code !== 0) return stageFail("composer install failed", ci.stderr, "composer error.", "build")
+    ranComposer = true
+  }
+
+  const done: LocalSetupProgress = { stage: "done", domain, destPath: plan.destPath, ranComposer }
+  onProgress(done)
+  return done
+}

package/src/lib/sshExec.ts

@@ -44,8 +44,9 @@ export async function execSshCommand(
   command: string,
   client: SpinupWPClientLike,
   cfg: AppConfig,
+  opts?: { server?: string | null },
 ): Promise<SshExecResult> {
-  const resolution = await resolveSshTargetInfo(domain, client, cfg)
+  const resolution = await resolveSshTargetInfo(domain, client, cfg, opts)
   if (!resolution.ok) {
     logSshExecAttempt({ domain, command, decision: "error", reason: resolution.result.reason, message: resolution.result.message })
     return { ...resolution.result, command }

package/src/ui/App.tsx

@@ -30,6 +30,7 @@ import { NewServer } from "./views/NewServer.tsx"
 import { VanityNewSite } from "./views/VanityNewSite.tsx"
 import { CloneWizard } from "./views/CloneWizard.tsx"
 import { LocalLinkOverlay } from "./views/LocalLink.tsx"
+import { LocalSetupOverlay } from "./views/LocalSetup.tsx"
 import { Discover } from "./views/Discover.tsx"
 import { Forgotten } from "./views/Forgotten.tsx"
 import { DnsInventory } from "./views/DnsInventory.tsx"
@@ -75,6 +76,7 @@ export function App() {
     store.vanityServer !== null ||
     store.cloneServer !== null ||
     store.localLinkSite !== null ||
+    store.localSetupSite !== null ||
     store.discoverOpen ||
     store.forgottenOpen ||
     store.dnsInventoryServer !== null ||
@@ -166,6 +168,9 @@ export function App() {
     // The local-link overlay owns the keyboard while open.
     if (store.localLinkSite) return
 
+    // The new-local-copy (clone/rsync) overlay owns the keyboard while open.
+    if (store.localSetupSite) return
+
     // The discovery overlay owns the keyboard while open.
     if (store.discoverOpen) return
 
@@ -256,6 +261,7 @@ export function App() {
       {store.vanityServer && <VanityNewSite />}
       {store.cloneServer && <CloneWizard />}
       {store.localLinkSite && <LocalLinkOverlay />}
+      {store.localSetupSite && <LocalSetupOverlay />}
       {store.discoverOpen && <Discover />}
       {store.forgottenOpen && <Forgotten />}
       {store.dnsInventoryServer && <DnsInventory />}

package/src/ui/Splash.tsx

@@ -4,6 +4,7 @@
 import { useEffect, useState } from "react"
 import { theme } from "../lib/theme.ts"
 import { Spinner } from "./components.tsx"
+import { APP_VERSION } from "../version.ts"
 
 const TAGLINE = "Terminal control center for your SpinupWP fleet"
 
@@ -40,6 +41,8 @@ export function Splash({ status }: { status: string }) {
       <box style={{ height: 1 }} />
       <text content={TAGLINE} fg={theme.text} />
       <box style={{ height: 1 }} />
+      <text content={`Version ${APP_VERSION}`} fg={theme.brand} />
+      <box style={{ height: 1 }} />
       <Pulse />
       <box style={{ height: 2 }} />
       <box style={{ flexDirection: "row" }}>

package/src/ui/store.tsx

@@ -55,6 +55,7 @@ import { resolvePhpEolDates, refreshPhpEolDates, isPhpEol as isPhpEolWith, offer
 import { resolveUbuntuEolDates, refreshUbuntuEolDates, isUbuntuEol as isUbuntuEolWith, type UbuntuEolDates } from "../lib/ubuntuEol.ts"
 import { planDbBackup, runDbBackup, type DbBackupProgress, type PlanResult } from "../lib/dbBackup.ts"
 import { planDbSync, runDbSync, type DbSyncProgress, type SyncPlanResult } from "../lib/dbSync.ts"
+import { planLocalSetup, runLocalSetup, type LocalSetupProgress, type LocalSetupPlanResult } from "../lib/localSetup.ts"
 import { planMediaFallback, type MediaFallbackResult } from "../lib/mediaFallback.ts"
 
 export type Route = "dashboard" | "servers" | "stacks" | "search" | "events"
@@ -372,12 +373,14 @@ const phpJobId = (siteId: number) => `phpUpgrade:${siteId}`
 const httpsJobId = (siteId: number) => `httpsToggle:${siteId}`
 const dbSyncJobId = (siteId: number) => `dbSync:${siteId}`
 const dbBackupJobId = (siteId: number) => `dbBackup:${siteId}`
+const localSetupJobId = (siteId: number) => `localSetup:${siteId}`
 
 // SSH-orchestrated jobs (no SpinupWP event to re-attach to) can't truly resume —
 // their child processes died with the app. On restart we surface them as
 // interrupted rather than pretend, since the local DB may be half-applied.
 const INTERRUPTED_SYNC_MSG = "Interrupted by a restart — your local database may be partially imported. Re-run the sync (p)."
 const INTERRUPTED_BACKUP_MSG = "Interrupted by a restart — the download didn't finish. Re-run the backup (d)."
+const INTERRUPTED_LOCAL_SETUP_MSG = "Interrupted by a restart — the local copy may be partial. Re-run the clone."
 // Server provisioning events settle with one of these (broader than PHP/site
 // writes, whose terminal is "deployed"); finished_at also implies done.
 const SERVER_DONE = new Set(["deployed", "completed", "provisioned", "finished", "success"])
@@ -715,6 +718,16 @@ interface StoreValue extends DataState {
   startDbSync: (site: Site) => void
   clearDbSync: (siteId: number) => void
 
+  // Set up a brand-new local working copy for a remote site (clone/rsync the
+  // code down, composer install if Bedrock/Radicle) — the missing first step
+  // before a link exists at all. Never touches the DB or webserver config.
+  localSetupSite: Site | null
+  setLocalSetupSite: (s: Site | null) => void
+  localSetups: Map<number, LocalSetupProgress>
+  planLocalSetupFor: (site: Site, destPath: string, destUrl: string) => LocalSetupPlanResult
+  startLocalSetup: (site: Site, destPath: string, destUrl: string) => void
+  clearLocalSetup: (siteId: number) => void
+
   // Production media fallback overlay (mu-plugin in the linked local copy). State
   // is the plugin file's presence, resolved fresh by planMediaFallbackFor.
   mediaFallbackSite: Site | null
@@ -1003,6 +1016,8 @@ export function StoreProvider({ children }: { children: ReactNode }) {
   const [dbBackups, setDbBackups] = useState<Map<number, DbBackupProgress>>(new Map())
   const [dbSyncSite, setDbSyncSite] = useState<Site | null>(null)
   const [dbSyncs, setDbSyncs] = useState<Map<number, DbSyncProgress>>(new Map())
+  const [localSetupSite, setLocalSetupSite] = useState<Site | null>(null)
+  const [localSetups, setLocalSetups] = useState<Map<number, LocalSetupProgress>>(new Map())
   const [localSync, setLocalSyncState] = useState<boolean>(() => cfgRef.current.localSync)
   const [enableLocalSyncSite, setEnableLocalSyncSite] = useState<Site | null>(null)
   const [mediaFallbackSite, setMediaFallbackSite] = useState<Site | null>(null)
@@ -2148,6 +2163,51 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     [dbSyncs, planDbSyncFor],
   )
 
+  // ---- New local working copy (clone/rsync + composer install) ----------
+
+  const setLocalSetup = (siteId: number, progress: LocalSetupProgress) =>
+    setLocalSetups((prev) => new Map(prev).set(siteId, progress))
+
+  const clearLocalSetup = useCallback(
+    (siteId: number) =>
+      setLocalSetups((prev) => {
+        if (!prev.has(siteId)) return prev
+        const next = new Map(prev)
+        next.delete(siteId)
+        return next
+      }),
+    [],
+  )
+
+  const planLocalSetupFor = useCallback(
+    (site: Site, destPath: string, destUrl: string): LocalSetupPlanResult =>
+      planLocalSetup(site, servers.find((s) => s.id === site.server_id), cfgRef.current.sshUser, destPath, destUrl),
+    [servers],
+  )
+
+  const startLocalSetup = useCallback(
+    (site: Site, destPath: string, destUrl: string) => {
+      const existing = localSetups.get(site.id)
+      if (existing && existing.stage !== "done" && existing.stage !== "error") return
+      const res = planLocalSetupFor(site, destPath, destUrl)
+      if (!res.ok) {
+        setLocalSetup(site.id, { stage: "error", domain: site.domain, error: res.error })
+        return
+      }
+      // SSH/local-process orchestrated (no event): persist only so a restart can
+      // flag it as interrupted; drop it the moment it settles.
+      void saveJob({ id: localSetupJobId(site.id), kind: "localSetup", status: "running", startedAt: Date.now(), inputs: { siteId: site.id, domain: site.domain } })
+      void runLocalSetup(res.plan, (p) => {
+        setLocalSetup(site.id, p)
+        // Link as soon as the files are down, same shape the manual `L` form
+        // writes — dbSync (`p`) and mediaFallback (`m`) both require a link.
+        if (p.stage === "done") linkSite(site.id, { domain: site.domain, path: res.plan.destPath, localUrl: res.plan.destUrl })
+        if (p.stage === "done" || p.stage === "error") void removeJob(localSetupJobId(site.id))
+      })
+    },
+    [localSetups, planLocalSetupFor, linkSite],
+  )
+
   // Compute a linked site's git drift once (cached), fire-and-forget. Stable
   // across renders (uses a ref for the dedup set), so views can call it freely
   // from an effect when a linked site comes into view.
@@ -4151,6 +4211,10 @@ export function StoreProvider({ children }: { children: ReactNode }) {
           if (inp.siteId != null) setSync(inp.siteId, { stage: "error", domain: inp.domain ?? "", error: INTERRUPTED_SYNC_MSG })
           void removeJob(job.id)
           break
+        case "localSetup":
+          if (inp.siteId != null) setLocalSetup(inp.siteId, { stage: "error", domain: inp.domain ?? "", error: INTERRUPTED_LOCAL_SETUP_MSG })
+          void removeJob(job.id)
+          break
         case "dbBackup":
           if (inp.siteId != null) setBackup(inp.siteId, { stage: "error", domain: inp.domain ?? "", error: INTERRUPTED_BACKUP_MSG })
           void removeJob(job.id)
@@ -4333,6 +4397,12 @@ export function StoreProvider({ children }: { children: ReactNode }) {
     planDbSyncFor,
     startDbSync,
     clearDbSync,
+    localSetupSite,
+    setLocalSetupSite,
+    localSetups,
+    planLocalSetupFor,
+    startLocalSetup,
+    clearLocalSetup,
     drift,
     ensureDrift,
     rebootInfo,

package/src/ui/views/LocalLink.tsx

@@ -1,14 +1,19 @@
-// Local working-copy link overlay — Phase 1 (link + view, no mutation).
+// Local working-copy link overlay — Phase 1 (link + view, no mutation) plus
+// the entry point into Phase 2 (LocalSetup.tsx's guided clone).
 //
-// Opened with `L` on a selected site (Browser / Search results). Two modes:
+// Opened with `L` on a selected site (Browser / Search results). Modes:
+//   • choose — no link exists yet: pick manual entry (`e`) or a guided clone
+//     from production (`c`, hands off to LocalSetupOverlay).
 //   • view — the site is linked: shows the validated status (Bedrock / WordPress
 //     / missing) and offers open-locally actions: `t` opens a terminal at the
 //     path, `v` opens the stored local URL in the browser. `e` edits, `x` unlinks.
 //   • edit — a small form to enter the local path + local URL (manual entry).
 //
-// Per the locked spec these are LOCAL conveniences only: we open a terminal and
-// the local URL — we never launch an editor and never run composer/git here.
-// The mutating maintenance loop (composer update → push → deploy) is a later phase.
+// This file itself still only links — we open a terminal and the local URL, and
+// never launch an editor. Getting code onto disk (git clone / rsync / composer)
+// lives entirely in LocalSetup.tsx, kept separate from this file's original
+// read-only-on-disk scope. The mutating maintenance loop (composer update → push
+// → deploy) is still a later phase.
 
 import { useEffect, useState } from "react"
 import { useKeyboard } from "@opentui/react"
@@ -19,7 +24,7 @@ import { StatusBar } from "../StatusBar.tsx"
 import { useStore } from "../store.tsx"
 import { resolveLocalLink, type LocalKind } from "../../lib/local.ts"
 
-type Mode = "view" | "edit"
+type Mode = "choose" | "view" | "edit"
 type EditField = "path" | "url"
 
 function kindColor(kind: LocalKind, exists: boolean): string {
@@ -31,11 +36,11 @@ function kindColor(kind: LocalKind, exists: boolean): string {
 
 export function LocalLinkOverlay() {
   const store = useStore()
-  const { localLinkSite: site, setLocalLinkSite, localLinks, linkSite, unlinkSite, setInputMode, openLocalTerminal, openLocalUrl, linkReturnToForgotten, setLinkReturnToForgotten, setForgottenOpen } = store
+  const { localLinkSite: site, setLocalLinkSite, localLinks, linkSite, unlinkSite, setInputMode, openLocalTerminal, openLocalUrl, linkReturnToForgotten, setLinkReturnToForgotten, setForgottenOpen, setLocalSetupSite } = store
 
   const existing = site ? localLinks.get(site.id) : undefined
 
-  const [mode, setMode] = useState<Mode>(() => (existing ? "view" : "edit"))
+  const [mode, setMode] = useState<Mode>(() => (existing ? "view" : "choose"))
   const [field, setField] = useState<EditField>("path")
   const [pathInput, setPathInput] = useState(existing?.path ?? "")
   const [urlInput, setUrlInput] = useState(existing?.localUrl ?? "")
@@ -73,9 +78,28 @@ export function LocalLinkOverlay() {
   useKeyboard((key) => {
     const name = key.name ?? ""
 
+    if (mode === "choose") {
+      if (name === "escape" || name === "q") return close()
+      if (name === "e") {
+        setPathInput("")
+        setUrlInput("")
+        setField("path")
+        return setMode("edit")
+      }
+      if (name === "c" && site) {
+        // Not close() — that hands back to the "needs a local copy" report if we
+        // arrived from there, which doesn't make sense mid-clone. Just hand off.
+        setInputMode(false)
+        setLocalLinkSite(null)
+        setLocalSetupSite(site)
+      }
+      return
+    }
+
     if (mode === "edit") {
-      // Esc backs out: to the view mode if a link already exists, else closes.
-      if (name === "escape") return existing ? setMode("view") : close()
+      // Esc backs out: to the view mode if a link already exists, else to the
+      // choose screen (there's no link yet, so there's nothing to "view").
+      if (name === "escape") return existing ? setMode("view") : setMode("choose")
       // ↑/↓ switch fields (Enter advances/saves via the inputs' onSubmit).
       if (name === "up") return setField("path")
       if (name === "down") return setField("url")
@@ -138,12 +162,33 @@ export function LocalLinkOverlay() {
         <text content={existing ? "linked" : "not linked"} fg={existing ? theme.good : theme.textFaint} style={{ flexShrink: 0 }} />
       </box>
 
-      <Centered>{mode === "edit" ? renderEdit() : renderView()}</Centered>
+      <Centered>{mode === "choose" ? renderChoose() : mode === "edit" ? renderEdit() : renderView()}</Centered>
 
       <StatusBar hints={hints()} message={flash ?? undefined} messageColor={theme.brand} showGlobal={false} />
     </box>
   )
 
+  function renderChoose() {
+    return (
+      <Panel title=" No local copy yet " active>
+        <box style={{ flexDirection: "column", width: 62, paddingTop: 1, paddingBottom: 1 }}>
+          <text content="How do you want to set this up?" fg={theme.text} wrapMode="none" />
+          <box style={{ height: 1 }} />
+          <box style={{ flexDirection: "row" }}>
+            <text content="c  " fg={theme.accent} style={{ flexShrink: 0 }} />
+            <text content="Clone fullsite (DB + files) from production" fg={theme.text} wrapMode="none" />
+          </box>
+          <text content="   git clone / file pull, no uploads/ — guided" fg={theme.textFaint} wrapMode="none" />
+          <box style={{ height: 1 }} />
+          <box style={{ flexDirection: "row" }}>
+            <text content="e  " fg={theme.accent} style={{ flexShrink: 0 }} />
+            <text content="Enter a path — you already have a copy" fg={theme.text} wrapMode="none" />
+          </box>
+        </box>
+      </Panel>
+    )
+  }
+
   function renderView() {
     return (
       <Panel title=" Linked working copy " active>
@@ -203,6 +248,12 @@ export function LocalLinkOverlay() {
   }
 
   function hints() {
+    if (mode === "choose")
+      return [
+        { key: "c", label: "clone from production" },
+        { key: "e", label: "enter a path" },
+        { key: "esc", label: "cancel" },
+      ]
     if (mode === "edit")
       return [
         { key: "↑↓", label: "field" },