@mndrk/agx 2.0.0 → 2.0.2

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/projectors/notificationProjector.js

@@ -1,351 +0,0 @@
-/**
- * lib/projectors/notificationProjector.js
- *
- * Notification projector — consumes the task_audit_log event stream and
- * materialises rows into the notifications + notification_outbox tables.
- *
- * Design goals:
- *  - Durable per-consumer cursor (restarts from last position after crash)
- *  - Idempotent via UNIQUE (event_id, user_id, type) → INSERT OR IGNORE
- *  - 5-second debounce for blocked↔running state flapping
- *  - Notification + outbox written in a single SQLite transaction
- *  - TTL prune job (60-90 days retention) callable on demand or on a schedule
- *  - At-least-once from event stream; exactly-once effect via DB unique key
- *
- * Event source: task_audit_log (rowid used as sequence number / cursor position)
- *
- * Usage:
- *   const projector = require('./notificationProjector');
- *   projector.start();          // begin polling loop
- *   projector.stop();           // graceful shutdown
- *   projector.runOnce();        // process pending events once (testing / CLI)
- *   projector.pruneOld();       // delete notifications older than TTL
- */
-
-'use strict';
-
-const { getSQLiteDb } = require('../sqlite-query-adapter');
-const { readCursor, advanceCursorInTxn } = require('../db/cursors');
-const { shouldNotify } = require('../db/preferences');
-const { pruneOldNotifications } = require('../db/notifications');
-const pruneJob = require('../jobs/pruneNotifications');
-
-// ── Constants ───────────────────────────────────────────────────────────────
-
-const CONSUMER_ID = 'notification_projector';
-const POLL_INTERVAL_MS = 2000;         // how often to poll for new events
-const BATCH_SIZE = 100;                // events per poll cycle
-const DEBOUNCE_MS = 5000;             // 5 s debounce for blocked↔running flap
-const TTL_DAYS_MIN = 60;
-const TTL_DAYS_MAX = 90;
-const MAX_UNREAD_PER_USER = 500;       // cap on unread notifications per user
-
-// Mapping from task_audit_log.action → notification type + tier + title template
-const ACTION_MAP = {
-  complete: { type: 'task.completed', tier: 'success', titleFn: (t) => `Task completed: ${t.title || t.id}` },
-  fail:     { type: 'task.failed',    tier: 'error',   titleFn: (t) => `Task failed: ${t.title || t.id}` },
-  reject:   { type: 'task.rejected',  tier: 'warning', titleFn: (t) => `Task rejected: ${t.title || t.id}` },
-  dispatch: { type: 'task.created',   tier: 'info',    titleFn: (t) => `Task created: ${t.title || t.id}` },
-  execute:  { type: 'task.started',   tier: 'info',    titleFn: (t) => `Task started: ${t.title || t.id}` },
-};
-
-// Actions that are subject to debounce (blocked↔running flapping)
-const DEBOUNCE_ACTIONS = new Set(['execute']);    // running state
-const DEBOUNCE_PAIR   = new Set(['execute']);     // keep symmetric for future blocked action
-
-// ── Debounce state machine ──────────────────────────────────────────────────
-// In-memory map: taskId → { lastAction, lastTs }
-// Scoped to this module; reset on process restart (safe — DB unique key is the guard)
-
-const _debounceState = new Map(); // taskId → { action, ts }
-
-/**
- * Check if an event should be suppressed by the debounce window.
- * We suppress a `blocked` event that follows a `running` event (or vice versa)
- * within DEBOUNCE_MS of the previous one.
- *
- * For simplicity, we track the last emitted action per task and suppress if
- * the new action is in {blocked, running} and the previous was too, within 5s.
- *
- * @param {string} taskId
- * @param {string} action  - audit log action
- * @param {number} eventTs - epoch ms of the event
- * @returns {boolean} true if this event should be dropped (debounced)
- */
-function isDebounced(taskId, action, eventTs) {
-  const FLAP_ACTIONS = new Set(['execute']); // 'blocked' is not in audit_log; extend here when added
-  if (!FLAP_ACTIONS.has(action)) return false;
-
-  const prev = _debounceState.get(taskId);
-  if (!prev) {
-    _debounceState.set(taskId, { action, ts: eventTs });
-    return false;
-  }
-
-  const elapsed = eventTs - prev.ts;
-  if (FLAP_ACTIONS.has(prev.action) && elapsed < DEBOUNCE_MS) {
-    // Same class of flapping event within window — suppress
-    return true;
-  }
-
-  _debounceState.set(taskId, { action, ts: eventTs });
-  return false;
-}
-
-// ── Core projection logic ───────────────────────────────────────────────────
-
-/**
- * Fetch up to BATCH_SIZE unprocessed events from task_audit_log after cursor.
- *
- * @param {import('better-sqlite3').Database} db
- * @param {number} afterRowid
- * @returns {Array<{rowid, id, task_id, user_id, action, payload, dispatched_at}>}
- */
-function fetchEvents(db, afterRowid) {
-  return db.prepare(`
-    SELECT
-      rowid,
-      id,
-      task_id,
-      user_id,
-      action,
-      payload,
-      dispatched_at
-    FROM task_audit_log
-    WHERE rowid > ?
-    ORDER BY rowid ASC
-    LIMIT ?
-  `).all(afterRowid, BATCH_SIZE);
-}
-
-/**
- * Fetch task metadata needed for notification title/body.
- * Returns null if the task no longer exists.
- *
- * @param {import('better-sqlite3').Database} db
- * @param {string} taskId
- * @returns {{id, title, slug, user_id}|null}
- */
-function getTask(db, taskId) {
-  return db.prepare(
-    'SELECT id, title, slug, user_id FROM tasks WHERE id = ?'
-  ).get(taskId) || null;
-}
-
-// shouldNotify is imported from ../db/preferences — see that module for resolution order:
-//   1. Task-level (tasks.stage_decisions.notifications[type])
-//   2. User-level (user_settings.notification_prefs[type])
-//   3. Global default → true
-
-/**
- * Write one notification + its outbox row atomically.
- * Uses INSERT OR IGNORE so duplicate event_id+user_id+type is a no-op.
- *
- * @param {import('better-sqlite3').Database} db
- * @param {{ eventId, userId, taskId, type, tier, title, body, payload }} row
- */
-function insertNotificationAndOutbox(db, { eventId, userId, taskId, type, tier, title, body, payload }) {
-  // INSERT OR IGNORE — idempotent via UNIQUE(event_id, user_id, type)
-  const result = db.prepare(`
-    INSERT OR IGNORE INTO notifications (user_id, task_id, event_id, type, tier, title, body)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `).run(userId, taskId, eventId, type, tier, title, body ?? null);
-
-  // Only write outbox if a row was actually inserted (changes = 1)
-  if (result.changes > 0) {
-    const notifRow = db.prepare(
-      'SELECT id FROM notifications WHERE event_id = ? AND user_id = ? AND type = ?'
-    ).get(eventId, userId, type);
-
-    if (notifRow) {
-      db.prepare(`
-        INSERT INTO notification_outbox (notification_id, payload)
-        VALUES (?, ?)
-      `).run(notifRow.id, JSON.stringify(payload));
-    }
-  }
-}
-
-/**
- * Cap unread notifications per user to MAX_UNREAD_PER_USER by marking
- * the oldest ones as read. Runs inside the same transaction.
- *
- * @param {import('better-sqlite3').Database} db
- * @param {string} userId
- */
-function capUnread(db, userId) {
-  const count = db.prepare(
-    'SELECT COUNT(*) AS n FROM notifications WHERE user_id = ? AND read_at IS NULL'
-  ).get(userId)?.n ?? 0;
-
-  if (count > MAX_UNREAD_PER_USER) {
-    const excess = count - MAX_UNREAD_PER_USER;
-    db.prepare(`
-      UPDATE notifications SET read_at = strftime('%Y-%m-%dT%H:%M:%fZ','now')
-      WHERE id IN (
-        SELECT id FROM notifications
-        WHERE user_id = ? AND read_at IS NULL
-        ORDER BY created_at ASC
-        LIMIT ?
-      )
-    `).run(userId, excess);
-  }
-}
-
-/**
- * Process one batch of events. Returns the number of events processed.
- *
- * @returns {number}
- */
-function processBatch() {
-  const db = getSQLiteDb();
-  const cursor = readCursor(CONSUMER_ID);
-  const events = fetchEvents(db, cursor);
-
-  if (events.length === 0) return 0;
-
-  let lastRowid = cursor;
-  const affectedUsers = new Set();
-
-  // Use a single transaction for the entire batch
-  const runBatch = db.transaction(() => {
-    for (const event of events) {
-      lastRowid = event.rowid;
-
-      const mapping = ACTION_MAP[event.action];
-      if (!mapping) continue; // unrecognised action — skip but advance cursor
-
-      const taskId = event.task_id;
-      const userId = event.user_id;
-      if (!taskId || !userId) continue;
-
-      const task = getTask(db, taskId);
-      if (!task) continue; // task deleted — skip
-
-      const eventTs = event.dispatched_at
-        ? new Date(event.dispatched_at).getTime()
-        : Date.now();
-
-      // Debounce check for flapping states
-      if (isDebounced(taskId, event.action, eventTs)) continue;
-
-      // Task-level / user-level preference check (lib/db/preferences.js)
-      if (!shouldNotify(db, taskId, userId, mapping.type)) continue;
-
-      const title = mapping.titleFn(task);
-      let payload;
-      try {
-        payload = typeof event.payload === 'string' ? JSON.parse(event.payload) : (event.payload || {});
-      } catch {
-        payload = {};
-      }
-
-      const outboxPayload = {
-        eventType: mapping.type,
-        taskId,
-        userId,
-        title,
-        slug: task.slug || null,
-        timestamp: event.dispatched_at || new Date().toISOString(),
-        details: payload,
-      };
-
-      insertNotificationAndOutbox(db, {
-        eventId: event.id,           // audit log UUID — stable dedup key
-        userId,
-        taskId,
-        type: mapping.type,
-        tier: mapping.tier,
-        title,
-        body: payload.error || payload.reason || null,
-        payload: outboxPayload,
-      });
-
-      affectedUsers.add(userId);
-    }
-
-    // Cap unread per user after batch
-    for (const uid of affectedUsers) {
-      capUnread(db, uid);
-    }
-
-    // Advance cursor atomically with the inserts
-    advanceCursorInTxn(db, CONSUMER_ID, lastRowid);
-  });
-
-  runBatch();
-  return events.length;
-}
-
-// ── TTL / prune job ─────────────────────────────────────────────────────────
-
-/**
- * Delete notifications older than TTL_DAYS_MIN (60) days.
- * Runs a second pass to also prune read notifications older than TTL_DAYS_MAX (90) days.
- * Safe to call at any time — does not interact with the cursor.
- *
- * @returns {{ deleted: number }}
- */
-function pruneOld() {
-  const { deleted } = pruneOldNotifications({ minDays: TTL_DAYS_MIN, maxDays: TTL_DAYS_MAX });
-  if (deleted > 0) {
-    console.log(`[notificationProjector] pruned ${deleted} old notifications`);
-  }
-  return { deleted };
-}
-
-// ── Polling loop ────────────────────────────────────────────────────────────
-
-let _timer = null;
-let _running = false;
-
-/**
- * Start the projector polling loop.
- * Safe to call multiple times — subsequent calls are no-ops.
- */
-function start() {
-  if (_running) return;
-  _running = true;
-  console.log(`[notificationProjector] starting (consumer=${CONSUMER_ID}, poll=${POLL_INTERVAL_MS}ms)`);
-  pruneJob.start();
-
-  const tick = () => {
-    if (!_running) return;
-    try {
-      const n = processBatch();
-      if (n > 0) {
-        console.debug(`[notificationProjector] processed ${n} events`);
-      }
-    } catch (err) {
-      console.error('[notificationProjector] error in batch', err);
-    }
-    if (_running) {
-      _timer = setTimeout(tick, POLL_INTERVAL_MS);
-    }
-  };
-
-  _timer = setTimeout(tick, 0);
-}
-
-/**
- * Stop the projector polling loop gracefully.
- */
-function stop() {
-  _running = false;
-  if (_timer) {
-    clearTimeout(_timer);
-    _timer = null;
-  }
-  pruneJob.stop();
-  console.log('[notificationProjector] stopped');
-}
-
-/**
- * Run a single batch synchronously (useful for tests and CLI replay).
- * @returns {number} number of events processed
- */
-function runOnce() {
-  return processBatch();
-}
-
-module.exports = { start, stop, runOnce, pruneOld, CONSUMER_ID };

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/sqlite.ts

@@ -1,61 +0,0 @@
-// Shim to bypass Turbopack's external module hashing for better-sqlite3.
-// Turbopack appends a content hash to externalized module names (e.g.
-// "better-sqlite3-e930ad348bee7320") which breaks resolution at runtime.
-// Using createRequire avoids Turbopack's static analysis.
-// Lazy-loaded to avoid errors during Next.js build-time page data collection.
-import { createRequire } from "module";
-import path from "path";
-import type BetterSqlite3 from "better-sqlite3";
-
-let _Database: typeof BetterSqlite3 | null = null;
-
-function getDatabase(): typeof BetterSqlite3 {
-  if (!_Database) {
-    // Try multiple resolve roots — __filename is virtual in Turbopack dev mode,
-    // and process.cwd() may not contain better-sqlite3 in standalone deployments.
-    const anchors = [
-      path.resolve(process.cwd(), "package.json"),
-      // In standalone builds, process.argv[1] is server.js in the app dir
-      process.argv[1] ? path.resolve(path.dirname(process.argv[1]), "package.json") : "",
-    ].filter(Boolean);
-
-    for (const anchor of anchors) {
-      try {
-        const req = createRequire(anchor);
-        _Database = req("better-sqlite3") as typeof BetterSqlite3;
-        break;
-      } catch {
-        // try next anchor
-      }
-    }
-    if (!_Database) {
-      throw new Error("Could not load better-sqlite3 from any known path");
-    }
-  }
-  return _Database;
-}
-
-// Proxy so callers can use `Database(path)` as a constructor and `Database.Database` as a type.
-const Database = new Proxy(function () {} as unknown as typeof BetterSqlite3, {
-  construct(_target, args) {
-    const Db = getDatabase();
-    return new (Db as unknown as new (...a: unknown[]) => BetterSqlite3.Database)(...args);
-  },
-  apply(_target, _thisArg, args) {
-    const Db = getDatabase();
-    return (Db as unknown as (...a: unknown[]) => unknown)(...args);
-  },
-  get(_target, prop) {
-    const Db = getDatabase();
-    return (Db as unknown as Record<string | symbol, unknown>)[prop];
-  },
-});
-
-namespace Database {
-  export type Database = BetterSqlite3.Database;
-  export type Statement<BindParameters extends unknown[] | {} = unknown[]> = BetterSqlite3.Statement<BindParameters>;
-  export type Options = BetterSqlite3.Options;
-  export type BackupMetadata = BetterSqlite3.BackupMetadata;
-}
-
-export default Database;

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/node_modules/better-sqlite3/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2017 Joshua Wise
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/node_modules/better-sqlite3/README.md

@@ -1,99 +0,0 @@
-# better-sqlite3 [![Build Status](https://github.com/JoshuaWise/better-sqlite3/actions/workflows/build.yml/badge.svg)](https://github.com/JoshuaWise/better-sqlite3/actions/workflows/build.yml?query=branch%3Amaster)
-
-The fastest and simplest library for SQLite in Node.js.
-
-- Full transaction support
-- High performance, efficiency, and safety
-- Easy-to-use synchronous API *(better concurrency than an asynchronous API... yes, you read that correctly)*
-- Support for user-defined functions, aggregates, virtual tables, and extensions
-- 64-bit integers *(invisible until you need them)*
-- Worker thread support *(for large/slow queries)*
-
-## Help this project stay strong! 💪
-
-`better-sqlite3` is used by thousands of developers and engineers on a daily basis. Long nights and weekends were spent keeping this project strong and dependable, with no ask for compensation or funding, until now. If your company uses `better-sqlite3`, ask your manager to consider supporting the project:
-
-- [Become a GitHub sponsor](https://github.com/sponsors/JoshuaWise)
-- [Become a backer on Patreon](https://www.patreon.com/joshuawise)
-- [Make a one-time donation on PayPal](https://www.paypal.me/joshuathomaswise)
-
-## How other libraries compare
-
-|   |select 1 row  `get()` |select 100 rows   `all()`  |select 100 rows `iterate()` 1-by-1|insert 1 row `run()`|insert 100 rows in a transaction|
-|---|---|---|---|---|---|
-|better-sqlite3|1x|1x|1x|1x|1x|
-|[sqlite](https://www.npmjs.com/package/sqlite) and [sqlite3](https://www.npmjs.com/package/sqlite3)|11.7x slower|2.9x slower|24.4x slower|2.8x slower|15.6x slower|
-
-> You can verify these results by [running the benchmark yourself](./docs/benchmark.md).
-
-## Installation
-
-```bash
-npm install better-sqlite3
-```
-
-> Requires Node.js v14.21.1 or later. Prebuilt binaries are available for [LTS versions](https://nodejs.org/en/about/releases/). If you have trouble installing, check the [troubleshooting guide](./docs/troubleshooting.md).
-
-## Usage
-
-```js
-const db = require('better-sqlite3')('foobar.db', options);
-
-const row = db.prepare('SELECT * FROM users WHERE id = ?').get(userId);
-console.log(row.firstName, row.lastName, row.email);
-```
-
-Though not required, [it is generally important to set the WAL pragma for performance reasons](https://github.com/WiseLibs/better-sqlite3/blob/master/docs/performance.md).
-
-```js
-db.pragma('journal_mode = WAL');
-```
-
-##### In ES6 module notation:
-
-```js
-import Database from 'better-sqlite3';
-const db = new Database('foobar.db', options);
-db.pragma('journal_mode = WAL');
-```
-
-## Why should I use this instead of [node-sqlite3](https://github.com/mapbox/node-sqlite3)?
-
-- `node-sqlite3` uses asynchronous APIs for tasks that are either CPU-bound or serialized. That's not only bad design, but it wastes tons of resources. It also causes [mutex thrashing](https://en.wikipedia.org/wiki/Resource_contention) which has devastating effects on performance.
-- `node-sqlite3` exposes low-level (C language) memory management functions. `better-sqlite3` does it the JavaScript way, allowing the garbage collector to worry about memory management.
-- `better-sqlite3` is simpler to use, and it provides nice utilities for some operations that are very difficult or impossible in `node-sqlite3`.
-- `better-sqlite3` is much faster than `node-sqlite3` in most cases, and just as fast in all other cases.
-
-#### When is this library not appropriate?
-
-In most cases, if you're attempting something that cannot be reasonably accomplished with `better-sqlite3`, it probably cannot be reasonably accomplished with SQLite in general. For example, if you're executing queries that take one second to complete, and you expect to have many concurrent users executing those queries, no amount of asynchronicity will save you from SQLite's serialized nature. Fortunately, SQLite is very *very* fast. With proper indexing, we've been able to achieve upward of 2000 queries per second with 5-way-joins in a 60 GB database, where each query was handling 5–50 kilobytes of real data.
-
-If you have a performance problem, the most likely causes are inefficient queries, improper indexing, or a lack of [WAL mode](./docs/performance.md)—not `better-sqlite3` itself. However, there are some cases where `better-sqlite3` could be inappropriate:
-
-- If you expect a high volume of concurrent reads each returning many megabytes of data (i.e., videos)
-- If you expect a high volume of concurrent writes (i.e., a social media site)
-- If your database's size is near the terabyte range
-
-For these situations, you should probably use a full-fledged RDBMS such as [PostgreSQL](https://www.postgresql.org/).
-
-## Upgrading
-
-Upgrading your `better-sqlite3` dependency can potentially introduce breaking changes, either in the `better-sqlite3` API (if you upgrade to a new [major version](https://semver.org/)), or between your existing database(s) and the underlying version of SQLite. Before upgrading, review:
-
-* [`better-sqlite3` release notes](https://github.com/WiseLibs/better-sqlite3/releases)
-* [SQLite release history](https://www.sqlite.org/changes.html)
-
-# Documentation
-
-- [API documentation](./docs/api.md)
-- [Performance](./docs/performance.md) (also see [benchmark results](./docs/benchmark.md))
-- [64-bit integer support](./docs/integer.md)
-- [Worker thread support](./docs/threads.md)
-- [Unsafe mode (advanced)](./docs/unsafe.md)
-- [SQLite compilation (advanced)](./docs/compilation.md)
-- [Contribution rules](./docs/contribution.md)
-- [Code of conduct](./docs/conduct.md)
-
-# License
-
-[MIT](./LICENSE)

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/node_modules/better-sqlite3/binding.gyp

@@ -1,38 +0,0 @@
-# ===
-# This is the main GYP file, which builds better-sqlite3 with SQLite itself.
-# ===
-
-{
-  'includes': ['deps/common.gypi'],
-  'targets': [
-    {
-      'target_name': 'better_sqlite3',
-      'dependencies': ['deps/sqlite3.gyp:sqlite3'],
-      'sources': ['src/better_sqlite3.cpp'],
-      'cflags_cc': ['-std=c++20'],
-      'xcode_settings': {
-        'OTHER_CPLUSPLUSFLAGS': ['-std=c++20', '-stdlib=libc++'],
-      },
-      'msvs_settings': {
-        'VCCLCompilerTool': {
-          'AdditionalOptions': [
-            '/std:c++20',
-          ],
-        },
-      },
-      'conditions': [
-        ['OS=="linux"', {
-          'ldflags': [
-            '-Wl,-Bsymbolic',
-            '-Wl,--exclude-libs,ALL',
-          ],
-        }],
-      ],
-    },
-    {
-      'target_name': 'test_extension',
-      'dependencies': ['deps/sqlite3.gyp:sqlite3'],
-      'conditions': [['sqlite3 == ""', { 'sources': ['deps/test_extension.c'] }]],
-    },
-  ],
-}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/node_modules/better-sqlite3/deps/common.gypi

@@ -1,68 +0,0 @@
-# ===
-# This configuration defines the differences between Release and Debug builds.
-# Some miscellaneous Windows settings are also defined here.
-# ===
-
-{
-  'variables': { 'sqlite3%': '' },
-  'target_defaults': {
-    'default_configuration': 'Release',
-    'msvs_settings': {
-      'VCCLCompilerTool': {
-        'ExceptionHandling': 1,
-      },
-    },
-    'conditions': [
-      ['OS == "win"', {
-        'defines': ['WIN32'],
-      }],
-    ],
-    'configurations': {
-      'Debug': {
-        'defines!': [
-          'NDEBUG',
-        ],
-        'defines': [
-          'DEBUG',
-          '_DEBUG',
-          'SQLITE_DEBUG',
-          'SQLITE_MEMDEBUG',
-          'SQLITE_ENABLE_API_ARMOR',
-          'SQLITE_WIN32_MALLOC_VALIDATE',
-        ],
-        'cflags': [
-          '-O0',
-        ],
-        'xcode_settings': {
-          'MACOSX_DEPLOYMENT_TARGET': '10.7',
-          'GCC_OPTIMIZATION_LEVEL': '0',
-          'GCC_GENERATE_DEBUGGING_SYMBOLS': 'YES',
-        },
-        'msvs_settings': {
-          'VCLinkerTool': {
-            'GenerateDebugInformation': 'true',
-          },
-        },
-      },
-      'Release': {
-        'defines!': [
-          'DEBUG',
-          '_DEBUG',
-        ],
-        'defines': [
-          'NDEBUG',
-        ],
-        'cflags': [
-          '-O3',
-        ],
-        'xcode_settings': {
-          'MACOSX_DEPLOYMENT_TARGET': '10.7',
-          'GCC_OPTIMIZATION_LEVEL': '3',
-          'GCC_GENERATE_DEBUGGING_SYMBOLS': 'NO',
-          'DEAD_CODE_STRIPPING': 'YES',
-          'GCC_INLINES_ARE_PRIVATE_EXTERN': 'YES',
-        },
-      },
-    },
-  },
-}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/node_modules/better-sqlite3/deps/copy.js

@@ -1,31 +0,0 @@
-'use strict';
-const path = require('path');
-const fs = require('fs');
-
-const dest = process.argv[2];
-const source = path.resolve(path.sep, process.argv[3] || path.join(__dirname, 'sqlite3'));
-const files = [
-	{ filename: 'sqlite3.c', optional: false },
-	{ filename: 'sqlite3.h', optional: false },
-];
-
-if (process.argv[3]) {
-	// Support "_HAVE_SQLITE_CONFIG_H" in custom builds.
-	files.push({ filename: 'config.h', optional: true });
-} else {
-	// Required for some tests.
-	files.push({ filename: 'sqlite3ext.h', optional: false });
-}
-
-for (const { filename, optional } of files) {
-	const sourceFilepath = path.join(source, filename);
-	const destFilepath = path.join(dest, filename);
-
-	if (optional && !fs.existsSync(sourceFilepath)) {
-		continue;
-	}
-
-	fs.accessSync(sourceFilepath);
-	fs.mkdirSync(path.dirname(destFilepath), { recursive: true });
-	fs.copyFileSync(sourceFilepath, destFilepath);
-}