@bash0816/copilot-termux 1.0.63

package/lib/setup.js

@@ -0,0 +1,143 @@
+'use strict';
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { execFileSync } = require('child_process');
+const manifest = require('../config/manifest.json');
+
+const REGISTRY = 'https://registry.npmjs.org';
+const CACHE_DIR = path.join(os.homedir(), '.copilot-termux');
+
+function httpsGet(url, headers) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const opts = {
+      hostname: parsedUrl.hostname,
+      path: parsedUrl.pathname + parsedUrl.search,
+      headers: headers || {},
+    };
+    https.get(opts, res => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        resolve(httpsGet(res.headers.location, headers));
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode} from ${url}`));
+        return;
+      }
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+      res.on('error', reject);
+    }).on('error', reject);
+  });
+}
+
+async function fetchWithIntegrity(url, expectedIntegrity) {
+  const buf = await httpsGet(url);
+  const [algo, expected] = expectedIntegrity.split('-');
+  const actual = crypto.createHash(algo).update(buf).digest('base64');
+  const expectedBuf = Buffer.from(expected, 'base64');
+  const actualBuf = Buffer.from(actual, 'base64');
+  if (expectedBuf.length !== actualBuf.length || !crypto.timingSafeEqual(expectedBuf, actualBuf)) {
+    throw new Error(`integrity check failed: expected ${expectedIntegrity}, got ${algo}-${actual}`);
+  }
+  return buf;
+}
+
+async function setup() {
+  const { version, integrity } = manifest.copilot;
+  const versionDir = path.join(CACHE_DIR, version);
+  const stagingDir = `${versionDir}.staging`;
+
+  if (fs.existsSync(path.join(versionDir, 'index.js'))) {
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+    console.log(`@github/copilot@${version} already installed, refreshing symlink...`);
+  } else {
+    console.log(`Fetching @github/copilot@${version} metadata...`);
+    const metaBuf = await httpsGet(`${REGISTRY}/@github/copilot/${version}`, { Accept: 'application/json' });
+    const meta = JSON.parse(metaBuf.toString());
+    const tarballUrl = meta.dist.tarball;
+
+    console.log(`Downloading @github/copilot@${version}...`);
+    const tarball = await fetchWithIntegrity(tarballUrl, integrity);
+
+    const tarballPath = path.join(CACHE_DIR, `copilot-${version}.tgz`);
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+
+    try {
+      fs.rmSync(stagingDir, { recursive: true, force: true });
+      fs.writeFileSync(tarballPath, tarball);
+
+      console.log('Extracting...');
+      fs.mkdirSync(stagingDir, { recursive: true });
+      execFileSync('tar', ['-xzf', tarballPath, '-C', stagingDir, '--strip-components=1']);
+
+      if (!fs.existsSync(path.join(stagingDir, 'index.js'))) {
+        throw new Error(`installation incomplete: missing ${path.join(stagingDir, 'index.js')}`);
+      }
+
+      if (fs.existsSync(versionDir)) {
+        fs.rmSync(versionDir, { recursive: true, force: true });
+      }
+      fs.renameSync(stagingDir, versionDir);
+    } catch (err) {
+      fs.rmSync(stagingDir, { recursive: true, force: true });
+      throw err;
+    } finally {
+      fs.rmSync(tarballPath, { force: true });
+    }
+  }
+
+  const currentLink = path.join(CACHE_DIR, 'current');
+  const tmp = path.join(CACHE_DIR, `current.tmp.${process.pid}`);
+  try { fs.unlinkSync(tmp); } catch (_) {}
+  fs.symlinkSync(versionDir, tmp);
+  fs.renameSync(tmp, currentLink);
+
+  await setupGlibcWrap();
+  console.log(`✓ copilot ${version} ready`);
+}
+
+async function setupGlibcWrap() {
+  const PREFIX = process.env.PREFIX || '/data/data/com.termux/files/usr';
+  const glibcDir = path.join(PREFIX, 'glibc', 'lib');
+  const LD = path.join(glibcDir, 'ld-linux-aarch64.so.1');
+  if (!fs.existsSync(LD)) {
+    throw new Error(`[copilot-termux] glibc not found at ${glibcDir}. Please install glibc-repo: pkg install glibc-repo && pkg install glibc`);
+  }
+
+  const wrapLibsDir = path.join(CACHE_DIR, 'glibc-wrap-libs');
+  const mxcWrapDir = path.join(CACHE_DIR, 'mxc-wrap', 'arm64');
+
+  fs.rmSync(wrapLibsDir, { recursive: true, force: true });
+  fs.mkdirSync(wrapLibsDir, { recursive: true });
+  fs.mkdirSync(mxcWrapDir, { recursive: true });
+
+  for (const lib of ['ld-linux-aarch64.so.1', 'libc.so.6', 'libgcc_s.so.1']) {
+    const src = path.join(glibcDir, lib);
+    if (!fs.existsSync(src)) throw new Error(`[copilot-termux] Missing glibc lib: ${src}`);
+    fs.copyFileSync(src, path.join(wrapLibsDir, lib));
+  }
+
+  const libcSo = path.join(wrapLibsDir, 'libc.so');
+  try { fs.unlinkSync(libcSo); } catch (_) {}
+  fs.symlinkSync('libc.so.6', libcSo);
+
+  const wrapperPath = path.join(mxcWrapDir, 'lxc-exec');
+  const wrapperContent = [
+    '#!/bin/sh',
+    '_CACHE="${HOME}/.copilot-termux"',
+    '_LIBS="${_CACHE}/glibc-wrap-libs"',
+    '_LD="${_LIBS}/ld-linux-aarch64.so.1"',
+    '_LXC="${_CACHE}/current/mxc-bin/arm64/lxc-exec"',
+    'exec env -u LD_PRELOAD "$_LD" --library-path "$_LIBS" "$_LXC" "$@"',
+  ].join('\n') + '\n';
+  fs.writeFileSync(wrapperPath, wrapperContent, { mode: 0o755 });
+
+  console.log('✓ glibc wrap for lxc-exec ready');
+}
+
+module.exports = { setup };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@bash0816/copilot-termux",
+  "version": "1.0.63",
+  "description": "GitHub Copilot CLI for Termux (Android aarch64)",
+  "license": "GPL-3.0-only",
+  "readme": "README.md",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bash0816/Github-Copilot-Termux.git"
+  },
+  "homepage": "https://github.com/bash0816/Github-Copilot-Termux#readme",
+  "keywords": ["termux", "android", "github-copilot", "copilot-cli", "aarch64"],
+  "bin": {
+    "copilot": "bin/copilot",
+    "copilot-termux": "bin/copilot-termux"
+  },
+  "scripts": {},
+  "files": ["bin", "lib/platform-patch.js", "lib/setup.js", "lib/bionic-compat.so", "lib/native/pty.node", "scripts/bionic-compat.c", "config", "LICENSE", "THIRD-PARTY-NOTICES.md", "THIRD-PARTY-LICENSES/", "README.md"],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": ["android", "linux"],
+  "cpu": ["arm64"]
+}

package/scripts/bionic-compat.c

@@ -0,0 +1,82 @@
+/*
+ * bionic-compat.so: provides glibc/musl symbols missing from Android bionic,
+ * so that linuxmusl-arm64/runtime.node can be dlopen'd on Termux.
+ * Load as LD_PRELOAD before Node.js.
+ */
+#define _GNU_SOURCE
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <spawn.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <dlfcn.h>
+#include <math.h>
+
+/* bionic exports __errno() instead of __errno_location() */
+extern int *__errno(void);
+int *__errno_location(void) { return __errno(); }
+
+int bcmp(const void *s1, const void *s2, size_t n) { return memcmp(s1, s2, n); }
+
+/* jemalloc sized dealloc - bionic uses scudo, delegate to free */
+void sdallocx(void *ptr, size_t size, int flags) {
+    (void)size; (void)flags;
+    free(ptr);
+}
+
+/* XSI strerror_r (int-returning); bionic's strerror_r returns char* */
+int __xpg_strerror_r(int errnum, char *buf, size_t buflen) {
+    const char *s = strerror(errnum);
+    if (!s) { *__errno() = EINVAL; return EINVAL; }
+    size_t len = strlen(s);
+    if (len >= buflen) { *__errno() = ERANGE; return ERANGE; }
+    memcpy(buf, s, len + 1);
+    return 0;
+}
+
+/* pidfd APIs absent from this Android kernel version */
+int pidfd_getpid(int fd) { (void)fd; *__errno() = ENOSYS; return -1; }
+
+int pidfd_spawnp(int *pidfd,
+                 const char *path,
+                 const posix_spawn_file_actions_t *fa,
+                 const posix_spawnattr_t *attr,
+                 char *const argv[],
+                 char *const envp[]) {
+    (void)pidfd; (void)path; (void)fa; (void)attr; (void)argv; (void)envp;
+    *__errno() = ENOSYS;
+    return -1;
+}
+
+/* musl bundles math in libc.so; bionic splits to libm.so.
+ * Since we are LD_PRELOAD, RTLD_NEXT finds the real libm.so symbols. */
+typedef double (*fn_dd)(double);
+typedef double (*fn_ddd)(double, double);
+typedef float  (*fn_ff)(float);
+
+static fn_ddd _pow;
+static fn_dd  _log;
+static fn_dd  _log2;
+static fn_ff  _expf;
+static fn_ff  _log10f;
+static fn_ff  _sinf;
+
+__attribute__((constructor))
+static void compat_init(void) {
+    _pow    = (fn_ddd)dlsym(RTLD_NEXT, "pow");
+    _log    = (fn_dd) dlsym(RTLD_NEXT, "log");
+    _log2   = (fn_dd) dlsym(RTLD_NEXT, "log2");
+    _expf   = (fn_ff) dlsym(RTLD_NEXT, "expf");
+    _log10f = (fn_ff) dlsym(RTLD_NEXT, "log10f");
+    _sinf   = (fn_ff) dlsym(RTLD_NEXT, "sinf");
+    /* NULL is expected in non-node processes (shells) that inherit LD_PRELOAD
+     * but do not link libm.so. Those processes never invoke math stubs. */
+}
+
+double pow(double x, double y)   { if (!_pow)    abort(); return _pow(x, y); }
+double log(double x)             { if (!_log)    abort(); return _log(x); }
+double log2(double x)            { if (!_log2)   abort(); return _log2(x); }
+float  expf(float x)             { if (!_expf)   abort(); return _expf(x); }
+float  log10f(float x)           { if (!_log10f) abort(); return _log10f(x); }
+float  sinf(float x)             { if (!_sinf)   abort(); return _sinf(x); }