cli-link 0.0.1

package/dist/server/terminal-qr.js

@@ -0,0 +1,317 @@
+const QR_TOTAL_CODEWORDS = [0, 26, 44, 70, 100, 134, 172];
+const QR_EC_CODEWORDS_PER_BLOCK_M = [0, 10, 16, 26, 18, 24, 16];
+const QR_NUM_ERROR_CORRECTION_BLOCKS_M = [0, 1, 1, 1, 2, 2, 4];
+const QR_ALIGNMENT_POSITIONS = [
+    [],
+    [],
+    [6, 18],
+    [6, 22],
+    [6, 26],
+    [6, 30],
+    [6, 34],
+];
+class BitBuffer {
+    bits = [];
+    append(value, length) {
+        for (let i = length - 1; i >= 0; i -= 1) {
+            this.bits.push((value >>> i) & 1);
+        }
+    }
+    toBytes() {
+        const bytes = [];
+        for (let i = 0; i < this.bits.length; i += 8) {
+            let value = 0;
+            for (let j = 0; j < 8; j += 1) {
+                value = (value << 1) | (this.bits[i + j] || 0);
+            }
+            bytes.push(value);
+        }
+        return bytes;
+    }
+}
+function getQrDataCodewordCount(version) {
+    return QR_TOTAL_CODEWORDS[version] - QR_EC_CODEWORDS_PER_BLOCK_M[version] * QR_NUM_ERROR_CORRECTION_BLOCKS_M[version];
+}
+function selectQrVersion(data) {
+    for (let version = 1; version < QR_TOTAL_CODEWORDS.length; version += 1) {
+        const capacityBits = getQrDataCodewordCount(version) * 8;
+        if (4 + 8 + data.length * 8 <= capacityBits)
+            return version;
+    }
+    return null;
+}
+function qrMultiply(x, y) {
+    let z = 0;
+    for (let i = 7; i >= 0; i -= 1) {
+        z = (z << 1) ^ ((z >>> 7) * 0x11d);
+        z ^= ((y >>> i) & 1) * x;
+    }
+    return z;
+}
+function qrReedSolomonDivisor(degree) {
+    const result = Array(degree).fill(0);
+    result[degree - 1] = 1;
+    let root = 1;
+    for (let i = 0; i < degree; i += 1) {
+        for (let j = 0; j < result.length; j += 1) {
+            result[j] = qrMultiply(result[j], root);
+            if (j + 1 < result.length)
+                result[j] ^= result[j + 1];
+        }
+        root = qrMultiply(root, 0x02);
+    }
+    return result;
+}
+function qrReedSolomonRemainder(data, divisor) {
+    const result = Array(divisor.length).fill(0);
+    for (const byte of data) {
+        const factor = byte ^ (result.shift() || 0);
+        result.push(0);
+        for (let i = 0; i < divisor.length; i += 1) {
+            result[i] ^= qrMultiply(divisor[i], factor);
+        }
+    }
+    return result;
+}
+function qrAddEccAndInterleave(dataCodewords, version) {
+    const numBlocks = QR_NUM_ERROR_CORRECTION_BLOCKS_M[version];
+    const blockEccLen = QR_EC_CODEWORDS_PER_BLOCK_M[version];
+    const rawCodewords = QR_TOTAL_CODEWORDS[version];
+    const numShortBlocks = numBlocks - (rawCodewords % numBlocks);
+    const shortBlockLen = Math.floor(rawCodewords / numBlocks);
+    const divisor = qrReedSolomonDivisor(blockEccLen);
+    const blocks = [];
+    for (let i = 0, offset = 0; i < numBlocks; i += 1) {
+        const dataLen = shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1);
+        const data = dataCodewords.slice(offset, offset + dataLen);
+        offset += dataLen;
+        const ecc = qrReedSolomonRemainder(data, divisor);
+        if (i < numShortBlocks)
+            data.push(0);
+        blocks.push(data.concat(ecc));
+    }
+    const result = [];
+    for (let i = 0; i < blocks[0].length; i += 1) {
+        for (let j = 0; j < blocks.length; j += 1) {
+            if (i !== shortBlockLen - blockEccLen || j >= numShortBlocks) {
+                result.push(blocks[j][i]);
+            }
+        }
+    }
+    return result;
+}
+function qrFormatBits(mask) {
+    const data = mask; // Error correction level M has format bits 00.
+    let rem = data;
+    for (let i = 0; i < 10; i += 1) {
+        rem = (rem << 1) ^ (((rem >>> 9) & 1) * 0x537);
+    }
+    return ((data << 10) | rem) ^ 0x5412;
+}
+function qrMask(mask, x, y) {
+    switch (mask) {
+        case 0: return (x + y) % 2 === 0;
+        case 1: return y % 2 === 0;
+        case 2: return x % 3 === 0;
+        case 3: return (x + y) % 3 === 0;
+        case 4: return (Math.floor(y / 2) + Math.floor(x / 3)) % 2 === 0;
+        case 5: return ((x * y) % 2) + ((x * y) % 3) === 0;
+        case 6: return (((x * y) % 2) + ((x * y) % 3)) % 2 === 0;
+        case 7: return (((x + y) % 2) + ((x * y) % 3)) % 2 === 0;
+        default: return false;
+    }
+}
+function createQrMatrix(text) {
+    const data = new TextEncoder().encode(text);
+    const version = selectQrVersion(data);
+    if (!version)
+        return null;
+    const dataCodewordCount = getQrDataCodewordCount(version);
+    const buffer = new BitBuffer();
+    buffer.append(0b0100, 4);
+    buffer.append(data.length, 8);
+    for (const byte of data)
+        buffer.append(byte, 8);
+    const capacityBits = dataCodewordCount * 8;
+    buffer.append(0, Math.min(4, capacityBits - buffer.bits.length));
+    while (buffer.bits.length % 8 !== 0)
+        buffer.append(0, 1);
+    const dataCodewords = buffer.toBytes();
+    for (let pad = 0xec; dataCodewords.length < dataCodewordCount; pad ^= 0xec ^ 0x11) {
+        dataCodewords.push(pad);
+    }
+    const codewords = qrAddEccAndInterleave(dataCodewords, version);
+    const size = version * 4 + 17;
+    const modules = Array.from({ length: size }, () => Array(size).fill(false));
+    const isFunction = Array.from({ length: size }, () => Array(size).fill(false));
+    const setFunction = (x, y, dark) => {
+        if (x < 0 || y < 0 || x >= size || y >= size)
+            return;
+        modules[y][x] = dark;
+        isFunction[y][x] = true;
+    };
+    const drawFinder = (cx, cy) => {
+        for (let dy = -4; dy <= 4; dy += 1) {
+            for (let dx = -4; dx <= 4; dx += 1) {
+                const dist = Math.max(Math.abs(dx), Math.abs(dy));
+                setFunction(cx + dx, cy + dy, dist !== 2 && dist !== 4);
+            }
+        }
+    };
+    const drawAlignment = (cx, cy) => {
+        for (let dy = -2; dy <= 2; dy += 1) {
+            for (let dx = -2; dx <= 2; dx += 1) {
+                setFunction(cx + dx, cy + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+            }
+        }
+    };
+    const drawFormat = (mask) => {
+        const bits = qrFormatBits(mask);
+        for (let i = 0; i <= 5; i += 1)
+            setFunction(8, i, ((bits >>> i) & 1) !== 0);
+        setFunction(8, 7, ((bits >>> 6) & 1) !== 0);
+        setFunction(8, 8, ((bits >>> 7) & 1) !== 0);
+        setFunction(7, 8, ((bits >>> 8) & 1) !== 0);
+        for (let i = 9; i < 15; i += 1)
+            setFunction(14 - i, 8, ((bits >>> i) & 1) !== 0);
+        for (let i = 0; i < 8; i += 1)
+            setFunction(size - 1 - i, 8, ((bits >>> i) & 1) !== 0);
+        for (let i = 8; i < 15; i += 1)
+            setFunction(8, size - 15 + i, ((bits >>> i) & 1) !== 0);
+        setFunction(8, size - 8, true);
+    };
+    drawFinder(3, 3);
+    drawFinder(size - 4, 3);
+    drawFinder(3, size - 4);
+    const alignment = QR_ALIGNMENT_POSITIONS[version];
+    for (const x of alignment) {
+        for (const y of alignment) {
+            if (isFunction[y]?.[x])
+                continue;
+            drawAlignment(x, y);
+        }
+    }
+    for (let i = 8; i < size - 8; i += 1) {
+        setFunction(6, i, i % 2 === 0);
+        setFunction(i, 6, i % 2 === 0);
+    }
+    drawFormat(0);
+    let bitIndex = 0;
+    for (let right = size - 1; right >= 1; right -= 2) {
+        if (right === 6)
+            right -= 1;
+        for (let vert = 0; vert < size; vert += 1) {
+            const y = ((right + 1) & 2) === 0 ? size - 1 - vert : vert;
+            for (let j = 0; j < 2; j += 1) {
+                const x = right - j;
+                if (isFunction[y][x])
+                    continue;
+                modules[y][x] = ((codewords[Math.floor(bitIndex / 8)] >>> (7 - (bitIndex % 8))) & 1) !== 0;
+                bitIndex += 1;
+            }
+        }
+    }
+    let bestMask = 0;
+    let bestPenalty = Infinity;
+    for (let mask = 0; mask < 8; mask += 1) {
+        const penalty = scoreQrMask(modules, isFunction, mask);
+        if (penalty < bestPenalty) {
+            bestMask = mask;
+            bestPenalty = penalty;
+        }
+    }
+    for (let y = 0; y < size; y += 1) {
+        for (let x = 0; x < size; x += 1) {
+            if (!isFunction[y][x] && qrMask(bestMask, x, y))
+                modules[y][x] = !modules[y][x];
+        }
+    }
+    drawFormat(bestMask);
+    return modules;
+}
+function scoreQrMask(modules, isFunction, mask) {
+    const size = modules.length;
+    const get = (x, y) => modules[y][x] !== (!isFunction[y][x] && qrMask(mask, x, y));
+    let penalty = 0;
+    for (let y = 0; y < size; y += 1) {
+        let runColor = get(0, y);
+        let runLen = 1;
+        for (let x = 1; x < size; x += 1) {
+            const color = get(x, y);
+            if (color === runColor) {
+                runLen += 1;
+                if (runLen === 5)
+                    penalty += 3;
+                else if (runLen > 5)
+                    penalty += 1;
+            }
+            else {
+                runColor = color;
+                runLen = 1;
+            }
+        }
+    }
+    for (let x = 0; x < size; x += 1) {
+        let runColor = get(x, 0);
+        let runLen = 1;
+        for (let y = 1; y < size; y += 1) {
+            const color = get(x, y);
+            if (color === runColor) {
+                runLen += 1;
+                if (runLen === 5)
+                    penalty += 3;
+                else if (runLen > 5)
+                    penalty += 1;
+            }
+            else {
+                runColor = color;
+                runLen = 1;
+            }
+        }
+    }
+    let dark = 0;
+    for (let y = 0; y < size; y += 1) {
+        for (let x = 0; x < size; x += 1) {
+            if (get(x, y))
+                dark += 1;
+            if (x + 1 < size && y + 1 < size) {
+                const color = get(x, y);
+                if (color === get(x + 1, y) && color === get(x, y + 1) && color === get(x + 1, y + 1)) {
+                    penalty += 3;
+                }
+            }
+        }
+    }
+    const total = size * size;
+    penalty += Math.floor(Math.abs(dark * 20 - total * 10) / total) * 10;
+    return penalty;
+}
+export function renderTerminalQr(text, options = {}) {
+    const modules = createQrMatrix(text);
+    if (!modules)
+        return null;
+    const size = modules.length;
+    const quiet = 2;
+    const lines = [];
+    if (options.color === false) {
+        for (let y = -quiet; y < size + quiet; y += 1) {
+            let line = '';
+            for (let x = -quiet; x < size + quiet; x += 1) {
+                const dark = x >= 0 && x < size && y >= 0 && y < size && modules[y][x];
+                line += dark ? '██' : '  ';
+            }
+            lines.push(line);
+        }
+        return lines.join('\n');
+    }
+    for (let y = -quiet; y < size + quiet; y += 2) {
+        let line = '\x1b[30;47m';
+        for (let x = -quiet; x < size + quiet; x += 1) {
+            const top = x >= 0 && x < size && y >= 0 && y < size && modules[y][x];
+            const bottom = x >= 0 && x < size && y + 1 >= 0 && y + 1 < size && modules[y + 1][x];
+            line += top && bottom ? '█' : top ? '▀' : bottom ? '▄' : ' ';
+        }
+        lines.push(`${line}\x1b[0m`);
+    }
+    return lines.join('\n');
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "cli-link",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": {
+    "cli-link": "bin/agentpilot.js"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md",
+    "package.json"
+  ],
+  "packageManager": "pnpm@10.32.1",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "dev": "vite",
+    "dev:server": "caffeinate -i tsx watch server/index.ts < /dev/null",
+    "dev:all": "concurrently \"pnpm dev\" \"pnpm dev:server\"",
+    "clean": "node scripts/clean-dist.js",
+    "build": "pnpm clean && pnpm build:client && pnpm build:server",
+    "build:client": "tsc && vite build",
+    "build:server": "tsc -p tsconfig.server.json",
+    "preview": "vite preview",
+    "start": "caffeinate -i tsx server/index.ts",
+    "serve": "node bin/agentpilot.js",
+    "prepack": "pnpm build",
+    "publish:dry-run": "npm publish --dry-run --registry=https://registry.npmjs.org --access public",
+    "publish:public": "npm publish --registry=https://registry.npmjs.org --access public"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.9.0",
+    "ws": "^8.16.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3",
+      "node-pty"
+    ]
+  },
+  "devDependencies": {
+    "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1",
+    "@tanstack/react-virtual": "^3.13.23",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.6.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@types/ws": "^8.5.10",
+    "@vitejs/plugin-react": "^4.2.0",
+    "autoprefixer": "^10.4.19",
+    "clsx": "2.1.1",
+    "concurrently": "^8.2.0",
+    "framer-motion": "11.1.7",
+    "lucide-react": "0.378.0",
+    "node-pty": "^1.1.0",
+    "postcss": "^8.4.38",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "react-markdown": "^9.0.1",
+    "react-router-dom": "6.23.0",
+    "rehype-highlight": "^7.0.2",
+    "remark-gfm": "^4.0.0",
+    "tailwindcss": "^3.4.3",
+    "tailwind-merge": "2.3.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0",
+    "vite": "^5.2.0"
+  }
+}