glop.dev 0.9.0 → 0.11.0

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command8 } from "commander";
+import { Command as Command7 } from "commander";
 
-// src/commands/auth.ts
+// src/commands/login.ts
 import { Command } from "commander";
 
 // src/lib/config.ts
@@ -151,21 +151,13 @@ function saveRepoConfig(config) {
 }
 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;
+  if (!global || !global.api_key) return null;
   return {
     server_url: global.server_url,
-    api_key: ws.api_key,
-    developer_id: ws.developer_id,
+    api_key: global.api_key,
+    developer_id: global.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
+    machine_id: global.machine_id
   };
 }
 function getDefaultServerUrl() {
@@ -223,10 +215,7 @@ function waitForCallback(port) {
           resolve({
             api_key: apiKey,
             developer_id: developerId,
-            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
+            developer_name: developerName
           });
           return;
         }
@@ -254,8 +243,53 @@ h1{margin:0 0 1rem;font-size:1.25rem}</style></head>
 </html>`;
 }
 
-// src/commands/auth.ts
-var authCommand = new Command("auth").description("Authenticate with a glop server").option("-s, --server <url>", "Server URL").action(async (opts) => {
+// src/commands/login.ts
+import { execSync as execSync2 } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+function installGlobalHooks() {
+  const claudeDir = path2.join(os2.homedir(), ".claude");
+  const settingsFile = path2.join(claudeDir, "settings.json");
+  if (!fs2.existsSync(claudeDir)) {
+    fs2.mkdirSync(claudeDir, { recursive: true });
+  }
+  let settings = {};
+  if (fs2.existsSync(settingsFile)) {
+    try {
+      settings = JSON.parse(fs2.readFileSync(settingsFile, "utf-8"));
+    } catch {
+    }
+  }
+  const hookHandler = {
+    type: "command",
+    command: "glop __hook"
+  };
+  const hookGroup = {
+    hooks: [hookHandler]
+  };
+  const hooks = settings.hooks || {};
+  const hookEvents = [
+    "PostToolUse",
+    "PermissionRequest",
+    "Stop",
+    "UserPromptSubmit",
+    "SessionStart",
+    "SessionEnd"
+  ];
+  for (const event of hookEvents) {
+    const existing = (hooks[event] || []).filter((group) => {
+      const groupHooks = group?.hooks || [];
+      return !groupHooks.some(
+        (h) => h?.command?.includes("glop __hook")
+      );
+    });
+    hooks[event] = [...existing, hookGroup];
+  }
+  settings.hooks = hooks;
+  fs2.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+}
+var loginCommand = new Command("login").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();
@@ -269,109 +303,67 @@ var authCommand = new Command("auth").description("Authenticate with a glop serv
   console.log("Waiting for authorization...");
   openBrowser(authUrl);
   const result = await waitForCallback(port);
-  const existing = loadGlobalConfig();
-  const globalConfig = existing || {
+  const globalConfig = {
     server_url: serverUrl,
     machine_id: machineId,
-    developer_name: result.developer_name,
-    workspaces: {}
+    api_key: result.api_key,
+    developer_id: result.developer_id,
+    developer_name: result.developer_name
   };
-  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);
+  installGlobalHooks();
+  try {
+    execSync2("which glop", { stdio: ["pipe", "pipe", "pipe"] });
+  } catch {
+    console.warn("\nWarning: `glop` not found in PATH. Hooks won't fire until it's accessible.");
+  }
   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(`Hooks installed in ~/.claude/settings.json`);
   console.log(
     `
-\u2192 Run \`glop init\` in a repo to start streaming sessions.`
+\u2192 Run \`glop link\` in a repo to start streaming sessions.`
   );
   process.exit(0);
 });
 
-// src/commands/deactivate.ts
+// src/commands/unlink.ts
 import { Command as Command2 } from "commander";
-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 () => {
+import fs3 from "fs";
+import path3 from "path";
+var unlinkCommand = new Command2("unlink").description("Unbind this repo from its glop workspace").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.");
+  const glopDir = path3.join(repoRoot, ".glop");
+  const configFile = path3.join(glopDir, "config.json");
+  if (!fs3.existsSync(configFile)) {
+    console.log("This repo is not bound to a workspace. Nothing to do.");
     return;
   }
-  let settings;
+  fs3.unlinkSync(configFile);
   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];
+    const remaining = fs3.readdirSync(glopDir);
+    if (remaining.length === 0) {
+      fs3.rmdirSync(glopDir);
     }
+  } catch {
   }
-  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.");
-  }
+  console.log("\u2713 Workspace binding removed. Hooks will no-op for this repo.");
 });
 
 // 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";
+import { execSync as execSync3 } from "child_process";
+import fs4 from "fs";
+import path4 from "path";
+import os3 from "os";
 function check(status, label, detail) {
   const icon = status === "pass" ? "\u2713" : status === "fail" ? "\u2717" : "!";
   const line = `  ${icon} ${label}`;
@@ -386,14 +378,11 @@ var doctorCommand = new Command3("doctor").description("Check that glop is set u
   };
   const config = loadConfig();
   if (!config) {
-    fail("Authenticated", "run `glop auth` first");
+    fail("Authenticated", "run `glop login` first");
     console.log();
     process.exit(1);
   }
-  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);
+  check("pass", "Authenticated", `${config.developer_name} on ${config.server_url}`);
   try {
     const res = await fetch(`${config.server_url}/api/v1/health`, {
       headers: {
@@ -405,7 +394,7 @@ var doctorCommand = new Command3("doctor").description("Check that glop is set u
     if (res.ok) {
       check("pass", "Server reachable");
     } else if (res.status === 401) {
-      fail("API key valid", "re-run `glop auth`");
+      fail("API key valid", "re-run `glop login`");
     } else {
       fail("Server reachable", `HTTP ${res.status}`);
     }
@@ -426,28 +415,35 @@ var doctorCommand = new Command3("doctor").description("Check that glop is set u
       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)) {
+  const globalSettingsFile = path4.join(os3.homedir(), ".claude", "settings.json");
+  if (fs4.existsSync(globalSettingsFile)) {
     try {
-      const settings = JSON.parse(fs3.readFileSync(settingsFile, "utf-8"));
+      const settings = JSON.parse(fs4.readFileSync(globalSettingsFile, "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}`);
+        check("pass", "Global hooks installed", `${glopEvents.length} events in ${globalSettingsFile}`);
       } else {
-        fail("Hooks installed", "run `glop init`");
+        fail("Global hooks installed", "run `glop login`");
       }
     } catch {
-      fail("Hooks installed", `${settingsFile} is corrupted`);
+      fail("Global hooks installed", `${globalSettingsFile} is corrupted`);
     }
   } else {
-    fail("Hooks installed", "run `glop init`");
+    fail("Global hooks installed", "run `glop login`");
+  }
+  const repoBinding = loadRepoConfig();
+  if (repoBinding) {
+    check("pass", "Repo bound to workspace", repoBinding.workspace_id);
+  } else if (repoRoot) {
+    check("warn", "Repo bound to workspace", "run `glop link` to bind this repo");
+  } else {
+    check("warn", "Repo bound to workspace", "not in a git repo");
   }
   try {
-    const which = execSync2("which glop", {
+    const which = execSync3("which glop", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -455,6 +451,15 @@ var doctorCommand = new Command3("doctor").description("Check that glop is set u
   } catch {
     fail("CLI in PATH", "hooks won't fire \u2014 ensure `glop` is in your PATH");
   }
+  try {
+    const ghWhich = execSync3("which gh", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    check("pass", "GitHub CLI (gh)", ghWhich);
+  } catch {
+    check("warn", "GitHub CLI (gh)", "PR comment features won't work \u2014 install from https://cli.github.com");
+  }
   console.log();
   if (hasFailure) {
     process.exit(1);
@@ -466,6 +471,10 @@ 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, readFileSync } from "fs";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import path5 from "path";
+var PR_URL_RE = /(https:\/\/github\.com\/[^\s]+\/pull\/\d+)/;
 function extractSlugFromTranscript(transcriptPath) {
   try {
     const fd = openSync(transcriptPath, "r");
@@ -485,6 +494,8 @@ function extractSlugFromTranscript(transcriptPath) {
 var hookCommand = new Command4("__hook").description("internal").action(async () => {
   const config = loadConfig();
   if (!config) return;
+  const repoConfig = loadRepoConfig();
+  if (!repoConfig) return;
   let input = "";
   for await (const chunk of process.stdin) {
     input += chunk;
@@ -498,6 +509,7 @@ var hookCommand = new Command4("__hook").description("internal").action(async ()
   payload.repo_key = getRepoKey() || payload.cwd || "unknown";
   payload.branch = getBranch();
   payload.machine_id = config.machine_id;
+  payload.workspace_id = repoConfig.workspace_id;
   payload.git_user_name = getGitUserName();
   payload.git_user_email = getGitUserEmail();
   if (payload.hook_event_name === "PostToolUse" && payload.tool_name === "Bash" && typeof payload.tool_response === "string" && /\bgit\s+commit\b/.test(
@@ -513,6 +525,13 @@ var hookCommand = new Command4("__hook").description("internal").action(async ()
     const slug = extractSlugFromTranscript(payload.transcript_path);
     if (slug) payload.slug = slug;
   }
+  let prUrl = null;
+  if (payload.hook_event_name === "PostToolUse" && payload.tool_name === "Bash" && typeof payload.tool_response === "string" && /\bgh\s+pr\s+create\b/.test(
+    typeof payload.tool_input?.command === "string" ? payload.tool_input.command : ""
+  )) {
+    const prMatch = payload.tool_response.match(PR_URL_RE);
+    if (prMatch) prUrl = prMatch[1];
+  }
   try {
     const res = await fetch(`${config.server_url}/api/v1/ingest/hook`, {
       method: "POST",
@@ -523,20 +542,36 @@ var hookCommand = new Command4("__hook").description("internal").action(async ()
       body: JSON.stringify(payload),
       signal: AbortSignal.timeout(5e3)
     });
+    const resBody = res.ok ? await res.json().catch(() => ({})) : null;
     if (payload.hook_event_name === "SessionStart") {
-      if (res.ok) {
-        const body = await res.json();
-        const runUrl = body.run_id ? `${config.server_url}/runs/${body.run_id}` : null;
+      if (res.ok && resBody) {
+        const runUrl = resBody.run_id ? `${config.server_url}/runs/${resBody.run_id}` : null;
         console.log(`glop: connected to ${config.server_url}`);
         if (runUrl) {
           console.log(`glop: Add "Glop-Run: ${runUrl}" as a git trailer in all commit messages and PR descriptions.`);
         }
       } else if (res.status === 401) {
-        console.log("glop: API key expired or invalid \u2014 run `glop auth` to re-authenticate");
+        console.log("glop: API key expired or invalid \u2014 run `glop login` to re-authenticate");
       } else {
         console.log(`glop: server returned HTTP ${res.status}`);
       }
     }
+    if (prUrl && resBody?.run_id) {
+      try {
+        const workerPath = path5.join(
+          path5.dirname(fileURLToPath(import.meta.url)),
+          "lib",
+          "pr-comment-worker.js"
+        );
+        const child = spawn(
+          process.execPath,
+          [workerPath, config.server_url, resBody.run_id, prUrl],
+          { detached: true, stdio: "ignore", env: { ...process.env, GLOP_API_KEY: config.api_key } }
+        );
+        child.unref();
+      } catch {
+      }
+    }
   } catch {
     if (payload.hook_event_name === "SessionStart") {
       console.log(`glop: server unreachable at ${config.server_url}`);
@@ -544,104 +579,8 @@ var hookCommand = new Command4("__hook").description("internal").action(async ()
   }
 });
 
-// src/commands/init.ts
+// src/commands/link.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));
-  const workspace = config.workspace_name || config.workspace_slug || config.workspace_id || "default";
-  console.log(`${hadHooks ? "\u2713 glop updated" : "\u2713 glop connected"} to workspace "${workspace}" \u2014 sessions will appear at ${config.server_url}/live`);
-});
-
-// src/commands/update.ts
-import { Command as Command6 } from "commander";
-import { execSync as execSync4 } from "child_process";
-var updateCommand = new Command6("update").description("Update glop to the latest version").action(() => {
-  console.log("Updating glop\u2026");
-  try {
-    execSync4("npm install -g glop.dev@latest", { stdio: "inherit" });
-    const version = execSync4("glop --version", { encoding: "utf-8" }).trim();
-    console.log(`
-glop has been updated successfully to v${version}.`);
-  } catch {
-    process.exitCode = 1;
-  }
-});
-
-// src/commands/workspace.ts
-import { Command as Command7 } from "commander";
 
 // src/lib/select.ts
 function interactiveSelect(items, initialIndex = 0) {
@@ -704,13 +643,26 @@ function interactiveSelect(items, initialIndex = 0) {
   });
 }
 
-// src/commands/workspace.ts
-var workspaceCommand = new Command7("workspace").description("View or switch workspaces").action(async () => {
+// src/commands/link.ts
+var linkCommand = new Command5("link").description("Bind this repo to a glop workspace").action(async () => {
   const config = loadConfig();
   if (!config) {
-    console.error("Not authenticated. Run `glop auth` first.");
+    console.error("Not authenticated. Run `glop login` first.");
+    process.exit(1);
+  }
+  const repoRoot = getRepoRoot();
+  if (!repoRoot) {
+    console.error("Not in a git repository. Run this from a git repo.");
     process.exit(1);
   }
+  const existingRepo = loadRepoConfig();
+  if (existingRepo) {
+    console.log(`This repo is already bound to workspace ${existingRepo.workspace_id}.`);
+    if (!process.stdin.isTTY) {
+      process.exit(0);
+    }
+    console.log("Re-running to switch workspace...\n");
+  }
   let data;
   try {
     const res = await fetch(`${config.server_url}/api/v1/cli/workspaces`, {
@@ -721,11 +673,11 @@ var workspaceCommand = new Command7("workspace").description("View or switch wor
       signal: AbortSignal.timeout(1e4)
     });
     if (res.status === 401) {
-      console.error("API key is invalid. Run `glop auth` to re-authenticate.");
+      console.error("API key is invalid or expired. Run `glop login` again.");
       process.exit(1);
     }
     if (!res.ok) {
-      console.error(`Failed to fetch workspaces (HTTP ${res.status}).`);
+      console.error(`Server error: HTTP ${res.status}. Try again later.`);
       process.exit(1);
     }
     data = await res.json();
@@ -738,90 +690,57 @@ var workspaceCommand = new Command7("workspace").description("View or switch wor
     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);
+    console.error("No workspaces found. Create one at " + config.server_url);
+    process.exit(1);
   }
+  let selectedWorkspace;
   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);
+    selectedWorkspace = data.workspaces[0];
+  } else {
+    if (!process.stdin.isTTY) {
+      console.error("Multiple workspaces available. Run interactively to choose.");
+      process.exit(1);
     }
-    console.log(`
-  Switched to ${selectedWorkspace.name}!`);
-    process.exit(0);
+    const currentId = existingRepo?.workspace_id || data.current_workspace_id;
+    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("  Select a workspace:\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);
+    }
+    selectedWorkspace = data.workspaces[selected];
   }
-  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;
+  saveRepoConfig({ workspace_id: selectedWorkspace.id });
+  console.log(`\u2713 Bound to workspace "${selectedWorkspace.name}" \u2014 sessions will appear at ${config.server_url}/live`);
+});
+
+// src/commands/update.ts
+import { Command as Command6 } from "commander";
+import { execSync as execSync4 } from "child_process";
+var updateCommand = new Command6("update").description("Update glop to the latest version").action(() => {
+  console.log("Updating glop\u2026");
+  try {
+    execSync4("npm install -g glop.dev@latest", { stdio: "inherit" });
+    const version = execSync4("glop --version", { encoding: "utf-8" }).trim();
+    console.log(`
+glop has been updated successfully to v${version}.`);
+  } catch {
+    process.exitCode = 1;
   }
-  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");
+import path6 from "path";
+import os4 from "os";
+var CONFIG_DIR2 = path6.join(os4.homedir(), ".glop");
+var CACHE_FILE = path6.join(CONFIG_DIR2, "update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function ensureConfigDir2() {
   if (!fs5.existsSync(CONFIG_DIR2)) {
@@ -882,7 +801,7 @@ async function checkForUpdate(currentVersion) {
 // package.json
 var package_default = {
   name: "glop.dev",
-  version: "0.9.0",
+  version: "0.11.0",
   type: "module",
   bin: {
     glop: "./dist/index.js"
@@ -910,14 +829,13 @@ var package_default = {
 };
 
 // src/index.ts
-var program = new Command8().name("glop").description("Passive control plane for local Claude-driven development").version(package_default.version);
-program.addCommand(authCommand);
-program.addCommand(deactivateCommand);
+var program = new Command7().name("glop").description("Passive control plane for local Claude-driven development").version(package_default.version);
+program.addCommand(loginCommand);
+program.addCommand(unlinkCommand);
 program.addCommand(doctorCommand);
 program.addCommand(hookCommand, { hidden: true });
-program.addCommand(initCommand);
+program.addCommand(linkCommand);
 program.addCommand(updateCommand);
-program.addCommand(workspaceCommand);
 program.hook("postAction", async (_thisCommand, actionCommand) => {
   if (actionCommand.name() === "__hook") return;
   await checkForUpdate(package_default.version);

package/dist/lib/pr-comment-worker.js

@@ -0,0 +1,86 @@
+// src/lib/pr-comment-worker.ts
+import { execFileSync } from "child_process";
+var [serverUrl, runId, prUrl] = process.argv.slice(2);
+var apiKey = process.env.GLOP_API_KEY;
+if (!serverUrl || !apiKey || !runId || !prUrl) {
+  process.exit(1);
+}
+async function main() {
+  const contextRes = await fetch(`${serverUrl}/api/v1/runs/${runId}/context`, {
+    headers: { Authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!contextRes.ok) {
+    process.exit(1);
+  }
+  const context = await contextRes.json();
+  const prompt = [
+    "Generate a concise GitHub PR comment summarizing this AI coding session.",
+    "Output ONLY the markdown body \u2014 no wrapping, no ```markdown fences, no preamble.",
+    "",
+    `Session title: ${context.title || "Untitled"}`,
+    `Session summary: ${context.summary || "No summary"}`,
+    "",
+    "Developer prompts:",
+    ...context.prompts.map((p, i) => `${i + 1}. ${p}`),
+    "",
+    "Actions taken:",
+    ...context.tool_use_labels.map((l, i) => `${i + 1}. ${l}`),
+    "",
+    "Files touched:",
+    ...context.files_touched.map((f) => `- ${f}`),
+    "",
+    "Format the comment with:",
+    "- A blockquote with the developer's core request",
+    "- 2-3 sentences on how the AI approached the task",
+    "- A bullet list of key decisions (if any)",
+    "- A collapsible <details> section listing files touched",
+    `- Stats line: ${context.event_count} events \xB7 ${context.file_count} files`
+  ].join("\n");
+  let commentBody;
+  try {
+    commentBody = execFileSync("claude", ["-p", prompt], {
+      encoding: "utf-8",
+      timeout: 6e4,
+      maxBuffer: 1024 * 1024
+    }).trim();
+  } catch {
+    commentBody = buildTemplate(context);
+  }
+  if (!commentBody) {
+    commentBody = buildTemplate(context);
+  }
+  const runUrl = `${serverUrl}/runs/${runId}`;
+  const fullComment = [
+    commentBody,
+    "",
+    `<sub>[View in Glop](${runUrl}) \xB7 Posted by [Glop](${serverUrl})</sub>`
+  ].join("\n");
+  execFileSync("gh", ["pr", "comment", prUrl, "--body", fullComment], {
+    encoding: "utf-8",
+    timeout: 15e3
+  });
+}
+function buildTemplate(context) {
+  const parts = [];
+  parts.push(`> ${context.prompts[0] || "No prompt recorded"}
+`);
+  parts.push(`${context.summary || context.title || "No summary available"}
+`);
+  if (context.files_touched.length > 0) {
+    parts.push(
+      "<details>",
+      `<summary>Files touched (${context.files_touched.length})</summary>
+`
+    );
+    for (const file of context.files_touched) {
+      parts.push(`- \`${file}\``);
+    }
+    parts.push("\n</details>\n");
+  }
+  parts.push(
+    `<sub>${context.event_count} events \xB7 ${context.file_count} files</sub>`
+  );
+  return parts.join("\n");
+}
+main().catch(() => process.exit(1));

package/package.json

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