@ghl-ai/aw 0.1.39-beta.1 → 0.1.39-beta.6

package/commands/init.mjs

@@ -47,6 +47,23 @@ import { syncFileTree } from '../file-tree.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
+const DEBUG_INIT_LOG = process.env.AW_DEBUG_INIT_LOG;
+
+function debugInit(message) {
+  if (!DEBUG_INIT_LOG) return;
+  try {
+    appendFileSync(DEBUG_INIT_LOG, `${new Date().toISOString()} ${message}\n`);
+  } catch { /* best effort */ }
+}
+
+function createSpinner(enabled) {
+  if (enabled) return fmt.spinner();
+  return {
+    start() {},
+    stop() {},
+    message() {},
+  };
+}
 
 // Resolve HOME to the real path — on macOS /var is a symlink to /private/var,
 // so homedir() returns /var/... while process.cwd() returns /private/var/...
@@ -121,8 +138,12 @@ export async function initCommand(args) {
   let namespace = args['--namespace'] || null;
   let user = args['--user'] || '';
   const silent = args['--silent'] === true;
+  const interactiveUi = !silent && Boolean(process.stdout.isTTY);
 
-  fmt.intro(`aw init ${chalk.dim('v' + VERSION)}`);
+  if (interactiveUi) {
+    fmt.intro(`aw init ${chalk.dim('v' + VERSION)}`);
+  }
+  debugInit('init:start');
 
   // ── Validate ──────────────────────────────────────────────────────────
 
@@ -170,7 +191,7 @@ export async function initCommand(args) {
 
   let namespaceExistsInRemote = false;
   if (folderName && !silent && !isGitNative && !isLegacy) {
-    const probeSpinner = fmt.spinner();
+    const probeSpinner = createSpinner(interactiveUi);
     probeSpinner.start(`Checking namespace ${chalk.cyan(folderName)} in registry...`);
     try {
       const probePaths = includeToSparsePaths([folderName]);
@@ -183,11 +204,15 @@ export async function initCommand(args) {
       } finally {
         cleanup(probeDir);
       }
-      probeSpinner.stop(namespaceExistsInRemote
-        ? `Namespace ${chalk.cyan(folderName)} found in registry`
-        : `Namespace ${chalk.cyan(folderName)} not yet in registry`);
+      if (interactiveUi) {
+        probeSpinner.stop(namespaceExistsInRemote
+          ? `Namespace ${chalk.cyan(folderName)} found in registry`
+          : `Namespace ${chalk.cyan(folderName)} not yet in registry`);
+      }
     } catch {
-      probeSpinner.stop(chalk.dim('Could not verify namespace (continuing)'));
+      if (interactiveUi) {
+        probeSpinner.stop(chalk.dim('Could not verify namespace (continuing)'));
+      }
       namespaceExistsInRemote = true;
     }
   }
@@ -229,7 +254,7 @@ export async function initCommand(args) {
       if (!silent) fmt.logStep('Already initialized — syncing...');
     }
 
-    const s = fmt.spinner();
+    const s = createSpinner(interactiveUi);
     if (!silent) s.start('Fetching latest from registry...');
     try {
       const { conflicts } = await fetchAndMerge(AW_HOME, { silent });
@@ -338,21 +363,26 @@ export async function initCommand(args) {
     sparsePaths.push(`.aw_registry/${folderName}`);
   }
 
-  fmt.note([
-    `${chalk.dim('source:')}     ~/.aw/ → ~/.aw_registry/ (symlink)`,
-    folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
-    user ? `${chalk.dim('user:')}       ${user}` : null,
-    `${chalk.dim('version:')}    v${VERSION}`,
-  ].filter(Boolean).join('\n'), 'Config');
+  if (interactiveUi) {
+    fmt.note([
+      `${chalk.dim('source:')}     ~/.aw/ → ~/.aw_registry/ (symlink)`,
+      folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
+      user ? `${chalk.dim('user:')}       ${user}` : null,
+      `${chalk.dim('version:')}    v${VERSION}`,
+    ].filter(Boolean).join('\n'), 'Config');
+  }
 
-  const s = fmt.spinner();
+  const s = createSpinner(interactiveUi);
   s.start(`Cloning registry...`);
 
   try {
+    debugInit(`clone:start repo=${repoUrl}`);
     await initPersistentClone(repoUrl, AW_HOME, sparsePaths);
+    debugInit('clone:done');
     ensureAwGitignore(AW_HOME);
     s.stop('Registry cloned');
   } catch (e) {
+    debugInit(`clone:error ${e.message}`);
     s.stop(chalk.red('Clone failed'));
     fmt.cancel(e.message);
   }
@@ -363,38 +393,55 @@ export async function initCommand(args) {
   try { awRegistryLstat = lstatSync(GLOBAL_AW_DIR); } catch { /* doesn't exist */ }
   if (!awRegistryLstat) {
     try {
+      debugInit('symlink:create:start');
       symlinkSync(join(AW_HOME, REGISTRY_DIR), GLOBAL_AW_DIR);
+      debugInit('symlink:create:done');
       fmt.logStep('Created ~/.aw_registry/ symlink');
     } catch (e) {
+      debugInit(`symlink:create:error ${e.message}`);
       fmt.logWarn(`Could not create symlink ~/.aw_registry/: ${e.message}`);
     }
   } else if (awRegistryLstat.isSymbolicLink()) {
     // Stale or dangling — re-point to the new clone
     try {
+      debugInit('symlink:update:start');
       rmSync(GLOBAL_AW_DIR);
       symlinkSync(join(AW_HOME, REGISTRY_DIR), GLOBAL_AW_DIR);
+      debugInit('symlink:update:done');
       fmt.logStep('Updated ~/.aw_registry/ symlink');
     } catch (e) {
+      debugInit(`symlink:update:error ${e.message}`);
       fmt.logWarn(`Could not update symlink ~/.aw_registry/: ${e.message}`);
     }
   }
 
   // Create sync config — default to 'platform' when no namespace specified
   const cfg = config.create(GLOBAL_AW_DIR, { namespace: team || 'platform', user });
+  debugInit('config:create:done');
   if (folderName) {
     config.addPattern(GLOBAL_AW_DIR, folderName);
+    debugInit('config:add-pattern:done');
   }
   if (existsSync(GLOBAL_AW_DIR)) {
+    debugInit('sync-file-tree:start');
     syncFileTree(join(AW_HOME, RULES_SOURCE_DIR), join(GLOBAL_AW_DIR, RULES_SOURCE_DIR));
+    debugInit('sync-file-tree:done');
   }
 
   // Step 3: Setup tasks, MCP, hooks
+  debugInit('ecc:start');
   await installAwEcc(cwd, { silent });
+  debugInit('ecc:done');
   const instructionFiles = copyInstructions(HOME, null, team) || [];
+  debugInit(`instructions:done count=${instructionFiles.length}`);
   initAwDocs(HOME);
+  debugInit('aw-docs:done');
   const mcpFiles = await setupMcp(HOME, team, { silent }) || [];
+  debugInit(`mcp:done count=${mcpFiles.length}`);
   const hooksInstalled = installGlobalHooks();
+  debugInit(`hooks:done installed=${hooksInstalled}`);
   installIdeTasks();
+  debugInit('ide-tasks:done');
 
   // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath
   if (cwd !== HOME) {
@@ -413,24 +460,33 @@ export async function initCommand(args) {
   const isAlreadySymlinkFresh = (() => { try { return lstatSync(awLinkFresh).isSymbolicLink() && existsSync(awLinkFresh); } catch { return false; } })();
   if (cwd !== HOME && !isInsideAw && !isAlreadySymlinkFresh) {
     try {
+      debugInit('link-project:start');
       addProjectWorktree(AW_HOME, cwd);
+      debugInit('link-project:done');
       fmt.logStep('Linked current project');
     } catch { /* best effort */ }
   }
 
   // Step 5: Wire ~/.claude/.cursor/.codex to the project's registry when in a project,
   // so edits to project/.aw/.aw_registry/ are instantly visible in global IDE dirs.
-  const ideSpinner = fmt.spinner();
+  const ideSpinner = createSpinner(interactiveUi);
   ideSpinner.start('Wiring IDE symlinks...');
+  debugInit('ide-wire:start');
   const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
   const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
   const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
   if (cwd !== HOME) installLocalCommitHook(cwd);
   ideSpinner.message('Generating commands...');
   const commands = generateCommands(HOME, { silent: true });
+  debugInit(`ide-wire:done symlinks=${symlinks} commands=${commands}`);
   ideSpinner.stop(`IDE wired — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`);
 
   // Offer to update if a newer version is available
+  if (silent) {
+    autoUpdate(await args._updateCheck);
+    return;
+  }
+
   await promptUpdate(await args._updateCheck);
 
   fmt.outro([

package/ecc.mjs

@@ -9,7 +9,7 @@ import * as fmt from "./fmt.mjs";
 
 const AW_ECC_REPO_SSH = "git@github.com:shreyansh-ghl/aw-ecc.git";
 const AW_ECC_REPO_HTTPS = "https://github.com/shreyansh-ghl/aw-ecc.git";
-const AW_ECC_TAG = "v1.4.29";
+const AW_ECC_TAG = "v1.4.31";
 
 const MARKETPLACE_NAME = "aw-marketplace";
 const PLUGIN_KEY = `aw@${MARKETPLACE_NAME}`;

package/git.mjs

@@ -124,15 +124,34 @@ export async function initPersistentClone(repoUrl, awHome, sparsePaths) {
   }
 
   try {
-    await exec(`git clone --filter=blob:none --no-checkout "${repoUrl}" "${awHome}"`);
+    execSync(`git clone --filter=blob:none --no-checkout "${repoUrl}" "${awHome}"`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: process.env.GIT_TERMINAL_PROMPT ?? '0',
+      },
+    });
   } catch (e) {
     throw new Error(`Failed to clone ${repoUrl}: ${e.message}`);
   }
 
   try {
-    await exec('git sparse-checkout init --no-cone', { cwd: awHome });
-    await exec(`git sparse-checkout set ${sparsePaths.map(p => `"${p}"`).join(' ')}`, { cwd: awHome });
-    await exec(`git checkout ${REGISTRY_BASE_BRANCH}`, { cwd: awHome });
+    execSync('git sparse-checkout init --no-cone', {
+      cwd: awHome,
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    execSync(`git sparse-checkout set ${sparsePaths.map(p => `"${p}"`).join(' ')}`, {
+      cwd: awHome,
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    execSync(`git checkout ${REGISTRY_BASE_BRANCH}`, {
+      cwd: awHome,
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
   } catch (e) {
     throw new Error(`Failed to configure sparse checkout: ${e.message}`);
   }

package/mcp.mjs

@@ -168,8 +168,16 @@ async function resolveClickUpToken(silent = false, cwd = process.cwd()) {
     return existing.token;
   }
 
-  // In silent mode (git hooks, auto-pull) there is no terminal — skip prompt
-  if (silent) return null;
+  // In silent mode (git hooks, auto-pull) there is no terminal — skip prompt.
+  // Also skip in any non-TTY context so automation and CI runs never crash
+  // while trying to render interactive prompts for an optional integration.
+  const hasInteractiveTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (silent || !hasInteractiveTty) {
+    if (!silent && !hasInteractiveTty) {
+      fmt.logInfo('Skipping ClickUp setup — no interactive terminal detected');
+    }
+    return null;
+  }
 
   // 3. Ask first — don't assume the user wants ClickUp
   const wantsClickUp = await p.select({

package/package.json

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