@ghl-ai/aw 0.1.35-beta.9 → 0.1.35

package/commands/init.mjs

@@ -19,7 +19,6 @@ import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs
 import { setupMcp } from '../mcp.mjs';
 import { autoUpdate, promptUpdate } from '../update.mjs';
 import { installGlobalHooks } from '../hooks.mjs';
-import { installAwEcc } from '../ecc.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
@@ -201,12 +200,11 @@ export async function initCommand(args) {
 
     // Re-link IDE dirs + hooks (idempotent)
     linkWorkspace(HOME);
-    await installAwEcc(cwd, { targets: ["cursor"], silent });
     generateCommands(HOME);
     copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
     initAwDocs(HOME);
-    setupMcp(HOME, freshCfg?.namespace || team) || [];
-    if (cwd !== HOME) setupMcp(cwd, freshCfg?.namespace || team);
+    await setupMcp(HOME, freshCfg?.namespace || team, { silent });
+    if (cwd !== HOME) await setupMcp(cwd, freshCfg?.namespace || team, { silent });
     installGlobalHooks();
 
     // Link current project if needed
@@ -282,12 +280,11 @@ export async function initCommand(args) {
   // Step 3: Link IDE dirs + setup tasks
   fmt.logStep('Linking IDE symlinks...');
   linkWorkspace(HOME);
-  await installAwEcc(cwd, { targets: ["cursor"], silent });
   generateCommands(HOME);
   const instructionFiles = copyInstructions(HOME, null, team) || [];
   initAwDocs(HOME);
-  const mcpFiles = setupMcp(HOME, team) || [];
-  if (cwd !== HOME) setupMcp(cwd, team);
+  const mcpFiles = await setupMcp(HOME, team) || [];
+  if (cwd !== HOME) await setupMcp(cwd, team);
   const hooksInstalled = installGlobalHooks();
   installIdeTasks();
 

package/mcp.mjs

@@ -3,26 +3,21 @@
 
 import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'node:fs';
 import { execSync } from 'node:child_process';
-import { join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { join } from 'node:path';
 import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
 
 const HOME = homedir();
-const DEFAULT_MCP_URL = 'https://staging.services.leadconnectorhq.com/agentic-workspace/mcp';
+const DEFAULT_MCP_URL = 'https://services.leadconnectorhq.com/agentic-workspace/mcp';
 
 /**
  * Auto-detect MCP server paths.
  */
 function detectPaths() {
-  const gitJenkinsCandidates = [
-    join(HOME, 'Documents', 'GitHub', 'git-jenkins-mcp', 'dist', 'index.js'),
-    resolve('..', 'git-jenkins-mcp', 'dist', 'index.js'),
-  ];
-
-  const gitJenkinsPath = gitJenkinsCandidates.find(p => existsSync(p)) || null;
   const ghlMcpUrl = process.env.GHL_MCP_URL || DEFAULT_MCP_URL;
 
-  return { gitJenkinsPath, ghlMcpUrl };
+  return { ghlMcpUrl };
 }
 
 /**
@@ -33,10 +28,10 @@ function detectPaths() {
  *   2. `gh auth token` (GitHub CLI — most devs have this)
  *   3. null (fall back to ${GITHUB_TOKEN} interpolation in config)
  */
-function resolveGitHubToken() {
+function resolveGitHubToken(silent = false) {
   // 1. Environment variable
   if (process.env.GITHUB_TOKEN) {
-    fmt.logStep('Using GITHUB_TOKEN from environment');
+    if (!silent) fmt.logStep('Using GITHUB_TOKEN from environment');
     return process.env.GITHUB_TOKEN;
   }
 
@@ -56,12 +51,14 @@ function resolveGitHubToken() {
         timeout: 5000,
       }).trim();
       if (token && (token.startsWith('ghp_') || token.startsWith('gho_') || token.startsWith('github_pat_'))) {
-        fmt.logStep('Using GitHub token from gh CLI');
+        if (!silent) fmt.logStep('Using GitHub token from gh CLI');
         return token;
       }
     } catch { /* not authenticated yet */ }
 
-    // 2b. Not authenticated — run gh auth login (opens browser)
+    // 2b. Not authenticated — skip browser login in silent mode (no terminal)
+    if (silent) return null;
+
     fmt.logStep('GitHub CLI found but not authenticated — launching login...');
     try {
       execSync('gh auth login --web --git-protocol https', {
@@ -111,45 +108,165 @@ function resolveGitHubUser(token) {
   }
 }
 
+/**
+ * Look for an existing ClickUp token already saved in IDE config files.
+ * Returns the first token found, or null.
+ */
+function findExistingClickUpToken(cwd) {
+  const candidates = [
+    join(HOME, '.claude', 'settings.json'),
+    join(HOME, '.claude', 'mcp.json'),
+    join(HOME, '.mcp.json'),
+    join(HOME, '.cursor', 'mcp.json'),
+    join(cwd, '.claude', 'mcp.json'),
+    join(cwd, '.mcp.json'),
+    join(cwd, '.cursor', 'mcp.json'),
+  ];
+
+  for (const filePath of candidates) {
+    try {
+      if (!existsSync(filePath)) continue;
+      const config = JSON.parse(readFileSync(filePath, 'utf8'));
+      const token = config?.mcpServers?.['ghl-ai']?.headers?.['X-ClickUp-Token'];
+      if (token && typeof token === 'string' && token.startsWith('pk_')) {
+        return { token, source: filePath };
+      }
+    } catch { /* corrupt file — skip */ }
+  }
+
+  return null;
+}
+
+/**
+ * Resolve ClickUp personal API token.
+ *
+ * Resolution chain:
+ *   1. $CLICKUP_API_TOKEN env var (already set)
+ *   2. Existing token in IDE config files (already configured)
+ *   3. Open browser + prompt user (one-time)
+ *   4. null (skip ClickUp — other MCP tools still work)
+ */
+async function resolveClickUpToken(silent = false, cwd = process.cwd()) {
+  // 1. Environment variable
+  if (process.env.CLICKUP_API_TOKEN) {
+    fmt.logStep('Using CLICKUP_API_TOKEN from environment');
+    return process.env.CLICKUP_API_TOKEN;
+  }
+
+  // 2. Already saved in an IDE config file — reuse it
+  const existing = findExistingClickUpToken(cwd);
+  if (existing) {
+    fmt.logStep(`Using existing ClickUp token from ${fmt.chalk.cyan(existing.source)}`);
+    return existing.token;
+  }
+
+  // In silent mode (git hooks, auto-pull) there is no terminal — skip prompt
+  if (silent) return null;
+
+  // 3. Interactive prompt — open browser and ask user to paste
+  fmt.logStep('ClickUp API token needed for per-user task attribution');
+  fmt.logStep('Go to https://app.clickup.com/settings/apps to copy your API token');
+
+  try {
+    const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    execSync(`${openCmd} "https://app.clickup.com/settings/apps"`, { stdio: 'ignore', timeout: 5000 });
+    fmt.logStep('Opened ClickUp settings in your browser');
+  } catch {
+    fmt.logWarn('Could not open browser — navigate to the URL above manually');
+  }
+
+  // Drain any leftover stdin bytes from prior interactive flows (e.g. gh auth login)
+  if (process.stdin.readable) {
+    process.stdin.resume();
+    await new Promise((r) => setTimeout(r, 100));
+    process.stdin.pause();
+    while (process.stdin.read() !== null) { /* drain */ }
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rawInput = await new Promise((resolve) => {
+    rl.question('  Paste your ClickUp API Token (pk_...): ', (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+
+  // Extract the pk_ token from the paste — handles accidental double-paste,
+  // surrounding whitespace, or trailing garbage from terminal paste buffers.
+  const match = typeof rawInput === 'string' ? rawInput.match(/\b(pk_\w+)\b/) : null;
+  const token = match ? match[1] : null;
+
+  if (!token) {
+    fmt.logWarn('No valid ClickUp token provided — skipping (ClickUp tools will use shared token)');
+    return null;
+  }
+
+  // Validate token against ClickUp API
+  try {
+    const res = execSync(`curl -s -H "Authorization: ${token}" "https://api.clickup.com/api/v2/user"`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10000,
+      maxBuffer: 1024 * 256,
+    });
+    const data = JSON.parse(res);
+    if (data.err) {
+      fmt.logWarn(`ClickUp token validation failed: ${data.err} — using it anyway`);
+    } else {
+      const username = data.user?.username || data.user?.email;
+      if (username) {
+        fmt.logSuccess(`ClickUp token valid — user: ${fmt.chalk.cyan(username)}`);
+      } else {
+        fmt.logWarn('ClickUp token accepted but no user found — using it anyway');
+      }
+    }
+  } catch (e) {
+    fmt.logWarn(`ClickUp token validation failed: ${e.message?.split('\n')[0]} — using it anyway`);
+  }
+
+  return token;
+}
+
 /**
  * Setup MCP configs globally for Claude Code and Cursor.
  * Merges ghl-ai server into existing configs without overwriting other servers.
  * Returns list of file paths that were created or updated.
  */
-export function setupMcp(cwd, namespace) {
+export async function setupMcp(cwd, namespace, { silent = false } = {}) {
   const paths = detectPaths();
   const updatedFiles = [];
 
   const mcpUrl = paths.ghlMcpUrl;
-  const ghToken = resolveGitHubToken();
+  const ghToken = resolveGitHubToken(silent);
 
   // Track who initialized MCP
-  if (ghToken) {
+  if (ghToken && !silent) {
     const ghUser = resolveGitHubUser(ghToken);
     if (ghUser) {
       fmt.logSuccess(`Authenticated as GitHub user: ${fmt.chalk.cyan(ghUser)}`);
     }
   }
 
-  // Server config with resolved token for local IDE configs (not committed, safe)
+  // Resolve ClickUp token — skipped in silent mode (no terminal)
+  const clickupToken = await resolveClickUpToken(silent, cwd);
+
+  // Server config with resolved tokens for local IDE configs (not committed, safe)
+  const headers = { Authorization: `Bearer ${ghToken || '${GITHUB_TOKEN}'}` };
+  if (clickupToken) {
+    headers['X-ClickUp-Token'] = clickupToken;
+  }
+
   const ghlAiServerLocal = {
     type: 'http',
     url: mcpUrl,
-    headers: { Authorization: `Bearer ${ghToken || '${GITHUB_TOKEN}'}` },
+    headers,
   };
 
-  const gitJenkinsServer = paths.gitJenkinsPath
-    ? { command: 'node', args: [paths.gitJenkinsPath] }
-    : null;
-
   // ── Claude Code: ~/.claude/settings.json (global, local) ──
   const claudeSettingsPath = join(HOME, '.claude', 'settings.json');
   if (mergeJsonMcpServer(claudeSettingsPath, 'ghl-ai', ghlAiServerLocal)) {
     updatedFiles.push(claudeSettingsPath);
   }
-  if (gitJenkinsServer && mergeJsonMcpServer(claudeSettingsPath, 'git-jenkins', gitJenkinsServer)) {
-    updatedFiles.push(claudeSettingsPath);
-  }
 
   // ── Claude Code: .mcp.json (project root — committed, uses env var) ──
   const projectMcpPath = join(cwd, '.mcp.json');
@@ -162,29 +279,20 @@ export function setupMcp(cwd, namespace) {
   if (mergeJsonMcpServer(claudeWorkspaceMcpPath, 'ghl-ai', ghlAiServerLocal)) {
     updatedFiles.push(claudeWorkspaceMcpPath);
   }
-  if (gitJenkinsServer && mergeJsonMcpServer(claudeWorkspaceMcpPath, 'git-jenkins', gitJenkinsServer)) {
-    updatedFiles.push(claudeWorkspaceMcpPath);
-  }
 
   // ── Cursor: project .cursor/mcp.json (workspace-level, local) ──
   const cursorProjectMcpPath = join(cwd, '.cursor', 'mcp.json');
   if (mergeJsonMcpServer(cursorProjectMcpPath, 'ghl-ai', ghlAiServerLocal)) {
     updatedFiles.push(cursorProjectMcpPath);
   }
-  if (gitJenkinsServer && mergeJsonMcpServer(cursorProjectMcpPath, 'git-jenkins', gitJenkinsServer)) {
-    updatedFiles.push(cursorProjectMcpPath);
-  }
 
   // ── Cursor: ~/.cursor/mcp.json (global, local) ──
   const cursorMcpPath = join(HOME, '.cursor', 'mcp.json');
   if (mergeJsonMcpServer(cursorMcpPath, 'ghl-ai', ghlAiServerLocal)) {
     updatedFiles.push(cursorMcpPath);
   }
-  if (gitJenkinsServer && mergeJsonMcpServer(cursorMcpPath, 'git-jenkins', gitJenkinsServer)) {
-    updatedFiles.push(cursorMcpPath);
-  }
 
-  // Deduplicate (claude settings may be added twice if both servers written)
+  // Deduplicate
   const unique = [...new Set(updatedFiles)];
 
   if (unique.length > 0) {
@@ -193,10 +301,6 @@ export function setupMcp(cwd, namespace) {
     fmt.logInfo('MCP servers already configured — no changes needed');
   }
 
-  if (!paths.gitJenkinsPath) {
-    fmt.logWarn('git-jenkins MCP not found — skipped');
-  }
-
   return unique;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.35-beta.9",
+  "version": "0.1.35",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {
@@ -24,8 +24,7 @@
     "registry.mjs",
     "apply.mjs",
     "update.mjs",
-    "hooks.mjs",
-    "ecc.mjs"
+    "hooks.mjs"
   ],
   "engines": {
     "node": ">=18.0.0"

package/ecc.mjs

@@ -1,48 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync, rmSync } from "node:fs";
-import { join } from "node:path";
-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.0.0";
-const TMP_DIR = "/tmp/aw-ecc";
-
-function cloneRepo(tag, dest, stdio) {
-  try {
-    execSync(`git clone --depth 1 --branch ${tag} ${AW_ECC_REPO_SSH} ${dest}`, {
-      stdio,
-    });
-  } catch {
-    execSync(
-      `git clone --depth 1 --branch ${tag} ${AW_ECC_REPO_HTTPS} ${dest}`,
-      { stdio },
-    );
-  }
-}
-
-export async function installAwEcc(
-  cwd,
-  { targets = ["cursor"], silent = false } = {},
-) {
-  if (!silent) fmt.logStep("Installing aw-ecc engine...");
-
-  if (existsSync(TMP_DIR)) rmSync(TMP_DIR, { recursive: true, force: true });
-
-  cloneRepo(AW_ECC_TAG, TMP_DIR, silent ? "pipe" : "inherit");
-
-  execSync("npm install --no-audit --no-fund", {
-    cwd: TMP_DIR,
-    stdio: silent ? "pipe" : "inherit",
-  });
-
-  for (const target of targets) {
-    execSync(
-      `node ${join(TMP_DIR, "scripts/install-apply.js")} --target ${target} --profile full`,
-      { cwd, stdio: silent ? "pipe" : "inherit" },
-    );
-  }
-
-  rmSync(TMP_DIR, { recursive: true, force: true });
-  if (!silent) fmt.logSuccess("aw-ecc engine installed");
-}