@winding-labs/glow 0.1.0 → 0.1.5

package/lib/agents.mjs

@@ -3,6 +3,10 @@
 //                session when a message arrives
 //   Codex        ~/.codex/hooks.json      hooks.Stop: the hook before the turn ends (≤ 15 s; it takes about a second)
 // Every other key in those files is kept as it was. A file that isn't valid JSON is never overwritten.
+//
+// And Glow's plugin in each (/glow:status, /glow:ignore, /glow:unignore), from the marketplace in ~/.glow/marketplace,
+// added and removed with the agent's own CLI (`claude plugin …`, `codex plugin …`) so it writes its settings its way.
+import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -70,6 +74,14 @@ function stripOurs(groups) {
     .filter((g) => !(g && typeof g === 'object' && Array.isArray(g.hooks) && g.hooks.length === 0));
 }
 
+const hasHookIn = (file) => {
+  try {
+    return hasHook(readJson(file));
+  } catch {
+    return false;
+  }
+};
+
 export const hasHook = (settings) => Array.isArray(settings?.hooks?.Stop) && settings.hooks.Stop.some((g) => Array.isArray(g?.hooks) && g.hooks.some(isOurs));
 
 /** The file's JSON ({} when missing). Throws when it exists but isn't a JSON object, so it's never clobbered. */
@@ -83,8 +95,9 @@ export function readJson(file) {
 }
 
 /**
- * Write next to the original with its mode kept; the first time, the original is copied to <file>.before-glow. A
- * symlinked settings file (dotfiles) is written through to its target, so the link stays a link.
+ * Write next to the original with its mode kept. The original is copied to <file>.before-glow once, and only while it
+ * has no Glow hook (so the backup is always the file as it was before Glow). A symlinked settings file (dotfiles) is
+ * written through to its target, so the link stays a link.
  */
 export function writeJson(file, value) {
   fs.mkdirSync(path.dirname(file), { recursive: true });
@@ -93,7 +106,7 @@ export function writeJson(file, value) {
   if (fs.existsSync(target)) {
     mode = fs.statSync(target).mode & 0o777;
     const backup = `${file}.before-glow`;
-    if (!fs.existsSync(backup)) fs.copyFileSync(target, backup);
+    if (!fs.existsSync(backup) && !hasHookIn(target)) fs.copyFileSync(target, backup);
   }
   writeFileAtomic(target, `${JSON.stringify(value, null, 2)}\n`, mode);
 }
@@ -120,3 +133,41 @@ export const installed = (id) => {
     return false;
   }
 };
+
+// ---------- the /glow plugin ----------
+
+export const marketplacePath = () => path.join(dir(), 'marketplace');
+const PLUGIN = 'glow@glow';
+const pluginSteps = (id) => ({
+  add: [['plugin', 'marketplace', 'add', marketplacePath()], id === 'codex' ? ['plugin', 'add', PLUGIN] : ['plugin', 'install', PLUGIN]],
+  remove: [[...(id === 'codex' ? ['plugin', 'remove'] : ['plugin', 'uninstall']), PLUGIN], ['plugin', 'marketplace', 'remove', 'glow']],
+});
+
+const agentCli = (id, args) =>
+  execFileSync(AGENTS[id].bin, args, { encoding: 'utf8', timeout: 60_000, stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 1024 * 1024 });
+
+/** Adds (or, run again, refreshes) the plugin in this agent. Throws with the agent's own message when it can't. */
+export function addPlugin(id) {
+  for (const args of pluginSteps(id).add) {
+    try {
+      agentCli(id, args);
+    } catch (e) {
+      const why = e?.code === 'ENOENT' ? `${AGENTS[id].bin} isn’t on your PATH` : String(e?.stderr || e?.stdout || e?.message || '').trim().split('\n').pop();
+      throw new Error(why || 'it failed');
+    }
+  }
+}
+
+/** Removes the plugin and its marketplace from this agent; true when the plugin was there. Never throws. */
+export function removePlugin(id) {
+  let removed = false;
+  for (const [i, args] of pluginSteps(id).remove.entries()) {
+    try {
+      agentCli(id, args);
+      if (i === 0) removed = true;
+    } catch {
+      // not there, or the agent isn't installed
+    }
+  }
+  return removed;
+}

package/lib/core.mjs

@@ -1,4 +1,5 @@
-// Shared by the installer (bin/glow.mjs) and the hook (~/.glow/hook.mjs). Plain Node 18+, no dependencies.
+// Shared by the CLI (bin/glow.mjs), the hook (lib/hook.mjs) and the runner (lib/runner.mjs), all copied to ~/.glow.
+// Plain Node 18+, no dependencies.
 //
 // Safety (docs/security/review-2026-11-02-agent-reports.md):
 //  - The only host this ever talks to is Glow's API: https://app.meetglow.ai (or staging.meetglow.ai), read from
@@ -6,7 +7,8 @@
 //    variable (the hook runs with an empty environment but HOME and PATH). A local API (http://localhost) only when
 //    installed with --dev. Redirects are refused, so the key never follows one.
 //  - The key (glowc_…) can only report sessions, read the linked repo names, and fetch messages for this computer.
-//  - Nothing is sent from a repo that isn't linked to a product in Glow; the reply is masked for keys before it leaves.
+//  - Nothing is sent from a repo that isn't linked to a product in Glow, or that's ignored on this computer (`glow
+//    ignore`: checked before any request); the reply is masked for keys before it leaves.
 //  - git runs without a shell, with hooks, fsmonitor and signature checks off and none of the caller's GIT_* variables,
 //    so a repo (or its .git/config) can't make it run anything.
 import { execFileSync } from 'node:child_process';
@@ -15,7 +17,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-export const VERSION = '0.1.0';
+export const VERSION = '0.1.5';
 export const DEFAULT_API = 'https://app.meetglow.ai';
 export const dir = () => path.join(os.homedir(), '.glow');
 export const configPath = () => path.join(dir(), 'config.json');
@@ -54,6 +56,9 @@ export function readConfig() {
 }
 
 /** Atomic, owner-only. */
+/** The repos ignored on this computer (`glow ignore`): nothing is sent from them, linked or not. */
+export const ignoredOf = (c) => (Array.isArray(c?.ignored) ? c.ignored.filter((r) => typeof r === 'string' && REPO_RE.test(r)) : []);
+
 export function writeConfig(c) {
   fs.mkdirSync(dir(), { recursive: true, mode: 0o700 });
   fs.chmodSync(dir(), 0o700);
@@ -185,6 +190,67 @@ export function mask(text) {
   return s.replace(LABELLED, '$1[masked]').replace(BEARER, '$1[masked]').replace(URL_CREDS, '$1[masked]@');
 }
 
+// ---------- the request a reply answers ----------
+
+const PROMPT_MAX = 4_000;
+const TAIL_BYTES = 2 * 1024 * 1024;
+
+/**
+ * The person's latest request in the agent's own transcript, masked, ≤ 4,000 characters; '' when there is none. Only a
+ * .jsonl under ~/.claude/projects (Claude Code) or ~/.codex/sessions (Codex) is read, and only its last 2 MB.
+ */
+export function promptIn(file, home = os.homedir()) {
+  if (typeof file !== 'string' || !path.isAbsolute(file) || !file.endsWith('.jsonl')) return '';
+  const real = (p) => {
+    try {
+      return fs.realpathSync(p);
+    } catch {
+      return '';
+    }
+  };
+  const at = real(file);
+  const roots = [path.join(home, '.claude', 'projects'), path.join(home, '.codex', 'sessions')].map(real).filter(Boolean);
+  if (!at || !roots.some((r) => at.startsWith(r + path.sep))) return '';
+  let text = '';
+  try {
+    const fd = fs.openSync(at, 'r');
+    try {
+      const size = fs.fstatSync(fd).size;
+      const n = Math.min(size, TAIL_BYTES);
+      const buf = Buffer.alloc(n);
+      fs.readSync(fd, buf, 0, n, size - n);
+      text = buf.toString('utf8');
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return '';
+  }
+  const lines = text.split('\n');
+  for (let k = lines.length - 1; k >= 0; k--) {
+    if (!lines[k].includes('"user')) continue;
+    let e;
+    try {
+      e = JSON.parse(lines[k]);
+    } catch {
+      continue;
+    }
+    const p = userText(e);
+    if (p) return mask(p).slice(0, PROMPT_MAX);
+  }
+  return '';
+}
+
+/** A typed request: Codex's user_message event, or a Claude Code user turn that isn't a tool result, meta or a command. */
+function userText(e) {
+  if (e?.type === 'event_msg' && e.payload?.type === 'user_message') return typeof e.payload.message === 'string' ? e.payload.message.trim() : '';
+  if (e?.type !== 'user' || e.isMeta || e.isSidechain || e.message?.role !== 'user') return '';
+  const c = e.message.content;
+  const t = typeof c === 'string' ? c : Array.isArray(c) && !c.some((x) => x?.type === 'tool_result') ? c.filter((x) => x?.type === 'text').map((x) => x.text).join('\n') : '';
+  const s = String(t ?? '').trim();
+  return /^<(command-|local-command|system-reminder|task-notification|bash-)/.test(s) ? '' : s;
+}
+
 // ---------- this computer ----------
 
 /** "Ilya’s MacBook Pro": the computer's own name (macOS), else the host name. Letters, digits, spaces, ’'._- only. */
@@ -202,3 +268,99 @@ export function computerName() {
 }
 
 export const sha = (s) => createHash('sha256').update(s).digest('hex');
+
+/**
+ * What else this computer can reach, for the green tags beside it in Glow: GitHub (gh signed in), Chrome, Docker, Xcode.
+ * File checks only (no process is started), so the hook can run it on every report. Never a token, an account or a path:
+ * only which of these four are there.
+ */
+export function tools(home = os.homedir(), env = process.env, platform = process.platform) {
+  const dirs = String(env.PATH ?? '').split(path.delimiter).filter(Boolean);
+  const has = (p) => {
+    try {
+      return fs.existsSync(p);
+    } catch {
+      return false;
+    }
+  };
+  const onPath = (bin) => dirs.some((d) => has(path.join(d, bin)));
+  const ghConfig = env.GH_CONFIG_DIR || path.join(env.XDG_CONFIG_HOME || path.join(home, '.config'), 'gh');
+  const out = [];
+  if (onPath('gh') && has(path.join(ghConfig, 'hosts.yml'))) out.push('github');
+  if (platform === 'darwin' ? has('/Applications/Google Chrome.app') || has(path.join(home, 'Applications', 'Google Chrome.app')) : onPath('google-chrome') || onPath('chrome') || onPath('chromium')) out.push('chrome');
+  if (onPath('docker')) out.push('docker');
+  if (platform === 'darwin' && has('/Applications/Xcode.app')) out.push('xcode');
+  return out;
+}
+
+// ---------- sessions Glow starts here (`glow run`) ----------
+
+/** The file that marks a session the runner started (by its Claude Code session id): the runner sends its reply to
+ *  Glow itself, so the Stop hook leaves it alone. In ~/.glow/sessions, tidied after a day like the hook's locks. */
+export const runMarker = (session) => path.join(dir(), 'sessions', `${sha(`run:${session}`).slice(0, 24)}.run`);
+
+const clip = (s, n) => {
+  const t = String(s ?? '').replace(/\s+/g, ' ').trim();
+  return t.length > n ? `${t.slice(0, n - 1)}…` : t;
+};
+
+/**
+ * A command as a session's status shows it: the program and its subcommand only ("$ git status", "$ psql …"), never its
+ * arguments, options or environment, which is where passwords go. Leading `VAR=…`, `export`, `cd` and wrappers like
+ * `sudo` are skipped. (The same as @glow/core commandHead, which Glow applies again.)
+ */
+export function commandHead(command) {
+  const parts = String(command ?? '').split(/&&|\|\||;|\||\n/).map((x) => x.trim().split(/\s+/).filter(Boolean));
+  const SKIP = new Set(['sudo', 'env', 'time', 'nohup', 'command', 'exec', 'nice']);
+  const SETUP = new Set(['export', 'cd', 'set', 'unset', 'source', '.', 'pushd', 'popd']);
+  let fallback = '';
+  for (const words of parts) {
+    let k = 0;
+    while (k < words.length && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(words[k]) || SKIP.has(words[k]) || words[k].startsWith('-'))) k++; // VAR=x, sudo -E, env, …
+    const prog = (words[k] ?? '').split('/').pop().replace(/[^\w.+-]/g, '').slice(0, 40);
+    if (!prog) continue;
+    // A subcommand is a plain lower-case word (`git status`, `npm run`): never what echo or printf print, nor a word
+    // with digits or capitals (a password piped to `sudo -S` looks like one).
+    const sub = words[k + 1] && !['echo', 'printf'].includes(prog) && /^[a-z][a-z_-]{0,30}$/.test(words[k + 1]) ? words[k + 1] : '';
+    const more = words.length > k + (sub ? 2 : 1) || parts.length > 1;
+    const head = `$ ${prog}${sub ? ` ${sub}` : ''}${more ? ' …' : ''}`;
+    if (!SETUP.has(prog)) return head;
+    fallback ||= head;
+  }
+  return fallback || '$ (a command)';
+}
+
+/**
+ * What a session is doing, from the tool it just called, for its row in Glow: "$ bun test …", "Edit src/app.ts",
+ * "Grep useSession". Short, one line, paths inside the repo relative and the home folder as ~, keys masked before
+ * anything is cut. A command by its program only; never what's written or fetched; an MCP tool by its name only.
+ */
+export function activityOf(name, input, cwd = '') {
+  const i = input && typeof input === 'object' ? input : {};
+  const home = os.homedir();
+  const where = (p) => {
+    const s = String(p ?? '');
+    if (cwd && s.startsWith(`${cwd}/`)) return s.slice(cwd.length + 1);
+    return home && s.startsWith(`${home}/`) ? `~/${s.slice(home.length + 1)}` : s;
+  };
+  // Masked whole, then cut: a key cut in half can't be told from text any more.
+  const safe = (v, n) => clip(mask(String(v ?? '').replace(/\s+/g, ' ')), n);
+  const tool = String(name ?? '').replace(/[^\w.:-]/g, '').slice(0, 60) || 'A tool';
+  let line;
+  if (tool === 'Bash') line = commandHead(i.command);
+  else if (['Read', 'Edit', 'Write', 'MultiEdit', 'NotebookEdit'].includes(tool)) line = `${tool} ${safe(where(i.file_path ?? i.notebook_path), 140)}`;
+  else if (tool === 'Glob' || tool === 'Grep') line = `${tool} ${safe(i.pattern, 100)}`;
+  else if (tool === 'WebFetch') {
+    let host = '';
+    try {
+      host = new URL(String(i.url)).host;
+    } catch {
+      host = '';
+    }
+    line = `WebFetch ${host}`;
+  } else if (tool === 'WebSearch') line = `WebSearch ${safe(i.query, 100)}`;
+  else if (tool === 'Task' || tool === 'Agent') line = `Agent: ${safe(i.description, 100)}`;
+  else if (tool === 'TodoWrite') line = 'Updating its to-do list';
+  else line = tool;
+  return printable(line, 160).trim();
+}

package/lib/hook.mjs

@@ -7,11 +7,13 @@
 //                {"decision":"block","reason":…}, which Codex takes as the next prompt.
 //
 // `npx @winding-labs/glow messages off` stops both: Glow then holds no message for this computer's sessions.
+// A repo ignored here (`glow ignore`, /glow:ignore) sends nothing at all: the hook stops before any request. A session
+// Glow started here (`glow run`, lib/runner.mjs) is the runner's to report.
 //
 // Quiet by design: whatever goes wrong, it exits 0 and the agent carries on. Nothing is written to a log.
 import fs from 'node:fs';
 import path from 'node:path';
-import { api, dir, gitContext, mask, prIn, printable, readConfig, repoOf, SESSION_RE, sha, writeConfig } from './core.mjs';
+import { api, dir, gitContext, ignoredOf, mask, prIn, printable, promptIn, readConfig, repoOf, runMarker, SESSION_RE, sha, tools, writeConfig } from './core.mjs';
 
 const LISTEN_MS = 25 * 60_000;
 // GLOW_POLL_MS only speeds up the tests (timing, never where anything is sent).
@@ -34,9 +36,11 @@ async function main() {
   if (!cfg || cfg.off) return 0;
   const session = typeof input.session_id === 'string' ? input.session_id : '';
   if (!SESSION_RE.test(session)) return 0;
+  // A session Glow started here (`glow run`): the runner sends its reply itself.
+  if (fs.existsSync(runMarker(session))) return 0;
   const cwd = typeof input.cwd === 'string' && path.isAbsolute(input.cwd) ? input.cwd : process.cwd();
   const repo = repoOf(cwd);
-  if (!repo || !(await linked(cfg, repo))) return 0;
+  if (!repo || ignoredOf(cfg).includes(repo) || !(await linked(cfg, repo))) return 0;
 
   const reply = typeof input.last_assistant_message === 'string' ? input.last_assistant_message : '';
   const inbox = cfg.messages !== false;
@@ -44,15 +48,17 @@ async function main() {
   if (reply.trim()) {
     const ctx = gitContext(cwd);
     const pr = prIn(reply, repo);
+    // The request this reply answers (masked), so Glow can name the recipe you ran; `recipes off` leaves it out.
+    const prompt = cfg.recipes === false ? '' : promptIn(input.transcript_path);
     const res = await api(cfg, 'POST', '/api/v1/agent/reports', {
-      agent, session_id: session, repo, ...(ctx.branch ? { branch: ctx.branch } : {}), message: mask(reply).slice(0, MESSAGE_MAX), commits: ctx.commits, ...(pr ? { pr_url: pr } : {}), inbox,
+      agent, session_id: session, repo, ...(ctx.branch ? { branch: ctx.branch } : {}), message: mask(reply).slice(0, MESSAGE_MAX), ...(prompt ? { prompt } : {}), commits: ctx.commits, ...(pr ? { pr_url: pr } : {}), inbox, tools: tools(),
     }, agent === 'codex' ? 6_000 : 10_000);
     if (res.status === 401 || res.status === 403) return 0;
     if (res.json?.skipped === 'repo_not_linked' && Array.isArray(res.json.repos)) saveRepos(cfg, res.json.repos);
     messages = inbox && Array.isArray(res.json?.messages) ? res.json.messages : [];
   }
   if (messages.length) return deliver(messages);
-  if (agent === 'claude_code' && inbox) return listen(cfg, session);
+  if (agent === 'claude_code' && inbox) return listen(cfg, session, repo);
   return 0;
 }
 
@@ -98,9 +104,10 @@ const timeOf = (iso) => {
 
 /**
  * Claude Code, idle: ask Glow for a message every 15 s for up to 25 minutes. One listener per session: a newer reply
- * writes its own token to the lock and this one stops. Stops too when Claude Code itself has gone.
+ * writes its own token to the lock and this one stops. Stops too when Claude Code itself has gone, or when sending,
+ * messages or this repo are turned off here.
  */
-async function listen(cfg, session) {
+async function listen(cfg, session, repo) {
   const locks = path.join(dir(), 'sessions');
   fs.mkdirSync(locks, { recursive: true, mode: 0o700 });
   const lock = path.join(locks, `${sha(`${agent}:${session}`).slice(0, 24)}.lock`);
@@ -115,7 +122,7 @@ async function listen(cfg, session) {
       await new Promise((r) => setTimeout(r, POLL_MS));
       if (!mine(lock, token) || !alive(parent)) return 0;
       const now = readConfig();
-      if (!now || now.off || now.messages === false) return 0;
+      if (!now || now.off || now.messages === false || ignoredOf(now).includes(repo)) return 0;
       const res = await api(now, 'GET', q, undefined, 10_000);
       if (res.status === 401 || res.status === 403 || res.status === 404) return 0;
       const messages = Array.isArray(res.json?.messages) ? res.json.messages : [];