ask-pro 0.1.0

package/dist/src/ask-pro/sessionControllerLease.js

@@ -0,0 +1,64 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { isProcessAlive } from "../browser/profileState.js";
+const LEASE_FILENAME = ".controller.lease";
+const OWNER_PATTERN = /^(\d+)-(.+)\.owner$/;
+const REMOVE_OPTIONS = { recursive: true, force: true, maxRetries: 5, retryDelay: 20 };
+export async function withSessionControllerLease(sessionDir, action) {
+    const id = randomUUID();
+    const leasePath = path.join(sessionDir, LEASE_FILENAME);
+    const candidatePath = `${leasePath}.${id}.candidate`;
+    const ownerName = `${process.pid}-${id}.owner`;
+    await mkdir(candidatePath);
+    let acquired = false;
+    try {
+        await writeFile(path.join(candidatePath, ownerName), "");
+        for (;;) {
+            try {
+                await rename(candidatePath, leasePath);
+                acquired = true;
+                break;
+            }
+            catch (error) {
+                if (!(await stat(leasePath).catch(() => null)))
+                    throw error;
+            }
+            const existingOwner = (await readdir(leasePath)).find((entry) => OWNER_PATTERN.test(entry));
+            const existingPid = Number(existingOwner?.match(OWNER_PATTERN)?.[1]);
+            if (!existingOwner || !Number.isInteger(existingPid) || existingPid <= 0) {
+                throw new Error("ask-pro session controller lease is unreadable");
+            }
+            if (isProcessAlive(existingPid)) {
+                throw new Error(`ask-pro session controller is already running (pid ${existingPid})`);
+            }
+            try {
+                await rename(path.join(leasePath, existingOwner), path.join(leasePath, ownerName));
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            const stalePath = `${leasePath}.${id}.stale`;
+            await rename(leasePath, stalePath);
+            await rm(stalePath, REMOVE_OPTIONS);
+        }
+        try {
+            return await action();
+        }
+        finally {
+            const ownsLease = (await readdir(leasePath).catch(() => [])).includes(ownerName);
+            if (ownsLease) {
+                const retiredPath = `${leasePath}.${id}.retired`;
+                const retired = await rename(leasePath, retiredPath).then(() => true, () => false);
+                if (retired)
+                    await rm(retiredPath, REMOVE_OPTIONS).catch(() => undefined);
+            }
+        }
+    }
+    finally {
+        if (!acquired)
+            await rm(candidatePath, REMOVE_OPTIONS).catch(() => undefined);
+    }
+}

package/dist/src/ask-pro/toon.js

@@ -0,0 +1,26 @@
+export function renderToonRecord(name, fields) {
+    const lines = [name];
+    for (const [key, value] of Object.entries(fields)) {
+        if (value === undefined)
+            continue;
+        lines.push(`  ${formatKey(key)}: ${formatValue(value)}`);
+    }
+    return lines.join("\n");
+}
+function formatKey(key) {
+    return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(key) ? key : JSON.stringify(key);
+}
+function formatValue(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number")
+        return Number.isFinite(value) ? String(value) : "null";
+    if (isBareString(value))
+        return value;
+    return JSON.stringify(value);
+}
+function isBareString(value) {
+    return /^[A-Za-z0-9_./@-]+$/.test(value);
+}

package/dist/src/ask-pro/zip.js

@@ -0,0 +1,85 @@
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i += 1) {
+        let value = i;
+        for (let bit = 0; bit < 8; bit += 1) {
+            value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+        }
+        table[i] = value >>> 0;
+    }
+    return table;
+})();
+export function createStoredZip(entries) {
+    const chunks = [];
+    const central = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const name = Buffer.from(normalizeZipName(entry.name), "utf8");
+        const data = Buffer.isBuffer(entry.data) ? entry.data : Buffer.from(entry.data, "utf8");
+        const crc32 = computeCrc32(data);
+        const localHeader = Buffer.alloc(30);
+        localHeader.writeUInt32LE(0x04034b50, 0);
+        localHeader.writeUInt16LE(20, 4);
+        localHeader.writeUInt16LE(0x0800, 6);
+        localHeader.writeUInt16LE(0, 8);
+        localHeader.writeUInt16LE(0, 10);
+        localHeader.writeUInt16LE(0, 12);
+        localHeader.writeUInt32LE(crc32, 14);
+        localHeader.writeUInt32LE(data.length, 18);
+        localHeader.writeUInt32LE(data.length, 22);
+        localHeader.writeUInt16LE(name.length, 26);
+        localHeader.writeUInt16LE(0, 28);
+        chunks.push(localHeader, name, data);
+        central.push({ name, crc32, size: data.length, offset });
+        offset += localHeader.length + name.length + data.length;
+    }
+    const centralStart = offset;
+    for (const entry of central) {
+        const header = Buffer.alloc(46);
+        header.writeUInt32LE(0x02014b50, 0);
+        header.writeUInt16LE(20, 4);
+        header.writeUInt16LE(20, 6);
+        header.writeUInt16LE(0x0800, 8);
+        header.writeUInt16LE(0, 10);
+        header.writeUInt16LE(0, 12);
+        header.writeUInt16LE(0, 14);
+        header.writeUInt32LE(entry.crc32, 16);
+        header.writeUInt32LE(entry.size, 20);
+        header.writeUInt32LE(entry.size, 24);
+        header.writeUInt16LE(entry.name.length, 28);
+        header.writeUInt16LE(0, 30);
+        header.writeUInt16LE(0, 32);
+        header.writeUInt16LE(0, 34);
+        header.writeUInt16LE(0, 36);
+        header.writeUInt32LE(0, 38);
+        header.writeUInt32LE(entry.offset, 42);
+        chunks.push(header, entry.name);
+        offset += header.length + entry.name.length;
+    }
+    const centralSize = offset - centralStart;
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(0, 4);
+    end.writeUInt16LE(0, 6);
+    end.writeUInt16LE(central.length, 8);
+    end.writeUInt16LE(central.length, 10);
+    end.writeUInt32LE(centralSize, 12);
+    end.writeUInt32LE(centralStart, 16);
+    end.writeUInt16LE(0, 20);
+    chunks.push(end);
+    return Buffer.concat(chunks);
+}
+function normalizeZipName(name) {
+    const normalized = name.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!normalized || normalized.includes("..")) {
+        throw new Error(`Invalid zip entry name: ${name}`);
+    }
+    return normalized;
+}
+function computeCrc32(data) {
+    let crc = 0xffffffff;
+    for (const byte of data) {
+        crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}