putmein-test 1.0.0

package/README.md

@@ -0,0 +1,93 @@
+# PutmeIn (`putmein`)
+
+> **Autonomous DevOps, Infrastructure Monitoring & Deployment Engine powered by Ray & Brain.**
+
+[![npm version](https://img.shields.io/npm/v/putmein.svg)](https://www.npmjs.com/package/putmein)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org/)
+
+PutmeIn combines **Ray** (an interactive Next.js web console and management dashboard) with **Brain** (a high-performance Go AI background daemon and Docker orchestrator) into a unified, daemonized system manager.
+
+---
+
+## ⚡ Quick Start
+
+### Option 1: Automatic One-Line Installation (Recommended)
+```bash
+# Linux / macOS / WSL
+curl -fsSL https://get.putme.in | bash
+```
+
+```powershell
+# Windows (PowerShell)
+irm https://get.putme.in/ps1 | iex
+```
+
+### Option 2: Global NPM Installation
+```bash
+npm install -g putmein
+```
+
+Once installed, simply run:
+```bash
+ray
+```
+
+PutmeIn will start as a resilient background daemon via PM2 and display your local and network dashboard URLs:
+* **Web Dashboard (Ray):** [http://localhost:4567](http://localhost:4567)
+* **API Engine (Brain):** [http://localhost:4500](http://localhost:4500)
+
+---
+
+## 🛠️ CLI Usage & Commands
+
+PutmeIn exposes the `ray` command globally:
+
+| Command | Description |
+|---|---|
+| `ray` or `ray start` | Starts Ray and Brain in the background via PM2 and displays dashboard URLs. |
+| `ray stop` | Gracefully stops the running background services. |
+| `ray restart` | Restarts all services with fresh state. |
+| `ray status` | Inspects running processes, PIDs, CPU usage, memory consumption, and port status. |
+| `ray logs` | Streams live unified output logs from both Ray and Brain. |
+| `ray starter` | Configures PutmeIn to start automatically on system boot (`pm2 startup` & `pm2 save`). |
+| `ray --no-startup` | Disables automatic startup on system boot. |
+| `ray cohen` | Launches the interactive terminal TUI client. |
+| `ray --help` | Displays help menu and command list. |
+| `ray --version` | Prints current installed version. |
+
+---
+
+## ⚙️ Configuration
+
+PutmeIn reads runtime configurations from `~/.putmein/.env` or environment variables:
+
+| Variable | Default | Description |
+|---|---|---|
+| `RAY_PORT` | `4567` | Port for the Ray web dashboard. |
+| `BRAIN_PORT` | `4500` | Port for the Brain AI backend engine. |
+| `DATABASE_URL` | — | MySQL / MariaDB connection string. |
+| `BRAIN_INTERNAL_SECRET` | auto-generated | Secret token for secure Brain <-> Ray communication. |
+| `AGENT_AUTONOMOUS` | `false` | Enable or disable autonomous DevOps action mode. |
+
+---
+
+## 🏗️ Building From Source
+
+```bash
+# Clone the repository
+git clone https://github.com/putmein/putmein.git
+cd putmein
+
+# Install dependencies and build standalone distribution
+npm run build
+
+# Start services locally
+npm start
+```
+
+---
+
+## 📄 License
+
+ISC © [Putme.in](https://putme.in)

package/bin/ray.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+
+const { execSync, spawn } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const http = require("http");
+
+const ROOT_DIR = path.resolve(__dirname, "..");
+const ECOSYSTEM_PATH = path.join(ROOT_DIR, "ecosystem.config.js");
+const PKG_PATH = path.join(ROOT_DIR, "package.json");
+
+// Read version
+let version = "1.0.0";
+try {
+  const pkg = JSON.parse(fs.readFileSync(PKG_PATH, "utf-8"));
+  version = pkg.version || version;
+} catch (_) {}
+
+// Color formatting
+const C = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+};
+
+function getLanIp() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const net of interfaces[name] || []) {
+      if (net.family === "IPv4" && !net.internal && !net.address.startsWith("127.")) {
+        return net.address;
+      }
+    }
+  }
+  return "127.0.0.1";
+}
+
+function getPm2Command() {
+  try {
+    execSync("pm2 -v", { stdio: "ignore" });
+    return "pm2";
+  } catch (_) {}
+  try {
+    execSync("npx pm2 -v", { stdio: "ignore" });
+    return "npx pm2";
+  } catch (_) {}
+  return null;
+}
+
+function waitForPort(port, timeoutMs = 15000) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const interval = setInterval(() => {
+      const req = http.get(`http://127.0.0.1:${port}`, () => {
+        clearInterval(interval);
+        resolve(true);
+      });
+      req.on("error", () => {
+        if (Date.now() - start > timeoutMs) {
+          clearInterval(interval);
+          resolve(false);
+        }
+      });
+      req.end();
+    }, 500);
+  });
+}
+
+function printBanner(rayPort = 4567, brainPort = 4500) {
+  const lanIp = getLanIp();
+  console.log(`
+${C.bold}${C.cyan}╭────────────────────────────────────────────────────────────────────────╮${C.reset}
+${C.bold}${C.cyan}│${C.reset}                                                                        ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}   ${C.bold}${C.green}✨ PutmeIn is running in the background!${C.reset} (v${version})               ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}                                                                        ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}   ${C.bold}Local Dashboard:${C.reset}   ${C.cyan}http://localhost:${rayPort}${C.reset}                             ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}   ${C.bold}Network Dashboard:${C.reset} ${C.cyan}http://${lanIp}:${rayPort}${C.reset}                        ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}   ${C.bold}Brain API Engine:${C.reset}  ${C.dim}http://localhost:${brainPort}${C.reset}                             ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}                                                                        ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}   ${C.bold}Management Commands:${C.reset}                                                 ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}     • ${C.yellow}ray status${C.reset}        View process status and memory               ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}     • ${C.yellow}ray logs${C.reset}          Stream live combined logs                    ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}     • ${C.yellow}ray stop${C.reset}          Stop background services                     ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}     • ${C.yellow}ray restart${C.reset}       Restart services with fresh state            ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}     • ${C.yellow}ray starter${C.reset}       Enable automatic startup on system boot      ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}     • ${C.yellow}ray --no-startup${C.reset}  Disable automatic startup on boot            ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}     • ${C.yellow}ray cohen${C.reset}         Launch interactive terminal TUI              ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}│${C.reset}                                                                        ${C.bold}${C.cyan}│${C.reset}
+${C.bold}${C.cyan}╰────────────────────────────────────────────────────────────────────────╯${C.reset}
+`);
+}
+
+function handleStart() {
+  const pm2 = getPm2Command();
+  if (!pm2) {
+    console.error(`${C.red}[ERROR]${C.reset} PM2 is required to run PutmeIn as a daemon.`);
+    console.log(`Please install it globally using: ${C.yellow}npm install -g pm2${C.reset}`);
+    process.exit(1);
+  }
+
+  console.log(`${C.cyan}➜ Starting PutmeIn services (Ray & Brain) with PM2...${C.reset}`);
+  try {
+    execSync(`${pm2} start "${ECOSYSTEM_PATH}"`, { stdio: "inherit" });
+    execSync(`${pm2} save`, { stdio: "ignore" });
+    printBanner();
+  } catch (err) {
+    console.error(`${C.red}[ERROR]${C.reset} Failed to start services: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function handleStop() {
+  const pm2 = getPm2Command();
+  if (!pm2) return;
+  console.log(`${C.cyan}➜ Stopping PutmeIn services...${C.reset}`);
+  try {
+    execSync(`${pm2} stop putmein-ray putmein-brain`, { stdio: "inherit" });
+    console.log(`${C.green}✔ PutmeIn services stopped successfully.${C.reset}`);
+  } catch (err) {
+    console.log(`${C.yellow}PutmeIn services were not running.${C.reset}`);
+  }
+}
+
+function handleRestart() {
+  const pm2 = getPm2Command();
+  if (!pm2) return;
+  console.log(`${C.cyan}➜ Restarting PutmeIn services...${C.reset}`);
+  try {
+    execSync(`${pm2} restart putmein-ray putmein-brain`, { stdio: "inherit" });
+    console.log(`${C.green}✔ PutmeIn services restarted successfully.${C.reset}`);
+    printBanner();
+  } catch (err) {
+    console.log(`${C.yellow}Starting fresh instance...${C.reset}`);
+    handleStart();
+  }
+}
+
+function handleStatus() {
+  const pm2 = getPm2Command();
+  if (!pm2) {
+    console.log(`${C.red}PM2 is not installed.${C.reset}`);
+    return;
+  }
+
+  try {
+    const raw = execSync(`${pm2} jlist`, { encoding: "utf-8" });
+    const list = JSON.parse(raw);
+    const putmeinProcs = list.filter((p) => p.name === "putmein-ray" || p.name === "putmein-brain");
+
+    if (putmeinProcs.length === 0) {
+      console.log(`\n${C.yellow}No active PutmeIn services found in PM2.${C.reset}`);
+      console.log(`Run ${C.cyan}ray start${C.reset} to launch them.\n`);
+      return;
+    }
+
+    console.log(`\n${C.bold}PutmeIn Service Status:${C.reset}`);
+    console.log("─".repeat(65));
+    console.log(
+      `${"PROCESS".padEnd(18)} ${"STATUS".padEnd(12)} ${"PID".padEnd(10)} ${"CPU".padEnd(8)} ${"MEMORY".padEnd(10)}`
+    );
+    console.log("─".repeat(65));
+
+    for (const p of putmeinProcs) {
+      const statusColor = p.pm2_env.status === "online" ? C.green : C.red;
+      const memMb = (p.monit.memory / (1024 * 1024)).toFixed(1) + " MB";
+      const cpu = (p.monit.cpu || 0) + "%";
+      console.log(
+        `${p.name.padEnd(18)} ${statusColor + p.pm2_env.status.padEnd(12) + C.reset} ${(p.pid + "").padEnd(10)} ${cpu.padEnd(8)} ${memMb.padEnd(10)}`
+      );
+    }
+    console.log("─".repeat(65) + "\n");
+  } catch (err) {
+    execSync(`${pm2} status putmein-ray putmein-brain`, { stdio: "inherit" });
+  }
+}
+
+function handleLogs() {
+  const pm2 = getPm2Command();
+  if (!pm2) return;
+  console.log(`${C.cyan}Streaming live PutmeIn logs (Ctrl+C to exit)...${C.reset}\n`);
+  const parts = pm2.split(" ");
+  const baseCmd = parts[0];
+  const baseArgs = parts.slice(1).concat(["logs", "putmein-ray", "putmein-brain", "--lines", "50"]);
+  spawn(baseCmd, baseArgs, {
+    stdio: "inherit",
+  });
+}
+
+function handleStarter() {
+  const pm2 = getPm2Command();
+  if (!pm2) return;
+  console.log(`${C.cyan}➜ Configuring PutmeIn to start automatically on system boot...${C.reset}`);
+  try {
+    execSync(`${pm2} startup`, { stdio: "inherit" });
+    execSync(`${pm2} save`, { stdio: "inherit" });
+    console.log(`\n${C.green}✔ PutmeIn will now start automatically on system boot!${C.reset}\n`);
+  } catch (err) {
+    console.error(`${C.red}[ERROR]${C.reset} Failed to set up startup: ${err.message}`);
+  }
+}
+
+function handleNoStartup() {
+  const pm2 = getPm2Command();
+  if (!pm2) return;
+  console.log(`${C.cyan}➜ Removing PutmeIn from system boot startup...${C.reset}`);
+  try {
+    execSync(`${pm2} unstartup`, { stdio: "inherit" });
+    console.log(`\n${C.green}✔ PutmeIn removed from system boot startup.${C.reset}\n`);
+  } catch (err) {
+    console.error(`${C.red}[ERROR]${C.reset} Failed to remove startup: ${err.message}`);
+  }
+}
+
+function handleCohen() {
+  const isWindows = process.platform === "win32";
+  const binaryName = isWindows ? "cohen.exe" : "cohen";
+  const candidatePaths = [
+    path.join(ROOT_DIR, "dist", "cohen", binaryName),
+    path.join(ROOT_DIR, "cohen", "bin", binaryName),
+    path.join(ROOT_DIR, "cohen", binaryName),
+  ];
+
+  const cohenBin = candidatePaths.find((p) => fs.existsSync(p));
+  if (!cohenBin) {
+    console.error(`${C.red}[ERROR]${C.reset} Cohen TUI binary not found.`);
+    process.exit(1);
+  }
+
+  const child = spawn(cohenBin, [], { stdio: "inherit" });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+function printHelp() {
+  console.log(`
+${C.bold}${C.cyan}PutmeIn CLI (ray)${C.reset} - v${version}
+Autonomous DevOps & Infrastructure Orchestrator
+
+${C.bold}USAGE:${C.reset}
+  ray [command] [options]
+
+${C.bold}COMMANDS:${C.reset}
+  ${C.green}ray${C.reset}, ${C.green}ray start${C.reset}          Start PutmeIn (Ray & Brain) in the background via PM2
+  ${C.green}ray stop${C.reset}, ${C.green}ray --stop${C.reset}     Stop running PutmeIn services
+  ${C.green}ray restart${C.reset}           Restart PutmeIn services
+  ${C.green}ray status${C.reset}, ${C.green}ray --status${C.reset}   View process status, CPU, memory, and ports
+  ${C.green}ray logs${C.reset}, ${C.green}ray --logs${C.reset}       Stream live output logs from Ray and Brain
+  ${C.green}ray starter${C.reset}            Configure PutmeIn to start automatically on system boot
+  ${C.green}ray --no-startup${C.reset}       Disable automatic startup on boot
+  ${C.green}ray cohen${C.reset}              Launch the interactive terminal TUI
+  ${C.green}ray --help${C.reset}, ${C.green}-h${C.reset}          Show this help message
+  ${C.green}ray --version${C.reset}, ${C.green}-v${C.reset}       Show current version
+`);
+}
+
+// CLI Command routing
+const args = process.argv.slice(2);
+const cmd = args[0] ? args[0].toLowerCase() : "start";
+
+switch (cmd) {
+  case "start":
+  case "--start":
+    handleStart();
+    break;
+  case "stop":
+  case "--stop":
+    handleStop();
+    break;
+  case "restart":
+  case "--restart":
+    handleRestart();
+    break;
+  case "status":
+  case "--status":
+    handleStatus();
+    break;
+  case "logs":
+  case "--logs":
+    handleLogs();
+    break;
+  case "starter":
+  case "--starter":
+    handleStarter();
+    break;
+  case "no-startup":
+  case "--no-startup":
+    handleNoStartup();
+    break;
+  case "cohen":
+    handleCohen();
+    break;
+  case "-v":
+  case "--version":
+    console.log(`v${version}`);
+    break;
+  case "-h":
+  case "--help":
+  case "help":
+    printHelp();
+    break;
+  default:
+    console.log(`${C.yellow}Unknown command: ${args[0]}${C.reset}`);
+    printHelp();
+    process.exit(1);
+}

package/dist/ray/.next/BUILD_ID

@@ -0,0 +1 @@
+Hhx7q8xLPLV444ELbuAGL

package/dist/ray/.next/app-path-routes-manifest.json

@@ -0,0 +1,78 @@
+{
+  "/(auth)/login/page": "/login",
+  "/(auth)/register/page": "/register",
+  "/(dashboard)/chat/[sessionId]/page": "/chat/[sessionId]",
+  "/(dashboard)/chat/page": "/chat",
+  "/(dashboard)/cicd/[id]/page": "/cicd/[id]",
+  "/(dashboard)/cicd/page": "/cicd",
+  "/(dashboard)/containers/[id]/page": "/containers/[id]",
+  "/(dashboard)/containers/page": "/containers",
+  "/(dashboard)/deployments/[id]/page": "/deployments/[id]",
+  "/(dashboard)/deployments/page": "/deployments",
+  "/(dashboard)/github/page": "/github",
+  "/(dashboard)/monitor/[id]/page": "/monitor/[id]",
+  "/(dashboard)/monitor/page": "/monitor",
+  "/(dashboard)/page": "/",
+  "/(dashboard)/projects/[id]/page": "/projects/[id]",
+  "/(dashboard)/projects/page": "/projects",
+  "/(dashboard)/servers/[id]/page": "/servers/[id]",
+  "/(dashboard)/servers/page": "/servers",
+  "/(dashboard)/settings/page": "/settings",
+  "/_global-error/page": "/_global-error",
+  "/_not-found/page": "/_not-found",
+  "/api/auth/login/route": "/api/auth/login",
+  "/api/auth/logout/route": "/api/auth/logout",
+  "/api/auth/register/route": "/api/auth/register",
+  "/api/chat/route": "/api/chat",
+  "/api/cicd/[id]/route": "/api/cicd/[id]",
+  "/api/cicd/poll/route": "/api/cicd/poll",
+  "/api/cicd/route": "/api/cicd",
+  "/api/containers/[id]/action/route": "/api/containers/[id]/action",
+  "/api/containers/[id]/logs/route": "/api/containers/[id]/logs",
+  "/api/containers/[id]/route": "/api/containers/[id]",
+  "/api/containers/route": "/api/containers",
+  "/api/deploy/[id]/action/route": "/api/deploy/[id]/action",
+  "/api/deploy/route": "/api/deploy",
+  "/api/deploy/upload/route": "/api/deploy/upload",
+  "/api/deployments/[id]/diagnose/route": "/api/deployments/[id]/diagnose",
+  "/api/deployments/[id]/redeploy/route": "/api/deployments/[id]/redeploy",
+  "/api/deployments/[id]/route": "/api/deployments/[id]",
+  "/api/deployments/active/route": "/api/deployments/active",
+  "/api/deployments/internal/save-deployment/route": "/api/deployments/internal/save-deployment",
+  "/api/deployments/route": "/api/deployments",
+  "/api/github/app/callback/route": "/api/github/app/callback",
+  "/api/github/app/manifest/route": "/api/github/app/manifest",
+  "/api/github/connect/route": "/api/github/connect",
+  "/api/github/repos/route": "/api/github/repos",
+  "/api/github/route": "/api/github",
+  "/api/github/status/route": "/api/github/status",
+  "/api/monitor/alerts/[id]/route": "/api/monitor/alerts/[id]",
+  "/api/monitor/alerts/route": "/api/monitor/alerts",
+  "/api/monitor/internal/add-project/route": "/api/monitor/internal/add-project",
+  "/api/monitor/internal/update-project/route": "/api/monitor/internal/update-project",
+  "/api/monitor/process/route": "/api/monitor/process",
+  "/api/monitor/projects/[id]/diagnose/route": "/api/monitor/projects/[id]/diagnose",
+  "/api/monitor/projects/[id]/fix/route": "/api/monitor/projects/[id]/fix",
+  "/api/monitor/projects/[id]/logs/route": "/api/monitor/projects/[id]/logs",
+  "/api/monitor/projects/[id]/memory/route": "/api/monitor/projects/[id]/memory",
+  "/api/monitor/projects/[id]/route": "/api/monitor/projects/[id]",
+  "/api/monitor/projects/[id]/run/route": "/api/monitor/projects/[id]/run",
+  "/api/monitor/projects/route": "/api/monitor/projects",
+  "/api/monitor/stream/route": "/api/monitor/stream",
+  "/api/ports/route": "/api/ports",
+  "/api/projects/[id]/domain-check/route": "/api/projects/[id]/domain-check",
+  "/api/projects/[id]/env/route": "/api/projects/[id]/env",
+  "/api/projects/[id]/file-content/route": "/api/projects/[id]/file-content",
+  "/api/projects/[id]/files/route": "/api/projects/[id]/files",
+  "/api/projects/[id]/route": "/api/projects/[id]",
+  "/api/projects/route": "/api/projects",
+  "/api/sessions/[id]/generate-title/route": "/api/sessions/[id]/generate-title",
+  "/api/sessions/[id]/messages/route": "/api/sessions/[id]/messages",
+  "/api/sessions/[id]/route": "/api/sessions/[id]",
+  "/api/sessions/route": "/api/sessions",
+  "/api/settings/route": "/api/settings",
+  "/api/webhooks/github/[id]/route": "/api/webhooks/github/[id]",
+  "/api/webhooks/github/route": "/api/webhooks/github",
+  "/favicon.ico/route": "/favicon.ico",
+  "/page": "/"
+}

package/dist/ray/.next/build-manifest.json

@@ -0,0 +1,25 @@
+{
+  "pages": {
+    "/_app": []
+  },
+  "devFiles": [],
+  "polyfillFiles": [
+    "static/chunks/0cz1d0mv5g_q7.js"
+  ],
+  "lowPriorityFiles": [
+    "static/Hhx7q8xLPLV444ELbuAGL/_buildManifest.js",
+    "static/Hhx7q8xLPLV444ELbuAGL/_ssgManifest.js",
+    "static/Hhx7q8xLPLV444ELbuAGL/_clientMiddlewareManifest.js"
+  ],
+  "rootMainFiles": [
+    "static/chunks/28gn02g-uwi5m.js",
+    "static/chunks/0h2boyvse-55_.js",
+    "static/chunks/1kcfbnumrv6bw.js",
+    "static/chunks/0edte-771726v.js",
+    "static/chunks/11be91k_gj8bl.js",
+    "static/chunks/turbopack-1mudd67qgc20e.js"
+  ],
+  "rootMainFilesTree": {},
+  "pagesChunkGroupBootstrapParams": {},
+  "chunkLoadingGlobal": "TURBOPACK"
+}

package/dist/ray/.next/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/ray/.next/prerender-manifest.json

@@ -0,0 +1,157 @@
+{
+  "version": 4,
+  "routes": {
+    "/_global-error": {
+      "routeType": "page",
+      "response": "complete",
+      "compute": "static",
+      "htmlSize": 9273,
+      "experimentalBypassFor": [
+        {
+          "type": "header",
+          "key": "next-action"
+        },
+        {
+          "type": "header",
+          "key": "content-type",
+          "value": "multipart/form-data;.*"
+        }
+      ],
+      "initialRevalidateSeconds": false,
+      "srcRoute": "/_global-error",
+      "dataRoute": "/_global-error.rsc",
+      "allowHeader": [
+        "host",
+        "x-matched-path",
+        "x-prerender-revalidate",
+        "x-prerender-revalidate-if-generated",
+        "x-next-revalidated-tags",
+        "x-next-revalidate-tag-token"
+      ]
+    },
+    "/_not-found": {
+      "initialStatus": 404,
+      "routeType": "page",
+      "response": "complete",
+      "compute": "static",
+      "htmlSize": 8826,
+      "experimentalBypassFor": [
+        {
+          "type": "header",
+          "key": "next-action"
+        },
+        {
+          "type": "header",
+          "key": "content-type",
+          "value": "multipart/form-data;.*"
+        }
+      ],
+      "initialRevalidateSeconds": false,
+      "srcRoute": "/_not-found",
+      "dataRoute": "/_not-found.rsc",
+      "allowHeader": [
+        "host",
+        "x-matched-path",
+        "x-prerender-revalidate",
+        "x-prerender-revalidate-if-generated",
+        "x-next-revalidated-tags",
+        "x-next-revalidate-tag-token"
+      ]
+    },
+    "/favicon.ico": {
+      "initialHeaders": {
+        "cache-control": "public, max-age=0, must-revalidate",
+        "content-type": "image/x-icon",
+        "x-next-cache-tags": "_N_T_/layout,_N_T_/favicon.ico/layout,_N_T_/favicon.ico/route,_N_T_/favicon.ico"
+      },
+      "routeType": "route",
+      "response": "complete",
+      "compute": "static",
+      "experimentalBypassFor": [
+        {
+          "type": "header",
+          "key": "next-action"
+        },
+        {
+          "type": "header",
+          "key": "content-type",
+          "value": "multipart/form-data;.*"
+        }
+      ],
+      "initialRevalidateSeconds": false,
+      "srcRoute": "/favicon.ico",
+      "dataRoute": null,
+      "allowHeader": [
+        "host",
+        "x-matched-path",
+        "x-prerender-revalidate",
+        "x-prerender-revalidate-if-generated",
+        "x-next-revalidated-tags",
+        "x-next-revalidate-tag-token"
+      ]
+    },
+    "/login": {
+      "routeType": "page",
+      "response": "complete",
+      "compute": "static",
+      "htmlSize": 12468,
+      "experimentalBypassFor": [
+        {
+          "type": "header",
+          "key": "next-action"
+        },
+        {
+          "type": "header",
+          "key": "content-type",
+          "value": "multipart/form-data;.*"
+        }
+      ],
+      "initialRevalidateSeconds": false,
+      "srcRoute": "/login",
+      "dataRoute": "/login.rsc",
+      "allowHeader": [
+        "host",
+        "x-matched-path",
+        "x-prerender-revalidate",
+        "x-prerender-revalidate-if-generated",
+        "x-next-revalidated-tags",
+        "x-next-revalidate-tag-token"
+      ]
+    },
+    "/register": {
+      "routeType": "page",
+      "response": "complete",
+      "compute": "static",
+      "htmlSize": 12881,
+      "experimentalBypassFor": [
+        {
+          "type": "header",
+          "key": "next-action"
+        },
+        {
+          "type": "header",
+          "key": "content-type",
+          "value": "multipart/form-data;.*"
+        }
+      ],
+      "initialRevalidateSeconds": false,
+      "srcRoute": "/register",
+      "dataRoute": "/register.rsc",
+      "allowHeader": [
+        "host",
+        "x-matched-path",
+        "x-prerender-revalidate",
+        "x-prerender-revalidate-if-generated",
+        "x-next-revalidated-tags",
+        "x-next-revalidate-tag-token"
+      ]
+    }
+  },
+  "dynamicRoutes": {},
+  "notFoundRoutes": [],
+  "preview": {
+    "previewModeId": "3e046b21a6bd35c69df52c7264504908",
+    "previewModeSigningKey": "49d4dd61599ca30a3fb3f281d686cfc978d749748eaf68f391dbbac3a8c4ace2",
+    "previewModeEncryptionKey": "28dcb94d57431d1b4ed17827b0f6cdb410624ff3d1199c193e65e0bb8ff72f9d"
+  }
+}