tui-cap 0.1.0

package/dist/timing.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimingTracker = exports.TIMING_SCHEMA_VERSION = void 0;
+exports.timingPathFor = timingPathFor;
+exports.writeTiming = writeTiming;
+exports.readTiming = readTiming;
+exports.timeAtOffset = timeAtOffset;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+exports.TIMING_SCHEMA_VERSION = 1;
+/** Sibling sidecar path for a capture file: `foo.ans` -> `foo.timing.json`. */
+function timingPathFor(captureFile) {
+    const dir = node_path_1.default.dirname(captureFile);
+    const base = node_path_1.default.basename(captureFile, node_path_1.default.extname(captureFile));
+    return node_path_1.default.join(dir, `${base}.timing.json`);
+}
+/**
+ * Accumulates timing checkpoints while a capture streams in. Call {@link mark}
+ * with the byte length of each chunk *as it's written to the `.ans`* (so offsets
+ * line up with the file the parser later reads), then {@link build} to get the
+ * serializable sidecar.
+ */
+class TimingTracker {
+    events = [];
+    startMs;
+    offset = 0;
+    constructor(startMs = Date.now()) {
+        this.startMs = startMs;
+    }
+    /** Record that `byteLength` more bytes were written at time `now`. */
+    mark(byteLength, now = Date.now()) {
+        if (byteLength <= 0)
+            return;
+        this.offset += byteLength;
+        this.events.push([Math.max(0, now - this.startMs), this.offset]);
+    }
+    /** Total bytes seen so far (the final stream length). */
+    get byteLength() {
+        return this.offset;
+    }
+    build() {
+        return {
+            schemaVersion: exports.TIMING_SCHEMA_VERSION,
+            startedAt: new Date(this.startMs).toISOString(),
+            events: this.events,
+        };
+    }
+}
+exports.TimingTracker = TimingTracker;
+/** Write the timing sidecar next to `captureFile`. Returns the sidecar path. */
+async function writeTiming(captureFile, timing) {
+    const out = timingPathFor(captureFile);
+    await (0, promises_1.writeFile)(out, `${JSON.stringify(timing)}\n`, 'utf8');
+    return out;
+}
+/**
+ * Read a capture's timing sidecar, or null if it's missing or unusable. Never
+ * throws — a missing/garbled sidecar simply means "no timing; fall back to a
+ * uniform default duration".
+ */
+async function readTiming(captureFile) {
+    try {
+        const raw = await (0, promises_1.readFile)(timingPathFor(captureFile), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.events))
+            return null;
+        const events = parsed.events.filter((e) => Array.isArray(e) &&
+            e.length === 2 &&
+            Number.isFinite(e[0]) &&
+            Number.isFinite(e[1]));
+        if (events.length === 0)
+            return null;
+        return {
+            schemaVersion: parsed.schemaVersion ?? exports.TIMING_SCHEMA_VERSION,
+            startedAt: parsed.startedAt ?? '',
+            events,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Map a byte offset in the captured stream to the moment (ms since start) it
+ * appeared on screen. A chunk ending at offset `o` arrived at time `t`, so every
+ * byte in `(prevOffset, o]` is attributed to `t`; we return the time of the
+ * first checkpoint whose end offset reaches `offset`. Offsets past the last
+ * checkpoint resolve to the final timestamp; an empty list yields 0.
+ */
+function timeAtOffset(events, offset) {
+    if (events.length === 0)
+        return 0;
+    if (offset <= 0)
+        return events[0][0];
+    const lastIdx = events.length - 1;
+    if (offset >= events[lastIdx][1])
+        return events[lastIdx][0];
+    // Binary search for the first checkpoint whose offset >= `offset`.
+    let lo = 0;
+    let hi = lastIdx;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (events[mid][1] >= offset)
+            hi = mid;
+        else
+            lo = mid + 1;
+    }
+    return events[lo][0];
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/version.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGE_NAME = void 0;
+exports.currentVersion = currentVersion;
+exports.parseVersion = parseVersion;
+exports.compareVersions = compareVersions;
+exports.isNewer = isNewer;
+exports.installKind = installKind;
+exports.updateCommand = updateCommand;
+exports.fetchLatestVersion = fetchLatestVersion;
+exports.checkForUpdate = checkForUpdate;
+exports.runSelfUpdate = runSelfUpdate;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+/** The published npm package name, shared by the registry lookup and update command. */
+exports.PACKAGE_NAME = 'tui-cap';
+/** npm registry endpoint for the latest published manifest (small payload). */
+const REGISTRY_URL = `https://registry.npmjs.org/${exports.PACKAGE_NAME}/latest`;
+let cachedVersion;
+/**
+ * The `version` field of the package this module ships in, read once and cached.
+ * `package.json` sits one level above this module in both dev (`src/`) and the
+ * published build (`dist/`), and npm always includes it in the tarball.
+ */
+function currentVersion() {
+    if (cachedVersion !== undefined)
+        return cachedVersion;
+    try {
+        const pkgPath = node_path_1.default.join(__dirname, '..', 'package.json');
+        const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, 'utf8'));
+        cachedVersion = typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+    }
+    catch {
+        cachedVersion = '0.0.0';
+    }
+    return cachedVersion;
+}
+/** Parse a semver-ish string (`1.2.3`, `v1.2.3`, `1.2.3-beta.1`), or null. */
+function parseVersion(value) {
+    const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(value.trim());
+    if (!m)
+        return null;
+    return {
+        major: Number(m[1]),
+        minor: Number(m[2]),
+        patch: Number(m[3]),
+        pre: m[4] ? m[4].split('.') : [],
+    };
+}
+/** Compare two pre-release identifier lists per semver precedence rules. */
+function comparePre(a, b) {
+    // A normal release outranks any pre-release of the same x.y.z.
+    if (a.length === 0 && b.length === 0)
+        return 0;
+    if (a.length === 0)
+        return 1;
+    if (b.length === 0)
+        return -1;
+    const n = Math.max(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        const ai = a[i];
+        const bi = b[i];
+        if (ai === undefined)
+            return -1; // shorter set is lower
+        if (bi === undefined)
+            return 1;
+        const aNum = /^\d+$/.test(ai);
+        const bNum = /^\d+$/.test(bi);
+        if (aNum && bNum) {
+            const d = Number(ai) - Number(bi);
+            if (d !== 0)
+                return d < 0 ? -1 : 1;
+        }
+        else if (aNum !== bNum) {
+            return aNum ? -1 : 1; // numeric identifiers are lower than alphanumeric
+        }
+        else if (ai !== bi) {
+            return ai < bi ? -1 : 1;
+        }
+    }
+    return 0;
+}
+/**
+ * Semver precedence compare: -1 if `a` < `b`, 0 if equal, 1 if `a` > `b`.
+ * Unparseable input compares as equal (0) so a garbled value never triggers a
+ * spurious update prompt.
+ */
+function compareVersions(a, b) {
+    const pa = parseVersion(a);
+    const pb = parseVersion(b);
+    if (!pa || !pb)
+        return 0;
+    if (pa.major !== pb.major)
+        return pa.major < pb.major ? -1 : 1;
+    if (pa.minor !== pb.minor)
+        return pa.minor < pb.minor ? -1 : 1;
+    if (pa.patch !== pb.patch)
+        return pa.patch < pb.patch ? -1 : 1;
+    return comparePre(pa.pre, pb.pre);
+}
+/** True when `candidate` is a strictly newer version than `base`. */
+function isNewer(candidate, base) {
+    return compareVersions(candidate, base) > 0;
+}
+/**
+ * Best-effort detection of how this CLI was installed. Uses the real (symlink-
+ * resolved) module directory: npm's npx cache lives under `…/_npx/…`, and a dev
+ * checkout sits under the current working directory; anything else is treated as
+ * a global install (the common case for `npm install -g`).
+ */
+function installKind() {
+    let dir = __dirname;
+    try {
+        dir = (0, node_fs_1.realpathSync)(__dirname);
+    }
+    catch {
+        // fall back to the un-resolved path
+    }
+    const normalized = dir.split(node_path_1.default.sep).join('/');
+    if (normalized.includes('/_npx/'))
+        return 'npx';
+    let cwd = process.cwd();
+    try {
+        cwd = (0, node_fs_1.realpathSync)(cwd);
+    }
+    catch {
+        // use cwd as-is
+    }
+    if (dir === cwd || dir.startsWith(cwd + node_path_1.default.sep))
+        return 'local';
+    if (normalized.includes('/node_modules/'))
+        return 'global';
+    return 'unknown';
+}
+/** The shell command that upgrades a global install to the latest release. */
+function updateCommand() {
+    return `npm install -g ${exports.PACKAGE_NAME}@latest`;
+}
+/**
+ * Fetch the latest published version from the npm registry, or null if the
+ * request fails or times out. Never throws — a missing answer simply means "no
+ * update prompt", so an offline machine degrades quietly.
+ */
+async function fetchLatestVersion(timeoutMs = 3500) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(REGISTRY_URL, {
+            signal: controller.signal,
+            headers: {
+                // The abbreviated metadata document is smaller and cache-friendly.
+                accept: 'application/vnd.npm.install-v1+json, application/json',
+            },
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return typeof body.version === 'string' ? body.version : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Gather everything the GUI/CLI needs to decide whether to prompt for an update. */
+async function checkForUpdate(timeoutMs) {
+    const current = currentVersion();
+    const latest = await fetchLatestVersion(timeoutMs);
+    return {
+        name: exports.PACKAGE_NAME,
+        current,
+        latest,
+        updateAvailable: latest !== null && isNewer(latest, current),
+        installKind: installKind(),
+        updateCommand: updateCommand(),
+    };
+}
+/**
+ * Run `npm install -g tui-cap@latest` and resolve with the outcome. Captures a
+ * bounded tail of the command output so a failure (e.g. EACCES on a root-owned
+ * global prefix) can be shown without flooding. Never rejects.
+ */
+function runSelfUpdate(timeoutMs = 120_000) {
+    const command = updateCommand();
+    const fromVersion = currentVersion();
+    return new Promise((resolve) => {
+        let output = '';
+        const capture = (buf) => {
+            output += buf.toString();
+            if (output.length > 20_000)
+                output = output.slice(-20_000);
+        };
+        let child;
+        try {
+            child = (0, node_child_process_1.spawn)('npm', ['install', '-g', `${exports.PACKAGE_NAME}@latest`], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                // npm is a `.cmd` shim on Windows; a shell lets it resolve on PATH.
+                shell: process.platform === 'win32',
+            });
+        }
+        catch (err) {
+            resolve({
+                ok: false,
+                fromVersion,
+                command,
+                output: err instanceof Error ? err.message : String(err),
+                code: null,
+            });
+            return;
+        }
+        const timer = setTimeout(() => {
+            output += '\nUpdate timed out.';
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.stdout?.on('data', capture);
+        child.stderr?.on('data', capture);
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({ ok: false, fromVersion, command, output: `${output}\n${err.message}`.trim(), code: null });
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ ok: code === 0, fromVersion, command, output: output.trim(), code });
+        });
+    });
+}