a2acalling 0.6.14 → 0.6.16

package/bin/cli.js

@@ -70,29 +70,28 @@ function getConvStore() {
 
 const store = new TokenStore();
 
+// ── enforceOnboarding ────────────────────────────────────────────────────
+// If onboarding is incomplete or the config is missing/invalid, run the
+// full quickstart flow inline — verbose, with direct stdio. The agent sees
+// the banner, port selection, server start, and disclosure prompt right here.
+//
+// This is the primary onboarding entry point for agents. npm postinstall
+// silently starts the server (npm captures its output), so the first time
+// the agent runs ANY `a2a` command, this function fires and gives the agent
+// the full verbose walkthrough it needs to complete setup.
+//
+// Returns a Promise if quickstart needs to run (caller must await), or
+// undefined if onboarding is already complete.
 function enforceOnboarding(command) {
   if (ONBOARDING_EXEMPT.has(command)) {
     return;
   }
 
   if (!isOnboarded()) {
-    // Check if we're mid-onboarding (server running, awaiting disclosure)
-    try {
-      const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
-      if (cfg.onboarding?.step === 'awaiting_disclosure') {
-        console.log('\nA2A setup in progress. Disclosure topics not yet submitted.\n');
-        console.log("Next: run `a2a quickstart --submit '<json>'` (or `a2a onboard --submit`)\n");
-        process.exit(1);
-      }
-    } catch (e) {
-      if (e.code !== 'ENOENT' && e.name !== 'SyntaxError') {
-        console.error(`Warning: could not read config: ${e.message}`);
-      }
-    }
-
-    console.log('\nA2A not configured yet.\n');
-    console.log('Next: run `a2a quickstart`\n');
-    process.exit(1);
+    // Run the full quickstart flow inline — verbose output, direct stdio.
+    // This replaces the original command; after onboarding the agent can
+    // re-run their intended command.
+    return commands.quickstart({ flags: {}, positional: [] });
   }
 }
 
@@ -265,70 +264,6 @@ function printSection(title) {
   console.log('\n━━━ ' + title + ' ━━━');
 }
 
-function readWorkspaceContext(baseDir = process.cwd()) {
-  const base = baseDir || process.cwd();
-  const workspaceFiles = {
-    USER: { filename: 'USER.md' },
-    SOUL: { filename: 'SOUL.md' },
-    HEARTBEAT: { filename: 'HEARTBEAT.md' },
-    SKILL: { filename: 'SKILL.md' },
-    CLAUDE: { filename: 'CLAUDE.md' }
-  };
-
-  const found = {};
-  for (const key of Object.keys(workspaceFiles)) {
-    found[key] = fs.existsSync(path.join(base, workspaceFiles[key].filename));
-  }
-
-  const memoryDir = path.join(base, 'memory');
-  let memoryCount = 0;
-  if (fs.existsSync(memoryDir)) {
-    try {
-      memoryCount = fs.readdirSync(memoryDir).filter(item => item.endsWith('.md')).length;
-    } catch (err) {
-      memoryCount = 0;
-    }
-  }
-  found.MEMORY = memoryCount;
-
-  return {
-    workspace: base,
-    found,
-    memoryCount
-  };
-}
-
-function printWorkspaceScan(context) {
-  const fileLabels = {
-    USER: 'USER.md — identity hints',
-    SOUL: 'SOUL.md — personality notes',
-    HEARTBEAT: 'HEARTBEAT.md — scheduled tasks',
-    SKILL: 'SKILL.md — capabilities',
-    CLAUDE: 'CLAUDE.md — agent instructions'
-  };
-  const found = Object.entries(fileLabels)
-    .filter(([key]) => context.found[key])
-    .map(([, label]) => label);
-  if (context.memoryCount > 0) found.push(`${context.memoryCount} memory file(s)`);
-
-  if (found.length) {
-    console.log(`Workspace context: ${found.join(', ')}`);
-  } else {
-    console.log('Workspace context: no context files found (disclosure topics will be minimal)');
-  }
-}
-
-function getDisclosurePromptFiles(context) {
-  return {
-    'USER.md': context.found.USER,
-    'SOUL.md': context.found.SOUL,
-    'HEARTBEAT.md': context.found.HEARTBEAT,
-    'SKILL.md': context.found.SKILL,
-    'CLAUDE.md': context.found.CLAUDE,
-    'memory/*.md': context.memoryCount > 0
-  };
-}
-
 async function inspectPorts(preferredPort = null) {
   const candidates = [];
   if (preferredPort) {
@@ -1854,13 +1789,21 @@ if (!commands[command]) {
   process.exit(1);
 }
 
-enforceOnboarding(command);
-
-// Handle async commands
-const result = commands[command](args);
-if (result instanceof Promise) {
-  result.catch(err => {
+// If onboarding is incomplete, enforceOnboarding runs quickstart inline
+// (verbose, full output) and returns a Promise. Otherwise returns undefined
+// and we proceed to the requested command.
+const onboardResult = enforceOnboarding(command);
+if (onboardResult instanceof Promise) {
+  onboardResult.catch(err => {
     console.error(err.message);
     process.exit(1);
   });
+} else {
+  const result = commands[command](args);
+  if (result instanceof Promise) {
+    result.catch(err => {
+      console.error(err.message);
+      process.exit(1);
+    });
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "a2acalling",
-  "version": "0.6.14",
+  "version": "0.6.16",
   "description": "Agent-to-agent calling for OpenClaw - A2A agent communication",
   "main": "src/index.js",
   "bin": {

package/scripts/postinstall.js

@@ -1,55 +1,37 @@
 #!/usr/bin/env node
 
 // ============================================================================
-// npm postinstall hook — automatic onboarding launcher
+// npm postinstall hook — silent server setup
 //
-// OBJECTIVE: When a user (or agent) runs `npm install -g a2acalling`, this
-// script fires automatically and launches the full quickstart onboarding flow.
-// The agent should never need a second command — install IS onboarding.
+// OBJECTIVE: When `npm install -g a2acalling` runs, this script silently
+// starts the A2A server and saves the initial config. No output is produced
+// because npm v7+ captures all lifecycle script stdio.
 //
-// KEY DESIGN DECISIONS:
+// The VERBOSE onboarding (disclosure prompt, workspace scan instructions)
+// happens when the agent runs any `a2a` command — enforceOnboarding detects
+// incomplete setup and runs the full quickstart flow inline with direct stdio.
 //
-//   1. No TTY gate. Agents are the primary users of this package and they
-//      run in non-interactive (piped) environments. Every prompt in the
-//      quickstart flow auto-accepts sensible defaults when there is no TTY,
-//      so the full onboarding completes unattended: port selection, hostname
-//      detection, server start, and disclosure prompt output.
+// This split exists because:
+//   - npm postinstall: stdio is piped/captured, output is invisible to agents
+//   - `a2a <command>`: agent runs directly, stdio is clean, output is visible
 //
-//   2. Bypassing npm's output capture. npm v7+ pipes lifecycle script stdout
-//      AND stderr to an internal buffer, only showing them on failure. This
-//      means normal console.log/console.error from postinstall is invisible.
-//      To make onboarding output visible:
-//
-//      a) Run quickstart with piped stdio, capturing all its output.
-//      b) Save the output to a2a-onboarding.txt in the config dir (reliable
-//         fallback — agents can always read this file).
-//      c) Try /dev/tty (interactive terminals — bypasses npm entirely).
-//      d) Try /proc/$PPID/fd/2 (Linux — writes directly to npm's stderr fd,
-//         which IS the caller's stderr, bypassing npm's pipe buffer).
-//      e) Last resort: process.stderr.write (npm may still buffer this).
-//
-//   3. Never fail the install. If quickstart can't launch (e.g. missing node
-//      binary edge case), we print a hint and exit 0. A broken postinstall
-//      would prevent the package from installing at all.
-//
-//   4. Skip non-global installs, CI, and Docker builds. Local `npm install`
-//      in a project shouldn't trigger onboarding. CI and Docker are build
-//      environments, not runtime hosts.
+// So postinstall handles the parts that don't need output (server start),
+// and the a2a binary handles the parts that DO need output (disclosure prompt).
 // ============================================================================
 
 if (process.env.CI || process.env.CONTINUOUS_INTEGRATION) process.exit(0);
 if (process.env.DOCKER) process.exit(0);
 if (process.env.npm_config_global !== 'true') process.exit(0);
 
-const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
 const initCwd = process.env.INIT_CWD || process.env.HOME || process.cwd();
 const cliPath = path.join(__dirname, '..', 'bin', 'cli.js');
 
-// Run quickstart with piped stdio so we capture all its output.
-// stdin is piped (empty) so all prompts auto-accept their defaults.
+// Run quickstart silently — starts server, saves config, detects hostname.
+// All prompts auto-accept defaults (stdin is piped with no input).
+// Output is captured (not shown) because npm would swallow it anyway.
 const result = spawnSync(process.execPath, [cliPath, 'quickstart'], {
   stdio: ['pipe', 'pipe', 'pipe'],
   cwd: initCwd,
@@ -60,58 +42,8 @@ const result = spawnSync(process.execPath, [cliPath, 'quickstart'], {
 });
 
 if (result.error) {
-  process.stderr.write('\nCould not auto-launch onboarding.\n');
-  process.stderr.write(`Reason: ${result.error.message}\n`);
-  process.stderr.write('\nRun manually: a2a quickstart\n\n');
-  process.exit(0); // don't fail the install
+  // Don't fail the install — the agent will get onboarding when it runs `a2a`.
+  process.exit(0);
 }
 
-const output = (result.stdout || '').toString() + (result.stderr || '').toString();
-
-// ── Always save to file (reliable fallback) ──────────────────────────────
-// Agents can read this after install regardless of output visibility.
-try {
-  const configDir = process.env.A2A_CONFIG_DIR
-    || path.join(process.env.HOME || '/root', '.config', 'openclaw');
-  if (fs.existsSync(configDir)) {
-    fs.writeFileSync(path.join(configDir, 'a2a-onboarding.txt'), output);
-  }
-} catch (_) {}
-
-// ── Make output visible to the caller ────────────────────────────────────
-// npm pipes BOTH stdout and stderr of lifecycle scripts (v7+), so writing
-// to our own fds goes into npm's buffer. We need to bypass npm entirely.
-
-function tryWrite(output) {
-  // Strategy 1: /dev/tty — interactive terminals.
-  // npm runs postinstall with piped stdio, but /dev/tty talks directly to
-  // the user's terminal. Works for humans, not for agents.
-  try {
-    const fd = fs.openSync('/dev/tty', 'w');
-    fs.writeSync(fd, output);
-    fs.closeSync(fd);
-    return true;
-  } catch (_) {}
-
-  // Strategy 2: /proc/$PPID/fd/2 — Linux, write to npm's stderr directly.
-  // npm's stderr IS the caller's stderr (the agent's output stream).
-  // This bypasses npm's pipe buffer because we open the fd independently.
-  try {
-    const fd = fs.openSync(`/proc/${process.ppid}/fd/2`, 'w');
-    fs.writeSync(fd, output);
-    fs.closeSync(fd);
-    return true;
-  } catch (_) {}
-
-  // Strategy 3: process.stderr — last resort, npm may still buffer this.
-  try {
-    process.stderr.write(output);
-    return true;
-  } catch (_) {}
-
-  return false;
-}
-
-tryWrite(output);
-
 process.exit(result.status || 0);