taskmonkey-cli 0.1.0

package/.tmrc

@@ -0,0 +1,7 @@
+{
+  "server": "https://gpt.meco-media.com",
+  "tenant": "bloomify",
+  "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJtZWNvZ3B0Iiwic3ViIjoiYzAyZWYyMjItMDU1MC00OTgwLTg0ODYtNzIzOTJmZDI2ZjY5IiwiZW1haWwiOiJtYXJjdXMuZ29lZGVAbWVjby1tZWRpYS5jb20iLCJyb2xlIjoiYWRtaW4iLCJpYXQiOjE3NzUxNTY4NDksImV4cCI6MTc3NTI0MzI0OX0.bpfHNBOuq1un8Psc89Xevn-Ibo4YVAYNNwDRYe6fb4A",
+  "refresh_token": "5c9eb7bacec249d2aacb57402f3f5fedee2faf2796d721be6c02970653e9186b",
+  "tenant_path": "."
+}

package/bin/tm.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { login } from '../src/commands/login.js';
+import { testTool } from '../src/commands/test-tool.js';
+import { sync } from '../src/commands/sync.js';
+import { pull } from '../src/commands/pull.js';
+import { watch } from '../src/commands/watch.js';
+import { logs } from '../src/commands/logs.js';
+import { chat } from '../src/commands/chat.js';
+
+const program = new Command();
+
+program
+  .name('tm')
+  .description('TaskMonkey CLI — Remote dev tools for tenant config')
+  .version('0.1.0');
+
+program
+  .command('login')
+  .description('Login and select tenant')
+  .option('-s, --server <url>', 'Server URL', 'https://gpt.meco-media.com')
+  .action(login);
+
+program
+  .command('test-tool <toolName> [args...]')
+  .description('Run a tenant tool with arguments (key=value)')
+  .option('--dry-run', 'Simulation mode')
+  .option('--json', 'JSON output only')
+  .action(testTool);
+
+program
+  .command('sync')
+  .description('Upload local config files to server')
+  .action(sync);
+
+program
+  .command('pull')
+  .description('Download config files from server')
+  .action(pull);
+
+program
+  .command('watch')
+  .description('Watch for file changes and auto-sync')
+  .action(watch);
+
+program
+  .command('logs')
+  .description('Stream server logs')
+  .option('-n, --lines <number>', 'Initial lines to show', '50')
+  .action(logs);
+
+program
+  .command('chat')
+  .description('Interactive chat REPL')
+  .option('-t, --task <slug>', 'Monkey task slug (e.g. inventur)')
+  .option('-p, --public', 'Public chat (no auth, no tools)')
+  .action(chat);
+
+program.parse();

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "taskmonkey-cli",
+  "version": "0.1.0",
+  "description": "TaskMonkey CLI — Remote dev tools for tenant config editing and tool testing",
+  "bin": {
+    "tm": "./bin/tm.js",
+    "taskmonkey": "./bin/tm.js"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "node bin/tm.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "chokidar": "^3.6.0",
+    "commander": "^12.0.0",
+    "eventsource": "^2.0.2",
+    "inquirer": "^9.2.0",
+    "ora": "^7.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/skills/chat.md

@@ -0,0 +1,18 @@
+---
+description: Interaktiven Chat im Terminal starten
+---
+
+Starte einen interaktiven Chat im Terminal. Der User kann optional einen Task angeben.
+
+```bash
+# Unified Chat (alle Tools)
+tm chat
+
+# Spezifischer Monkey Task
+tm chat --task inventur
+
+# Öffentlicher Chat (keine Auth, keine internen Tools)
+tm chat --public
+```
+
+Frage den User welchen Modus er möchte, falls nicht angegeben.

package/skills/logs.md

@@ -0,0 +1,12 @@
+---
+description: Server-Logs live streamen
+---
+
+Streame die Server-Logs in Echtzeit. Nützlich zum Debuggen nach Config-Änderungen.
+
+```bash
+tm logs
+```
+
+Die Logs werden farbig angezeigt (Fehler=rot, Warnungen=gelb, Erfolg=grün).
+Ctrl+C zum Beenden.

package/skills/pull.md

@@ -0,0 +1,11 @@
+---
+description: Config-Dateien vom Server herunterladen
+---
+
+Führe `tm pull` aus um die aktuellen Config-Dateien vom Server herunterzuladen.
+
+```bash
+tm pull
+```
+
+Zeige dem User anschließend welche Dateien heruntergeladen wurden.

package/skills/sync.md

@@ -0,0 +1,11 @@
+---
+description: Lokale Config-Dateien zum Server hochladen
+---
+
+Führe `tm sync` aus um die lokalen Config-Dateien zum Server zu synchronisieren. Der Server prüft die PHP-Syntax und leert den Cache automatisch.
+
+```bash
+tm sync
+```
+
+Zeige dem User das Ergebnis. Bei Fehlern (PHP Syntax etc.) die betroffenen Dateien nennen.

package/skills/test-tool.md

@@ -0,0 +1,24 @@
+---
+description: Ein Tool auf dem Server testen
+---
+
+Führe ein Tool auf dem Server aus. Der User gibt den Tool-Namen und optionale Argumente an.
+
+Wenn der User nur `/test-tool` ohne Argumente sagt:
+1. Frage nach dem Tool-Namen
+2. Frage nach den Argumenten (key=value Format)
+
+Dann ausführen:
+```bash
+tm test-tool <toolName> [key=value ...]
+```
+
+Beispiele:
+```bash
+tm test-tool searchItems searchSku=bodo
+tm test-tool getStockBySku skus='["X0047"]'
+tm test-tool matchDeliveryItems --dry-run
+```
+
+Für `--dry-run` (Simulation ohne echte Buchung) das Flag anhängen.
+Zeige dem User das Ergebnis übersichtlich formatiert.

package/src/commands/chat.js

@@ -0,0 +1,173 @@
+import { createInterface } from 'readline';
+import chalk from 'chalk';
+import { loadConfig } from '../config.js';
+
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+export async function chat(options) {
+  const config = loadConfig();
+  if (!config) {
+    console.error(chalk.red('Not logged in. Run `tm login` first.'));
+    process.exit(1);
+  }
+
+  const task = options.task || null;
+  const isPublic = options.public || false;
+  let chatId;
+  if (task) chatId = `task_${task}_cli_${Date.now()}`;
+  else if (isPublic) chatId = `public_cli_${Date.now()}`;
+  else chatId = `unified_cli_${Date.now()}`;
+
+  const label = task ? `(${task})` : isPublic ? '(public)' : '(unified)';
+  console.log(chalk.cyan('💬 Chat'), chalk.gray(label));
+  console.log(chalk.gray('   Empty line to quit.\n'));
+
+  await sendMessage('', config, chatId);
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  const prompt = () => {
+    rl.question(chalk.green('\n> '), async (input) => {
+      if (input.trim() === '') {
+        rl.close();
+        process.exit(0);
+      }
+      await sendMessage(input.trim(), config, chatId);
+      prompt();
+    });
+  };
+
+  prompt();
+}
+
+function trunc(obj, max = 140) {
+  const s = typeof obj === 'string' ? obj : JSON.stringify(obj);
+  return s.length <= max ? s : s.substring(0, max) + '…';
+}
+
+async function sendMessage(message, config, chatId) {
+  const params = new URLSearchParams({ tenant: config.tenant, chat_id: chatId, message });
+  const url = `${config.server}/chat/stream?${params}`;
+
+  let si = null, sf = 0, st = 'Thinking';
+  const spin = (text) => {
+    st = text || st;
+    if (!si) si = setInterval(() => {
+      process.stdout.write(`\r  ${chalk.cyan(SPINNER[sf++ % SPINNER.length])} ${chalk.gray(st)}   `);
+    }, 80);
+  };
+  const stop = () => {
+    if (si) { clearInterval(si); si = null; process.stdout.write('\r' + ' '.repeat(50) + '\r'); }
+  };
+
+  try {
+    const headers = { 'Accept': 'text/event-stream' };
+    if (config.token && !chatId.startsWith('public_')) {
+      headers['Authorization'] = `Bearer ${config.token}`;
+    }
+
+    spin('Thinking');
+    const response = await fetch(url, { headers });
+
+    if (!response.ok) {
+      stop();
+      console.error(chalk.red(`HTTP ${response.status}`));
+      return;
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = '', evt = 'message', msg = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split('\n');
+      buf = lines.pop();
+
+      for (const line of lines) {
+        if (line.startsWith('event: ')) {
+          evt = line.substring(7).trim();
+        } else if (line.startsWith('data: ')) {
+          const raw = line.substring(6);
+          if (raw === '[DONE]') continue;
+
+          try {
+            const d = JSON.parse(raw);
+
+            switch (evt) {
+              case 'message': {
+                const c = d.content || d.message || '';
+                if (c) { stop(); msg += stripHtml(c); }
+                break;
+              }
+              case 'status': {
+                const s = d.status || d.message || '';
+                if (s) spin(s);
+                break;
+              }
+              case 'tool_start': {
+                stop();
+                const name = d.tool || d.name || '?';
+                const args = d.args || d.arguments || null;
+                let argStr = '';
+                if (args && Object.keys(args).length > 0) {
+                  argStr = ' ' + chalk.gray(trunc(args, 100));
+                }
+                console.log(chalk.yellow(`  ▶ ${name}`) + argStr);
+                spin(name);
+                break;
+              }
+              case 'tool_complete': {
+                stop();
+                const name = d.tool || d.name || '?';
+                const ok = d.success !== false;
+                console.log(ok ? chalk.green(`  ✓ ${name}`) : chalk.red(`  ✗ ${name}`));
+                spin('Thinking');
+                break;
+              }
+              case 'suggestions': {
+                const sug = d.suggestions;
+                if (sug?.length) msg += '\n' + sug.map(s => chalk.bgGray.white(` ${s} `)).join(' ');
+                break;
+              }
+              case 'error':
+                stop();
+                console.error(chalk.red(`  ✗ ${d.message || JSON.stringify(d)}`));
+                break;
+            }
+          } catch {}
+        }
+      }
+    }
+
+    stop();
+    if (msg) console.log(compact(msg));
+
+  } catch (err) {
+    stop();
+    console.error(chalk.red(err.message));
+  }
+}
+
+function stripHtml(h) {
+  return h
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>\s*<p[^>]*>/gi, '\n')
+    .replace(/<\/?(?:p|div|h[1-6])[^>]*>/gi, '')
+    .replace(/<li[^>]*>/gi, '\n  • ')
+    .replace(/<\/li>/gi, '')
+    .replace(/<\/?(?:ul|ol)[^>]*>/gi, '')
+    .replace(/<strong>(.*?)<\/strong>/gi, (_, t) => chalk.bold(t))
+    .replace(/<em>(.*?)<\/em>/gi, (_, t) => chalk.italic(t))
+    .replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, (_, u, t) => `${t} ${chalk.gray(`(${u})`)}`)
+    .replace(/<[^>]+>/g, '')
+    .replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, ' ');
+}
+
+function compact(t) {
+  return t.replace(/\n{2,}/g, '\n').replace(/^\n+/, '').replace(/\n+$/, '');
+}

package/src/commands/login.js

@@ -0,0 +1,50 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { initConfig } from '../config.js';
+
+export async function login(options) {
+  const server = options.server || 'https://gpt.meco-media.com';
+
+  const { email, password } = await inquirer.prompt([
+    { type: 'input', name: 'email', message: 'E-Mail:' },
+    { type: 'password', name: 'password', message: 'Passwort:', mask: '*' },
+  ]);
+
+  const res = await fetch(`${server}/api/users/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ email, password }),
+  });
+
+  const data = await res.json();
+
+  if (!res.ok || data.success === false) {
+    console.error(chalk.red('Login fehlgeschlagen:'), data.message || 'Unbekannter Fehler');
+    process.exit(1);
+  }
+
+  const tenants = data.tenants || [];
+
+  if (tenants.length === 0) {
+    console.error(chalk.red('Keine Tenants verfügbar'));
+    process.exit(1);
+  }
+
+  let tenant;
+  if (tenants.length === 1) {
+    tenant = tenants[0].code;
+    console.log(chalk.gray(`Tenant: ${tenant}`));
+  } else {
+    const { selectedTenant } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selectedTenant',
+      message: 'Tenant wählen:',
+      choices: tenants.map(t => ({ name: `${t.name} (${t.code})`, value: t.code })),
+    }]);
+    tenant = selectedTenant;
+  }
+
+  const configPath = initConfig(server, tenant, data.token, data.refresh_token);
+  console.log(chalk.green('✓'), `Eingeloggt als ${data.user.fullname || email}`);
+  console.log(chalk.gray(`  Config: ${configPath}`));
+}

package/src/commands/logs.js

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import EventSource from 'eventsource';
+import { createClient } from '../lib/api.js';
+import { loadConfig } from '../config.js';
+
+export async function logs(options) {
+  const config = loadConfig();
+  if (!config) {
+    console.error(chalk.red('Not logged in. Run `tm login` first.'));
+    process.exit(1);
+  }
+
+  const lines = options.lines || 50;
+  const url = `${config.server}/api/logs/stream?tenant=${config.tenant}&lines=${lines}`;
+
+  console.log(chalk.cyan('📋 Streaming logs'), chalk.gray(`(${config.tenant})`));
+  console.log(chalk.gray('   Ctrl+C to stop\n'));
+
+  const es = new EventSource(url, {
+    headers: { 'Authorization': `Bearer ${config.token}` },
+  });
+
+  es.onmessage = (e) => {
+    try {
+      const data = JSON.parse(e.data);
+      const line = data.line || '';
+      const type = data.type || 'info';
+
+      switch (type) {
+        case 'error':
+          console.log(chalk.red(line));
+          break;
+        case 'warning':
+          console.log(chalk.yellow(line));
+          break;
+        case 'success':
+          console.log(chalk.green(line));
+          break;
+        default:
+          console.log(chalk.gray(line));
+      }
+    } catch {
+      console.log(chalk.gray(e.data));
+    }
+  };
+
+  es.addEventListener('init_complete', () => {
+    console.log(chalk.gray('--- live ---\n'));
+  });
+
+  es.onerror = (err) => {
+    if (es.readyState === EventSource.CLOSED) {
+      console.log(chalk.gray('\nConnection closed.'));
+      process.exit(0);
+    }
+  };
+
+  process.on('SIGINT', () => {
+    es.close();
+    console.log(chalk.gray('\nStopped.'));
+    process.exit(0);
+  });
+}

package/src/commands/pull.js

@@ -0,0 +1,165 @@
+import { mkdirSync, writeFileSync, existsSync, readdirSync, readFileSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig } from '../config.js';
+import { createClient } from '../lib/api.js';
+
+export async function pull() {
+  const config = loadConfig();
+  if (!config) {
+    console.error(chalk.red('Not logged in. Run `tm login` first.'));
+    process.exit(1);
+  }
+
+  const client = createClient();
+  const tenantDir = join(config._configDir, config.tenant_path || '.');
+
+  const spinner = ora('Downloading config...').start();
+
+  try {
+    // Download all file contents
+    const contents = await client.get('/api/tenant/pull');
+
+    // Also download docs
+    const docs = await client.get('/api/tenant/docs').catch(() => null);
+
+    spinner.stop();
+
+    let written = 0;
+    for (const [relativePath, content] of Object.entries(contents.files || {})) {
+      const fullPath = join(tenantDir, relativePath);
+      mkdirSync(dirname(fullPath), { recursive: true });
+      writeFileSync(fullPath, content);
+      console.log(chalk.gray(`  ${relativePath}`));
+      written++;
+    }
+
+    // Write docs if available
+    if (docs?.files) {
+      const docsDir = join(config._configDir, 'docs');
+      mkdirSync(docsDir, { recursive: true });
+      for (const [name, content] of Object.entries(docs.files)) {
+        writeFileSync(join(docsDir, name), content);
+        console.log(chalk.gray(`  docs/${name}`));
+        written++;
+      }
+    }
+
+    // Create CLAUDE.md if it doesn't exist
+    const claudeMdPath = join(config._configDir, 'CLAUDE.md');
+    if (!existsSync(claudeMdPath)) {
+      writeFileSync(claudeMdPath, generateClaudeMd(config.tenant));
+      console.log(chalk.cyan(`  CLAUDE.md (created)`));
+      written++;
+    }
+
+    // Install Claude Code skills to .claude/commands/
+    const skillsInstalled = installSkills(config._configDir);
+    written += skillsInstalled;
+
+    console.log(chalk.green('✓'), `${written} files downloaded`);
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+}
+
+function installSkills(targetDir) {
+  const commandsDir = join(targetDir, '.claude', 'commands');
+  mkdirSync(commandsDir, { recursive: true });
+
+  // Find skills directory relative to this file
+  const __filename = fileURLToPath(import.meta.url);
+  const skillsDir = resolve(dirname(__filename), '..', '..', 'skills');
+
+  if (!existsSync(skillsDir)) return 0;
+
+  let count = 0;
+  const files = readdirSync(skillsDir).filter(f => f.endsWith('.md'));
+  for (const file of files) {
+    const content = readFileSync(join(skillsDir, file), 'utf8');
+    writeFileSync(join(commandsDir, file), content);
+    console.log(chalk.cyan(`  .claude/commands/${file}`));
+    count++;
+  }
+  return count;
+}
+
+function generateClaudeMd(tenant) {
+  return `# TaskMonkey Tenant: ${tenant}
+
+## Was ist das?
+
+Dieses Verzeichnis enthält die Konfiguration für den Tenant **${tenant}** der TaskMonkey-Plattform.
+Du kannst hier Prompts, Tools und Einstellungen bearbeiten und sie mit dem \`tm\` CLI auf den Server synchronisieren.
+
+## Verzeichnisstruktur
+
+\`\`\`
+.tmrc                    # Login-Daten (nicht committen!)
+CLAUDE.md                # Diese Datei
+docs/                    # Dokumentation (TenantConfig.md etc.)
+monkey_tasks/            # Monkey Task Definitionen (Name, Tools, Prompts)
+prompts/                 # Allgemeine Prompts (System, First Message)
+tools/                   # Tool-Konfigurationen
+  jtl/                   # JTL-spezifische Tools
+  lieferschein/          # Lieferschein/Wareneingang Tools
+  google_sheets/         # Google Sheets Tools
+  support/               # Support Tools
+scan.php                 # Barcode/QR Scanner Konfiguration
+apis.php                 # API-Verbindungen (JTL etc.)
+\`\`\`
+
+## CLI Befehle
+
+\`\`\`bash
+tm login                              # Einloggen und Tenant wählen
+tm pull                               # Config-Dateien vom Server herunterladen
+tm sync                               # Lokale Dateien zum Server hochladen
+tm watch                              # Auto-Sync bei Dateiänderung
+tm test-tool <name> [key=value ...]   # Tool auf dem Server testen
+tm test-tool <name> --dry-run         # Tool im Simulationsmodus testen
+tm logs                               # Server-Logs live streamen
+\`\`\`
+
+## Workflow
+
+1. **Datei bearbeiten** — z.B. einen Prompt in \`monkey_tasks/inventur.php\` ändern
+2. **Synchronisieren** — \`tm sync\` oder \`tm watch\` für Auto-Sync
+3. **Testen** — Im Chat ausprobieren oder \`tm test-tool\` für direktes Tool-Testing
+4. **Logs prüfen** — \`tm logs\` bei Problemen
+
+## Config-Format
+
+Jede .php Datei gibt ein Array zurück mit Dot-Notation Keys:
+
+\`\`\`php
+<?php
+return [
+    'monkey_tasks.inventur' => [
+        'name' => 'Inventur',
+        'description' => 'Lagerbestand erfassen',
+        'icon' => '✅',
+        'tools' => ['searchItems', 'updateStock', ...],
+    ],
+    'monkey_tasks.inventur.prompt' => <<<'PROMPT'
+    Du bist der Inventur-Assistent...
+    PROMPT,
+];
+\`\`\`
+
+Siehe \`docs/TenantConfig.md\` für die vollständige Dokumentation aller Config-Keys.
+
+## Wichtige Regeln
+
+- **Nur .php Dateien** werden synchronisiert
+- **PHP-Syntax wird geprüft** vor dem Schreiben auf dem Server
+- **\`.tmrc\` nie committen** — enthält Login-Token
+- **Prompts** definieren das Verhalten der KI im Chat
+- **Tools** definieren welche Aktionen die KI ausführen kann
+- **\`internal: true\`** bei Tools bedeutet: nur für Monkey Tasks, nicht für öffentliche Chats
+`;
+}
+

package/src/commands/sync.js

@@ -0,0 +1,71 @@
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { join, relative } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig } from '../config.js';
+import { createClient } from '../lib/api.js';
+
+function collectFiles(dir, base = dir) {
+  const files = {};
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      Object.assign(files, collectFiles(fullPath, base));
+    } else if (entry.isFile() && entry.name.endsWith('.php')) {
+      const relPath = relative(base, fullPath);
+      files[relPath] = readFileSync(fullPath, 'utf8');
+    }
+  }
+
+  return files;
+}
+
+export async function sync() {
+  const config = loadConfig();
+  if (!config) {
+    console.error(chalk.red('Not logged in. Run `tm login` first.'));
+    process.exit(1);
+  }
+
+  const tenantDir = join(config._configDir, config.tenant_path || '.');
+
+  const spinner = ora('Collecting files...').start();
+
+  const files = collectFiles(tenantDir);
+  const fileCount = Object.keys(files).length;
+
+  if (fileCount === 0) {
+    spinner.warn('No .php files found');
+    return;
+  }
+
+  spinner.text = `Syncing ${fileCount} files...`;
+
+  try {
+    const client = createClient();
+    const result = await client.post('/api/tenant/sync', { files });
+
+    spinner.stop();
+
+    if (result.success) {
+      console.log(chalk.green('✓'), `${result.written} files synced`);
+      for (const file of result.files || []) {
+        console.log(chalk.gray(`  ${file}`));
+      }
+    } else {
+      console.log(chalk.yellow('⚠'), `${result.written || 0} files synced, ${result.errors?.length || 0} errors`);
+    }
+
+    if (result.errors?.length > 0) {
+      console.log(chalk.red('\nErrors:'));
+      for (const err of result.errors) {
+        console.log(chalk.red(`  ${err.path}: ${err.error}`));
+      }
+    }
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+}

package/src/commands/test-tool.js

@@ -0,0 +1,67 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { createClient } from '../lib/api.js';
+
+export async function testTool(toolName, args, options) {
+  const client = createClient();
+
+  // Parse key=value args
+  const toolArgs = {};
+  for (const arg of args) {
+    const eq = arg.indexOf('=');
+    if (eq > 0) {
+      const key = arg.substring(0, eq);
+      let val = arg.substring(eq + 1);
+      // Auto-convert types
+      if (val === 'true') val = true;
+      else if (val === 'false') val = false;
+      else if (val === 'null') val = null;
+      else if (/^\d+$/.test(val)) val = parseInt(val, 10);
+      else if (/^\d+\.\d+$/.test(val)) val = parseFloat(val);
+      toolArgs[key] = val;
+    }
+  }
+
+  const spinner = ora(`Running ${toolName}...`).start();
+
+  try {
+    const result = await client.post('/api/tools/run', {
+      tool: toolName,
+      args: toolArgs,
+      dry_run: options.dryRun || false,
+    });
+
+    spinner.stop();
+
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    // Formatted output
+    const success = result.success;
+    const icon = success ? chalk.green('✓') : chalk.red('✗');
+    console.log(`${icon} ${toolName} (${result.duration_ms}ms)`);
+
+    // Show log entries if present
+    const log = result.result?.log || result.result?._logger?.log || [];
+    if (log.length > 0) {
+      console.log(chalk.gray('─'.repeat(40)));
+      for (const line of log) {
+        console.log(chalk.gray('  ' + line));
+      }
+    }
+
+    // Show result (without log/logger)
+    const cleanResult = { ...result.result };
+    delete cleanResult.log;
+    delete cleanResult._logger;
+
+    console.log(chalk.gray('─'.repeat(40)));
+    console.log(JSON.stringify(cleanResult, null, 2));
+
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+}

package/src/commands/watch.js

@@ -0,0 +1,46 @@
+import chokidar from 'chokidar';
+import chalk from 'chalk';
+import { loadConfig } from '../config.js';
+import { sync } from './sync.js';
+import { join } from 'path';
+
+export async function watch() {
+  const config = loadConfig();
+  if (!config) {
+    console.error(chalk.red('Not logged in. Run `tm login` first.'));
+    process.exit(1);
+  }
+
+  const tenantDir = join(config._configDir, config.tenant_path || '.');
+
+  console.log(chalk.cyan('👀 Watching'), tenantDir);
+  console.log(chalk.gray('   Ctrl+C to stop\n'));
+
+  let debounceTimer = null;
+
+  const watcher = chokidar.watch(join(tenantDir, '**/*.php'), {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 300 },
+  });
+
+  watcher.on('all', (event, path) => {
+    console.log(chalk.gray(`  ${event}: ${path.replace(tenantDir + '/', '')}`));
+
+    // Debounce: wait 500ms after last change
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      try {
+        await sync();
+      } catch (err) {
+        console.error(chalk.red(`  Sync error: ${err.message}`));
+      }
+    }, 500);
+  });
+
+  // Keep process alive
+  process.on('SIGINT', () => {
+    watcher.close();
+    console.log(chalk.gray('\nStopped.'));
+    process.exit(0);
+  });
+}

package/src/config.js

@@ -0,0 +1,50 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const CONFIG_FILE = '.tmrc';
+
+export function findConfig(startDir = process.cwd()) {
+  let dir = startDir;
+  while (dir !== '/') {
+    const configPath = join(dir, CONFIG_FILE);
+    if (existsSync(configPath)) {
+      return { path: configPath, dir };
+    }
+    dir = join(dir, '..');
+  }
+  return null;
+}
+
+export function loadConfig() {
+  const found = findConfig();
+  if (!found) return null;
+
+  try {
+    const raw = readFileSync(found.path, 'utf8');
+    const config = JSON.parse(raw);
+    config._configDir = found.dir;
+    config._configPath = found.path;
+    return config;
+  } catch {
+    return null;
+  }
+}
+
+export function saveConfig(data) {
+  const path = data._configPath || join(process.cwd(), CONFIG_FILE);
+  const { _configDir, _configPath, ...clean } = data;
+  writeFileSync(path, JSON.stringify(clean, null, 2) + '\n');
+}
+
+export function initConfig(server, tenant, token, refreshToken) {
+  const data = {
+    server,
+    tenant,
+    token,
+    refresh_token: refreshToken,
+    tenant_path: '.',
+  };
+  const path = join(process.cwd(), CONFIG_FILE);
+  writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+  return path;
+}

package/src/lib/api.js

@@ -0,0 +1,101 @@
+import { loadConfig, saveConfig } from '../config.js';
+
+export class ApiClient {
+  constructor(config) {
+    this.server = config.server;
+    this.tenant = config.tenant;
+    this.token = config.token;
+    this.refreshToken = config.refresh_token;
+    this._config = config;
+  }
+
+  async get(path, params = {}) {
+    const url = new URL(path, this.server);
+    url.searchParams.set('tenant', this.tenant);
+    for (const [k, v] of Object.entries(params)) {
+      url.searchParams.set(k, v);
+    }
+
+    let res = await fetch(url.toString(), { headers: this._headers() });
+
+    if (res.status === 401) {
+      const refreshed = await this._refresh();
+      if (refreshed) {
+        res = await fetch(url.toString(), { headers: this._headers() });
+      }
+    }
+
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`HTTP ${res.status}: ${body}`);
+    }
+
+    return res.json();
+  }
+
+  async post(path, body = {}) {
+    const url = new URL(path, this.server);
+    url.searchParams.set('tenant', this.tenant);
+
+    let res = await fetch(url.toString(), {
+      method: 'POST',
+      headers: this._headers(),
+      body: JSON.stringify(body),
+    });
+
+    if (res.status === 401) {
+      const refreshed = await this._refresh();
+      if (refreshed) {
+        res = await fetch(url.toString(), {
+          method: 'POST',
+          headers: this._headers(),
+          body: JSON.stringify(body),
+        });
+      }
+    }
+
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+
+    return res.json();
+  }
+
+  async _refresh() {
+    if (!this.refreshToken) return false;
+
+    try {
+      const url = new URL('/api/users/refresh', this.server);
+      const res = await fetch(url.toString(), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ refresh_token: this.refreshToken }),
+      });
+
+      if (res.ok) {
+        const data = await res.json();
+        this.token = data.token;
+        this._config.token = data.token;
+        saveConfig(this._config);
+        return true;
+      }
+    } catch {}
+    return false;
+  }
+
+  _headers() {
+    return {
+      'Authorization': `Bearer ${this.token}`,
+      'Content-Type': 'application/json',
+    };
+  }
+}
+
+export function createClient() {
+  const config = loadConfig();
+  if (!config) {
+    throw new Error('Not logged in. Run `tm login` first.');
+  }
+  return new ApiClient(config);
+}