glop.dev 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,611 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command7 } from "commander";
+
+// src/commands/auth.ts
+import { Command } from "commander";
+
+// src/lib/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+var CONFIG_DIR = path.join(os.homedir(), ".glop");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function getMachineId() {
+  const machineIdFile = path.join(CONFIG_DIR, "machine_id");
+  ensureConfigDir();
+  if (fs.existsSync(machineIdFile)) {
+    return fs.readFileSync(machineIdFile, "utf-8").trim();
+  }
+  const machineId = crypto.randomUUID();
+  fs.writeFileSync(machineIdFile, machineId);
+  return machineId;
+}
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) return null;
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getServerUrl() {
+  return process.env.GLOP_SERVER_URL || loadConfig()?.server_url || "https://www.glop.dev";
+}
+
+// src/commands/auth.ts
+import http from "http";
+import { exec } from "child_process";
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  const child = exec(`${cmd} "${url}"`);
+  child.unref();
+}
+function findOpenPort() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer();
+    server.listen(0, () => {
+      const addr = server.address();
+      if (addr && typeof addr === "object") {
+        const port = addr.port;
+        server.close(() => resolve(port));
+      } else {
+        reject(new Error("Could not find open port"));
+      }
+    });
+  });
+}
+var authCommand = new Command("auth").description("Authenticate with a glop server").option("-s, --server <url>", "Server URL").action(async (opts) => {
+  const serverUrl = (opts.server || getServerUrl()).replace(/\/+$/, "");
+  const port = await findOpenPort();
+  const machineId = getMachineId();
+  console.log("Opening browser for authentication...");
+  console.log(
+    "If the browser doesn't open, visit this URL manually:"
+  );
+  const authUrl = `${serverUrl}/cli-auth?port=${port}`;
+  console.log(`  ${authUrl}
+`);
+  console.log("Waiting for authorization...");
+  openBrowser(authUrl);
+  const result = await waitForCallback(port);
+  saveConfig({
+    server_url: serverUrl,
+    api_key: result.api_key,
+    developer_id: result.developer_id,
+    developer_name: result.developer_name,
+    machine_id: machineId
+  });
+  console.log("\nAuthenticated successfully!");
+  console.log(`  Developer: ${result.developer_name}`);
+  console.log(`  Server:    ${serverUrl}`);
+  console.log(`  Machine:   ${machineId.slice(0, 8)}...`);
+  console.log(`
+API key saved to ~/.glop/config.json`);
+  console.log(
+    `
+\u2192 Run \`glop init\` in a repo to start streaming sessions.`
+  );
+  process.exit(0);
+});
+function waitForCallback(port) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timed out after 5 minutes"));
+    }, 5 * 60 * 1e3);
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || "/", `http://localhost:${port}`);
+      if (url.pathname === "/callback") {
+        const apiKey = url.searchParams.get("api_key");
+        const developerId = url.searchParams.get("developer_id");
+        const developerName = url.searchParams.get("developer_name");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(htmlPage("Authentication Failed", `<p>Error: ${escapeHtml(error)}</p><p>You can close this tab.</p>`));
+          clearTimeout(timeout);
+          server.close();
+          reject(new Error(error));
+          return;
+        }
+        if (apiKey && developerId && developerName) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(htmlPage("Authenticated!", `<p>You can close this tab and return to the terminal.</p>`));
+          clearTimeout(timeout);
+          server.close();
+          resolve({
+            api_key: apiKey,
+            developer_id: developerId,
+            developer_name: developerName
+          });
+          return;
+        }
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(htmlPage("Error", "<p>Missing parameters. Please try again.</p>"));
+        return;
+      }
+      res.writeHead(404);
+      res.end("Not found");
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function htmlPage(title, body) {
+  return `<!DOCTYPE html>
+<html>
+<head><title>glop - ${escapeHtml(title)}</title>
+<style>body{font-family:system-ui,sans-serif;display:flex;justify-content:center;align-items:center;min-height:100vh;margin:0;background:#fafafa}
+.card{background:white;border:1px solid #e5e5e5;border-radius:8px;padding:2rem;text-align:center;max-width:400px}
+h1{margin:0 0 1rem;font-size:1.25rem}</style></head>
+<body><div class="card"><h1>${escapeHtml(title)}</h1>${body}</div></body>
+</html>`;
+}
+
+// src/commands/deactivate.ts
+import { Command as Command2 } from "commander";
+
+// src/lib/git.ts
+import { execSync } from "child_process";
+function getRepoRoot() {
+  try {
+    return execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function getRepoKey() {
+  try {
+    const remote = execSync("git remote get-url origin", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = remote.match(
+      /(?:github\.com|gitlab\.com|bitbucket\.org)[/:](.+?)(?:\.git)?$/
+    );
+    if (match) return match[1];
+    const parts = remote.split("/").filter(Boolean);
+    if (parts.length >= 2) {
+      return `${parts[parts.length - 2]}/${parts[parts.length - 1].replace(".git", "")}`;
+    }
+    return remote;
+  } catch {
+    return null;
+  }
+}
+function getBranch() {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return "noname";
+  }
+}
+function getGitUserName() {
+  try {
+    return execSync("git config user.name", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function getGitUserEmail() {
+  try {
+    return execSync("git config user.email", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/deactivate.ts
+import fs2 from "fs";
+import path2 from "path";
+var HOOK_EVENTS = [
+  "PostToolUse",
+  "PermissionRequest",
+  "Stop",
+  "UserPromptSubmit",
+  "SessionStart",
+  "SessionEnd"
+];
+var deactivateCommand = new Command2("deactivate").description("Remove glop hooks from the current repo").action(async () => {
+  const repoRoot = getRepoRoot();
+  if (!repoRoot) {
+    console.error("Not in a git repository.");
+    process.exit(1);
+  }
+  const settingsFile = path2.join(repoRoot, ".claude", "settings.json");
+  if (!fs2.existsSync(settingsFile)) {
+    console.log("No .claude/settings.json found. Nothing to remove.");
+    return;
+  }
+  let settings;
+  try {
+    settings = JSON.parse(fs2.readFileSync(settingsFile, "utf-8"));
+  } catch {
+    console.error("Could not parse .claude/settings.json");
+    process.exit(1);
+  }
+  const hooks = settings.hooks;
+  if (!hooks) {
+    console.log("No hooks found in settings. Nothing to remove.");
+    return;
+  }
+  let removed = 0;
+  for (const event of HOOK_EVENTS) {
+    if (!hooks[event]) continue;
+    const before = hooks[event].length;
+    hooks[event] = hooks[event].filter((group) => {
+      const groupHooks = group?.hooks || [];
+      return !groupHooks.some(
+        (h) => h.command && (h.command.includes("glop __hook") || h.command.includes("/api/v1/ingest/hook"))
+      );
+    });
+    removed += before - hooks[event].length;
+    if (hooks[event].length === 0) {
+      delete hooks[event];
+    }
+  }
+  if (Object.keys(hooks).length === 0) {
+    delete settings.hooks;
+  }
+  fs2.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+  if (removed > 0) {
+    console.log(`Removed glop hooks from ${removed} event(s).`);
+    console.log(`  Settings: ${settingsFile}`);
+  } else {
+    console.log("No glop hooks found. Nothing to remove.");
+  }
+});
+
+// src/commands/doctor.ts
+import { Command as Command3 } from "commander";
+import { execSync as execSync2 } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+function check(status, label, detail) {
+  const icon = status === "pass" ? "\u2713" : status === "fail" ? "\u2717" : "!";
+  const line = `  ${icon} ${label}`;
+  console.log(detail ? `${line} \u2014 ${detail}` : line);
+  return status;
+}
+var doctorCommand = new Command3("doctor").description("Check that glop is set up correctly").action(async () => {
+  let hasFailure = false;
+  const fail = (label, detail) => {
+    hasFailure = true;
+    return check("fail", label, detail);
+  };
+  const config = loadConfig();
+  if (!config) {
+    fail("Authenticated", "run `glop auth` first");
+    console.log();
+    process.exit(1);
+  }
+  check("pass", "Authenticated", `${config.developer_name} on ${config.server_url}`);
+  try {
+    const res = await fetch(`${config.server_url}/api/v1/health`, {
+      headers: {
+        Authorization: `Bearer ${config.api_key}`,
+        "X-Machine-Id": config.machine_id
+      },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (res.ok) {
+      check("pass", "Server reachable");
+    } else if (res.status === 401) {
+      fail("API key valid", "re-run `glop auth`");
+    } else {
+      fail("Server reachable", `HTTP ${res.status}`);
+    }
+  } catch {
+    fail("Server reachable", `cannot connect to ${config.server_url}`);
+  }
+  const repoRoot = getRepoRoot();
+  if (repoRoot) {
+    check("pass", "Git repository", repoRoot);
+  } else {
+    check("warn", "Git repository", "not in a git repo");
+  }
+  if (repoRoot) {
+    const repoKey = getRepoKey();
+    if (repoKey) {
+      check("pass", "Git remote", repoKey);
+    } else {
+      check("warn", "Git remote", "no origin remote found");
+    }
+  }
+  const baseDir = repoRoot || process.cwd();
+  const settingsFile = path3.join(baseDir, ".claude", "settings.json");
+  if (fs3.existsSync(settingsFile)) {
+    try {
+      const settings = JSON.parse(fs3.readFileSync(settingsFile, "utf-8"));
+      const hooks = settings.hooks || {};
+      const glopEvents = Object.entries(hooks).filter(
+        ([, handlers]) => JSON.stringify(handlers).includes("glop __hook")
+      );
+      if (glopEvents.length > 0) {
+        check("pass", "Hooks installed", `${glopEvents.length} events in ${settingsFile}`);
+      } else {
+        fail("Hooks installed", "run `glop init`");
+      }
+    } catch {
+      fail("Hooks installed", `${settingsFile} is corrupted`);
+    }
+  } else {
+    fail("Hooks installed", "run `glop init`");
+  }
+  try {
+    const which = execSync2("which glop", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    check("pass", "CLI in PATH", which);
+  } catch {
+    fail("CLI in PATH", "hooks won't fire \u2014 ensure `glop` is in your PATH");
+  }
+  console.log();
+  if (hasFailure) {
+    process.exit(1);
+  } else {
+    console.log("Everything looks good!");
+  }
+});
+
+// src/commands/hook.ts
+import { Command as Command4 } from "commander";
+import { openSync, readSync, closeSync } from "fs";
+function extractSlugFromTranscript(transcriptPath) {
+  try {
+    const fd = openSync(transcriptPath, "r");
+    const buf = Buffer.alloc(65536);
+    const bytesRead = readSync(fd, buf, 0, 65536, 0);
+    closeSync(fd);
+    const head = buf.toString("utf-8", 0, bytesRead);
+    const match = head.match(/"slug":"([^"]+)"/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+var hookCommand = new Command4("__hook").description("internal").action(async () => {
+  const config = loadConfig();
+  if (!config) return;
+  let input = "";
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+  let payload;
+  try {
+    payload = JSON.parse(input);
+  } catch {
+    return;
+  }
+  payload.repo_key = getRepoKey() || payload.cwd || "unknown";
+  payload.branch = getBranch();
+  payload.machine_id = config.machine_id;
+  payload.git_user_name = getGitUserName();
+  payload.git_user_email = getGitUserEmail();
+  const skipSlugEvents = /* @__PURE__ */ new Set(["PostToolUse"]);
+  if (!skipSlugEvents.has(payload.hook_event_name) && typeof payload.transcript_path === "string") {
+    const slug = extractSlugFromTranscript(payload.transcript_path);
+    if (slug) payload.slug = slug;
+  }
+  try {
+    const res = await fetch(`${config.server_url}/api/v1/ingest/hook`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.api_key}`
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (payload.hook_event_name === "SessionStart") {
+      if (res.ok) {
+        console.log(`glop: connected to ${config.server_url}`);
+      } else if (res.status === 401) {
+        console.log("glop: API key expired or invalid \u2014 run `glop auth` to re-authenticate");
+      } else {
+        console.log(`glop: server returned HTTP ${res.status}`);
+      }
+    }
+  } catch {
+    if (payload.hook_event_name === "SessionStart") {
+      console.log(`glop: server unreachable at ${config.server_url}`);
+    }
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command5 } from "commander";
+import { execSync as execSync3 } from "child_process";
+import fs4 from "fs";
+import path4 from "path";
+function hasGlopHooks(settings) {
+  const hooks = settings.hooks;
+  if (!hooks) return false;
+  return Object.values(hooks).some(
+    (handlers) => JSON.stringify(handlers).includes("glop __hook")
+  );
+}
+var initCommand = new Command5("init").description("Install Claude Code hooks in the current repo").action(async () => {
+  const config = loadConfig();
+  if (!config) {
+    console.error("Not authenticated. Run `glop auth` first.");
+    process.exit(1);
+  }
+  try {
+    const res = await fetch(`${config.server_url}/api/v1/health`, {
+      headers: {
+        Authorization: `Bearer ${config.api_key}`,
+        "X-Machine-Id": config.machine_id
+      },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (res.status === 401) {
+      console.error("API key is invalid or expired. Run `glop auth` again.");
+      process.exit(1);
+    }
+    if (!res.ok) {
+      console.error(`Server error: HTTP ${res.status}. Try again later.`);
+      process.exit(1);
+    }
+  } catch {
+    console.warn(`Warning: Cannot reach ${config.server_url}. Key validation skipped.`);
+  }
+  try {
+    execSync3("which glop", { stdio: ["pipe", "pipe", "pipe"] });
+  } catch {
+    console.warn("Warning: `glop` not found in PATH. Hooks won't fire until it's accessible.");
+  }
+  const repoRoot = getRepoRoot();
+  if (!repoRoot) {
+    console.warn("Warning: not in a git repository. Repo and branch tracking will be limited.");
+  }
+  const baseDir = repoRoot || process.cwd();
+  const claudeDir = path4.join(baseDir, ".claude");
+  const settingsFile = path4.join(claudeDir, "settings.json");
+  if (!fs4.existsSync(claudeDir)) {
+    fs4.mkdirSync(claudeDir, { recursive: true });
+  }
+  let settings = {};
+  const isUpdate = fs4.existsSync(settingsFile);
+  if (isUpdate) {
+    try {
+      settings = JSON.parse(fs4.readFileSync(settingsFile, "utf-8"));
+    } catch {
+    }
+  }
+  const hadHooks = hasGlopHooks(settings);
+  const hookHandler = {
+    type: "command",
+    command: "glop __hook"
+  };
+  const hookGroup = {
+    hooks: [hookHandler]
+  };
+  const hooks = settings.hooks || {};
+  hooks.PostToolUse = [hookGroup];
+  hooks.PermissionRequest = [hookGroup];
+  hooks.Stop = [hookGroup];
+  hooks.UserPromptSubmit = [hookGroup];
+  hooks.SessionStart = [hookGroup];
+  hooks.SessionEnd = [hookGroup];
+  settings.hooks = hooks;
+  fs4.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+  console.log(`${hadHooks ? "\u2713 glop updated" : "\u2713 glop connected"} \u2014 sessions will appear at ${config.server_url}/live`);
+});
+
+// src/commands/status.ts
+import { Command as Command6 } from "commander";
+
+// src/lib/api-client.ts
+function getConfig() {
+  const config = loadConfig();
+  if (!config) {
+    console.error(
+      "Not authenticated. Run `glop auth` first."
+    );
+    process.exit(1);
+  }
+  return config;
+}
+async function apiRequest(path5, options = {}) {
+  const config = getConfig();
+  const url = `${config.server_url}${path5}`;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${config.api_key}`,
+    "X-Machine-Id": config.machine_id,
+    ...options.headers
+  };
+  return fetch(url, {
+    ...options,
+    headers
+  });
+}
+
+// src/commands/status.ts
+function timeAgo(iso) {
+  const seconds = Math.floor((Date.now() - new Date(iso).getTime()) / 1e3);
+  if (seconds < 5) return "just now";
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+var statusCommand = new Command6("status").description("Show current Run status for this repo").action(async () => {
+  const repoKey = getRepoKey();
+  const branch = getBranch();
+  if (!repoKey) {
+    console.error("Not in a git repository with a remote.");
+    process.exit(1);
+  }
+  try {
+    const res = await apiRequest("/api/v1/live");
+    if (!res.ok) {
+      console.error("Failed to fetch status:", res.statusText);
+      process.exit(1);
+    }
+    const data = await res.json();
+    const matchingRuns = data.runs.filter(
+      (r) => r.repo_key.includes(repoKey.split("/").pop() || "") && r.branch_name === branch
+    );
+    if (matchingRuns.length === 0) {
+      console.log(`No active runs for ${repoKey} (${branch})`);
+      return;
+    }
+    for (const run of matchingRuns) {
+      console.log(`Run: ${run.id.slice(0, 8)}`);
+      console.log(`  Status: ${run.status}`);
+      console.log(`  Phase:  ${run.phase}`);
+      console.log(`  Title:  ${run.title || "-"}`);
+      console.log(`  Last:   ${run.last_action_label || "-"}`);
+      console.log(`  Updated: ${timeAgo(run.last_event_at)}`);
+    }
+  } catch (err) {
+    console.error(
+      "Failed to connect:",
+      err instanceof Error ? err.message : err
+    );
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command7().name("glop").description("Passive control plane for local Claude-driven development").version("0.1.0");
+program.addCommand(authCommand);
+program.addCommand(deactivateCommand);
+program.addCommand(doctorCommand);
+program.addCommand(hookCommand, { hidden: true });
+program.addCommand(initCommand);
+program.addCommand(statusCommand);
+program.parse();

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "glop.dev",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "glop": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "node -e \"if (!process.env.GLOP_DEFAULT_SERVER_URL) { console.error('Error: GLOP_DEFAULT_SERVER_URL must be set before publishing'); process.exit(1); }\" && tsup"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  }
+}