taskmonkey-cli 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskmonkey-cli",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "TaskMonkey CLI — Remote dev tools for tenant config editing and tool testing",
   "bin": {
     "tm": "./bin/tm.js",

package/src/commands/pull.js

@@ -36,17 +36,21 @@ export async function pull() {
       written++;
     }
 
-    // Write docs if available
+    // Write docs if available. The server returns relative paths that may
+    // contain subdirectories (e.g. cms/contao.md), so we need to mkdir -p
+    // the dirname of each full target path, not just the top-level folder.
     if (docs?.files) {
       for (const [name, content] of Object.entries(docs.files)) {
-        // shared/ files go to shared/, docs go to docs/
-        const targetDir = name.startsWith('shared/')
+        // shared/ files go to shared/, everything else to docs/
+        const isShared = name.startsWith('shared/');
+        const baseDir = isShared
           ? join(config._configDir, 'shared')
           : join(config._configDir, 'docs');
-        const fileName = name.startsWith('shared/') ? name.substring(7) : name;
-        mkdirSync(targetDir, { recursive: true });
-        writeFileSync(join(targetDir, fileName), content);
-        console.log(chalk.gray(`  ${name.startsWith('shared/') ? 'shared' : 'docs'}/${fileName}`));
+        const relName = isShared ? name.substring(7) : name;
+        const fullPath = join(baseDir, relName);
+        mkdirSync(dirname(fullPath), { recursive: true });
+        writeFileSync(fullPath, content);
+        console.log(chalk.gray(`  ${isShared ? 'shared' : 'docs'}/${relName}`));
         written++;
       }
     }

package/src/commands/sync.js

@@ -1,15 +1,21 @@
-import { readdirSync, readFileSync } from 'fs';
-import { join, relative } from 'path';
+import { readdirSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join, relative, dirname } from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
 import { loadConfig } from '../config.js';
 import { createClient } from '../lib/api.js';
 
+// Skip runtime dirs and the local CLI metadata when collecting files to upload.
+const SKIP_TOP_LEVEL = new Set(['logs', 'tmp', '.claude', '.git', 'node_modules', 'docs', 'shared']);
+
 function collectFiles(dir, base = dir) {
   const files = {};
   const entries = readdirSync(dir, { withFileTypes: true });
 
   for (const entry of entries) {
+    if (dir === base && SKIP_TOP_LEVEL.has(entry.name)) {
+      continue;
+    }
     const fullPath = join(dir, entry.name);
     if (entry.isDirectory()) {
       Object.assign(files, collectFiles(fullPath, base));
@@ -22,6 +28,55 @@ function collectFiles(dir, base = dir) {
   return files;
 }
 
+/**
+ * Pulls logs/ and tmp/ from the server into the local working copy so the
+ * developer can read them with normal file tools (cat, grep, Claude, etc.).
+ *
+ * Text files come back as utf-8 strings; binary files come back as base64
+ * under `binary_files`. We write both verbatim.
+ *
+ * Failures here are non-fatal — the sync itself was already successful.
+ */
+export async function pullRuntime(tenantDir, { quiet = false } = {}) {
+  const client = createClient();
+  let runtime;
+  try {
+    runtime = await client.get('/api/tenant/runtime');
+  } catch (err) {
+    if (!quiet) {
+      console.log(chalk.gray(`  (runtime pull skipped: ${err.message})`));
+    }
+    return 0;
+  }
+
+  let written = 0;
+  const writeOne = (relPath, content, isBase64) => {
+    const fullPath = join(tenantDir, relPath);
+    mkdirSync(dirname(fullPath), { recursive: true });
+    if (isBase64) {
+      writeFileSync(fullPath, Buffer.from(content, 'base64'));
+    } else {
+      writeFileSync(fullPath, content);
+    }
+    written++;
+  };
+
+  // Some servers serialize empty PHP arrays as JSON [] instead of {}.
+  // Treat plain arrays as empty since they have no path-keyed entries.
+  const asMap = (v) => (v && typeof v === 'object' && !Array.isArray(v)) ? v : {};
+  for (const [relPath, content] of Object.entries(asMap(runtime.files))) {
+    writeOne(relPath, content, false);
+  }
+  for (const [relPath, content] of Object.entries(asMap(runtime.binary_files))) {
+    writeOne(relPath, content, true);
+  }
+
+  if (written > 0 && !quiet) {
+    console.log(chalk.gray(`  ↓ ${written} runtime files (logs/, tmp/)`));
+  }
+  return written;
+}
+
 export async function sync(options = {}) {
   const config = loadConfig();
   if (!config) {
@@ -88,6 +143,9 @@ export async function sync(options = {}) {
         console.log(chalk.red(`  ${err.path}: ${err.error}`));
       }
     }
+
+    // Mirror server-side logs/ and tmp/ into the working copy for debugging.
+    await pullRuntime(tenantDir);
   } catch (err) {
     spinner.fail(err.message);
     process.exit(1);

package/src/commands/watch.js

@@ -20,9 +20,19 @@ export async function watch() {
   let syncTimer = null;
   const pendingDeletes = [];
 
+  // Watch only .php files, and explicitly ignore the runtime dirs that
+  // sync() writes back into the working copy — otherwise pullRuntime would
+  // re-trigger sync in an endless loop.
   const watcher = chokidar.watch(join(tenantDir, '**/*.php'), {
     ignoreInitial: true,
     awaitWriteFinish: { stabilityThreshold: 300 },
+    ignored: [
+      /(^|[\/\\])logs[\/\\]/,
+      /(^|[\/\\])tmp[\/\\]/,
+      /(^|[\/\\])\.claude[\/\\]/,
+      /(^|[\/\\])\.git[\/\\]/,
+      /(^|[\/\\])node_modules[\/\\]/,
+    ],
   });
 
   watcher.on('add', (path) => {