ninja-terminals 2.3.1 → 2.3.2

package/ninja-login.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+'use strict';
+
+const readline = require('readline');
+const https = require('https');
+const { execSync } = require('child_process');
+const { writeAuthToken, readAuthToken, updateRuntimeSession, SESSION_DIR } = require('./lib/runtime-session');
+const fs = require('fs');
+const path = require('path');
+
+const BACKEND_URL = process.env.NINJA_BACKEND_URL || 'https://emtchat-backend.onrender.com';
+const CREDENTIALS_FILE = path.join(SESSION_DIR, 'credentials.json');
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = { username: null, password: null };
+
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === '--username' || args[i] === '--user' || args[i] === '-u') && args[i + 1]) {
+      result.username = args[++i];
+    } else if (args[i] === '--password' && args[i + 1]) {
+      result.password = args[++i];
+    } else if (args[i] === '-h' || args[i] === '--help') {
+      console.log(`
+ninja-login — Authenticate with Ninja Terminals
+
+Usage:
+  ninja-login                              Interactive login
+  ninja-login --username x --password y    Non-interactive login
+  ninja-login -u x --password y            Short form
+
+Environment:
+  NINJA_BACKEND_URL   Backend URL (default: https://emtchat-backend.onrender.com)
+
+After login, token saved to ~/.ninja/token for CLI/MCP tools.
+`);
+      process.exit(0);
+    }
+  }
+  return result;
+}
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+function promptPassword(question) {
+  return new Promise((resolve) => {
+    // Disable terminal echo using stty (works on macOS/Linux)
+    try { execSync('stty -echo', { stdio: 'pipe' }); } catch {}
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    process.stdout.write(question);
+    rl.question('', (answer) => {
+      // Re-enable echo
+      try { execSync('stty echo', { stdio: 'pipe' }); } catch {}
+      console.log(); // newline
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+function postJson(url, body) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const payload = JSON.stringify(body);
+
+    const req = https.request({
+      hostname: parsed.hostname,
+      port: parsed.port || 443,
+      path: parsed.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+      },
+    }, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, body: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, body: data });
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+async function login(username, password) {
+  console.log('Authenticating...');
+
+  try {
+    const res = await postJson(`${BACKEND_URL}/api/auth/login`, { username, password });
+
+    if (res.status === 200 && res.body.token) {
+      writeAuthToken(res.body.token);
+
+      // Also update runtime session if it exists
+      updateRuntimeSession({ authToken: res.body.token, username });
+
+      // Save username for whoami (not password)
+      fs.mkdirSync(SESSION_DIR, { recursive: true, mode: 0o700 });
+      fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify({ username }, null, 2), { mode: 0o600 });
+
+      console.log(`✓ Logged in as ${username}`);
+      console.log(`  Token saved to ~/.ninja/token`);
+      return true;
+    } else {
+      console.error(`✗ Login failed: ${res.body.error || res.body.message || 'Unknown error'}`);
+      return false;
+    }
+  } catch (err) {
+    console.error(`✗ Connection failed: ${err.message}`);
+    return false;
+  }
+}
+
+async function main() {
+  const args = parseArgs();
+  let { username, password } = args;
+
+  // Check if already logged in
+  const existingToken = readAuthToken();
+  if (existingToken && !username) {
+    try {
+      const creds = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, 'utf8'));
+      console.log(`Already logged in as ${creds.username || creds.email}`);
+      console.log(`Run 'ninja-logout' to sign out, or continue with new credentials.`);
+    } catch {
+      console.log('Token exists but no stored user. Re-authenticating...');
+    }
+  }
+
+  // Interactive prompts if needed
+  if (!username) {
+    username = await prompt('Username: ');
+  }
+  if (!password) {
+    password = await promptPassword('Password: ');
+  }
+
+  if (!username || !password) {
+    console.error('Username and password required.');
+    process.exit(1);
+  }
+
+  const success = await login(username, password);
+  process.exit(success ? 0 : 1);
+}
+
+main();

package/ninja-logout.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { SESSION_DIR, TOKEN_FILE, readAuthToken, updateRuntimeSession } = require('./lib/runtime-session');
+
+const CREDENTIALS_FILE = path.join(SESSION_DIR, 'credentials.json');
+
+function main() {
+  const token = readAuthToken();
+
+  if (!token) {
+    console.log('Not logged in.');
+    return;
+  }
+
+  // Clear token file
+  try {
+    fs.unlinkSync(TOKEN_FILE);
+  } catch {
+    // already gone
+  }
+
+  // Clear credentials
+  try {
+    fs.unlinkSync(CREDENTIALS_FILE);
+  } catch {
+    // already gone
+  }
+
+  // Clear authToken from session
+  try {
+    updateRuntimeSession({ authToken: null, email: null });
+  } catch {
+    // session may not exist
+  }
+
+  console.log('✓ Logged out. Token cleared.');
+}
+
+main();

package/ninja-visual.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+'use strict';
+
+const {
+  VISUAL_LEDGER_FILE,
+  VALID_VISUAL_STAGES,
+  appendVisualEntry,
+  readVisualEntries,
+  clearVisualLedger,
+} = require('./lib/runtime-session');
+
+function printUsage() {
+  console.log(`Usage:
+  node ninja-visual.js --record <stage> --note "<what was seen>" [--terminal <id>]
+  node ninja-visual.js --ledger [N]
+  node ninja-visual.js --clear
+
+Valid stages: ${VALID_VISUAL_STAGES.join(', ')}
+
+Examples:
+  node ninja-visual.js --record pre-dispatch --note "Ninja tab visible, T1-T4 idle"
+  node ninja-visual.js --record post-output --terminal 1 --note "T1 STATUS: DONE visible"
+  node ninja-visual.js --ledger
+  node ninja-visual.js --ledger 10`);
+}
+
+function parseArgs(args) {
+  const result = {};
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === '--record' && args[i + 1]) {
+      result.command = 'record';
+      result.stage = args[i + 1];
+      i += 2;
+    } else if (arg === '--note' && args[i + 1]) {
+      result.note = args[i + 1];
+      i += 2;
+    } else if (arg === '--terminal' && args[i + 1]) {
+      result.terminalId = args[i + 1];
+      i += 2;
+    } else if (arg === '--ledger') {
+      result.command = 'ledger';
+      if (args[i + 1] && !args[i + 1].startsWith('--')) {
+        result.limit = parseInt(args[i + 1], 10);
+        i += 2;
+      } else {
+        i += 1;
+      }
+    } else if (arg === '--clear') {
+      result.command = 'clear';
+      i += 1;
+    } else if (arg === '--help' || arg === '-h') {
+      result.command = 'help';
+      i += 1;
+    } else {
+      i += 1;
+    }
+  }
+  return result;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.command === 'help' || !args.command) {
+    printUsage();
+    process.exit(args.command === 'help' ? 0 : 1);
+  }
+
+  if (args.command === 'clear') {
+    clearVisualLedger();
+    console.log('Visual ledger cleared.');
+    return;
+  }
+
+  if (args.command === 'ledger') {
+    const limit = args.limit || 20;
+    const entries = readVisualEntries(limit);
+    if (entries.length === 0) {
+      console.log('No visual verification entries recorded.');
+      return;
+    }
+    console.log(`Last ${Math.min(entries.length, limit)} visual verification(s):\n`);
+    for (const entry of entries) {
+      const ts = entry.timestamp.replace('T', ' ').slice(0, 19);
+      const term = entry.terminalId ? ` T${entry.terminalId}` : '';
+      console.log(`${ts} [${entry.stage}]${term}`);
+      console.log(`  ${entry.note}`);
+    }
+    return;
+  }
+
+  if (args.command === 'record') {
+    if (!args.stage) {
+      console.error('Error: --record requires a stage');
+      process.exit(1);
+    }
+    if (!VALID_VISUAL_STAGES.includes(args.stage)) {
+      console.error(`Error: Invalid stage "${args.stage}". Valid stages: ${VALID_VISUAL_STAGES.join(', ')}`);
+      process.exit(1);
+    }
+    if (!args.note || args.note.trim() === '') {
+      console.error('Error: --note is required and must be non-empty');
+      process.exit(1);
+    }
+
+    const entry = {
+      stage: args.stage,
+      note: args.note.trim(),
+      cwd: process.cwd(),
+      command: 'ninja-visual',
+    };
+    if (args.terminalId) {
+      entry.terminalId = args.terminalId;
+    }
+
+    const record = appendVisualEntry(entry);
+    console.log(`Visual verification recorded: [${args.stage}]${args.terminalId ? ' T' + args.terminalId : ''}`);
+    console.log(`  ${args.note}`);
+    return;
+  }
+}
+
+main();

package/ninja-whoami.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { SESSION_DIR, readAuthToken } = require('./lib/runtime-session');
+
+const CREDENTIALS_FILE = path.join(SESSION_DIR, 'credentials.json');
+
+function main() {
+  const token = readAuthToken();
+
+  if (!token) {
+    console.log('Not logged in. Run: ninja-login');
+    process.exit(1);
+  }
+
+  try {
+    const creds = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, 'utf8'));
+    console.log(`Logged in as: ${creds.username || creds.email}`);
+    console.log(`Token: ${token.slice(0, 20)}...`);
+  } catch {
+    console.log('Logged in (token present)');
+    console.log(`Token: ${token.slice(0, 20)}...`);
+    console.log('User unknown (logged in before ninja-login existed)');
+  }
+}
+
+main();

package/package.json

@@ -1,15 +1,28 @@
 {
   "name": "ninja-terminals",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "MCP server for multi-terminal Claude Code orchestration with DAG task management, parallel execution, and self-improvement",
   "main": "server.js",
   "bin": {
     "ninja-terminals": "cli.js",
-    "ninja-terminals-mcp": "mcp-server.js"
+    "ninja-terminals-mcp": "mcp-server.js",
+    "agent-send": "agent-send.js",
+    "ninja-dispatch": "agent-send.js",
+    "ninja-status": "agent-send.js",
+    "ninja-ensure": "ninja-ensure.js",
+    "ninja-visual": "ninja-visual.js",
+    "ninja-gate": "ninja-gate.js",
+    "ninja-codex-visual": "ninja-codex-visual.js",
+    "ninja-claude-visual": "ninja-claude-visual.js",
+    "ninja-codex": "ninja-codex.js",
+    "ninja-login": "ninja-login.js",
+    "ninja-logout": "ninja-logout.js",
+    "ninja-whoami": "ninja-whoami.js"
   },
   "scripts": {
     "start": "node server.js",
-    "mcp": "node mcp-server.js"
+    "mcp": "node mcp-server.js",
+    "install-hooks": "node scripts/install-ninja-hooks.js"
   },
   "files": [
     "lib/",
@@ -25,6 +38,16 @@
     "cli.js",
     "server.js",
     "mcp-server.js",
+    "agent-send.js",
+    "ninja-ensure.js",
+    "ninja-visual.js",
+    "ninja-gate.js",
+    "ninja-codex-visual.js",
+    "ninja-claude-visual.js",
+    "ninja-codex.js",
+    "ninja-login.js",
+    "ninja-logout.js",
+    "ninja-whoami.js",
     "CLAUDE.md",
     "ORCHESTRATOR-PROMPT.md"
   ],