regionclaw 0.0.3 → 0.0.4

package/apps/ui/regionclaw-build/types/routes.d.ts

@@ -2,7 +2,7 @@
 // Do not edit this file manually
 
 type AppRoutes = "/" | "/dashboard" | "/login" | "/setup"
-type AppRouteHandlerRoutes = "/api/auth/[...nextauth]" | "/api/auth/first-run" | "/api/trpc/[trpc]"
+type AppRouteHandlerRoutes = "/api/auth/[...nextauth]" | "/api/auth/first-run" | "/api/trpc/[trpc]" | "/api/update/run" | "/api/update/status"
 type PageRoutes = never
 type LayoutRoutes = "/"
 type RedirectRoutes = never
@@ -15,6 +15,8 @@ interface ParamMap {
   "/api/auth/[...nextauth]": { "nextauth": string[]; }
   "/api/auth/first-run": {}
   "/api/trpc/[trpc]": { "trpc": string; }
+  "/api/update/run": {}
+  "/api/update/status": {}
   "/dashboard": {}
   "/login": {}
   "/setup": {}

package/apps/ui/regionclaw-build/types/validator.ts

@@ -110,6 +110,24 @@ type RouteHandlerConfig<Route extends AppRouteHandlerRoutes = AppRouteHandlerRou
   type __Unused = __Check
 }
 
+// Validate ../../src/app/api/update/run/route.ts
+{
+  type __IsExpected<Specific extends RouteHandlerConfig<"/api/update/run">> = Specific
+  const handler = {} as typeof import("../../src/app/api/update/run/route.js")
+  type __Check = __IsExpected<typeof handler>
+  // @ts-ignore
+  type __Unused = __Check
+}
+
+// Validate ../../src/app/api/update/status/route.ts
+{
+  type __IsExpected<Specific extends RouteHandlerConfig<"/api/update/status">> = Specific
+  const handler = {} as typeof import("../../src/app/api/update/status/route.js")
+  type __Check = __IsExpected<typeof handler>
+  // @ts-ignore
+  type __Unused = __Check
+}
+
 
 
 

package/apps/ui/src/app/(app)/layout.tsx

@@ -3,7 +3,9 @@ import { redirect } from "next/navigation";
 import { getServerAuthSession } from "@/auth";
 import { AppLayoutHeader } from "@/components/app-layout-header";
 import { AppSidebar } from "@/components/app-sidebar";
+import { RegionClawUpdateBanner } from "@/components/regionclaw-update-banner";
 import { SidebarInset, SidebarProvider } from "@/components/ui/sidebar";
+import { getRegionClawVersion } from "@/server/regionclaw-meta";
 
 export default async function AppLayout({
   children,
@@ -13,6 +15,8 @@ export default async function AppLayout({
     redirect("/login");
   }
 
+  const version = getRegionClawVersion();
+
   return (
     <SidebarProvider defaultOpen>
       <AppSidebar
@@ -21,9 +25,11 @@ export default async function AppLayout({
           email: session.user.email,
           username: session.user.username,
         }}
+        version={version}
       />
       <SidebarInset className="overflow-hidden border md:m-2 md:ml-0">
-        <AppLayoutHeader title="Dashboard" />
+        <AppLayoutHeader title="Dashboard" version={version} />
+        <RegionClawUpdateBanner />
         <div className="flex flex-1 flex-col bg-background">{children}</div>
       </SidebarInset>
     </SidebarProvider>

package/apps/ui/src/app/api/update/run/route.ts

@@ -0,0 +1,36 @@
+import { NextResponse } from "next/server";
+
+import { getServerAuthSession } from "@/auth";
+import {
+  canScheduleRegionClawRestart,
+  runRegionClawUpdate,
+  scheduleRegionClawRestart,
+} from "@/server/update-cli";
+
+export async function POST() {
+  const session = await getServerAuthSession();
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  try {
+    const result = await runRegionClawUpdate();
+    if (result.status === "updated" && result.requiresRestart && canScheduleRegionClawRestart()) {
+      result.restartScheduled = true;
+      result.message = "RegionClaw updated. Restarting now.";
+      setTimeout(() => {
+        scheduleRegionClawRestart();
+      }, 750).unref();
+    }
+    return NextResponse.json(result);
+  } catch (error) {
+    return NextResponse.json(
+      {
+        ok: false,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 },
+    );
+  }
+}

package/apps/ui/src/app/api/update/status/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server";
+
+import { getServerAuthSession } from "@/auth";
+import { getRegionClawUpdateStatus } from "@/server/update-cli";
+
+export async function GET() {
+  const session = await getServerAuthSession();
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  try {
+    const status = await getRegionClawUpdateStatus();
+    return NextResponse.json(status);
+  } catch (error) {
+    return NextResponse.json(
+      {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 },
+    );
+  }
+}

package/apps/ui/src/components/app-layout-header.tsx

@@ -1,12 +1,18 @@
 import { SidebarTrigger } from "@/components/ui/sidebar";
 
-export function AppLayoutHeader({ title }: { title: string }) {
+export function AppLayoutHeader({
+  title,
+  version,
+}: {
+  title: string;
+  version: string;
+}) {
   return (
     <header className="flex h-16 shrink-0 items-center gap-3 border-b px-4">
       <SidebarTrigger className="-ml-1" />
       <div className="min-w-0">
         <p className="truncate text-sm font-medium text-muted-foreground">
-          RegionClaw
+          RegionClaw v{version}
         </p>
         <h1 className="truncate text-base font-semibold text-foreground">{title}</h1>
       </div>

package/apps/ui/src/components/app-sidebar.tsx

@@ -11,9 +11,11 @@ import {
 
 export function AppSidebar({
   user,
+  version,
   ...props
 }: React.ComponentProps<typeof Sidebar> & {
   user: SidebarUser;
+  version: string;
 }) {
   return (
     <Sidebar variant="inset" {...props}>
@@ -23,6 +25,7 @@ export function AppSidebar({
             Workspace
           </p>
           <p className="text-base font-semibold text-sidebar-foreground">RegionClaw</p>
+          <p className="text-xs text-sidebar-foreground/70">v{version}</p>
         </div>
       </SidebarHeader>
       <SidebarContent />

package/apps/ui/src/components/regionclaw-update-banner.tsx

@@ -0,0 +1,229 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { RefreshCwIcon, TerminalSquareIcon } from "lucide-react";
+import { toast } from "sonner";
+
+import { Alert, AlertAction, AlertDescription, AlertTitle } from "@/components/ui/alert";
+import { Button } from "@/components/ui/button";
+
+type UpdateStatus = {
+  ok: boolean;
+  currentVersion: string;
+  latestVersion: string | null;
+  updateAvailable: boolean;
+  installKind: "global" | "npx" | "local";
+  packageManager: "npm" | "pnpm" | "unknown";
+  canUpdateInPlace: boolean;
+  recommendedCommand: string | null;
+  error?: string;
+};
+
+type UpdateRunResult = UpdateStatus & {
+  status: "updated" | "already-current" | "manual" | "error";
+  message: string;
+  requiresRestart?: boolean;
+  restartScheduled?: boolean;
+};
+
+export function RegionClawUpdateBanner() {
+  const [status, setStatus] = useState<UpdateStatus | null>(null);
+  const [result, setResult] = useState<UpdateRunResult | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [updating, setUpdating] = useState(false);
+  const [dismissed, setDismissed] = useState(false);
+
+  useEffect(() => {
+    let cancelled = false;
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+    function scheduleNextHourlyCheck() {
+      const now = new Date();
+      const next = new Date(now);
+      next.setMinutes(0, 0, 0);
+      next.setHours(next.getHours() + 1);
+      timeoutId = setTimeout(() => {
+        void loadStatus();
+      }, Math.max(1_000, next.getTime() - now.getTime()));
+    }
+
+    async function loadStatus() {
+      try {
+        const response = await fetch("/api/update/status", {
+          method: "GET",
+          credentials: "same-origin",
+          cache: "no-store",
+        });
+        const payload = (await response.json()) as UpdateStatus;
+        if (!cancelled) {
+          setStatus(payload.ok ? payload : null);
+        }
+      } catch {
+        if (!cancelled) {
+          setStatus(null);
+        }
+      } finally {
+        if (!cancelled) {
+          setLoading(false);
+          scheduleNextHourlyCheck();
+        }
+      }
+    }
+
+    void loadStatus();
+    return () => {
+      cancelled = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, []);
+
+  async function waitForRestart(targetVersion: string) {
+    const startedAt = Date.now();
+
+    while (Date.now() - startedAt < 120_000) {
+      try {
+        const response = await fetch("/api/update/status", {
+          method: "GET",
+          credentials: "same-origin",
+          cache: "no-store",
+        });
+
+        if (response.ok) {
+          const payload = (await response.json()) as UpdateStatus;
+          if (payload.currentVersion === targetVersion || !payload.updateAvailable) {
+            window.location.reload();
+            return;
+          }
+        }
+      } catch {
+        // RegionClaw is probably restarting; keep polling.
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 2_000));
+    }
+
+    toast.error("RegionClaw restarted too slowly. Refresh the page manually.");
+  }
+
+  async function copyCommand(command: string) {
+    try {
+      await navigator.clipboard.writeText(command);
+      toast.success("Update command copied.");
+    } catch {
+      toast.error("Failed to copy update command.");
+    }
+  }
+
+  async function runUpdate() {
+    setUpdating(true);
+    try {
+      const response = await fetch("/api/update/run", {
+        method: "POST",
+        credentials: "same-origin",
+      });
+      const payload = (await response.json()) as UpdateRunResult;
+      setResult(payload);
+
+      if (payload.status === "updated") {
+        toast.success(payload.message);
+        if (payload.restartScheduled && payload.latestVersion) {
+          void waitForRestart(payload.latestVersion);
+          return;
+        }
+
+        setStatus((previous) =>
+          previous
+            ? {
+                ...previous,
+                currentVersion: payload.latestVersion ?? previous.currentVersion,
+                updateAvailable: false,
+              }
+            : previous,
+        );
+        return;
+      }
+
+      if (payload.status === "manual" && payload.recommendedCommand) {
+        await copyCommand(payload.recommendedCommand);
+        return;
+      }
+
+      if (payload.status === "already-current") {
+        toast.success(payload.message);
+        return;
+      }
+
+      toast.error(payload.message);
+    } catch {
+      toast.error("Failed to run RegionClaw update.");
+    } finally {
+      setUpdating(false);
+    }
+  }
+
+  if (loading || dismissed) {
+    return null;
+  }
+
+  if (result?.status === "updated") {
+    return (
+      <div className="border-b px-4 py-3">
+        <Alert>
+          <TerminalSquareIcon className="size-4" />
+          <AlertTitle>RegionClaw updated</AlertTitle>
+          <AlertDescription>{result.message}</AlertDescription>
+          <AlertAction>
+            <Button size="sm" variant="ghost" onClick={() => setDismissed(true)}>
+              Dismiss
+            </Button>
+          </AlertAction>
+        </Alert>
+      </div>
+    );
+  }
+
+  if (!status?.ok || !status.updateAvailable || !status.latestVersion) {
+    return null;
+  }
+
+  const description = status.canUpdateInPlace
+    ? `Version ${status.latestVersion} is available. RegionClaw is currently running ${status.currentVersion}.`
+    : status.recommendedCommand
+      ? `Version ${status.latestVersion} is available. This session is running via ${status.installKind}, so update must be started with a command.`
+      : `Version ${status.latestVersion} is available, but this install cannot be updated automatically from inside RegionClaw.`;
+
+  return (
+    <div className="border-b px-4 py-3">
+      <Alert variant="destructive">
+        <RefreshCwIcon className="size-4" />
+        <AlertTitle>Update available</AlertTitle>
+        <AlertDescription>{description}</AlertDescription>
+        <AlertAction className="flex gap-2">
+          {status.recommendedCommand && !status.canUpdateInPlace ? (
+            <Button
+              size="sm"
+              variant="outline"
+              onClick={() => void copyCommand(status.recommendedCommand!)}
+            >
+              Copy command
+            </Button>
+          ) : null}
+          {status.canUpdateInPlace || status.recommendedCommand ? (
+            <Button size="sm" onClick={() => void runUpdate()} disabled={updating}>
+              {updating
+                ? "Updating..."
+                : status.canUpdateInPlace
+                  ? "Update now"
+                  : "Copy update command"}
+            </Button>
+          ) : null}
+          <Button size="sm" variant="ghost" onClick={() => setDismissed(true)}>
+            Dismiss
+          </Button>
+        </AlertAction>
+      </Alert>
+    </div>
+  );
+}

package/apps/ui/src/server/regionclaw-meta.ts

@@ -0,0 +1,3 @@
+export function getRegionClawVersion() {
+  return process.env.REGIONCLAW_VERSION ?? "dev";
+}

package/apps/ui/src/server/update-cli.ts

@@ -0,0 +1,88 @@
+import { execFile, spawn } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+function resolvePackageRoot() {
+  return (
+    process.env.REGIONCLAW_PACKAGE_ROOT ??
+    path.resolve(process.cwd(), "..", "..")
+  );
+}
+
+function resolveBinPath() {
+  return path.join(resolvePackageRoot(), "bin", "regionclaw.js");
+}
+
+export type RegionClawUpdateStatus = {
+  ok: boolean;
+  packageName: string;
+  currentVersion: string;
+  latestVersion: string | null;
+  updateAvailable: boolean;
+  installKind: "global" | "npx" | "local";
+  packageManager: "npm" | "pnpm" | "unknown";
+  canUpdateInPlace: boolean;
+  recommendedCommand: string | null;
+  error?: string;
+};
+
+export type RegionClawUpdateRunResult = RegionClawUpdateStatus & {
+  status: "updated" | "already-current" | "manual" | "error";
+  message: string;
+  requiresRestart?: boolean;
+  restartScheduled?: boolean;
+  command?: string;
+  stdout?: string | null;
+  stderr?: string | null;
+};
+
+async function runRegionClawCommand(args: string[]) {
+  const { stdout } = await execFileAsync(process.execPath, [resolveBinPath(), ...args], {
+    cwd: resolvePackageRoot(),
+    env: process.env,
+    maxBuffer: 1024 * 1024 * 4,
+  });
+
+  return stdout;
+}
+
+export async function getRegionClawUpdateStatus(): Promise<RegionClawUpdateStatus> {
+  const stdout = await runRegionClawCommand(["update", "status", "--json"]);
+  return JSON.parse(stdout) as RegionClawUpdateStatus;
+}
+
+export async function runRegionClawUpdate(): Promise<RegionClawUpdateRunResult> {
+  const stdout = await runRegionClawCommand(["update", "--json"]);
+  return JSON.parse(stdout) as RegionClawUpdateRunResult;
+}
+
+export function canScheduleRegionClawRestart() {
+  return Boolean(
+    process.env.REGIONCLAW_PARENT_PID &&
+      process.env.REGIONCLAW_HOST &&
+      process.env.REGIONCLAW_PORT,
+  );
+}
+
+export function scheduleRegionClawRestart() {
+  const parentPid = process.env.REGIONCLAW_PARENT_PID;
+  const host = process.env.REGIONCLAW_HOST;
+  const port = process.env.REGIONCLAW_PORT;
+
+  if (!parentPid || !host || !port) {
+    return false;
+  }
+
+  const helperPath = path.join(resolvePackageRoot(), "scripts", "restart-running-regionclaw.mjs");
+  const child = spawn(process.execPath, [helperPath, parentPid, resolveBinPath(), host, port], {
+    cwd: resolvePackageRoot(),
+    detached: true,
+    stdio: "ignore",
+    env: process.env,
+  });
+
+  child.unref();
+  return true;
+}