@ghl-ai/aw 0.1.30-beta.1 → 0.1.30-beta.3

package/commands/init.mjs

@@ -1,10 +1,10 @@
-// commands/init.mjs — Clean init: clone registry, link IDEs, git hooks for omnipresence.
+// commands/init.mjs — Clean init: clone registry, link IDEs, global git hooks.
 //
 // No shell profile modifications. No daemons. No background processes.
-// Uses git's built-in template hooks for automatic linking on clone/checkout.
+// Uses core.hooksPath (git-lfs pattern) for system-wide hook interception.
 // Uses IDE tasks for auto-pull on workspace open.
 
-import { mkdirSync, existsSync, writeFileSync, symlinkSync, chmodSync } from 'node:fs';
+import { mkdirSync, existsSync, writeFileSync, symlinkSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
@@ -18,6 +18,7 @@ import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
 import { autoUpdate, promptUpdate } from '../update.mjs';
+import { installGlobalHooks } from '../hooks.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
@@ -25,46 +26,6 @@ const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), '
 const HOME = homedir();
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
 const MANIFEST_PATH = join(GLOBAL_AW_DIR, '.aw-manifest.json');
-const GIT_TEMPLATE_DIR = join(HOME, '.git-templates', 'aw');
-
-// ── Git template hook for omnipresence ──────────────────────────────────
-// Git's init.templateDir copies hooks into every new clone/init.
-// post-checkout fires on clone and branch switch — perfect for auto-linking.
-
-const POST_CHECKOUT_HOOK = `#!/bin/sh
-# aw: auto-link registry on clone/checkout (installed by aw init)
-AW_REGISTRY="$HOME/.aw_registry"
-if [ -d "$AW_REGISTRY" ] && [ ! -e ".aw_registry" ] && [ -d ".git" ]; then
-  ln -s "$AW_REGISTRY" ".aw_registry" 2>/dev/null
-fi
-`;
-
-function installGitTemplate() {
-  const hooksDir = join(GIT_TEMPLATE_DIR, 'hooks');
-  mkdirSync(hooksDir, { recursive: true });
-
-  const hookPath = join(hooksDir, 'post-checkout');
-  writeFileSync(hookPath, POST_CHECKOUT_HOOK);
-  chmodSync(hookPath, '755');
-
-  // Set git global template dir (merges with existing hooks)
-  try {
-    const current = execSync('git config --global init.templateDir', {
-      encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-
-    if (current && current !== GIT_TEMPLATE_DIR) {
-      // Another template dir is set — don't override, just inform
-      fmt.logWarn(`Git template dir already set to ${current}`);
-      fmt.logStep(chalk.dim('  Skipping git template — run: git config --global init.templateDir ~/.git-templates/aw'));
-      return false;
-    }
-  } catch { /* not set yet — good */ }
-
-  execSync(`git config --global init.templateDir "${GIT_TEMPLATE_DIR}"`, { stdio: 'pipe' });
-  fmt.logStep('Git template hook installed (auto-links on clone)');
-  return true;
-}
 
 // ── IDE tasks for auto-pull ─────────────────────────────────────────────
 
@@ -237,12 +198,14 @@ export async function initCommand(args) {
       await Promise.all(pullJobs);
     }
 
-    // Re-link IDE dirs (idempotent)
+    // Re-link IDE dirs + hooks (idempotent)
     linkWorkspace(HOME);
     generateCommands(HOME);
     copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
     initAwDocs(HOME);
     setupMcp(HOME, freshCfg?.namespace || team) || [];
+    if (cwd !== HOME) setupMcp(cwd, freshCfg?.namespace || team);
+    installGlobalHooks();
 
     // Link current project if needed
     if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
@@ -321,7 +284,8 @@ export async function initCommand(args) {
   const instructionFiles = copyInstructions(HOME, null, team) || [];
   initAwDocs(HOME);
   const mcpFiles = setupMcp(HOME, team) || [];
-  const gitTemplateInstalled = installGitTemplate();
+  if (cwd !== HOME) setupMcp(cwd, team);
+  const hooksInstalled = installGlobalHooks();
   installIdeTasks();
 
   // Step 4: Symlink in current directory if it's a git repo
@@ -341,7 +305,7 @@ export async function initCommand(args) {
       ...instructionFiles.map(p => p.startsWith(HOME) ? p.slice(HOME.length + 1) : p),
       ...mcpFiles.map(p => p.startsWith(HOME) ? p.slice(HOME.length + 1) : p),
     ],
-    gitTemplate: gitTemplateInstalled ? GIT_TEMPLATE_DIR : null,
+    globalHooksDir: hooksInstalled ? join(HOME, '.aw', 'hooks') : null,
   };
   saveManifest(manifest);
 
@@ -354,13 +318,13 @@ export async function initCommand(args) {
     '',
     `  ${chalk.green('✓')} Source of truth: ~/.aw_registry/`,
     `  ${chalk.green('✓')} IDE integration: ~/.claude/, ~/.cursor/, ~/.codex/`,
-    gitTemplateInstalled ? `  ${chalk.green('✓')} Git hook: new clones auto-link .aw_registry` : null,
+    hooksInstalled ? `  ${chalk.green('✓')} Git hooks: auto-sync on pull/clone (core.hooksPath)` : null,
     `  ${chalk.green('✓')} IDE task: auto-sync on workspace open`,
     cwd !== HOME && existsSync(join(cwd, '.aw_registry')) ? `  ${chalk.green('✓')} Linked in current project` : null,
     '',
     `  ${chalk.dim('Existing repos:')} ${chalk.bold('cd <project> && aw link')}`,
     `  ${chalk.dim('New clones:')}     auto-linked via git hook`,
-    `  ${chalk.dim('Update:')}         ${chalk.bold('aw init')} ${chalk.dim('(or auto on IDE open)')}`,
+    `  ${chalk.dim('Update:')}         ${chalk.bold('aw init')} ${chalk.dim('(or auto on pull/IDE open)')}`,
     `  ${chalk.dim('Uninstall:')}      ${chalk.bold('aw nuke')}`,
   ].filter(Boolean).join('\n'));
 }

package/commands/nuke.mjs

@@ -8,6 +8,7 @@ import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
+import { removeGlobalHooks } from '../hooks.mjs';
 
 const HOME = homedir();
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
@@ -169,21 +170,24 @@ function removeProjectSymlinks() {
   if (removed > 0) fmt.logStep(`Removed ${removed} project .aw_registry symlink${removed > 1 ? 's' : ''}`);
 }
 
-// 4. Remove git template hook
-function removeGitTemplate(manifest) {
-  const gitTemplateDir = manifest?.gitTemplate || join(HOME, '.git-templates', 'aw');
-  if (!existsSync(gitTemplateDir)) return;
+// 4. Remove git hooks (global core.hooksPath + legacy template)
+function removeGitHooks(manifest) {
+  removeGlobalHooks();
 
-  rmSync(gitTemplateDir, { recursive: true, force: true });
-  try {
-    const current = execSync('git config --global init.templateDir', {
-      encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-    if (current === gitTemplateDir) {
-      execSync('git config --global --unset init.templateDir', { stdio: 'pipe' });
-    }
-  } catch { /* not set */ }
-  fmt.logStep('Removed git template hook');
+  // Backward compat: also clean up old git template dir from previous versions
+  const legacyTemplateDir = manifest?.gitTemplate || join(HOME, '.git-templates', 'aw');
+  if (existsSync(legacyTemplateDir)) {
+    rmSync(legacyTemplateDir, { recursive: true, force: true });
+    try {
+      const current = execSync('git config --global init.templateDir', {
+        encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      if (current === legacyTemplateDir) {
+        execSync('git config --global --unset init.templateDir', { stdio: 'pipe' });
+      }
+    } catch { /* not set */ }
+    fmt.logStep('Removed legacy git template hook');
+  }
 }
 
 // 5. Remove IDE auto-init tasks
@@ -242,12 +246,17 @@ export function nukeCommand(args) {
   // 3. Remove .aw_registry symlinks from ALL project directories
   removeProjectSymlinks();
 
-  // 4. Remove git template hook
-  removeGitTemplate(manifest);
+  // 4. Remove git hooks (core.hooksPath + legacy template)
+  removeGitHooks(manifest);
 
   // 5. Remove IDE auto-init tasks
   removeIdeTasks();
 
+  // 5b. Remove upgrade lock/log (inside .aw_registry, must happen before dir removal)
+  for (const p of [join(GLOBAL_AW_DIR, '.aw-upgrade.lock'), join(GLOBAL_AW_DIR, '.aw-upgrade.log')]) {
+    try { if (existsSync(p)) rmSync(p, { recursive: true, force: true }); } catch { /* best effort */ }
+  }
+
   // 6. Remove ~/.aw_docs/
   const awDocs = join(HOME, '.aw_docs');
   if (existsSync(awDocs)) {
@@ -287,7 +296,7 @@ export function nukeCommand(args) {
     `  ${chalk.green('✓')} Generated files cleaned`,
     `  ${chalk.green('✓')} IDE symlinks cleaned`,
     `  ${chalk.green('✓')} Project symlinks cleaned`,
-    `  ${chalk.green('✓')} Git template hook removed`,
+    `  ${chalk.green('✓')} Git hooks removed`,
     `  ${chalk.green('✓')} IDE auto-sync tasks removed`,
     `  ${chalk.green('✓')} Source of truth deleted`,
     '',

package/mcp.mjs

@@ -84,10 +84,13 @@ function resolveGitHubToken() {
     }
   }
 
-  // 3. No gh CLI — prompt manual setup
-  fmt.logWarn('No GitHub token found — MCP auth will use ${GITHUB_TOKEN} env var interpolation');
-  fmt.logWarn('  Install gh CLI: brew install gh && gh auth login');
-  fmt.logWarn('  Or export: export GITHUB_TOKEN=ghp_xxx');
+  // 3. No token found anywhere
+  fmt.logWarn('⚠ No GitHub token found — MCP authentication will not work!');
+  fmt.logWarn('');
+  fmt.logWarn('  Fix (recommended): brew install gh && gh auth login');
+  fmt.logWarn('  Fix (manual):      export GITHUB_TOKEN=ghp_xxx');
+  fmt.logWarn('');
+  fmt.logWarn('  Then re-run: aw init');
   return null;
 }
 
@@ -135,13 +138,6 @@ export function setupMcp(cwd, namespace) {
     headers: { Authorization: `Bearer ${ghToken || '${GITHUB_TOKEN}'}` },
   };
 
-  // Server config with env var interpolation for committed project files
-  const ghlAiServerProject = {
-    type: 'http',
-    url: mcpUrl,
-    headers: { Authorization: 'Bearer ${GITHUB_TOKEN}' },
-  };
-
   const gitJenkinsServer = paths.gitJenkinsPath
     ? { command: 'node', args: [paths.gitJenkinsPath] }
     : null;
@@ -157,7 +153,7 @@ export function setupMcp(cwd, namespace) {
 
   // ── Claude Code: .mcp.json (project root — committed, uses env var) ──
   const projectMcpPath = join(cwd, '.mcp.json');
-  if (mergeJsonMcpServer(projectMcpPath, 'ghl-ai', ghlAiServerProject)) {
+  if (mergeJsonMcpServer(projectMcpPath, 'ghl-ai', ghlAiServerLocal)) {
     updatedFiles.push(projectMcpPath);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.30-beta.1",
+  "version": "0.1.30-beta.3",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {

package/update.mjs

@@ -2,18 +2,24 @@
 //
 // checkForUpdate()  → fires npm view in background, returns { current, latest, hasUpdate }
 // notifyUpdate(r)   → prints banner if r says update available
-// autoUpdate(r)     → spawns npm install in background (--silent mode)
+// autoUpdate(r)     → synchronous install with atomic lock, verification, logging
 // promptUpdate(r)   → asks user interactively (normal init)
 
-import { readFileSync } from 'node:fs';
-import { exec as execCb, execSync, spawn } from 'node:child_process';
+import { readFileSync, mkdirSync, writeFileSync, statSync, rmSync, appendFileSync, existsSync } from 'node:fs';
+import { exec as execCb, execSync } from 'node:child_process';
 import { promisify } from 'node:util';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
 import { chalk } from './fmt.mjs';
 
 const exec = promisify(execCb);
 
 const PKG_NAME = '@ghl-ai/aw';
+const LOCK_DIR = join(homedir(), '.aw_registry', '.aw-upgrade.lock');
+const LOG_PATH = join(homedir(), '.aw_registry', '.aw-upgrade.log');
+const LOCK_MAX_AGE_MS = 5 * 60 * 1000;
+const LOG_MAX_ENTRIES = 50;
 
 function getLocalVersion() {
   try {
@@ -45,13 +51,66 @@ function compareVersions(a, b) {
   return 0;
 }
 
+// ── Atomic lock via mkdir ──────────────────────────────────────────────
+// mkdir is atomic on all POSIX filesystems. Stale detection uses
+// directory mtime (OS-maintained) rather than parsing PIDs.
+
+function acquireLock() {
+  try {
+    mkdirSync(LOCK_DIR);
+    writeFileSync(join(LOCK_DIR, 'pid'), String(process.pid));
+    return true;
+  } catch (e) {
+    if (e.code !== 'EEXIST') return false;
+    try {
+      const stat = statSync(LOCK_DIR);
+      if (Date.now() - stat.mtimeMs > LOCK_MAX_AGE_MS) {
+        rmSync(LOCK_DIR, { recursive: true, force: true });
+        return acquireLock();
+      }
+    } catch { /* stat failed — lock dir vanished, retry */ return acquireLock(); }
+    return false;
+  }
+}
+
+function releaseLock() {
+  try { rmSync(LOCK_DIR, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+
+// ── Upgrade log ────────────────────────────────────────────────────────
+
+function appendLog(entry) {
+  try {
+    const line = JSON.stringify(entry) + '\n';
+    appendFileSync(LOG_PATH, line);
+
+    const content = readFileSync(LOG_PATH, 'utf8');
+    const lines = content.trim().split('\n');
+    if (lines.length > LOG_MAX_ENTRIES) {
+      writeFileSync(LOG_PATH, lines.slice(-LOG_MAX_ENTRIES).join('\n') + '\n');
+    }
+  } catch { /* logging is best-effort */ }
+}
+
+// ── Installed version verification ─────────────────────────────────────
+
+function getInstalledVersion() {
+  try {
+    const prefix = execSync('npm prefix -g', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000 }).trim();
+    const pkgPath = join(prefix, 'lib', 'node_modules', PKG_NAME, 'package.json');
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version;
+  } catch {
+    return getLocalVersion();
+  }
+}
+
 /**
- * Fetch the latest version from npm (non-blocking, 5s timeout).
+ * Fetch the latest version from npm (non-blocking, 15s timeout).
  * Call at the start of any command, await at the end.
  */
 export async function checkForUpdate() {
   try {
-    const { stdout } = await exec(`npm view ${PKG_NAME} version`, { timeout: 5000 });
+    const { stdout } = await exec(`npm view ${PKG_NAME} version`, { timeout: 15_000 });
     const latest = stdout.trim();
     const current = getLocalVersion();
     return { current, latest, hasUpdate: compareVersions(latest, current) > 0 };
@@ -76,19 +135,29 @@ export function notifyUpdate(result) {
 }
 
 /**
- * Auto-update in background (fire-and-forget, detached process).
+ * Synchronous auto-update with atomic lock, verification, and logging.
  * Used by `aw init --silent`. Skipped for prerelease versions.
+ * @returns {{ status: string, reason?: string, from?: string, to?: string, error?: string }}
  */
 export function autoUpdate(result) {
-  if (!result?.hasUpdate) return;
-  if (isPrerelease(result.current)) return;
+  if (!result?.hasUpdate) return { status: 'skipped', reason: 'up-to-date' };
+  if (isPrerelease(result.current)) return { status: 'skipped', reason: 'prerelease' };
+  if (!acquireLock()) return { status: 'skipped', reason: 'locked' };
+
   try {
-    const child = spawn('npm', ['i', '-g', `${PKG_NAME}@latest`], {
-      detached: true,
-      stdio: 'ignore',
-    });
-    child.unref();
-  } catch { /* best effort */ }
+    execSync(`npm i -g ${PKG_NAME}@latest`, { stdio: 'pipe', timeout: 60_000 });
+    const installed = getInstalledVersion();
+    const ok = compareVersions(installed, result.current) > 0;
+    const entry = { ts: new Date().toISOString(), from: result.current, to: installed, ok };
+    appendLog(entry);
+    return { status: ok ? 'upgraded' : 'failed', ...entry };
+  } catch (e) {
+    const entry = { ts: new Date().toISOString(), from: result.current, error: e.message, ok: false };
+    appendLog(entry);
+    return { status: 'failed', error: e.message };
+  } finally {
+    releaseLock();
+  }
 }
 
 /**
@@ -115,9 +184,11 @@ export async function promptUpdate(result) {
   const s = fmt.spinner();
   s.start(`Updating to ${result.latest}...`);
   try {
-    execSync(`npm i -g ${PKG_NAME}@latest`, { stdio: 'pipe', timeout: 30000 });
-    s.stop(`Updated to ${chalk.green(result.latest)}`);
-    return true;
+    execSync(`npm i -g ${PKG_NAME}@latest`, { stdio: 'pipe', timeout: 60_000 });
+    const installed = getInstalledVersion();
+    const ok = compareVersions(installed, result.current) > 0;
+    s.stop(ok ? `Updated to ${chalk.green(installed)}` : chalk.red('Update may have failed — verify with: aw --version'));
+    return ok;
   } catch {
     s.stop(chalk.red('Update failed'));
     fmt.logWarn(`Manual update: ${chalk.bold(`npm i -g ${PKG_NAME}@latest`)}`);