@nocobase/plugin-logger 0.18.0-alpha.7

package/dist/node_modules/tar-fs/node_modules/tar-stream/pack.js

@@ -0,0 +1,287 @@
+const { Readable, Writable, getStreamError } = require('streamx')
+const b4a = require('b4a')
+
+const constants = require('./constants')
+const headers = require('./headers')
+
+const DMODE = 0o755
+const FMODE = 0o644
+
+const END_OF_TAR = b4a.alloc(1024)
+
+class Sink extends Writable {
+  constructor (pack, header, callback) {
+    super({ mapWritable, eagerOpen: true })
+
+    this.written = 0
+    this.header = header
+
+    this._callback = callback
+    this._linkname = null
+    this._isLinkname = header.type === 'symlink' && !header.linkname
+    this._isVoid = header.type !== 'file' && header.type !== 'contiguous-file'
+    this._finished = false
+    this._pack = pack
+    this._openCallback = null
+
+    if (this._pack._stream === null) this._pack._stream = this
+    else this._pack._pending.push(this)
+  }
+
+  _open (cb) {
+    this._openCallback = cb
+    if (this._pack._stream === this) this._continueOpen()
+  }
+
+  _continuePack (err) {
+    if (this._callback === null) return
+
+    const callback = this._callback
+    this._callback = null
+
+    callback(err)
+  }
+
+  _continueOpen () {
+    if (this._pack._stream === null) this._pack._stream = this
+
+    const cb = this._openCallback
+    this._openCallback = null
+    if (cb === null) return
+
+    if (this._pack.destroying) return cb(new Error('pack stream destroyed'))
+    if (this._pack._finalized) return cb(new Error('pack stream is already finalized'))
+
+    this._pack._stream = this
+
+    if (!this._isLinkname) {
+      this._pack._encode(this.header)
+    }
+
+    if (this._isVoid) {
+      this._finish()
+      this._continuePack(null)
+    }
+
+    cb(null)
+  }
+
+  _write (data, cb) {
+    if (this._isLinkname) {
+      this._linkname = this._linkname ? b4a.concat([this._linkname, data]) : data
+      return cb(null)
+    }
+
+    if (this._isVoid) {
+      if (data.byteLength > 0) {
+        return cb(new Error('No body allowed for this entry'))
+      }
+      return cb()
+    }
+
+    this.written += data.byteLength
+    if (this._pack.push(data)) return cb()
+    this._pack._drain = cb
+  }
+
+  _finish () {
+    if (this._finished) return
+    this._finished = true
+
+    if (this._isLinkname) {
+      this.header.linkname = this._linkname ? b4a.toString(this._linkname, 'utf-8') : ''
+      this._pack._encode(this.header)
+    }
+
+    overflow(this._pack, this.header.size)
+
+    this._pack._done(this)
+  }
+
+  _final (cb) {
+    if (this.written !== this.header.size) { // corrupting tar
+      return cb(new Error('Size mismatch'))
+    }
+
+    this._finish()
+    cb(null)
+  }
+
+  _getError () {
+    return getStreamError(this) || new Error('tar entry destroyed')
+  }
+
+  _predestroy () {
+    this._pack.destroy(this._getError())
+  }
+
+  _destroy (cb) {
+    this._pack._done(this)
+
+    this._continuePack(this._finished ? null : this._getError())
+
+    cb()
+  }
+}
+
+class Pack extends Readable {
+  constructor (opts) {
+    super(opts)
+    this._drain = noop
+    this._finalized = false
+    this._finalizing = false
+    this._pending = []
+    this._stream = null
+  }
+
+  entry (header, buffer, callback) {
+    if (this._finalized || this.destroying) throw new Error('already finalized or destroyed')
+
+    if (typeof buffer === 'function') {
+      callback = buffer
+      buffer = null
+    }
+
+    if (!callback) callback = noop
+
+    if (!header.size || header.type === 'symlink') header.size = 0
+    if (!header.type) header.type = modeToType(header.mode)
+    if (!header.mode) header.mode = header.type === 'directory' ? DMODE : FMODE
+    if (!header.uid) header.uid = 0
+    if (!header.gid) header.gid = 0
+    if (!header.mtime) header.mtime = new Date()
+
+    if (typeof buffer === 'string') buffer = b4a.from(buffer)
+
+    const sink = new Sink(this, header, callback)
+
+    if (b4a.isBuffer(buffer)) {
+      header.size = buffer.byteLength
+      sink.write(buffer)
+      sink.end()
+      return sink
+    }
+
+    if (sink._isVoid) {
+      return sink
+    }
+
+    return sink
+  }
+
+  finalize () {
+    if (this._stream || this._pending.length > 0) {
+      this._finalizing = true
+      return
+    }
+
+    if (this._finalized) return
+    this._finalized = true
+
+    this.push(END_OF_TAR)
+    this.push(null)
+  }
+
+  _done (stream) {
+    if (stream !== this._stream) return
+
+    this._stream = null
+
+    if (this._finalizing) this.finalize()
+    if (this._pending.length) this._pending.shift()._continueOpen()
+  }
+
+  _encode (header) {
+    if (!header.pax) {
+      const buf = headers.encode(header)
+      if (buf) {
+        this.push(buf)
+        return
+      }
+    }
+    this._encodePax(header)
+  }
+
+  _encodePax (header) {
+    const paxHeader = headers.encodePax({
+      name: header.name,
+      linkname: header.linkname,
+      pax: header.pax
+    })
+
+    const newHeader = {
+      name: 'PaxHeader',
+      mode: header.mode,
+      uid: header.uid,
+      gid: header.gid,
+      size: paxHeader.byteLength,
+      mtime: header.mtime,
+      type: 'pax-header',
+      linkname: header.linkname && 'PaxHeader',
+      uname: header.uname,
+      gname: header.gname,
+      devmajor: header.devmajor,
+      devminor: header.devminor
+    }
+
+    this.push(headers.encode(newHeader))
+    this.push(paxHeader)
+    overflow(this, paxHeader.byteLength)
+
+    newHeader.size = header.size
+    newHeader.type = header.type
+    this.push(headers.encode(newHeader))
+  }
+
+  _doDrain () {
+    const drain = this._drain
+    this._drain = noop
+    drain()
+  }
+
+  _predestroy () {
+    const err = getStreamError(this)
+
+    if (this._stream) this._stream.destroy(err)
+
+    while (this._pending.length) {
+      const stream = this._pending.shift()
+      stream.destroy(err)
+      stream._continueOpen()
+    }
+
+    this._doDrain()
+  }
+
+  _read (cb) {
+    this._doDrain()
+    cb()
+  }
+}
+
+module.exports = function pack (opts) {
+  return new Pack(opts)
+}
+
+function modeToType (mode) {
+  switch (mode & constants.S_IFMT) {
+    case constants.S_IFBLK: return 'block-device'
+    case constants.S_IFCHR: return 'character-device'
+    case constants.S_IFDIR: return 'directory'
+    case constants.S_IFIFO: return 'fifo'
+    case constants.S_IFLNK: return 'symlink'
+  }
+
+  return 'file'
+}
+
+function noop () {}
+
+function overflow (self, size) {
+  size &= 511
+  if (size) self.push(END_OF_TAR.subarray(0, 512 - size))
+}
+
+function mapWritable (buf) {
+  return b4a.isBuffer(buf) ? buf : b4a.from(buf)
+}

package/dist/node_modules/tar-fs/node_modules/tar-stream/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "tar-stream",
+  "version": "3.1.6",
+  "description": "tar-stream is a streaming tar parser and generator and nothing else. It operates purely using streams which means you can easily extract/parse tarballs without ever hitting the file system.",
+  "main": "index.js",
+  "files": [
+    "*.js"
+  ],
+  "browser": {
+    "fs": false
+  },
+  "scripts": {
+    "test": "standard && brittle test/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mafintosh/tar-stream.git"
+  },
+  "author": "Mathias Buus <mathiasbuus@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mafintosh/tar-stream/issues"
+  },
+  "homepage": "https://github.com/mafintosh/tar-stream",
+  "dependencies": {
+    "b4a": "^1.6.4",
+    "fast-fifo": "^1.2.0",
+    "streamx": "^2.15.0"
+  },
+  "devDependencies": {
+    "brittle": "^3.3.2",
+    "concat-stream": "^2.0.0",
+    "standard": "^17.0.1"
+  }
+}

package/dist/node_modules/tar-fs/package.json

@@ -0,0 +1 @@
+{"name":"tar-fs","version":"3.0.4","description":"filesystem bindings for tar-stream","dependencies":{"mkdirp-classic":"^0.5.2","pump":"^3.0.0","tar-stream":"^3.1.5"},"files":["index.js"],"standard":{"ignore":["test/fixtures/**"]},"keywords":["tar","fs","file","tarball","directory","stream"],"devDependencies":{"brittle":"^3.1.3","rimraf":"^2.6.3","standard":"^17.0.1"},"scripts":{"test":"standard && brittle test/index.js"},"bugs":{"url":"https://github.com/mafintosh/tar-fs/issues"},"homepage":"https://github.com/mafintosh/tar-fs","main":"index.js","directories":{"test":"test"},"author":"Mathias Buus","license":"MIT","repository":{"type":"git","url":"https://github.com/mafintosh/tar-fs.git"},"_lastModified":"2023-12-29T07:00:39.527Z"}

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export { default } from './plugin';

package/dist/server/index.js

@@ -0,0 +1,33 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(server_exports);
+var import_plugin = __toESM(require("./plugin"));

package/dist/server/plugin.d.ts

@@ -0,0 +1,11 @@
+import { InstallOptions, Plugin } from '@nocobase/server';
+export declare class PluginLoggerServer extends Plugin {
+    afterAdd(): void;
+    beforeLoad(): void;
+    load(): Promise<void>;
+    install(options?: InstallOptions): Promise<void>;
+    afterEnable(): Promise<void>;
+    afterDisable(): Promise<void>;
+    remove(): Promise<void>;
+}
+export default PluginLoggerServer;

package/dist/server/plugin.js

@@ -0,0 +1,61 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  PluginLoggerServer: () => PluginLoggerServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@nocobase/server");
+var import_logger = __toESM(require("./resourcer/logger"));
+class PluginLoggerServer extends import_server.Plugin {
+  afterAdd() {
+  }
+  beforeLoad() {
+  }
+  async load() {
+    this.app.resource(import_logger.default);
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}.logger`,
+      actions: ["logger:*"]
+    });
+  }
+  async install(options) {
+  }
+  async afterEnable() {
+  }
+  async afterDisable() {
+  }
+  async remove() {
+  }
+}
+var plugin_default = PluginLoggerServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginLoggerServer
+});

package/dist/server/resourcer/logger.d.ts

@@ -0,0 +1,9 @@
+import { Context, Next } from '@nocobase/actions';
+declare const _default: {
+    name: string;
+    actions: {
+        list: (ctx: Context, next: Next) => Promise<void>;
+        download: (ctx: Context, next: Next) => Promise<void>;
+    };
+};
+export default _default;

package/dist/server/resourcer/logger.js

@@ -0,0 +1,114 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+__export(logger_exports, {
+  default: () => logger_default
+});
+module.exports = __toCommonJS(logger_exports);
+var import_logger = require("@nocobase/logger");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_stream = __toESM(require("stream"));
+var import_tar_fs = require("tar-fs");
+var import_zlib = __toESM(require("zlib"));
+const tarFiles = (files) => {
+  return new Promise((resolve, reject) => {
+    const passthrough = new import_stream.default.PassThrough();
+    const gz = import_zlib.default.createGzip();
+    (0, import_tar_fs.pack)((0, import_logger.getLoggerFilePath)(), {
+      entries: files
+    }).on("data", (chunk) => {
+      passthrough.write(chunk);
+    }).on("end", () => {
+      passthrough.end();
+    }).on("error", (err) => reject(err));
+    passthrough.on("data", (chunk) => {
+      gz.write(chunk);
+    }).on("end", () => {
+      gz.end();
+      resolve(gz);
+    }).on("error", (err) => reject(err));
+    gz.on("error", (err) => reject(err));
+  });
+};
+var logger_default = {
+  name: "logger",
+  actions: {
+    list: async (ctx, next) => {
+      const path = (0, import_logger.getLoggerFilePath)();
+      const readDir = async (path2) => {
+        const fileTree = [];
+        try {
+          const files2 = await (0, import_promises.readdir)(path2, { withFileTypes: true });
+          for (const file of files2) {
+            if (file.isDirectory()) {
+              const subFiles = await readDir((0, import_path.join)(path2, file.name));
+              if (!subFiles.length) {
+                continue;
+              }
+              fileTree.push({
+                name: file.name,
+                files: subFiles
+              });
+            } else if (file.name.endsWith(".log")) {
+              fileTree.push(file.name);
+            }
+          }
+          return fileTree;
+        } catch (err) {
+          ctx.log.error("readDir error", { err, path: path2 });
+          return [];
+        }
+      };
+      const files = await readDir(path);
+      ctx.body = files;
+      await next();
+    },
+    download: async (ctx, next) => {
+      let { files = [] } = ctx.action.params.values || {};
+      const invalid = files.some((file) => !file.endsWith(".log"));
+      if (invalid) {
+        ctx.throw(400, ctx.t("Invalid file type: ") + invalid);
+      }
+      files = files.map((file) => {
+        if (file.startsWith("/")) {
+          return file.slice(1);
+        }
+        return file;
+      });
+      try {
+        ctx.attachment("logs.tar.gz");
+        ctx.body = await tarFiles(files);
+      } catch (err) {
+        ctx.log.error(`download error: ${err.message}`, { files, err: err.stack });
+        ctx.throw(500, ctx.t("Download logs failed."));
+      }
+      await next();
+    }
+  }
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@nocobase/plugin-logger",
+  "displayName": "Logger",
+  "displayName.zh-CN": "日志",
+  "description": "Package and download log files",
+  "description.zh-CN": "打包下载日志文件",
+  "version": "0.18.0-alpha.7",
+  "license": "AGPL-3.0",
+  "main": "dist/server/index.js",
+  "devDependencies": {
+    "@types/tar-fs": "^2.0.2",
+    "tar-fs": "^3.0.4"
+  },
+  "peerDependencies": {
+    "@nocobase/actions": "0.x",
+    "@nocobase/client": "0.x",
+    "@nocobase/server": "0.x",
+    "@nocobase/test": "0.x"
+  },
+  "gitHead": "979a9c59a98c61a2287dd847580746a9b597cbde"
+}

package/server.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/server';
+export { default } from './dist/server';

package/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server/index.js');