@vicinae/api 0.16.8 → 0.16.9

package/dist/commands/develop/index.js

@@ -40,14 +40,15 @@ const core_1 = require("@oclif/core");
 const chokidar = __importStar(require("chokidar"));
 const esbuild = __importStar(require("esbuild"));
 const node_child_process_1 = require("node:child_process");
-const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
-const node_path_1 = require("node:path");
+const fs = __importStar(require("node:fs"));
+const fsp = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
 const logger_js_1 = require("../../utils/logger.js");
 const utils_js_1 = require("../../utils/utils.js");
 const extension_types_js_1 = require("../../utils/extension-types.js");
 const vicinae_js_1 = require("../../utils/vicinae.js");
 const manifest_js_1 = __importDefault(require("../../schemas/manifest.js"));
+const tail_js_1 = require("../../utils/tail.js");
 class Develop extends core_1.Command {
     static args = {};
     static description = "Start an extension development session";
@@ -67,13 +68,13 @@ class Develop extends core_1.Command {
     async run() {
         const { flags } = await this.parse(Develop);
         const logger = new logger_js_1.Logger();
-        const pkgPath = (0, node_path_1.join)(flags.target, "package.json");
+        const pkgPath = path.join(flags.target, "package.json");
         const parseManifest = () => {
-            if (!(0, node_fs_1.existsSync)(pkgPath)) {
+            if (!fs.existsSync(pkgPath)) {
                 logger.logError(`No package.json found at ${pkgPath}. Does this location point to a valid extension repository?`);
                 process.exit(1);
             }
-            const json = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf8"));
+            const json = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
             const e = manifest_js_1.default.safeParse(json);
             if (e.error) {
                 logger.logError(`${pkgPath} is not a valid extension manifest: ${e.error}`);
@@ -107,22 +108,22 @@ class Develop extends core_1.Command {
       });
       */
             const entryPoints = manifest.commands
-                .map((cmd) => (0, node_path_1.join)("src", `${cmd.name}.tsx`))
-                .filter(node_fs_1.existsSync);
+                .map((cmd) => path.join("src", `${cmd.name}.tsx`))
+                .filter(fs.existsSync);
             logger.logInfo(`entrypoints [${entryPoints.join(", ")}]`);
             const promises = manifest.commands.map((cmd) => {
-                const base = (0, node_path_1.join)(process.cwd(), "src", `${cmd.name}`);
+                const base = path.join(process.cwd(), "src", `${cmd.name}`);
                 const tsxSource = `${base}.tsx`;
                 const tsSource = `${base}.ts`;
                 let source = tsxSource;
-                if (cmd.mode === "view" && !(0, node_fs_1.existsSync)(tsxSource)) {
+                if (cmd.mode === "view" && !fs.existsSync(tsxSource)) {
                     throw new Error(`could not find entrypoint src/${cmd.name}.tsx for command ${cmd.name}.`);
                 }
                 // we allow .ts or .tsx for no-view
                 if (cmd.mode === "no-view") {
-                    if (!(0, node_fs_1.existsSync)(tsxSource)) {
+                    if (!fs.existsSync(tsxSource)) {
                         source = tsSource;
-                        if (!(0, node_fs_1.existsSync)(tsSource)) {
+                        if (!fs.existsSync(tsSource)) {
                             throw new Error(`could not find entrypoint src/${cmd.name}.{ts,tsx} for command ${cmd.name}.`);
                         }
                     }
@@ -132,19 +133,19 @@ class Develop extends core_1.Command {
                     entryPoints: [source],
                     external: ["react", "@vicinae/api", "@raycast/api"],
                     format: "cjs",
-                    outfile: (0, node_path_1.join)(outDir, `${cmd.name}.js`),
+                    outfile: path.join(outDir, `${cmd.name}.js`),
                     platform: "node",
                 });
             });
             await Promise.all(promises);
-            const targetPkg = (0, node_path_1.join)(outDir, "package.json");
-            const targetAssets = (0, node_path_1.join)(outDir, "assets");
-            (0, node_fs_1.cpSync)("package.json", targetPkg, { force: true });
-            if ((0, node_fs_1.existsSync)("assets")) {
-                (0, node_fs_1.cpSync)("assets", targetAssets, { force: true, recursive: true });
+            const targetPkg = path.join(outDir, "package.json");
+            const targetAssets = path.join(outDir, "assets");
+            fs.cpSync("package.json", targetPkg, { force: true });
+            if (fs.existsSync("assets")) {
+                fs.cpSync("assets", targetAssets, { force: true, recursive: true });
             }
             else {
-                (0, node_fs_1.mkdirSync)(targetAssets, { recursive: true });
+                fs.mkdirSync(targetAssets, { recursive: true });
             }
         };
         const pingError = vicinae.ping();
@@ -172,12 +173,23 @@ class Develop extends core_1.Command {
         process.chdir(flags.target);
         const dataDir = (0, utils_js_1.extensionDataDir)();
         const id = `${manifest.name}`;
-        const extensionDir = (0, node_path_1.join)(dataDir, id);
-        const logFile = (0, node_path_1.join)(extensionDir, "dev.log");
-        const pidFile = (0, node_path_1.join)(extensionDir, "cli.pid");
-        (0, node_fs_1.mkdirSync)(extensionDir, { recursive: true });
-        (0, node_fs_1.writeFileSync)(pidFile, `${process.pid}`);
-        (0, node_fs_1.writeFileSync)(logFile, "");
+        const extensionDir = path.join(dataDir, id);
+        const internalSupportDir = (0, utils_js_1.extensionInternalSupportDir)(id);
+        const stdoutPath = path.join(internalSupportDir, "stdout.txt");
+        const stderrPath = path.join(internalSupportDir, "stderr.txt");
+        const pidFile = path.join(internalSupportDir, "cli.pid");
+        await Promise.all([extensionDir, internalSupportDir].map((dir) => fsp.mkdir(dir, { recursive: true })));
+        await fsp.writeFile(pidFile, `${process.pid}`);
+        const outStream = new tail_js_1.Tail(stdoutPath, { forceCreate: true, nLines: 0 });
+        const errStream = new tail_js_1.Tail(stderrPath, { forceCreate: true, nLines: 0 });
+        outStream.on("line", (data) => {
+            logger.logExtensionOut(data.toString());
+        });
+        outStream.on("error", () => { });
+        errStream.on("line", (data) => {
+            logger.logExtensionError(data.toString());
+        });
+        errStream.on("error", () => { });
         await safeBuild(extensionDir);
         process.on("SIGINT", () => {
             logger.logInfo("Shutting down...");
@@ -203,31 +215,6 @@ class Develop extends core_1.Command {
             logger.logEvent(`changed file ${path}`);
             await safeBuild(extensionDir);
         });
-        const logFiles = new Map();
-        chokidar.watch(logFile).on("all", async (_, path) => {
-            const stats = await (0, promises_1.stat)(path);
-            if (!stats.isFile())
-                return;
-            if (!logFiles.has(path)) {
-                //logger.logInfo(`Monitoring new log file at ${path}`);
-                logFiles.set(path, { cursor: 0, path });
-            }
-            const info = logFiles.get(path);
-            if (info.cursor > stats.size) {
-                info.cursor = 0;
-            }
-            if (stats.size === info.cursor)
-                return;
-            const handle = await (0, promises_1.open)(path, "r");
-            const buffer = Buffer.alloc(stats.size - info.cursor);
-            (0, node_fs_1.read)(handle.fd, buffer, 0, buffer.length, info.cursor, (error, nRead) => {
-                if (error)
-                    return;
-                info.cursor += nRead;
-                logger.logTimestamp(buffer.toString());
-                handle.close();
-            });
-        });
     }
 }
 exports.default = Develop;

package/dist/utils/logger.d.ts

@@ -9,5 +9,7 @@ export declare class Logger {
     logEvent(message: string): void;
     logInfo(message: string): void;
     logReady(message: string): void;
+    logExtensionOut(s: string): void;
+    logExtensionError(s: string): void;
     logTimestamp(s: string): void;
 }

package/dist/utils/logger.js

@@ -1,16 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
-const chalk_1 = __importDefault(require("chalk"));
+const yoctocolors_1 = require("./yoctocolors");
 class Logger {
     prefixes = {
-        error: `${chalk_1.default.red("error")}${chalk_1.default.reset()}`,
-        event: `${chalk_1.default.magenta("event")}${chalk_1.default.reset()}`,
-        info: `${chalk_1.default.blue("info")}${chalk_1.default.reset()}`,
-        ready: `${chalk_1.default.green("ready")}${chalk_1.default.reset()}`,
+        error: `${(0, yoctocolors_1.red)("error")}${(0, yoctocolors_1.reset)()}`,
+        event: `${(0, yoctocolors_1.magenta)("event")}${(0, yoctocolors_1.reset)()}`,
+        info: `${(0, yoctocolors_1.blue)("info")}${(0, yoctocolors_1.reset)()}`,
+        ready: `${(0, yoctocolors_1.green)("ready")}${(0, yoctocolors_1.reset)()}`,
     };
     logError(message) {
         console.log(`${this.prefixes.error.padEnd(15)} - ${message}`);
@@ -24,6 +21,12 @@ class Logger {
     logReady(message) {
         console.log(`${this.prefixes.ready.padEnd(15)} - ${message}`);
     }
+    logExtensionOut(s) {
+        this.logTimestamp(s);
+    }
+    logExtensionError(s) {
+        this.logTimestamp(`${(0, yoctocolors_1.red)(s)}${(0, yoctocolors_1.reset)()}`);
+    }
     logTimestamp(s) {
         const ts = new Date().toJSON();
         const lines = s.split("\n");
@@ -31,7 +34,7 @@ class Logger {
             const line = lines[i];
             if (i === lines.length - 1 && line.length === 0)
                 continue;
-            console.log(`${chalk_1.default.gray(ts.padEnd(20))}${chalk_1.default.reset()} - ${line}`);
+            console.log(`${(0, yoctocolors_1.gray)(ts.padEnd(20))}${(0, yoctocolors_1.reset)()} - ${line}`);
         }
     }
 }

package/dist/utils/tail.d.ts

@@ -0,0 +1,66 @@
+import events from "node:events";
+interface FSWatchOptions {
+    interval: number;
+}
+export interface TailOptions {
+    separator?: string | RegExp | null;
+    fsWatchOptions?: FSWatchOptions;
+    follow?: boolean;
+    logger?: DevNull;
+    useWatchFile?: boolean;
+    flushAtEOF?: boolean;
+    encoding?: BufferEncoding;
+    fromBeginning?: boolean;
+    nLines?: number;
+    /**
+     * Create an empty file if it does not exist.
+     */
+    forceCreate?: boolean;
+}
+declare class DevNull {
+    info(...args: any): void;
+    error(...args: any): void;
+}
+export declare class Tail extends events.EventEmitter {
+    private filename;
+    private absPath;
+    private separator?;
+    private fsWatchOptions;
+    private follow;
+    private logger;
+    private useWatchFile;
+    private flushAtEOF;
+    private encoding;
+    private nLines?;
+    private rewatchId;
+    private isWatching;
+    private queue;
+    private buffer;
+    private watcher;
+    private internalDispatcher;
+    private currentCursorPos;
+    constructor(filename: string, options?: TailOptions);
+    /**
+     * Grabs the index of the last line of text in the format /.*(\n)?/.
+     * Returns null if a full line can not be found.
+     * @param {string} text
+     * @returns {number | null}
+     */
+    private getIndexOfLastLine;
+    /**
+     * Returns the position of the start of the `nLines`th line from the bottom.
+     * Returns 0 if `nLines` is greater than the total number of lines in the file.
+     * @param {number} nLines
+     * @returns {number}
+     */
+    private getPositionAtNthLine;
+    private latestPosition;
+    private readBlock;
+    private change;
+    watch(startingCursor: number, flush?: boolean): void;
+    private rename;
+    private watchEvent;
+    private watchFileEvent;
+    unwatch(): void;
+}
+export {};

package/dist/utils/tail.js

@@ -0,0 +1,352 @@
+"use strict";
+// Based on https://github.com/WandersonAlves/node-tail/blob/master/src/tail.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tail = void 0;
+const node_events_1 = __importDefault(require("node:events"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+class DevNull {
+    info(...args) { }
+    error(...args) { }
+}
+class Tail extends node_events_1.default.EventEmitter {
+    filename;
+    absPath;
+    separator;
+    fsWatchOptions;
+    follow;
+    logger;
+    useWatchFile;
+    flushAtEOF;
+    encoding;
+    nLines;
+    rewatchId;
+    isWatching;
+    queue = [];
+    // NOTE Should we rename that as it is a string instead of a Buffer?
+    buffer;
+    watcher;
+    internalDispatcher;
+    currentCursorPos = 0;
+    constructor(filename, options = {}) {
+        super();
+        this.filename = filename;
+        this.absPath = (0, node_path_1.dirname)(this.filename);
+        this.separator =
+            options.separator !== undefined ? options.separator : /[\r]{0,1}\n/; // null is a valid param
+        this.fsWatchOptions = options.fsWatchOptions || {};
+        this.follow = options.follow ?? true;
+        this.logger = options.logger || new DevNull();
+        this.useWatchFile = options.useWatchFile || false;
+        this.flushAtEOF = options.flushAtEOF || false;
+        this.encoding = options.encoding || "utf-8";
+        const fromBeginning = options.fromBeginning || false;
+        this.nLines = options.nLines ?? 0;
+        this.logger.info(`Tail starting...`);
+        this.logger.info(`filename: ${this.filename}`);
+        this.logger.info(`encoding: ${this.encoding}`);
+        try {
+            (0, node_fs_1.accessSync)(this.filename, node_fs_1.constants.F_OK);
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                if (!options.forceCreate)
+                    throw err;
+                (0, node_fs_1.writeFileSync)(this.filename, "");
+            }
+        }
+        this.buffer = "";
+        this.internalDispatcher = new node_events_1.default.EventEmitter();
+        this.isWatching = false;
+        // this.internalDispatcher.on('next',this.readBlock);
+        this.internalDispatcher.on("next", () => {
+            this.readBlock();
+        });
+        let cursor = 0;
+        this.logger.info(`fromBeginning: ${fromBeginning}`);
+        if (fromBeginning) {
+            cursor = 0;
+        }
+        else if (this.nLines <= 0) {
+            cursor = 0;
+        }
+        else if (this.nLines !== undefined) {
+            cursor = this.getPositionAtNthLine(this.nLines);
+        }
+        else {
+            cursor = this.latestPosition();
+        }
+        if (cursor === undefined)
+            throw new Error("Tail can't initialize.");
+        const flush = fromBeginning || this.nLines !== undefined;
+        try {
+            this.watch(cursor, flush);
+        }
+        catch (err) {
+            this.logger.error(`watch for ${this.filename} failed: ${err}`);
+            this.emit("error", `watch for ${this.filename} failed: ${err}`);
+        }
+    }
+    /**
+     * Grabs the index of the last line of text in the format /.*(\n)?/.
+     * Returns null if a full line can not be found.
+     * @param {string} text
+     * @returns {number | null}
+     */
+    getIndexOfLastLine(text) {
+        /**
+         * Helper function get the last match as string
+         * @param {string} haystack
+         * @param {string | RegExp} needle
+         * @returns {string | undefined}
+         */
+        const getLastMatch = (haystack, needle) => {
+            // NOTE `as string` was used to cast the needle to string, but it can be null as well. Just making TS compiler happy
+            const matches = haystack.match(needle);
+            if (matches === null) {
+                return;
+            }
+            return matches[matches.length - 1];
+        };
+        // NOTE `as string` was used to cast the needle to string, but it can be null as well. Just making TS compiler happy
+        const endSep = getLastMatch(text, this.separator);
+        if (!endSep)
+            return null;
+        const endSepIndex = text.lastIndexOf(endSep);
+        let lastLine = "";
+        if (text.endsWith(endSep)) {
+            // If the text ends with a separator, look back further to find the next
+            // separator to complete the line
+            const trimmed = text.substring(0, endSepIndex);
+            // NOTE `as string` was used to cast the needle to string, but it can be null as well. Just making TS compiler happy
+            const startSep = getLastMatch(trimmed, this.separator);
+            // If there isn't another separator, the line isn't complete so
+            // so return null to get more data
+            if (!startSep) {
+                return null;
+            }
+            const startSepIndex = trimmed.lastIndexOf(startSep);
+            // Exclude the starting separator, include the ending separator
+            lastLine = text.substring(startSepIndex + startSep.length, endSepIndex + endSep.length);
+        }
+        else {
+            // If the text does not end with a separator, grab everything after
+            // the last separator
+            lastLine = text.substring(endSepIndex + endSep.length);
+        }
+        return text.lastIndexOf(lastLine);
+    }
+    /**
+     * Returns the position of the start of the `nLines`th line from the bottom.
+     * Returns 0 if `nLines` is greater than the total number of lines in the file.
+     * @param {number} nLines
+     * @returns {number}
+     */
+    getPositionAtNthLine(nLines) {
+        const { size } = (0, node_fs_1.statSync)(this.filename);
+        if (size === 0) {
+            return 0;
+        }
+        const fd = (0, node_fs_1.openSync)(this.filename, "r");
+        // Start from the end of the file and work backwards in specific chunks
+        let currentReadPosition = size;
+        const chunkSizeBytes = Math.min(1024, size);
+        const lineBytes = [];
+        let remaining = "";
+        while (lineBytes.length < nLines) {
+            // Shift the current read position backward to the amount we're about to read
+            currentReadPosition -= chunkSizeBytes;
+            // If negative, we've reached the beginning of the file and we should stop and return 0, starting the
+            // stream at the beginning.
+            if (currentReadPosition < 0) {
+                return 0;
+            }
+            // Read a chunk of the file and prepend it to the working buffer
+            const buffer = Buffer.alloc(chunkSizeBytes);
+            const bytesRead = (0, node_fs_1.readSync)(fd, buffer, 0, // position in buffer to write to
+            chunkSizeBytes, // number of bytes to read
+            currentReadPosition);
+            // .subarray returns Uint8Array in node versions < 16.x and Buffer
+            // in versions >= 16.x. To support both, allocate a new buffer with
+            // Buffer.from which accepts both types
+            const readArray = buffer.subarray(0, bytesRead);
+            remaining = Buffer.from(readArray).toString(this.encoding) + remaining;
+            let index = this.getIndexOfLastLine(remaining);
+            while (index !== null && lineBytes.length < nLines) {
+                const line = remaining.substring(index);
+                lineBytes.push(Buffer.byteLength(line));
+                remaining = remaining.substring(0, index);
+                index = this.getIndexOfLastLine(remaining);
+            }
+        }
+        (0, node_fs_1.closeSync)(fd);
+        return size - lineBytes.reduce((acc, cur) => acc + cur, 0);
+    }
+    latestPosition() {
+        try {
+            return (0, node_fs_1.statSync)(this.filename).size;
+        }
+        catch (err) {
+            this.logger.error(`size check for ${this.filename} failed: ${err}`);
+            this.emit("error", `size check for ${this.filename} failed: ${err}`);
+            throw err;
+        }
+    }
+    readBlock() {
+        if (this.queue.length >= 1) {
+            const block = this.queue[0];
+            if (block.end > block.start) {
+                const stream = (0, node_fs_1.createReadStream)(this.filename, {
+                    start: block.start,
+                    end: block.end - 1,
+                    encoding: this.encoding,
+                });
+                stream.on("error", (error) => {
+                    this.logger.error(`Tail error: ${error}`);
+                    this.emit("error", error);
+                });
+                stream.on("end", () => {
+                    this.queue.shift();
+                    if (this.queue.length > 0) {
+                        this.internalDispatcher.emit("next");
+                    }
+                    if (this.flushAtEOF && this.buffer.length > 0) {
+                        this.emit("line", this.buffer);
+                        this.buffer = "";
+                    }
+                });
+                stream.on("data", (d) => {
+                    if (this.separator === null) {
+                        this.emit("line", d);
+                    }
+                    else {
+                        this.buffer += d;
+                        // NOTE `as string` was used to cast the needle to string, but it can be null as well. Just making TS compiler happy
+                        let parts = this.buffer.split(this.separator);
+                        // NOTE Since parts.pop could return undefined, i'm returning a empty string when that happens
+                        this.buffer = parts.pop() ?? "";
+                        for (const chunk of parts) {
+                            this.emit("line", chunk);
+                        }
+                    }
+                });
+            }
+        }
+    }
+    change() {
+        const p = this.latestPosition();
+        if (p < this.currentCursorPos) {
+            //scenario where text is not appended but it's actually a w+
+            this.currentCursorPos = p;
+        }
+        else if (p > this.currentCursorPos) {
+            this.queue.push({ start: this.currentCursorPos, end: p });
+            this.currentCursorPos = p;
+            if (this.queue.length === 1) {
+                this.internalDispatcher.emit("next");
+            }
+        }
+    }
+    watch(startingCursor, flush) {
+        if (this.isWatching)
+            return;
+        this.logger.info(`filesystem.watch present? ${node_fs_1.watch !== undefined}`);
+        this.logger.info(`useWatchFile: ${this.useWatchFile}`);
+        this.isWatching = true;
+        this.currentCursorPos = startingCursor;
+        //force a file flush is either fromBegining or nLines flags were passed.
+        if (flush)
+            this.change();
+        if (!this.useWatchFile) {
+            this.logger.info(`watch strategy: watch`);
+            this.watcher = (0, node_fs_1.watch)(this.filename, this.fsWatchOptions, (e, filename) => {
+                // NOTE Filename here is a `Buffer`, how it's used as a string?
+                // NOTE Test if filename.toString changes the behavior
+                if (filename)
+                    this.watchEvent(e, filename.toString());
+            });
+        }
+        else {
+            this.logger.info(`watch strategy: watchFile`);
+            (0, node_fs_1.watchFile)(this.filename, this.fsWatchOptions, (curr, prev) => {
+                this.watchFileEvent(curr, prev);
+            });
+        }
+    }
+    rename(filename) {
+        //TODO
+        //MacOS sometimes throws a rename event for no reason.
+        //Different platforms might behave differently.
+        //see https://nodejs.org/api/fs.html#fs_fs_watch_filename_options_listener
+        //filename might not be present.
+        //https://nodejs.org/api/fs.html#fs_filename_argument
+        //Better solution would be check inode but it will require a timeout and
+        // a sync file read.
+        if (filename === undefined || filename !== this.filename) {
+            this.unwatch();
+            if (this.follow) {
+                this.filename = (0, node_path_1.join)(this.absPath, filename);
+                this.rewatchId = setTimeout(() => {
+                    try {
+                        this.watch(this.currentCursorPos);
+                    }
+                    catch (ex) {
+                        this.logger.error(`'rename' event for ${this.filename}. File not available anymore.`);
+                        this.emit("error", ex);
+                    }
+                }, 1000);
+            }
+            else {
+                this.logger.error(`'rename' event for ${this.filename}. File not available anymore.`);
+                this.emit("error", `'rename' event for ${this.filename}. File not available anymore.`);
+            }
+        }
+        else {
+            // this.logger.info("rename event but same filename")
+        }
+    }
+    watchEvent(evtName, evtFilename) {
+        try {
+            if (evtName === "change") {
+                this.change();
+            }
+            else if (evtName === "rename") {
+                this.rename(evtFilename);
+            }
+        }
+        catch (err) {
+            this.logger.error(`watchEvent for ${this.filename} failed: ${err}`);
+            this.emit("error", `watchEvent for ${this.filename} failed: ${err}`);
+        }
+    }
+    watchFileEvent(curr, prev) {
+        if (curr.size > prev.size) {
+            this.currentCursorPos = curr.size; //Update this.currentCursorPos so that a consumer can determine if entire file has been handled
+            this.queue.push({ start: prev.size, end: curr.size });
+            if (this.queue.length === 1) {
+                this.internalDispatcher.emit("next");
+            }
+        }
+    }
+    unwatch() {
+        if (this.watcher) {
+            this.watcher.close();
+        }
+        else {
+            (0, node_fs_1.unwatchFile)(this.filename);
+        }
+        if (this.rewatchId) {
+            clearTimeout(this.rewatchId);
+            this.rewatchId = undefined;
+        }
+        this.isWatching = false;
+        this.queue = []; // TODO: is this correct behaviour?
+        if (this.logger) {
+            this.logger.info(`Unwatch ${this.filename}`);
+        }
+    }
+}
+exports.Tail = Tail;

package/dist/utils/utils.d.ts

@@ -1,2 +1,4 @@
 export declare const dataDir: () => string;
 export declare const extensionDataDir: () => string;
+export declare const supportDir: string;
+export declare const extensionInternalSupportDir: (id: string) => string;