glop.dev 0.4.0 → 0.6.0

package/dist/index.js

@@ -11,6 +11,70 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import crypto from "crypto";
+
+// 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/lib/config.ts
 var CONFIG_DIR = path.join(os.homedir(), ".glop");
 var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
 function ensureConfigDir() {
@@ -28,7 +92,7 @@ function getMachineId() {
   fs.writeFileSync(machineIdFile, machineId);
   return machineId;
 }
-function loadConfig() {
+function loadGlobalConfig() {
   if (!fs.existsSync(CONFIG_FILE)) return null;
   try {
     const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
@@ -37,15 +101,58 @@ function loadConfig() {
     return null;
   }
 }
-function saveConfig(config) {
+function saveGlobalConfig(config) {
   ensureConfigDir();
   fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
+function loadRepoConfig() {
+  const repoRoot = getRepoRoot();
+  if (!repoRoot) return null;
+  const repoConfigFile = path.join(repoRoot, ".glop", "config.json");
+  if (!fs.existsSync(repoConfigFile)) return null;
+  try {
+    const raw = fs.readFileSync(repoConfigFile, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveRepoConfig(config) {
+  const repoRoot = getRepoRoot();
+  if (!repoRoot) throw new Error("Not in a git repository");
+  const repoConfigDir = path.join(repoRoot, ".glop");
+  if (!fs.existsSync(repoConfigDir)) {
+    fs.mkdirSync(repoConfigDir, { recursive: true });
+  }
+  fs.writeFileSync(
+    path.join(repoConfigDir, "config.json"),
+    JSON.stringify(config, null, 2)
+  );
+}
+function loadConfig() {
+  const global = loadGlobalConfig();
+  if (!global || Object.keys(global.workspaces).length === 0) return null;
+  const repoConfig = loadRepoConfig();
+  const workspaceId = repoConfig?.workspace_id || global.default_workspace || Object.keys(global.workspaces)[0];
+  if (!workspaceId) return null;
+  const ws = global.workspaces[workspaceId];
+  if (!ws) return null;
+  return {
+    server_url: global.server_url,
+    api_key: ws.api_key,
+    developer_id: ws.developer_id,
+    developer_name: global.developer_name,
+    machine_id: global.machine_id,
+    workspace_id: workspaceId,
+    workspace_name: ws.workspace_name,
+    workspace_slug: ws.workspace_slug
+  };
+}
 function getDefaultServerUrl() {
   return process.env.GLOP_SERVER_URL || "https://www.glop.dev";
 }
 
-// src/commands/auth.ts
+// src/lib/auth-flow.ts
 import http from "http";
 import { exec } from "child_process";
 function openBrowser(url) {
@@ -67,39 +174,6 @@ function findOpenPort() {
     });
   });
 }
-var authCommand = new Command("auth").description("Authenticate with a glop server").option("-s, --server <url>", "Server URL").action(async (opts) => {
-  const serverUrl = (opts.server || getDefaultServerUrl()).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(() => {
@@ -129,7 +203,10 @@ function waitForCallback(port) {
           resolve({
             api_key: apiKey,
             developer_id: developerId,
-            developer_name: developerName
+            developer_name: developerName,
+            workspace_id: url.searchParams.get("workspace_id") || void 0,
+            workspace_name: url.searchParams.get("workspace_name") || void 0,
+            workspace_slug: url.searchParams.get("workspace_slug") || void 0
           });
           return;
         }
@@ -157,72 +234,59 @@ h1{margin:0 0 1rem;font-size:1.25rem}</style></head>
 </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/auth.ts
+var authCommand = new Command("auth").description("Authenticate with a glop server").option("-s, --server <url>", "Server URL").action(async (opts) => {
+  const serverUrl = (opts.server || getDefaultServerUrl()).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);
+  const existing = loadGlobalConfig();
+  const globalConfig = existing || {
+    server_url: serverUrl,
+    machine_id: machineId,
+    developer_name: result.developer_name,
+    workspaces: {}
+  };
+  globalConfig.server_url = serverUrl;
+  globalConfig.machine_id = machineId;
+  globalConfig.developer_name = result.developer_name;
+  if (result.workspace_id) {
+    globalConfig.workspaces[result.workspace_id] = {
+      api_key: result.api_key,
+      developer_id: result.developer_id,
+      workspace_name: result.workspace_name,
+      workspace_slug: result.workspace_slug
+    };
+    globalConfig.default_workspace = result.workspace_id;
+  }
+  saveGlobalConfig(globalConfig);
+  console.log("\nAuthenticated successfully!");
+  console.log(`  Developer:  ${result.developer_name}`);
+  if (result.workspace_name) {
+    console.log(`  Workspace:  ${result.workspace_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);
+});
 
 // src/commands/deactivate.ts
+import { Command as Command2 } from "commander";
 import fs2 from "fs";
 import path2 from "path";
 var HOOK_EVENTS = [
@@ -306,7 +370,10 @@ var doctorCommand = new Command3("doctor").description("Check that glop is set u
     console.log();
     process.exit(1);
   }
-  check("pass", "Authenticated", `${config.developer_name} on ${config.server_url}`);
+  const repoBinding = loadRepoConfig();
+  const wsSource = repoBinding?.workspace_id ? "repo binding" : "default";
+  const authDetail = config.workspace_name ? `${config.developer_name} on ${config.server_url} (${config.workspace_name}, ${wsSource})` : `${config.developer_name} on ${config.server_url}`;
+  check("pass", "Authenticated", authDetail);
   try {
     const res = await fetch(`${config.server_url}/api/v1/health`, {
       headers: {
@@ -378,16 +445,19 @@ var doctorCommand = new Command3("doctor").description("Check that glop is set u
 
 // src/commands/hook.ts
 import { Command as Command4 } from "commander";
-import { openSync, readSync, closeSync } from "fs";
+import { openSync, readSync, closeSync, readFileSync } from "fs";
 function extractSlugFromTranscript(transcriptPath) {
   try {
     const fd = openSync(transcriptPath, "r");
-    const buf = Buffer.alloc(65536);
-    const bytesRead = readSync(fd, buf, 0, 65536, 0);
+    const buf = Buffer.alloc(262144);
+    const bytesRead = readSync(fd, buf, 0, 262144, 0);
     closeSync(fd);
     const head = buf.toString("utf-8", 0, bytesRead);
     const match = head.match(/"slug":"([^"]+)"/);
-    return match ? match[1] : null;
+    if (match) return match[1];
+    if (bytesRead < 262144) return null;
+    const full = readFileSync(transcriptPath, "utf-8");
+    return full.match(/"slug":"([^"]+)"/)?.[1] ?? null;
   } catch {
     return null;
   }
@@ -526,89 +596,249 @@ var initCommand = new Command5("init").description("Install Claude Code hooks in
   console.log(`${hadHooks ? "\u2713 glop updated" : "\u2713 glop connected"} \u2014 sessions will appear at ${config.server_url}/live`);
 });
 
-// src/commands/status.ts
+// src/commands/workspace.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/lib/select.ts
+function interactiveSelect(items, initialIndex = 0) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY) {
+      resolve(null);
+      return;
+    }
+    let cursor = initialIndex;
+    function render() {
+      if (rendered) {
+        process.stdout.write(`\x1B[${items.length}A`);
+      }
+      for (let i = 0; i < items.length; i++) {
+        const isSelected = i === cursor;
+        const prefix = isSelected ? "\x1B[36m\u276F\x1B[0m " : "  ";
+        process.stdout.write(`\x1B[2K${prefix}${items[i]}
+`);
+      }
+      rendered = true;
+    }
+    let rendered = false;
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    function cleanup() {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.removeListener("data", onData);
+    }
+    function onData(key) {
+      if (key === "") {
+        cleanup();
+        resolve(null);
+        return;
+      }
+      if (key === "\x1B" || key === "\x1B\x1B") {
+        cleanup();
+        resolve(null);
+        return;
+      }
+      if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve(cursor);
+        return;
+      }
+      if (key === "\x1B[A" || key === "k") {
+        cursor = (cursor - 1 + items.length) % items.length;
+        render();
+        return;
+      }
+      if (key === "\x1B[B" || key === "j") {
+        cursor = (cursor + 1) % items.length;
+        render();
+        return;
+      }
+    }
+    process.stdin.on("data", onData);
+    render();
   });
 }
 
-// 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.");
+// src/commands/workspace.ts
+var workspaceCommand = new Command6("workspace").description("View or switch workspaces").action(async () => {
+  const config = loadConfig();
+  if (!config) {
+    console.error("Not authenticated. Run `glop auth` first.");
     process.exit(1);
   }
+  let data;
   try {
-    const res = await apiRequest("/api/v1/live");
-    if (!res.ok) {
-      console.error("Failed to fetch status:", res.statusText);
+    const res = await fetch(`${config.server_url}/api/v1/cli/workspaces`, {
+      headers: {
+        Authorization: `Bearer ${config.api_key}`,
+        "X-Machine-Id": config.machine_id
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (res.status === 401) {
+      console.error("API key is invalid. Run `glop auth` to re-authenticate.");
       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)}`);
+    if (!res.ok) {
+      console.error(`Failed to fetch workspaces (HTTP ${res.status}).`);
+      process.exit(1);
     }
+    data = await res.json();
   } catch (err) {
-    console.error(
-      "Failed to connect:",
-      err instanceof Error ? err.message : err
-    );
+    if (err instanceof Error && err.name === "TimeoutError") {
+      console.error(`Cannot connect to ${config.server_url}`);
+    } else {
+      console.error("Failed to fetch workspaces.");
+    }
     process.exit(1);
   }
+  if (data.workspaces.length === 0) {
+    console.log("No workspaces found.");
+    process.exit(0);
+  }
+  const repoConfig = loadRepoConfig();
+  const currentId = repoConfig?.workspace_id || config.workspace_id || data.current_workspace_id;
+  if (!process.stdin.isTTY) {
+    const current = data.workspaces.find((w) => w.id === currentId);
+    console.log(current ? current.name : currentId);
+    process.exit(0);
+  }
+  if (data.workspaces.length === 1) {
+    console.log(`  Workspace: ${data.workspaces[0].name}`);
+    console.log("  (only workspace)");
+    process.exit(0);
+  }
+  const items = data.workspaces.map((w) => {
+    const marker = w.id === currentId ? "\u25CF" : "\u25CB";
+    return `${marker}  ${w.name}`;
+  });
+  const currentIndex = data.workspaces.findIndex((w) => w.id === currentId);
+  console.log("\n  Workspaces:\n");
+  console.log("  \x1B[2m\u2191/\u2193 navigate \xB7 Enter select \xB7 Esc cancel\x1B[0m\n");
+  const selected = await interactiveSelect(items, Math.max(currentIndex, 0));
+  if (selected === null) {
+    console.log("\n  Cancelled.");
+    process.exit(0);
+  }
+  const selectedWorkspace = data.workspaces[selected];
+  if (selectedWorkspace.id === currentId) {
+    console.log(`
+  Already on ${selectedWorkspace.name}.`);
+    process.exit(0);
+  }
+  const globalConfig = loadGlobalConfig();
+  const existingCreds = globalConfig.workspaces[selectedWorkspace.id];
+  const repoRoot = getRepoRoot();
+  if (existingCreds) {
+    if (repoRoot) {
+      saveRepoConfig({ workspace_id: selectedWorkspace.id });
+    } else {
+      globalConfig.default_workspace = selectedWorkspace.id;
+      saveGlobalConfig(globalConfig);
+    }
+    console.log(`
+  Switched to ${selectedWorkspace.name}!`);
+    process.exit(0);
+  }
+  console.log(`
+  Switching to ${selectedWorkspace.name}...`);
+  console.log("  Opening browser for authorization...\n");
+  const port = await findOpenPort();
+  const machineId = getMachineId();
+  const authUrl = `${config.server_url}/cli-auth?port=${port}&workspace_id=${selectedWorkspace.id}`;
+  console.log("  If the browser doesn't open, visit this URL manually:");
+  console.log(`  ${authUrl}
+`);
+  console.log("  Waiting for authorization...");
+  openBrowser(authUrl);
+  const result = await waitForCallback(port);
+  const wsId = result.workspace_id || selectedWorkspace.id;
+  globalConfig.workspaces[wsId] = {
+    api_key: result.api_key,
+    developer_id: result.developer_id,
+    workspace_name: result.workspace_name,
+    workspace_slug: result.workspace_slug
+  };
+  globalConfig.developer_name = result.developer_name;
+  if (repoRoot) {
+    saveRepoConfig({ workspace_id: wsId });
+  } else {
+    globalConfig.default_workspace = wsId;
+  }
+  saveGlobalConfig(globalConfig);
+  console.log(`
+  Switched to ${result.workspace_name || selectedWorkspace.name}!`);
+  process.exit(0);
 });
 
+// src/lib/update-check.ts
+import fs5 from "fs";
+import path5 from "path";
+import os2 from "os";
+var CONFIG_DIR2 = path5.join(os2.homedir(), ".glop");
+var CACHE_FILE = path5.join(CONFIG_DIR2, "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function ensureConfigDir2() {
+  if (!fs5.existsSync(CONFIG_DIR2)) {
+    fs5.mkdirSync(CONFIG_DIR2, { recursive: true });
+  }
+}
+function isNewerVersion(current, latest) {
+  const currentParts = current.split(".").map(Number);
+  const latestParts = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const c = currentParts[i] || 0;
+    const l = latestParts[i] || 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  return false;
+}
+async function checkForUpdate(currentVersion) {
+  try {
+    if (process.env.CI) return;
+    if (!process.stderr.isTTY) return;
+    let latestVersion = null;
+    if (fs5.existsSync(CACHE_FILE)) {
+      try {
+        const raw = fs5.readFileSync(CACHE_FILE, "utf-8");
+        const cache = JSON.parse(raw);
+        if (Date.now() - cache.last_check < CHECK_INTERVAL_MS) {
+          latestVersion = cache.latest_version;
+        }
+      } catch {
+      }
+    }
+    if (!latestVersion) {
+      const response = await fetch(
+        "https://registry.npmjs.org/glop.dev/latest",
+        { signal: AbortSignal.timeout(3e3) }
+      );
+      const data = await response.json();
+      latestVersion = data.version;
+      ensureConfigDir2();
+      const cache = {
+        last_check: Date.now(),
+        latest_version: latestVersion
+      };
+      fs5.writeFileSync(CACHE_FILE, JSON.stringify(cache));
+    }
+    if (isNewerVersion(currentVersion, latestVersion)) {
+      console.error(
+        `
+  Update available: ${currentVersion} \u2192 ${latestVersion}. Run \`npm i -g glop.dev\` to update.
+`
+      );
+    }
+  } catch {
+  }
+}
+
 // package.json
 var package_default = {
   name: "glop.dev",
-  version: "0.4.0",
+  version: "0.6.0",
   type: "module",
   bin: {
     glop: "./dist/index.js"
@@ -641,5 +871,9 @@ program.addCommand(deactivateCommand);
 program.addCommand(doctorCommand);
 program.addCommand(hookCommand, { hidden: true });
 program.addCommand(initCommand);
-program.addCommand(statusCommand);
+program.addCommand(workspaceCommand);
+program.hook("postAction", async (_thisCommand, actionCommand) => {
+  if (actionCommand.name() === "__hook") return;
+  await checkForUpdate(package_default.version);
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glop.dev",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "bin": {
     "glop": "./dist/index.js"