deepdebug-local-agent 1.0.22 → 1.0.23

package/src/adapters/oracle-forms/index.js

@@ -0,0 +1,145 @@
+// src/adapters/oracle-forms/index.js
+// OracleFormsLogAdapter — watches *.trc files in the configured Forms trace
+// dir; emits 6-key error events. AD-1 lifecycle, AD-3 polling, AD-4 byte-position
+// dedup with TAIL-on-startup default, AD-5 per-file ordering, AD-6 Latin-1
+// mojibake-trap tolerance via latin1 decode (never throws on any byte).
+// T-2-01 mitigation: default polling interval 5000 ms.
+
+import { EventEmitter } from 'node:events';
+import { stat, open } from 'node:fs/promises';
+import { join } from 'node:path';
+import chokidar from 'chokidar';
+import { extractFormsCode } from './oracle-forms-parser.js';
+
+const ADAPTER = 'oracle-forms';
+
+// Decode buffer using Latin-1 (single-byte) encoding — never throws on any
+// byte sequence. ORA/FRM message codes are ASCII so the regex match is
+// unaffected by the choice; accented free-text payload bytes survive into
+// `message` as Latin-1 characters (mojibake-tolerant per AD-6 Forms trap).
+function decodeTolerant(buf) {
+  return buf.toString('latin1');
+}
+
+export class OracleFormsLogAdapter extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.traceDir = config.traceDir || '/u01/oracle/forms/trace';
+    this.interval = config.interval ?? 5000;
+    this.replayOnStart = config.replayOnStart === true;
+    this._watcher = null;
+    this._offsets = new Map(); // filePath → byte offset
+    this._inodes = new Map();  // filePath → inode
+    this._isRunning = false;
+  }
+
+  get isRunning() {
+    return this._isRunning;
+  }
+
+  async start() {
+    if (this._isRunning) return;
+    this._isRunning = true;
+
+    // Glob bound to *.trc only (wildcard — chokidar polling-mode bracket-class
+    // workaround from Plan 02-08 does NOT apply here; *.trc is a plain wildcard).
+    const glob = join(this.traceDir, '*.trc');
+
+    this._watcher = chokidar.watch(glob, {
+      usePolling: true,
+      interval: this.interval,
+      ignoreInitial: false, // we handle initial ourselves via TAIL seek
+      awaitWriteFinish: false,
+    });
+
+    const onAdd = async (filePath) => {
+      if (this.replayOnStart) {
+        this._offsets.set(filePath, 0);
+        // fall through to _readNew below
+      } else {
+        try {
+          const st = await stat(filePath);
+          this._offsets.set(filePath, st.size);
+          this._inodes.set(filePath, st.ino);
+          return; // TAIL mode — don't emit pre-existing content
+        } catch {
+          return;
+        }
+      }
+      this._readNew(filePath).catch(() => { /* ENOENT silence */ });
+    };
+
+    this._watcher.on('add', onAdd);
+    this._watcher.on('change', (fp) => {
+      this._readNew(fp).catch(() => { /* ENOENT silence */ });
+    });
+
+    // Swallow chokidar's own bubbled errors (e.g., watch-path ENOENT) —
+    // dual-layer suppression with the per-read try/catch ensures full
+    // ENOENT silence (canonical pattern from Plan 02-07).
+    this._watcher.on('error', () => {});
+  }
+
+  async stop() {
+    if (!this._isRunning) return;
+    this._isRunning = false;
+    if (this._watcher) {
+      await this._watcher.close().catch(() => {});
+      this._watcher = null;
+    }
+    this._offsets.clear();
+    this._inodes.clear();
+  }
+
+  async _readNew(filePath) {
+    let st;
+    try {
+      st = await stat(filePath);
+    } catch {
+      return; // ENOENT silence
+    }
+
+    const lastOffset = this._offsets.get(filePath) ?? 0;
+    const lastInode = this._inodes.get(filePath);
+
+    // Rotation: inode changed OR size shrunk → reset to 0
+    if ((lastInode !== undefined && st.ino !== lastInode) || st.size < lastOffset) {
+      this._offsets.set(filePath, 0);
+      this._inodes.set(filePath, st.ino);
+      return this._readNew(filePath); // re-enter with offset=0
+    }
+    this._inodes.set(filePath, st.ino);
+
+    if (st.size <= lastOffset) return;
+
+    const fh = await open(filePath, 'r');
+    try {
+      const len = st.size - lastOffset;
+      const buf = Buffer.alloc(len);
+      await fh.read(buf, 0, len, lastOffset);
+      this._offsets.set(filePath, st.size);
+      const text = decodeTolerant(buf);
+      const lines = text.split(/\r?\n/);
+      const sourceDir = filePath.split('/').slice(0, -1).join('/');
+      for (const line of lines) {
+        if (line.trim().length === 0) continue;
+        const code = extractFormsCode(line);
+        if (!code) continue;
+        // 6-key frozen event payload (AD-4 contract — extra keys forbidden)
+        const event = Object.freeze({
+          adapter: ADAPTER,
+          errorCode: code,
+          file: filePath,
+          message: line,
+          source: sourceDir,
+          timestamp: new Date().toISOString(),
+        });
+        this.emit('error', event);
+      }
+    } finally {
+      await fh.close();
+    }
+  }
+}
+
+export default OracleFormsLogAdapter;

package/src/adapters/oracle-forms/oracle-forms-parser.js

@@ -0,0 +1,11 @@
+// src/adapters/oracle-forms/oracle-forms-parser.js
+// T-2-03 isolation surface: regex exported as a named const so it can be
+// unit-tested against arbitrary text decoupled from the file-watching
+// machinery in index.js. The watcher itself is bound to a literal *.trc
+// glob so this regex never engages arbitrary text by construction.
+export const ORACLE_FORMS_REGEX = /(?:Line \d+:|^)\s*(ORA-\d{5}|FRM-\d{5}):\s*(.+)/;
+
+export function extractFormsCode(line) {
+  const m = line.match(ORACLE_FORMS_REGEX);
+  return m ? m[1] : null;
+}

package/src/adapters/sap/index.js

@@ -0,0 +1,146 @@
+// src/adapters/sap/index.js
+// SapLogAdapter — watches dev_w* and SLOG* files; emits 6-key error events.
+// AD-1 lifecycle, AD-3 polling, AD-4 byte-position dedup, AD-5 per-file ordering.
+
+import { EventEmitter } from 'node:events';
+import { stat, open } from 'node:fs/promises';
+import { join } from 'node:path';
+import chokidar from 'chokidar';
+import { SAP_DEV_W_REGEX, SAP_SLOG_REGEX, normalizeDevWMatch, normalizeSlogMatch } from './sap-parser.js';
+
+const ADAPTER = 'sap';
+
+export class SapLogAdapter extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.sapDir = config.sapDir || '/usr/sap/PRD';
+    this.instanceNumber = config.instanceNumber || '00';
+    this.interval = config.interval ?? 5000;
+    this.replayOnStart = config.replayOnStart === true;
+    this._watchers = [];
+    this._offsets = new Map();   // filePath → byte offset
+    this._inodes = new Map();    // filePath → inode
+    this._isRunning = false;
+  }
+
+  get isRunning() { return this._isRunning; }
+
+  async start() {
+    if (this._isRunning) return;
+    this._isRunning = true;
+
+    const workGlob = join(this.sapDir, `D${this.instanceNumber}`, 'work', 'dev_w*');
+    const logGlob = join(this.sapDir, `D${this.instanceNumber}`, 'log', 'SLOG*');
+
+    const watcherOpts = {
+      usePolling: true,
+      interval: this.interval,
+      ignoreInitial: false, // we handle initial ourselves via TAIL seek
+      awaitWriteFinish: false,
+    };
+
+    const wWork = chokidar.watch(workGlob, watcherOpts);
+    const wSlog = chokidar.watch(logGlob, watcherOpts);
+
+    const handle = (filePath, kind) => {
+      // ENOENT-tolerant: stat() inside _readNew handles disappearance.
+      this._readNew(filePath, kind).catch(() => { /* swallow per ENOENT silence rule */ });
+    };
+
+    // 'add' fires for files present at watch start; honor TAIL/replay flag.
+    const onAdd = (kind) => async (filePath) => {
+      if (this.replayOnStart) {
+        this._offsets.set(filePath, 0);
+      } else {
+        try {
+          const st = await stat(filePath);
+          this._offsets.set(filePath, st.size);
+          this._inodes.set(filePath, st.ino);
+          return; // TAIL mode — don't emit pre-existing content
+        } catch { return; }
+      }
+      handle(filePath, kind);
+    };
+
+    wWork.on('add', onAdd('dev_w'));
+    wWork.on('change', (fp) => handle(fp, 'dev_w'));
+    wSlog.on('add', onAdd('slog'));
+    wSlog.on('change', (fp) => handle(fp, 'slog'));
+
+    // chokidar's 'error' events would otherwise bubble; swallow to keep ENOENT silent.
+    wWork.on('error', () => {});
+    wSlog.on('error', () => {});
+
+    this._watchers.push(wWork, wSlog);
+  }
+
+  async stop() {
+    if (!this._isRunning) return;
+    this._isRunning = false;
+    await Promise.all(this._watchers.map((w) => w.close().catch(() => {})));
+    this._watchers = [];
+    this._offsets.clear();
+    this._inodes.clear();
+  }
+
+  async _readNew(filePath, kind) {
+    let st;
+    try { st = await stat(filePath); } catch { return; } // ENOENT silence
+
+    const lastOffset = this._offsets.get(filePath) ?? 0;
+    const lastInode = this._inodes.get(filePath);
+
+    // Rotation: inode changed OR size shrunk → reset to 0
+    if ((lastInode !== undefined && st.ino !== lastInode) || st.size < lastOffset) {
+      this._offsets.set(filePath, 0);
+      this._inodes.set(filePath, st.ino);
+      return this._readNew(filePath, kind); // re-enter with offset=0
+    }
+    this._inodes.set(filePath, st.ino);
+
+    if (st.size <= lastOffset) return;
+
+    const fh = await open(filePath, 'r');
+    try {
+      const len = st.size - lastOffset;
+      const buf = Buffer.alloc(len);
+      await fh.read(buf, 0, len, lastOffset);
+      this._offsets.set(filePath, st.size);
+      // Tolerate CRLF and LF; split, drop trailing empty (no event for blank lines per AD-6 SAP empty-line trap).
+      const text = buf.toString('utf8');
+      const lines = text.split(/\r?\n/);
+      const sourceDir = filePath.split('/').slice(0, -1).join('/');
+      for (const line of lines) {
+        if (line.trim().length === 0) continue;
+        this._tryEmit(line, filePath, sourceDir, kind);
+      }
+    } finally {
+      await fh.close();
+    }
+  }
+
+  _tryEmit(line, filePath, sourceDir, kind) {
+    let errorCode = null;
+    if (kind === 'dev_w') {
+      const m = line.match(SAP_DEV_W_REGEX);
+      errorCode = normalizeDevWMatch(m);
+    } else if (kind === 'slog') {
+      const m = line.match(SAP_SLOG_REGEX);
+      errorCode = normalizeSlogMatch(m);
+    }
+    if (errorCode === null) return; // no recognizable code → no event
+
+    // 6-key frozen event payload (AD-4 contract — extra keys forbidden)
+    const event = Object.freeze({
+      adapter: ADAPTER,
+      errorCode,
+      file: filePath,
+      message: line,
+      source: sourceDir,
+      timestamp: new Date().toISOString(),
+    });
+    this.emit('error', event);
+  }
+}
+
+export default SapLogAdapter;

package/src/adapters/sap/sap-parser.js

@@ -0,0 +1,41 @@
+// src/adapters/sap/sap-parser.js
+// T-2-03 mitigation: regexes exported as named constants for isolated testing.
+// Adapter binds chokidar to dev_w* and SLOG* file globs only; these regexes
+// never run against arbitrary text by the adapter itself.
+
+// Matches ABAP work-process trace error lines:
+//   "M  *** ERROR => Runtime error CONVT_NO_NUMBER"
+//   "M  *** ERROR => Exception condition CX_SY_OPEN_SQL_DB raised"
+//   "B  *** ERROR => SQL error in SELECT, sy-subrc = 4"
+export const SAP_DEV_W_REGEX = /\*\*\* ERROR =>\s+(?:Runtime error|Exception condition|SQL error in [A-Z]+,)\s*([A-Z_]+(?:[A-Z_0-9]*)|sy-subrc\s*=\s*\d+)/i;
+
+// Matches SLOG pipe-delimited error/fatal records:
+//   "| 2024-01-15 09:12:44 | E | 04 | Database error..., sy-subrc = 4 |"
+//   "| 2024-01-15 14:01:55 | F | 22 | Short dump 4815162343 created |"
+export const SAP_SLOG_REGEX = /^\|\s*\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\s*\|\s*([EF])\s*\|\s*\d+\s*\|\s*(.+?)\s*\|/;
+
+// Normalizes captured payload to errorCode string (or null when no recognizable code).
+export function normalizeDevWMatch(match) {
+  if (!match) return null;
+  const raw = (match[1] || '').trim();
+  if (/^sy-subrc/i.test(raw)) {
+    const m = raw.match(/=\s*(\d+)/);
+    return m ? `SY-SUBRC=${m[1]}` : 'SY-SUBRC';
+  }
+  return raw.toUpperCase();
+}
+
+export function normalizeSlogMatch(match) {
+  if (!match) return null;
+  const body = (match[2] || '').trim();
+  // Try to extract a known runtime-error keyword from the SLOG message body
+  const m = body.match(/(CONVT_NO_NUMBER|CX_SY_OPEN_SQL_DB|sy-subrc\s*=\s*\d+|Short dump \d+)/i);
+  if (!m) return null;
+  const cap = m[1].trim();
+  if (/^sy-subrc/i.test(cap)) {
+    const num = cap.match(/=\s*(\d+)/);
+    return num ? `SY-SUBRC=${num[1]}` : 'SY-SUBRC';
+  }
+  if (/^Short dump/i.test(cap)) return 'SHORT_DUMP';
+  return cap.toUpperCase();
+}

package/src/server.js

@@ -25,6 +25,7 @@ import { ConfigAnalyzer } from "./analyzers/config-analyzer.js";
 import { WorkspaceManager } from "./workspace-manager.js";
 import { startMCPHttpServer } from "./mcp-http-server.js";
 import { registerVercelRoutes } from "./vercel-proxy.js";
+import { loadAdapters, stopAll } from "./adapters/index.js";
 
 const execAsync = promisify(exec);
 
@@ -541,6 +542,10 @@ class AIVibeCodingEngine extends EventEmitter {
 // Instncia global do AI Engine
 let aiEngine = null;
 
+// Phase 2 — Legacy connector adapters (lifecycle owned by SIGTERM/SIGINT handlers below).
+// Populated at boot from LEGACY_STACKS env var; empty when env var unset (zero-regression).
+let _legacyAdapters = [];
+
 const app = express();
 
 //  FIXED: Support Cloud Run PORT environment variable (GCP uses PORT)
@@ -644,6 +649,31 @@ const MCP_PORT = process.env.MCP_PORT || 5056;
 //  Inicializar AI Vibe Coding Engine
 aiEngine = new AIVibeCodingEngine(processManager, () => WORKSPACE_ROOT);
 
+// Phase 2 — bootstrap legacy connectors from LEGACY_STACKS env var.
+// Adapters are loaded UNSTARTED by the registry (AD-1); we start them inline so that
+// the existing local-agent flow is byte-for-byte unchanged when LEGACY_STACKS is unset.
+// Errors during start surface via the adapter's own 'error' event; the loop never throws.
+try {
+    const stacks = (process.env.LEGACY_STACKS || '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (stacks.length > 0) {
+        _legacyAdapters = loadAdapters({ legacyStacks: stacks });
+        for (const a of _legacyAdapters) {
+            // Start failures are surfaced via the adapter's 'error' event; do not crash boot.
+            Promise.resolve()
+                .then(() => a.start())
+                .catch((err) => {
+                    process.stderr.write(`legacy-connectors: ${a.constructor.name}.start() failed: ${err.message}\n`);
+                });
+        }
+    }
+} catch (err) {
+    // Bad LEGACY_STACKS = programmer/operator error; emit to stderr without crashing boot.
+    process.stderr.write(`legacy-connectors: ${err.message}\n`);
+}
+
 // ============================================
 //  BACKUP STORAGE (Sprint 1.3)
 // In-memory backup storage with configurable max size
@@ -6250,8 +6280,22 @@ async function startWebSocketTunnel(port, gatewayUrl, apiKey, tenantId) {
         }
     }
 
-    process.on('SIGINT', () => { isShuttingDown = true; if (ws) ws.close(); });
-    process.on('SIGTERM', () => { isShuttingDown = true; if (ws) ws.close(); });
+    process.on('SIGINT', async () => {
+        isShuttingDown = true;
+        if (ws) ws.close();
+        // Phase 2: graceful shutdown of legacy connectors (AC-11; bounded to 5 s).
+        try { await stopAll(_legacyAdapters, 5000); } catch (_) { /* never block exit */ }
+        // Preserve existing process model: signal trap does NOT call process.exit();
+        // Node exits naturally once the event loop drains.
+    });
+    process.on('SIGTERM', async () => {
+        isShuttingDown = true;
+        if (ws) ws.close();
+        // Phase 2: graceful shutdown of legacy connectors (AC-11; bounded to 5 s).
+        try { await stopAll(_legacyAdapters, 5000); } catch (_) { /* never block exit */ }
+        // Preserve existing process model: signal trap does NOT call process.exit();
+        // Node exits naturally once the event loop drains.
+    });
     connect();
 }
 

package/test/adapters/as400/as400.test.js

@@ -0,0 +1,121 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { As400LogAdapter } from '../../../src/adapters/as400/index.js';
+import { AS400_MSGID_REGEX } from '../../../src/adapters/as400/as400-parser.js';
+
+// Stub ssh2.Client — supports .connect(), .exec(callback), .on('close'/'error'/'ready'), .end()
+class StubSshClient extends EventEmitter {
+  constructor() {
+    super();
+    this.connectCalls = [];
+    this.execCalls = [];
+    this._channels = [];
+    this._cannedOutput = '';
+  }
+  connect(opts) {
+    this.connectCalls.push(opts);
+    // emit 'ready' on next tick
+    process.nextTick(() => this.emit('ready'));
+  }
+  exec(cmd, cb) {
+    this.execCalls.push(cmd);
+    const stream = new EventEmitter();
+    stream.stderr = new EventEmitter();
+    process.nextTick(() => {
+      cb(null, stream);
+      // Push canned output then close.
+      stream.emit('data', Buffer.from(this._cannedOutput || ''));
+      stream.emit('close', 0);
+    });
+    this._channels.push(stream);
+  }
+  end() {
+    process.nextTick(() => this.emit('close'));
+  }
+  setCannedOutput(text) { this._cannedOutput = text; }
+}
+
+describe('As400LogAdapter', () => {
+  test('constructor sets keepalive defaults (T-2-02)', () => {
+    const adapter = new As400LogAdapter({ host: '1.2.3.4', username: 'u', password: 'p' });
+    assert.equal(adapter._sshOpts.keepaliveInterval, 30000);
+    assert.equal(adapter._sshOpts.keepaliveCountMax, 3);
+  });
+
+  test('emits 6-key event for CPF/MCH/SQL lines (AC-2)', async () => {
+    const stub = new StubSshClient();
+    stub.setCannedOutput([
+      'CPF1234 ERROR Job DAILY01 ended abnormally',
+      'INFO  This line should not match',
+      'MCH3601 Pointer not set for location *N',
+      ''
+    ].join('\n'));
+    const adapter = new As400LogAdapter({
+      host: '1.2.3.4', username: 'u', password: 'p',
+      pollInterval: 100, sshClientFactory: () => stub,
+    });
+    const events = [];
+    adapter.on('error', (e) => events.push(e));
+    await adapter.start();
+    await sleep(400);
+    await adapter.stop();
+    assert.ok(events.length >= 2, `expected 2 events, got ${events.length}`);
+    const e = events[0];
+    assert.equal(Object.keys(e).sort().join(','), 'adapter,errorCode,file,message,source,timestamp');
+    assert.equal(e.adapter, 'as400');
+    assert.match(e.errorCode, /^(CPF|MCH|SQL)\d{4}$/);
+  });
+
+  test('non-matching lines do not emit', async () => {
+    const stub = new StubSshClient();
+    stub.setCannedOutput('INFO Just an info line\nDEBUG diag\n');
+    const adapter = new As400LogAdapter({
+      host: '1.2.3.4', username: 'u', password: 'p',
+      pollInterval: 100, sshClientFactory: () => stub,
+    });
+    const events = [];
+    adapter.on('error', (e) => events.push(e));
+    await adapter.start();
+    await sleep(400);
+    await adapter.stop();
+    assert.equal(events.length, 0);
+  });
+
+  test('reconnect on close with exponential backoff (T-2-02)', async () => {
+    const factories = [];
+    const adapter = new As400LogAdapter({
+      host: '1.2.3.4', username: 'u', password: 'p',
+      pollInterval: 60000, // no poll churn
+      sshClientFactory: () => { const s = new StubSshClient(); factories.push(s); return s; },
+      backoffSchedule: [50, 100, 200], // shortened for test
+    });
+    await adapter.start();
+    await sleep(50);
+    // First client connected; force a close.
+    assert.ok(factories.length >= 1);
+    factories[0].emit('close');
+    await sleep(200); // wait for first backoff (50ms) to fire reconnect
+    assert.ok(factories.length >= 2, 'reconnect must spawn a second client after close');
+    await adapter.stop();
+  });
+
+  test('lifecycle idempotent (AC-1)', async () => {
+    const stub = new StubSshClient();
+    const adapter = new As400LogAdapter({
+      host: '1.2.3.4', username: 'u', password: 'p',
+      pollInterval: 60000, sshClientFactory: () => stub,
+    });
+    await adapter.start();
+    await adapter.start();
+    await adapter.stop();
+    await adapter.stop();
+  });
+
+  test('parser regex exported and isolated', () => {
+    assert.ok(AS400_MSGID_REGEX instanceof RegExp);
+    assert.ok('CPF1234 ...'.match(AS400_MSGID_REGEX));
+    assert.equal('INFO ...'.match(AS400_MSGID_REGEX), null);
+  });
+});