@unlikeotherai/unloved 0.2.0

package/dist/index.js

@@ -0,0 +1,820 @@
+#!/usr/bin/env node
+
+// src/parse-flags.ts
+function parseArgs(argv) {
+  const args2 = argv.slice(2);
+  const command = args2[0] ?? "start";
+  const positional = [];
+  const flags = {};
+  let i = 1;
+  while (i < args2.length) {
+    const arg = args2[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args2[i + 1];
+      if (next && !next.startsWith("--")) {
+        flags[key] = next;
+        i += 2;
+      } else {
+        flags[key] = true;
+        i += 1;
+      }
+    } else {
+      positional.push(arg);
+      i += 1;
+    }
+  }
+  return { command, positional, flags };
+}
+
+// src/version.ts
+import { readFile } from "fs/promises";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+async function getVersion() {
+  try {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = resolve(__dirname, "..", "package.json");
+    const content = await readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// src/commands/start.ts
+import { createConnection } from "net";
+import { resolve as resolve6, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// ../server/dist/index.js
+import { createServer as createHttpServer } from "http";
+import { resolve as resolve3 } from "path";
+import cors from "cors";
+import express from "express";
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { Router } from "express";
+
+// ../shared/src/config.ts
+var DEFAULT_CONFIG = {
+  theme: "light"
+};
+
+// ../server/dist/index.js
+import { z } from "zod";
+import { Router as Router2 } from "express";
+import { execFile } from "child_process";
+import { mkdir, readFile as readFile22, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve22 } from "path";
+import { promisify } from "util";
+import { Router as Router3 } from "express";
+import { z as z2 } from "zod";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { Router as Router4 } from "express";
+import { WebSocketServer } from "ws";
+import { execFileSync } from "child_process";
+import { spawn } from "node-pty";
+var configRouter = Router();
+var getConfigPath = (homeDir) => resolve2(homeDir, "config.json");
+var patchSchema = z.object({
+  theme: z.enum(["light", "dark"]).optional()
+});
+var readConfig = async (homeDir) => {
+  try {
+    const content = await readFile2(getConfigPath(homeDir), "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+  } catch (error) {
+    const fileError = error;
+    if (fileError.code === "ENOENT") {
+      return DEFAULT_CONFIG;
+    }
+    throw error;
+  }
+};
+configRouter.get("/", async (request, response) => {
+  try {
+    const config = await readConfig(request.app.locals.homeDir);
+    response.json(config);
+  } catch {
+    response.status(500).json({ error: "Failed to read config" });
+  }
+});
+configRouter.patch("/", async (request, response) => {
+  const parsedBody = patchSchema.safeParse(request.body);
+  if (!parsedBody.success) {
+    response.status(400).json({ error: "Invalid config payload" });
+    return;
+  }
+  try {
+    const homeDir = request.app.locals.homeDir;
+    const config = await readConfig(homeDir);
+    const updatedConfig = { ...config, ...parsedBody.data };
+    await writeFile(getConfigPath(homeDir), `${JSON.stringify(updatedConfig, null, 2)}
+`, "utf-8");
+    response.json(updatedConfig);
+  } catch {
+    response.status(500).json({ error: "Failed to write config" });
+  }
+});
+var config_default = configRouter;
+var healthRouter = Router2();
+healthRouter.get("/", (_request, response) => {
+  response.json({ status: "ok" });
+});
+var health_default = healthRouter;
+var execFileAsync = promisify(execFile);
+var sessionMetaRouter = Router3();
+var metaSchema = z2.object({
+  previewUrl: z2.string().optional(),
+  restartCommand: z2.string().optional(),
+  projectDir: z2.string().optional(),
+  cliTool: z2.string().optional(),
+  createdAt: z2.string().optional()
+});
+var nameSchema = z2.string().min(1).regex(/^[\w.-]+$/);
+function getMetaPath(homeDir, name) {
+  return resolve22(homeDir, "sessions", name, "meta.json");
+}
+async function readMeta(homeDir, name) {
+  try {
+    const content = await readFile22(getMetaPath(homeDir, name), "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    const fileError = error;
+    if (fileError.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+async function writeMeta(homeDir, name, meta) {
+  const metaPath = getMetaPath(homeDir, name);
+  await mkdir(resolve22(homeDir, "sessions", name), { recursive: true });
+  await writeFile2(metaPath, `${JSON.stringify(meta, null, 2)}
+`, "utf-8");
+}
+sessionMetaRouter.get("/:name/meta", async (request, response) => {
+  const parsed = nameSchema.safeParse(request.params.name);
+  if (!parsed.success) {
+    response.status(400).json({ error: "Invalid session name" });
+    return;
+  }
+  try {
+    const meta = await readMeta(request.app.locals.homeDir, parsed.data);
+    response.json(meta);
+  } catch {
+    response.status(500).json({ error: "Failed to read session metadata" });
+  }
+});
+sessionMetaRouter.put("/:name/meta", async (request, response) => {
+  const parsedName = nameSchema.safeParse(request.params.name);
+  if (!parsedName.success) {
+    response.status(400).json({ error: "Invalid session name" });
+    return;
+  }
+  const parsedBody = metaSchema.safeParse(request.body);
+  if (!parsedBody.success) {
+    response.status(400).json({ error: "Invalid metadata payload" });
+    return;
+  }
+  try {
+    const homeDir = request.app.locals.homeDir;
+    const existing = await readMeta(homeDir, parsedName.data);
+    const merged = { ...existing, ...parsedBody.data };
+    await writeMeta(homeDir, parsedName.data, merged);
+    response.json(merged);
+  } catch {
+    response.status(500).json({ error: "Failed to write session metadata" });
+  }
+});
+sessionMetaRouter.post("/:name/restart", async (request, response) => {
+  const parsedName = nameSchema.safeParse(request.params.name);
+  if (!parsedName.success) {
+    response.status(400).json({ error: "Invalid session name" });
+    return;
+  }
+  try {
+    await execFileAsync("tmux", [
+      "send-keys",
+      "-t",
+      parsedName.data,
+      "unloved restart",
+      "Enter"
+    ]);
+    response.json({ sent: true });
+  } catch (error) {
+    const tmuxError = error;
+    if (tmuxError.code === "ENOENT") {
+      response.status(400).json({ error: "tmux is not installed" });
+      return;
+    }
+    response.status(500).json({ error: "Failed to send restart command" });
+  }
+});
+var session_meta_default = sessionMetaRouter;
+var execFileAsync2 = promisify2(execFile2);
+var tmuxRouter = Router4();
+tmuxRouter.get("/sessions", async (_request, response) => {
+  try {
+    const { stdout } = await execFileAsync2("tmux", [
+      "list-sessions",
+      "-F",
+      "#{session_name}	#{session_windows}	#{session_created}	#{session_attached}"
+    ]);
+    const sessions = stdout.trim().split("\n").filter(Boolean).map((line) => {
+      const [name, windowsRaw, created, attachedRaw] = line.split("	");
+      return {
+        name,
+        windows: Number.parseInt(windowsRaw, 10),
+        created,
+        attached: attachedRaw === "1"
+      };
+    });
+    response.json(sessions);
+  } catch (error) {
+    const tmuxError = error;
+    if (tmuxError.code === "ENOENT" || tmuxError.status === 1) {
+      response.json([]);
+      return;
+    }
+    response.status(500).json({ error: "Failed to list tmux sessions" });
+  }
+});
+tmuxRouter.post("/sessions", async (request, response) => {
+  const { name } = request.body;
+  if (!name || !name.trim()) {
+    response.status(400).json({ error: "Session name is required" });
+    return;
+  }
+  try {
+    await execFileAsync2("tmux", ["new-session", "-d", "-s", name.trim()]);
+    response.json({ name: name.trim(), created: true });
+  } catch (error) {
+    const tmuxError = error;
+    if (tmuxError.code === "ENOENT") {
+      response.status(400).json({ error: "tmux is not installed" });
+      return;
+    }
+    response.status(500).json({ error: "Failed to create tmux session" });
+  }
+});
+var tmux_default = tmuxRouter;
+function createApp(options) {
+  const app = express();
+  app.locals.homeDir = options.homeDir;
+  app.use(
+    cors({
+      origin: (_origin, callback) => callback(null, true)
+    })
+  );
+  app.use(express.json());
+  app.use("/api/health", health_default);
+  app.use("/api/tmux", tmux_default);
+  app.use("/api/config", config_default);
+  app.use("/api/sessions", session_meta_default);
+  if (options.staticDir) {
+    app.use(express.static(options.staticDir));
+    app.get("/{*splat}", (_req, res) => {
+      res.sendFile(resolve3(options.staticDir, "index.html"));
+    });
+  }
+  return app;
+}
+var MAX_BYTES = 1024 * 1024;
+var RingBuffer = class {
+  chunks = [];
+  totalBytes = 0;
+  push(data) {
+    const buf = typeof data === "string" ? Buffer.from(data) : data;
+    this.chunks.push(buf);
+    this.totalBytes += buf.length;
+    this.trim();
+  }
+  getAll() {
+    return Buffer.concat(this.chunks);
+  }
+  trim() {
+    while (this.totalBytes > MAX_BYTES && this.chunks.length > 1) {
+      const removed = this.chunks.shift();
+      this.totalBytes -= removed.length;
+    }
+  }
+};
+var tmuxBin = "tmux";
+try {
+  tmuxBin = execFileSync("which", ["tmux"], { encoding: "utf-8" }).trim();
+} catch {
+}
+var entries = /* @__PURE__ */ new Map();
+var GRACE_MS = 6e4;
+function sendJson(ws, msg) {
+  ws.send(JSON.stringify(msg));
+}
+function attach(sessionName, ws) {
+  let entry = entries.get(sessionName);
+  if (!entry) {
+    let pty;
+    try {
+      pty = spawn(tmuxBin, ["attach-session", "-t", sessionName], {
+        name: "xterm-256color",
+        cols: 120,
+        rows: 30,
+        cwd: process.env.HOME ?? "/",
+        env: { ...process.env }
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to spawn pty";
+      console.error(`[pty] spawn failed for ${sessionName}:`, msg);
+      sendJson(ws, { type: "error", message: msg });
+      ws.close();
+      return;
+    }
+    const buffer = new RingBuffer();
+    const clients = /* @__PURE__ */ new Set();
+    pty.onData((data) => {
+      buffer.push(data);
+      for (const c of clients) {
+        if (c.readyState === 1) c.send(data);
+      }
+    });
+    pty.onExit(() => {
+      for (const c of clients) {
+        sendJson(c, { type: "error", message: "tmux session ended" });
+        c.close();
+      }
+      entries.delete(sessionName);
+    });
+    entry = { pty, buffer, clients, graceTimer: null };
+    entries.set(sessionName, entry);
+  }
+  if (entry.graceTimer) {
+    clearTimeout(entry.graceTimer);
+    entry.graceTimer = null;
+  }
+  const replay = entry.buffer.getAll();
+  if (replay.length > 0) {
+    sendJson(ws, { type: "replay", data: replay.toString("utf-8") });
+  }
+  entry.clients.add(ws);
+}
+function detach(sessionName, ws) {
+  const entry = entries.get(sessionName);
+  if (!entry) return;
+  entry.clients.delete(ws);
+  if (entry.clients.size === 0) {
+    entry.graceTimer = setTimeout(() => {
+      entry.pty.kill();
+      entries.delete(sessionName);
+    }, GRACE_MS);
+  }
+}
+function write(sessionName, data) {
+  entries.get(sessionName)?.pty.write(data);
+}
+function resize(sessionName, cols, rows) {
+  entries.get(sessionName)?.pty.resize(cols, rows);
+}
+function createWsHandler(server) {
+  const wss = new WebSocketServer({ noServer: true });
+  server.on("upgrade", (req, socket, head) => {
+    const match = req.url?.match(/^\/ws\/terminal\/([^/?]+)/);
+    if (!match) {
+      socket.destroy();
+      return;
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req, match[1]);
+    });
+  });
+  wss.on("connection", (ws, _req, sessionName) => {
+    attach(sessionName, ws);
+    ws.on("message", (raw, isBinary) => {
+      if (isBinary) {
+        write(sessionName, raw.toString());
+        return;
+      }
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (msg.type === "resize" && msg.cols > 0 && msg.rows > 0) {
+          resize(sessionName, msg.cols, msg.rows);
+        }
+      } catch {
+        write(sessionName, raw.toString());
+      }
+    });
+    ws.on("close", () => {
+      detach(sessionName, ws);
+    });
+  });
+}
+var DEFAULT_PORT = 6200;
+function startServer(options) {
+  const { port = DEFAULT_PORT, ...appOptions } = options;
+  const app = createApp(appOptions);
+  const server = createHttpServer(app);
+  createWsHandler(server);
+  server.listen(port, "0.0.0.0", () => {
+    console.log(`@unloved/server listening on http://localhost:${port}`);
+  });
+  return server;
+}
+
+// src/home.ts
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+var SESSION_NAME_RE = /^[\w.-]+$/;
+function getHomeDir() {
+  return resolve4(process.env.UNLOVED_HOME ?? resolve4(process.env.HOME ?? "", ".unloved"));
+}
+async function ensureHome() {
+  const homeDir = getHomeDir();
+  await mkdir2(resolve4(homeDir, "sessions"), { recursive: true });
+  return homeDir;
+}
+function validateSessionName(session) {
+  if (!SESSION_NAME_RE.test(session)) {
+    console.error(`Error: Invalid session name "${session}". Use only letters, numbers, dots, hyphens, and underscores.`);
+    process.exit(1);
+  }
+}
+function getMetaPath2(homeDir, session) {
+  validateSessionName(session);
+  return resolve4(homeDir, "sessions", session, "meta.json");
+}
+async function readSessionMeta(homeDir, session) {
+  try {
+    const content = await readFile3(getMetaPath2(homeDir, session), "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    const fileError = error;
+    if (fileError.code === "ENOENT") return {};
+    throw error;
+  }
+}
+async function writeSessionMeta(homeDir, session, meta) {
+  const dir = resolve4(homeDir, "sessions", session);
+  await mkdir2(dir, { recursive: true });
+  await writeFile3(resolve4(dir, "meta.json"), `${JSON.stringify(meta, null, 2)}
+`, "utf-8");
+}
+
+// src/banner.ts
+import { networkInterfaces } from "os";
+function getLocalIP() {
+  const nets = networkInterfaces();
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name] ?? []) {
+      if (net.family === "IPv4" && !net.internal) {
+        return net.address;
+      }
+    }
+  }
+  return null;
+}
+function printBanner(port) {
+  const localIP = getLocalIP();
+  console.log();
+  console.log("  unloved is running");
+  console.log();
+  console.log(`  Local:   http://localhost:${port}`);
+  if (localIP) {
+    console.log(`  Network: http://${localIP}:${port}`);
+  }
+  console.log();
+}
+
+// src/detect-session.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+async function detectTmuxSession() {
+  if (!process.env.TMUX) return null;
+  try {
+    const { stdout } = await execFileAsync3("tmux", ["display-message", "-p", "#{session_name}"]);
+    const name = stdout.trim();
+    return name || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/sync.ts
+import { existsSync } from "fs";
+import { execFileSync as execFileSync2 } from "child_process";
+import { resolve as resolve5 } from "path";
+function syncRepo(homeDir) {
+  const repoDir = resolve5(homeDir, "repo");
+  const webDist = resolve5(repoDir, "packages", "web", "dist");
+  try {
+    if (!existsSync(repoDir)) {
+      console.log("  Cloning unloved repo...");
+      execFileSync2("git", ["clone", "https://github.com/UnlikeOtherAI/unloved.git", repoDir], {
+        stdio: "inherit"
+      });
+    } else {
+      console.log("  Pulling latest...");
+      execFileSync2("git", ["pull", "origin", "main"], {
+        cwd: repoDir,
+        stdio: "inherit"
+      });
+    }
+    console.log("  Installing dependencies...");
+    execFileSync2("pnpm", ["install", "--frozen-lockfile"], {
+      cwd: repoDir,
+      stdio: "inherit"
+    });
+    console.log("  Building...");
+    execFileSync2("pnpm", ["build"], {
+      cwd: repoDir,
+      stdio: "inherit"
+    });
+    if (existsSync(webDist)) {
+      return webDist;
+    }
+    console.warn("  Warning: build succeeded but web dist not found, using bundled assets");
+    return null;
+  } catch {
+    console.warn("  Warning: sync failed, falling back to bundled assets");
+    return null;
+  }
+}
+
+// src/open-browser.ts
+import { execFile as execFile4 } from "child_process";
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  const args2 = process.platform === "win32" ? ["", url] : [url];
+  const child = execFile4(cmd, args2, { stdio: "ignore" });
+  child.unref();
+}
+
+// src/commands/start.ts
+function isPortInUse(port) {
+  return new Promise((resolve7) => {
+    const socket = createConnection({ port }, () => {
+      socket.destroy();
+      resolve7(true);
+    });
+    socket.on("error", () => {
+      resolve7(false);
+    });
+  });
+}
+async function startCommand(args2) {
+  const port = args2.flags.port ? Number(args2.flags.port) : 6200;
+  if (!Number.isFinite(port) || port < 1 || port > 65535) {
+    console.error("Error: --port must be a number between 1 and 65535");
+    process.exit(1);
+  }
+  const sessionName = args2.positional[0] ?? await detectTmuxSession() ?? void 0;
+  if (await isPortInUse(port)) {
+    console.log(`unloved is already running at http://localhost:${port}`);
+    process.exit(0);
+  }
+  const homeDir = await ensureHome();
+  const __dirname = dirname2(fileURLToPath2(import.meta.url));
+  const bundledDir = resolve6(__dirname, "..", "public");
+  let staticDir = bundledDir;
+  if (!args2.flags["no-sync"]) {
+    const syncedDir = syncRepo(homeDir);
+    if (syncedDir) {
+      staticDir = syncedDir;
+    }
+  }
+  startServer({ homeDir, staticDir, port });
+  printBanner(port);
+  if (!args2.flags["no-open"]) {
+    openBrowser(`http://localhost:${port}`);
+  }
+  if (sessionName) {
+    const meta = {
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (args2.flags.url && typeof args2.flags.url === "string") meta.previewUrl = args2.flags.url;
+    if (args2.flags.restart && typeof args2.flags.restart === "string")
+      meta.restartCommand = args2.flags.restart;
+    meta.projectDir = process.cwd();
+    await writeSessionMeta(homeDir, sessionName, meta);
+    console.log(`  Session: ${sessionName}`);
+  }
+}
+
+// src/commands/restart.ts
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execFileAsync4 = promisify4(execFile5);
+async function restartCommand(args2) {
+  const sessionName = args2.positional[0] ?? await detectTmuxSession();
+  if (!sessionName) {
+    console.error("Error: No session name provided and not in a tmux session");
+    process.exit(1);
+  }
+  const homeDir = getHomeDir();
+  const meta = await readSessionMeta(homeDir, sessionName);
+  if (!meta.restartCommand) {
+    console.error(`Error: No restart command configured for session "${sessionName}"`);
+    console.error('Set one with: unloved meta restartCommand="your command"');
+    process.exit(1);
+  }
+  console.log(`Restarting: ${meta.restartCommand}`);
+  try {
+    const { stdout, stderr } = await execFileAsync4("sh", ["-c", meta.restartCommand], {
+      cwd: meta.projectDir ?? process.cwd(),
+      env: process.env
+    });
+    if (stdout) process.stdout.write(stdout);
+    if (stderr) process.stderr.write(stderr);
+  } catch (error) {
+    const execError = error;
+    if (execError.stdout) process.stdout.write(execError.stdout);
+    if (execError.stderr) process.stderr.write(execError.stderr);
+    process.exit(1);
+  }
+}
+
+// src/commands/url.ts
+async function urlCommand(args2) {
+  let sessionName;
+  let url;
+  if (args2.positional.length === 2) {
+    sessionName = args2.positional[0];
+    url = args2.positional[1];
+  } else if (args2.positional.length === 1) {
+    url = args2.positional[0];
+    sessionName = await detectTmuxSession();
+  }
+  if (!sessionName) {
+    console.error("Error: No session name provided and not in a tmux session");
+    process.exit(1);
+  }
+  if (!url) {
+    console.error("Usage: unloved url [session] <url>");
+    process.exit(1);
+  }
+  const homeDir = getHomeDir();
+  const meta = await readSessionMeta(homeDir, sessionName);
+  meta.previewUrl = url;
+  await writeSessionMeta(homeDir, sessionName, meta);
+  console.log(`Preview URL set to ${url} for session "${sessionName}"`);
+}
+
+// src/commands/meta.ts
+var VALID_META_KEYS = /* @__PURE__ */ new Set(["previewUrl", "restartCommand", "projectDir", "cliTool", "createdAt"]);
+async function metaCommand(args2) {
+  const assignments = [];
+  let sessionName;
+  for (const arg of args2.positional) {
+    if (arg.includes("=")) {
+      assignments.push(arg);
+    } else if (!sessionName) {
+      sessionName = arg;
+    }
+  }
+  if (!sessionName) {
+    sessionName = await detectTmuxSession();
+  }
+  if (!sessionName) {
+    console.error("Error: No session name provided and not in a tmux session");
+    process.exit(1);
+  }
+  const homeDir = getHomeDir();
+  const meta = await readSessionMeta(homeDir, sessionName);
+  if (assignments.length === 0) {
+    console.log(JSON.stringify(meta, null, 2));
+    return;
+  }
+  for (const assignment of assignments) {
+    const eqIndex = assignment.indexOf("=");
+    const key = assignment.slice(0, eqIndex);
+    const value = assignment.slice(eqIndex + 1);
+    if (!VALID_META_KEYS.has(key)) {
+      console.error(`Unknown meta key: ${key}`);
+      console.error(`Valid keys: ${[...VALID_META_KEYS].join(", ")}`);
+      process.exit(1);
+    }
+    ;
+    meta[key] = value;
+  }
+  await writeSessionMeta(homeDir, sessionName, meta);
+  console.log(JSON.stringify(meta, null, 2));
+}
+
+// src/commands/help.ts
+var HUMAN_HELP = `
+unloved \u2014 local multi-device AI coding cockpit
+
+Usage:
+  unloved                     Auto-sync from GitHub, build, start server, open browser
+  unloved start [session]     Start with optional session and flags
+  unloved restart [session]   Run the session's restart command locally
+  unloved url [session] <url> Set the preview URL for a session
+  unloved meta [session] [key=val...]
+  unloved help [--llm]
+  unloved version
+
+Flags:
+  --no-sync    Skip pulling latest from GitHub (use bundled assets)
+  --no-open    Skip opening the browser
+  --port <n>   Server port (default: 6200)
+  --url <url>  Set preview URL for the session
+  --restart <cmd>  Set restart command for the session
+
+Running \`unloved\` with no arguments syncs the latest code from GitHub,
+installs dependencies, builds, then starts the server and opens your browser.
+If sync fails, it falls back to the bundled assets from the installed package.
+
+Session name is auto-detected from your current tmux session when omitted.
+`.trim();
+var LLM_HELP = `
+UNLOVED SESSION PROTOCOL
+
+You are running inside a tmux session managed by unloved, a local multi-device
+AI coding cockpit. The user is monitoring your work from a web dashboard on
+another device (phone, tablet, or second screen). The dashboard shows your
+session status, a preview of the running app, and controls to restart your
+dev server.
+
+AVAILABLE COMMANDS
+
+All commands auto-detect the session name from your current tmux session.
+Run them directly in your shell \u2014 no HTTP calls needed.
+
+  unloved restart
+    Re-run the session's configured restart command (e.g. restart dev server).
+    Use this after making changes that require a server/build restart.
+
+  unloved url <url>
+    Update the preview URL shown in the dashboard.
+    Example: unloved url http://localhost:3000
+    The dashboard will load this URL in an iframe for the user to see.
+
+  unloved meta
+    Print current session metadata as JSON.
+    Shows: previewUrl, restartCommand, projectDir, cliTool, createdAt.
+
+  unloved meta <key>=<value> [key=value...]
+    Set session metadata fields.
+    Examples:
+      unloved meta previewUrl=http://localhost:3000
+      unloved meta restartCommand="pnpm dev"
+      unloved meta cliTool="claude-code"
+
+WORKFLOW
+
+1. After making code changes that need a dev server restart:
+   $ unloved restart
+
+2. After starting a dev server on a new port:
+   $ unloved url http://localhost:<port>
+
+3. To let the user know which tool you are:
+   $ unloved meta cliTool="claude-code"
+
+NOTES
+
+- The session name is derived from your TMUX environment. Do not hardcode it.
+- The restart command runs locally in your session's shell. It is whatever was
+  configured when the session was created (via --restart flag or meta command).
+- The preview URL is displayed in an iframe on the dashboard. Make sure the
+  dev server binds to 0.0.0.0 (not just localhost) if the dashboard is on
+  another device.
+- These commands write to ~/.unloved/sessions/<session>/meta.json. The web
+  dashboard polls this metadata to update the UI.
+`.trim();
+function helpCommand(args2) {
+  if (args2.flags.llm) {
+    console.log(LLM_HELP);
+  } else {
+    console.log(HUMAN_HELP);
+  }
+}
+
+// src/index.ts
+var args = parseArgs(process.argv);
+switch (args.command) {
+  case "start":
+    await startCommand(args);
+    break;
+  case "restart":
+    await restartCommand(args);
+    break;
+  case "url":
+    await urlCommand(args);
+    break;
+  case "meta":
+    await metaCommand(args);
+    break;
+  case "version":
+    console.log(await getVersion());
+    break;
+  case "help":
+    helpCommand(args);
+    break;
+  default:
+    console.error(`Unknown command: ${args.command}`);
+    helpCommand({ ...args, flags: {} });
+    process.exit(1);
+}