@h-rig/cli 0.0.6-alpha.88 → 0.0.6-alpha.89

package/dist/src/app-opentui/scenes/tasks.js

@@ -356,14 +356,56 @@ function sortTasks(tasks, spec) {
   return applyDir(tasks, compare, dir);
 }
 
+// packages/cli/src/app-opentui/remote-link.ts
+var REPAIRABLE_REMOTE_LINK_STATUSES = new Set([
+  "auth_required",
+  "project_not_registered",
+  "no_server_checkout",
+  "invalid_root",
+  "needs_prepare",
+  "error"
+]);
+function remoteProjectLinkError(message) {
+  return /no server-host project root link|remote project(?:-root)? link|x-rig-project-root|serverProjectRoot/i.test(message ?? "");
+}
+function serverRecordForRemoteLink(state) {
+  const server = state.data.server;
+  return server && typeof server === "object" && !Array.isArray(server) ? server : null;
+}
+function remoteProjectLinkState(state) {
+  const serverRecord = serverRecordForRemoteLink(state);
+  if (!serverRecord || serverRecord.kind !== "remote")
+    return null;
+  const link = serverRecord.remoteProjectLink;
+  if (link && typeof link === "object" && !Array.isArray(link))
+    return link;
+  const direct = state.data.remoteProjectLink;
+  if (direct && typeof direct === "object" && !Array.isArray(direct))
+    return direct;
+  return null;
+}
+function shouldOfferRemoteLinkRepair(state, message) {
+  const link = remoteProjectLinkState(state);
+  if (link) {
+    if (link.ok === true)
+      return false;
+    const status = link.status ?? "";
+    return REPAIRABLE_REMOTE_LINK_STATUSES.has(status);
+  }
+  const serverRecord = serverRecordForRemoteLink(state);
+  if (serverRecord && serverRecord.kind !== "remote")
+    return false;
+  return remoteProjectLinkError(message ?? state.error?.message);
+}
+
 // packages/cli/src/app-opentui/scenes/tasks.ts
-var TASK_RECOVERY_ITEMS = [
+var BASE_TASK_RECOVERY_ITEMS = [
   { id: "refresh", label: "refresh", intent: { scene: "tasks", argv: ["tasks"], action: { kind: "refresh", label: "Refresh tasks" } }, message: "refresh task source" },
-  { id: "next", label: "next", intent: { scene: "command", argv: ["task", "run", "--next"], action: { kind: "command-run", label: "Run next task" } }, message: "dispatch next runnable task" },
-  { id: "repair", label: "repair", intent: { scene: "command", argv: ["init", "--repair"], action: { kind: "command-run", label: "Repair task source" } }, message: "repair project/task source" },
+  { id: "next", label: "next", intent: { scene: "tasks", argv: ["task", "run", "--next"], action: { kind: "task-run-next", label: "Dispatch next task" } }, message: "dispatch next runnable task" },
   { id: "server", label: "server", intent: { scene: "server", argv: ["server", "status"], action: { kind: "refresh", label: "Open server controls" } }, message: "server controls" },
   { id: "doctor", label: "doctor", intent: { scene: "doctor", argv: ["doctor"], action: { kind: "doctor-run", label: "Run doctor" } }, message: "diagnose task source" }
 ];
+var TASK_REPAIR_LINK_ITEM = { id: "repair-link", label: "repair link", intent: { scene: "server", argv: ["server", "repair-link"], action: { kind: "remote-link-repair", label: "Repair remote link", payload: { returnScene: "tasks" } } }, message: "backfill or prepare remote project link" };
 var COL = {
   glyph: 1,
   id: 11,
@@ -523,34 +565,44 @@ function taskRow(width, task, active, optimistic) {
   const item = taskSelectableItem(task);
   return item ? withSelectable(row, item) : row;
 }
-var RECOVERY_DECKS = [
+var BASE_RECOVERY_DECKS = [
   { label: "refresh", detail: "reload task source" },
   { label: "next", detail: "dispatch next runnable task" },
-  { label: "repair", detail: "repair project/task source link" },
   { label: "server", detail: "open server controls" },
   { label: "doctor", detail: "diagnose task source" }
 ];
-function recoveryRows(selected, reason) {
+function taskRecoveryItems(state) {
+  if (!shouldOfferRemoteLinkRepair(state))
+    return BASE_TASK_RECOVERY_ITEMS;
+  return [BASE_TASK_RECOVERY_ITEMS[0], BASE_TASK_RECOVERY_ITEMS[1], TASK_REPAIR_LINK_ITEM, ...BASE_TASK_RECOVERY_ITEMS.slice(2)];
+}
+function taskRecoveryDecks(state) {
+  if (!shouldOfferRemoteLinkRepair(state))
+    return BASE_RECOVERY_DECKS;
+  return [BASE_RECOVERY_DECKS[0], BASE_RECOVERY_DECKS[1], { label: "repair link", detail: "backfill/prepare remote project-root link" }, ...BASE_RECOVERY_DECKS.slice(2)];
+}
+function recoveryRows(state, selected, reason) {
+  const items = taskRecoveryItems(state);
   return [
     ...reason ? [line(reason, { fg: RIG_UI.yellow }), line("", { fg: RIG_UI.ink3 })] : [],
     line("ACTIONS", { fg: RIG_UI.ink3, bold: true }),
-    ...RECOVERY_DECKS.map((deck, index) => selectableDeckRow({ ...deck, index, active: selected === index }, TASK_RECOVERY_ITEMS[index]))
+    ...taskRecoveryDecks(state).map((deck, index) => selectableDeckRow({ ...deck, index, active: selected === index }, items[index]))
   ];
 }
-function emptyRows(query, total, selected) {
+function emptyRows(state, query, total, selected) {
   if (!query.trim() && total === 0)
-    return recoveryRows(selected, "No tasks loaded.");
+    return recoveryRows(state, selected, "No tasks loaded.");
   if (query.trim() && total > 0) {
     return [
-      ...recoveryRows(selected, `No matching tasks for ${JSON.stringify(query)} (${total} total).`)
+      ...recoveryRows(state, selected, `No matching tasks for ${JSON.stringify(query)} (${total} total).`)
     ];
   }
-  return recoveryRows(selected, "No tasks are visible with this filter.");
+  return recoveryRows(state, selected, "No tasks are visible with this filter.");
 }
 function degradedRows(state, selected) {
   if (!state.error)
     return [];
-  return recoveryRows(selected, state.error.message);
+  return recoveryRows(state, selected, state.error.message);
 }
 function rawString(raw, key) {
   const value = raw?.[key];
@@ -574,7 +626,10 @@ function renderTaskDetail(state, taskId, layout) {
   const activeRunId = task?.activeRun?.runId?.trim();
   const width = panelWidth(layout);
   const selected = Math.max(0, state.selection.index);
+  const errorText = state.error?.message ?? lastRefreshError(state);
+  const offerRepairLink = shouldOfferRemoteLinkRepair(state, errorText);
   const headerLines = [
+    ...errorText ? errorBanner(errorText, offerRepairLink ? "select repair link below to prepare the remote checkout" : "retry dispatch after resolving the issue") : [],
     line(`${glyph} ${title}`, { fg: color, bold: true }),
     line(`task ${taskId} \xB7 ${status}`, { fg: RIG_UI.ink3 }),
     ...task && task.labels.length > 0 ? [line(`labels: ${task.labels.join(", ")}`, { fg: RIG_UI.ink4 })] : [],
@@ -586,8 +641,16 @@ function renderTaskDetail(state, taskId, layout) {
   const actionRows = [];
   actionRows.push(selectableDeckRow({ label: "back", detail: "return to the task list", index, active: selected === index }, { id: "task-detail-back", label: "back", data: { taskDetailId: undefined }, message: "back to task list" }));
   index += 1;
-  actionRows.push(selectableDeckRow({ label: "dispatch", detail: "submit a Pi run for this task", index, active: selected === index }, { id: `task-detail-run:${taskId}`, label: `dispatch ${taskId}`, intent: { scene: "tasks", argv: ["run", taskId], action: { kind: "task-run-id", payload: { task: taskId }, label: `Dispatching ${taskId}` } }, message: `dispatch task ${taskId}` }));
-  index += 1;
+  if (offerRepairLink) {
+    actionRows.push(selectableDeckRow({ label: "repair link", detail: "prepare/backfill the selected remote project-root link", index, active: selected === index }, { id: `task-detail-repair-link:${taskId}`, label: "repair link", intent: { scene: "server", argv: ["server", "repair-link"], action: { kind: "remote-link-repair", label: "Repair remote link", payload: { returnScene: "tasks", taskDetailId: taskId } } }, message: "prepare remote checkout link" }));
+    index += 1;
+  }
+  if (offerRepairLink) {
+    actionRows.push(line("  dispatch   blocked until the remote project link is repaired", { fg: RIG_UI.ink4 }));
+  } else {
+    actionRows.push(selectableDeckRow({ label: "dispatch", detail: "submit a Pi run for this task", index, active: selected === index }, { id: `task-detail-run:${taskId}`, label: `dispatch ${taskId}`, intent: { scene: "tasks", argv: ["run", taskId], action: { kind: "task-run-id", payload: { task: taskId }, label: `Dispatching ${taskId}` } }, message: `dispatch task ${taskId}` }));
+    index += 1;
+  }
   if (activeRunId) {
     actionRows.push(selectableDeckRow({ label: "attach", detail: `attach the Pi console to run ${activeRunId.slice(0, 8)}`, index, active: selected === index }, { id: `task-detail-attach:${taskId}`, label: `attach ${activeRunId.slice(0, 8)}`, intent: { scene: "handoff", argv: ["attach", activeRunId], action: { kind: "run-attach", payload: { runId: activeRunId }, label: `Attach Pi ${activeRunId.slice(0, 8)}` } }, message: `attach Pi to ${activeRunId.slice(0, 8)}` }));
     index += 1;
@@ -646,7 +709,7 @@ function renderTasksScene(state, layout) {
   const tasks = sortTasks(filterTasksForSearch(allTasks, query), spec);
   const selected = typeof state.data.selectedTaskId === "string" && tasks.some((task) => task.id === state.data.selectedTaskId) ? state.data.selectedTaskId : tasks[0]?.id;
   const selectedIndex = Math.max(0, tasks.findIndex((task) => task.id === selected));
-  const recoveryIndex = Math.max(0, Math.min(4, state.selection.index));
+  const recoveryIndex = Math.max(0, Math.min(taskRecoveryItems(state).length - 1, state.selection.index));
   const dispatching = dispatchingFor(state);
   const dispatchLine = dispatching ? ` \xB7 ${state.data.dispatchingRun?.runId ?? "new"} ${dispatching.status}` : "";
   const updatedAgo = updatedAgoLabel(state);
@@ -666,7 +729,7 @@ function renderTasksScene(state, layout) {
       ...tasks.map((task, index) => taskRow(contentWidth, task, index === selectedIndex, dispatching && dispatching.taskId === task.id ? dispatching.status : undefined))
     ] : state.error ? degradedRows(state, recoveryIndex) : loading ? loadingRows("tasks", state.tick) : [
       ...query.trim() ? [line(searchSummary("tasks", query, tasks.length, allTasks.length), { fg: RIG_UI.ink4 }), line("", { fg: RIG_UI.ink3 })] : [],
-      ...emptyRows(query, allTasks.length, recoveryIndex)
+      ...emptyRows(state, query, allTasks.length, recoveryIndex)
     ]
   ];
   return makeSceneFrame({

package/dist/src/app-opentui/state.js

@@ -152,16 +152,31 @@ function taskViewIntent(argv, command = "", rest = [], raw) {
   const { payload, label } = taskViewPayload(command, rest);
   return intent("tasks", argv, "refresh", payload, label, raw);
 }
-function routeServer(argv, command, raw, checkingLabel) {
-  if (!command || command === "status") {
+function routeServer(argv, command, rest, raw, checkingLabel) {
+  if (!command || command === "status" || command === "list") {
     return intent("server", argv, "refresh", undefined, command ? checkingLabel : "Loading server", raw);
   }
+  if (command === "use") {
+    const alias = firstNonOption(rest);
+    if (alias === "local")
+      return intent("server", argv, "server-use-local", undefined, "Use local server", raw);
+    if (alias)
+      return intent("server", argv, "server-use-remote", { alias }, `Use ${alias}`, raw);
+    return intent("server", argv, "refresh", undefined, "Select a remote alias in Server", raw);
+  }
+  if (command === "add")
+    return intent("server", argv, "server-add-remote", { argv: [...argv] }, "Add remote server", raw);
+  if (command === "repair-link")
+    return intent("server", argv, "remote-link-repair", undefined, "Repair remote link", raw);
   return commandRunIntent(argv, raw);
 }
 function routeGithub(argv, command, rest, raw) {
   if (command === "auth" && (rest[0]?.toLowerCase() ?? "status") === "status" && rest.length <= 1) {
     return intent("server", argv, "refresh", undefined, "Checking GitHub auth", raw);
   }
+  if (command === "auth" && rest[0]?.toLowerCase() === "import-gh" && rest.length <= 1) {
+    return intent("server", argv, "github-auth-import", undefined, "Import GitHub auth", raw);
+  }
   return commandRunIntent(argv, raw);
 }
 function routeDoctor(argv, command, raw) {
@@ -210,11 +225,16 @@ function intentFromArgv(argv) {
     return commandRunIntent(argv);
   }
   if (normalizedGroup === "server")
-    return routeServer(argv, normalizedCommand, undefined, "Checking server");
+    return routeServer(argv, normalizedCommand, rest, undefined, "Checking server");
   if (normalizedGroup === "github")
     return routeGithub(argv, normalizedCommand, rest);
-  if (normalizedGroup === "init")
-    return commandRunIntent(argv);
+  if (normalizedGroup === "init") {
+    if (!normalizedCommand)
+      return intent("init", argv, "refresh", undefined, "Open init");
+    if (rest.includes("--yes") || normalizedCommand === "--yes")
+      return intent("init", argv, "init-start", undefined, "Run init");
+    return intent("init", argv, "refresh", undefined, "Open init");
+  }
   if (normalizedGroup === "doctor")
     return routeDoctor(argv, normalizedCommand);
   if (normalizedGroup === "inbox")

package/dist/src/app-opentui/surface-catalog.js

@@ -67,12 +67,13 @@ var PRIMARY_GROUPS = [
   {
     name: "server",
     summary: "Choose, inspect, and start the Rig server that owns tasks and runs.",
-    usage: ["rig server <status|list|add|use|start> [options]"],
+    usage: ["rig server <status|list|add|use|repair-link|start> [options]"],
     commands: [
-      { command: "status", description: "Show the selected server for this repo.", primary: true },
+      { command: "status", description: "Show the selected server and remote project-root link for this repo.", primary: true },
       { command: "use local", description: "Switch this repo to the local Rig server.", primary: true },
       { command: "add <alias> <url>", description: "Save a remote Rig server URL.", primary: true },
       { command: "use <alias>", description: "Select a saved remote server alias.", primary: true },
+      { command: "repair-link [--prepare|--backfill-only] [--repo owner/repo]", description: "Backfill or prepare the selected remote's server-host checkout link.", primary: true },
       { command: "list", description: "List saved local/remote server aliases.", primary: true },
       { command: "start [--host <host>] [--port <n>]", description: "Start a local rig-server process." }
     ],
@@ -80,6 +81,7 @@ var PRIMARY_GROUPS = [
       "rig server status",
       "rig server add prod https://where.rig-does.work",
       "rig server use prod",
+      "rig server repair-link --repo owner/repo",
       "rig server use local",
       "rig server start --port 3773"
     ],

package/dist/src/app-opentui/types.d.ts

@@ -2,7 +2,7 @@ import type { StyledText } from "@opentui/core";
 import type { RunnerContext } from "../runner";
 import type { StageLayout } from "./layout";
 export type AppSceneId = "main" | "fleet" | "tasks" | "inbox" | "server" | "init" | "doctor" | "command" | "run-detail" | "handoff" | "pi" | "plugin" | "repo" | "workspace" | "inspect" | "family" | "help" | "error";
-export type AppActionKind = "none" | "refresh" | "navigate" | "task-run-next" | "task-run-id" | "run-stop" | "run-attach" | "run-steer" | "inbox-approve" | "inbox-reject" | "inbox-answer" | "init-start" | "command-run" | "doctor-run";
+export type AppActionKind = "none" | "refresh" | "navigate" | "task-run-next" | "task-run-id" | "run-stop" | "run-attach" | "run-steer" | "inbox-approve" | "inbox-reject" | "inbox-answer" | "init-start" | "server-use-local" | "server-use-remote" | "server-add-remote" | "github-auth-import" | "remote-link-repair" | "command-run" | "doctor-run";
 export type AppIntent = {
     readonly scene: AppSceneId;
     readonly argv: readonly string[];

package/dist/src/commands/_cli-format.d.ts

@@ -46,4 +46,13 @@ export declare function formatConnectionStatus(selected: string, connections: Re
     kind: string;
     baseUrl?: string;
     mode?: string;
-}>): string;
+}>, repo?: {
+    project?: string;
+    serverProjectRoot?: string;
+} | null, remoteProjectLink?: {
+    ok?: boolean;
+    status?: string;
+    serverProjectRoot?: string;
+    message?: string;
+    hint?: string;
+} | null): string;

package/dist/src/commands/_cli-format.js

@@ -415,16 +415,19 @@ function formatConnectionList(connections) {
   return [formatSection("Rig servers", `${rows.length} available`), `${pc.bold(pad("ALIAS", aliasWidth))}  ${pc.bold("KIND")}  ${pc.bold("TARGET")}`, ...lines, "", ...formatNextSteps(["Select one: `rig server use <alias|local>`"])].join(`
 `);
 }
-function formatConnectionStatus(selected, connections) {
+function formatConnectionStatus(selected, connections, repo, remoteProjectLink) {
   const connection = selected === "local" ? { kind: "local", mode: "auto" } : connections[selected];
   const target = !connection ? "not configured" : connection.kind === "remote" ? connection.baseUrl : "local";
+  const rootLabel = remoteProjectLink ? remoteProjectLink.ok ? `ready \xB7 ${remoteProjectLink.serverProjectRoot ?? repo?.serverProjectRoot ?? "linked"}` : `${remoteProjectLink.status ?? "needs repair"} \xB7 ${remoteProjectLink.hint ?? remoteProjectLink.message ?? "run rig server repair-link"}` : repo?.serverProjectRoot ? repo.serverProjectRoot : "not required";
   return [
     formatSection("Rig server", "selected for this repo"),
     `${themeFaint("\u2502")} ${themeDim("selected ")} ${pc.bold(selected)}`,
     `${themeFaint("\u2502")} ${themeDim("kind     ")} ${formatStatusPill(connection?.kind ?? "unknown")}`,
     `${themeFaint("\u2502")} ${themeDim("target   ")} ${target ?? "not configured"}`,
+    ...repo?.project ? [`${themeFaint("\u2502")} ${themeDim("project  ")} ${repo.project}`] : [],
+    ...connection?.kind === "remote" ? [`${themeFaint("\u2502")} ${themeDim("root     ")} ${rootLabel}`] : [],
     "",
-    ...formatNextSteps(["Change: `rig server use <alias|local>`", "List saved servers: `rig server list`"])
+    ...formatNextSteps(remoteProjectLink && !remoteProjectLink.ok ? ["Repair remote link: `rig server repair-link`", "Authenticate first if needed: `rig github auth import-gh`"] : ["Change: `rig server use <alias|local>`", "List saved servers: `rig server list`"])
   ].join(`
 `);
 }

package/dist/src/commands/_connection-state.d.ts

@@ -17,6 +17,10 @@ export type RepoConnectionState = {
      * Sent as the x-rig-project-root header on every remote request.
      */
     serverProjectRoot?: string;
+    /** The selected alias that produced serverProjectRoot. Prevents cross-alias reuse. */
+    serverProjectRootAlias?: string;
+    /** The remote base URL that produced serverProjectRoot. Prevents same-alias retarget leaks. */
+    serverProjectRootBaseUrl?: string;
 };
 export declare function resolveGlobalConnectionsPath(env?: NodeJS.ProcessEnv): string;
 export declare function resolveRepoConnectionPath(projectRoot: string): string;
@@ -39,6 +43,12 @@ export declare function resolveSelectedConnection(projectRoot: string, options?:
     serverProjectRoot?: string;
 } | null;
 /** Persist the server-host project root this repo scopes to (multi-root serving). */
-export declare function writeRepoServerProjectRoot(projectRoot: string, serverProjectRoot: string): void;
+export declare function writeRepoServerProjectRoot(projectRoot: string, serverProjectRoot: string, metadata?: {
+    alias?: string;
+    baseUrl?: string;
+    project?: string;
+}): void;
+/** Remove a stale server-host root while preserving selected server/repo state. */
+export declare function clearRepoServerProjectRoot(projectRoot: string): void;
 /** Whether this repo's selected connection targets a remote Rig server. */
 export declare function isRemoteConnectionSelected(projectRoot: string): boolean;

package/dist/src/commands/_connection-state.js

@@ -100,12 +100,28 @@ function readRepoConnection(projectRoot) {
     selected,
     project: typeof record.project === "string" ? record.project : undefined,
     linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
-    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined,
+    serverProjectRootAlias: typeof record.serverProjectRootAlias === "string" && record.serverProjectRootAlias.trim() ? record.serverProjectRootAlias.trim() : undefined,
+    serverProjectRootBaseUrl: typeof record.serverProjectRootBaseUrl === "string" && record.serverProjectRootBaseUrl.trim() ? record.serverProjectRootBaseUrl.trim().replace(/\/+$/, "") : undefined
   };
 }
 function writeRepoConnection(projectRoot, state) {
   writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
 }
+function rootAllowedForSelection(repo, connection) {
+  const root = repo.serverProjectRoot?.trim();
+  if (!root)
+    return;
+  if (connection.kind === "remote") {
+    if (repo.serverProjectRootAlias !== repo.selected)
+      return;
+    if (repo.serverProjectRootBaseUrl !== connection.baseUrl)
+      return;
+  } else if (repo.serverProjectRootAlias && repo.serverProjectRootAlias !== repo.selected) {
+    return;
+  }
+  return root;
+}
 function resolveSelectedConnection(projectRoot, options = {}) {
   const repo = readRepoConnection(projectRoot);
   if (!repo)
@@ -117,13 +133,41 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   if (!connection) {
     throw new CliError(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
   }
-  return { alias: repo.selected, connection, serverProjectRoot: repo.serverProjectRoot };
+  return { alias: repo.selected, connection, serverProjectRoot: rootAllowedForSelection(repo, connection) };
+}
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot, metadata = {}) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return;
+  let inferred = metadata;
+  if (!inferred.alias || !inferred.baseUrl) {
+    try {
+      const selected = resolveSelectedConnection(projectRoot);
+      if (selected?.connection.kind === "remote") {
+        inferred = {
+          alias: inferred.alias ?? selected.alias,
+          baseUrl: inferred.baseUrl ?? selected.connection.baseUrl
+        };
+      }
+    } catch {}
+  }
+  writeRepoConnection(projectRoot, {
+    ...repo,
+    ...metadata.project ? { project: metadata.project } : {},
+    serverProjectRoot,
+    ...inferred.alias ? { serverProjectRootAlias: inferred.alias } : {},
+    ...inferred.baseUrl ? { serverProjectRootBaseUrl: inferred.baseUrl.replace(/\/+$/, "") } : {}
+  });
 }
-function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
+function clearRepoServerProjectRoot(projectRoot) {
   const repo = readRepoConnection(projectRoot);
   if (!repo)
     return;
-  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
+  writeRepoConnection(projectRoot, {
+    selected: repo.selected,
+    ...repo.project ? { project: repo.project } : {},
+    ...repo.linkedAt ? { linkedAt: repo.linkedAt } : {}
+  });
 }
 function isRemoteConnectionSelected(projectRoot) {
   return resolveSelectedConnection(projectRoot)?.connection.kind === "remote";
@@ -138,5 +182,6 @@ export {
   resolveGlobalConnectionsPath,
   readRepoConnection,
   readGlobalConnections,
-  isRemoteConnectionSelected
+  isRemoteConnectionSelected,
+  clearRepoServerProjectRoot
 };