@bash0816/copilot-termux 1.0.63 → 1.0.65

package/config/manifest.json

@@ -1,7 +1,8 @@
 {
   "wrapperVersion": "2.0.0",
   "copilot": {
-    "version": "1.0.63",
-    "integrity": "sha512-e8DRYiWJQc4kepVXsXjC8vpDU2FXS/TfR+Z6p/KAojfcwIUZzKMAfCV5D1lD25hV4CryVH1Z9t7mHqChickj0Q=="
+    "package": "@github/copilot-linuxmusl-arm64",
+    "version": "1.0.64",
+    "integrity": "sha512-C+EYoMvmlUxR0YYxLkD3nwn940y0zId8z+pPl9rFO6f9heMGXYCwCZL2i2c3GW6CvGgZF6Wbzw1Kk0Gvw46F2w=="
   }
 }

package/lib/platform-patch.js

@@ -19,6 +19,10 @@ const Module = require('module');
 const fs = require('fs');
 const path = require('path');
 
+const _pkgVersion = (() => {
+  try { return require(path.join(__dirname, '..', 'package.json')).version; } catch (_) { return '1.0.65'; }
+})();
+
 // Bundled Termux-native pty.node (built against bionic, not glibc).
 const NATIVE_PTY = path.join(__dirname, 'native', 'pty.node');
 
@@ -58,19 +62,86 @@ Module._load = function (request, parent, isMain) {
   const result = origLoad(request, parent, isMain);
   if (typeof request === 'string' &&
       path.basename(request) === 'runtime.node') {
+    if (result.__copilotTermuxPatched) return result;
+    result.__copilotTermuxPatched = true;
     // Rust tokio を使う関数群を no-op に差し替え。
     // sessionStore*/sessionSqlite* は非同期 SQLite (tokio)、
     // modelHttp*/networkFetch*/ahpRelay*/websocketResponses* は Rust HTTP (tokio)。
+    // jsonrpcServer* は拡張 JSON-RPC サーバー (ThreadsafeFunction)、
+    // lspClient* は LSP クライアント (ThreadsafeFunction)。
     // featureFlagService* は同期 Rust のため除外（no-op にすると .handle クラッシュ）。
-    const TOKIO_PATTERN = /^(modelHttp|networkFetch|ahpRelay|websocketResponses|sessionStore|sessionSqlite)/;
+    const TOKIO_PATTERN = /^(modelHttp|networkFetch|ahpRelay|websocketResponses|sessionStore|sessionSqlite|jsonrpcServer|lspClient)/;
     for (const key of Object.keys(result)) {
       if (TOKIO_PATTERN.test(key) && typeof result[key] === 'function') {
         result[key] = () => undefined;
       }
     }
+    // git*Async: Rust tokio async functions — type-safe stubs to prevent SIGSEGV.
+    // Returns empty/null values matching what app.js callers expect.
+    const GIT_ASYNC_STUBS = {
+      gitMutateAsync:             async () => undefined,
+      gitCommandAsync:            async () => '',
+      gitRemotesAsync:            async () => [],
+      gitDiffFileAsync:           async () => '',
+      gitHashFileAsync:           async () => [],
+      gitMergeBaseAsync:          async () => null,
+      gitDiffForRefAsync:         async () => '',
+      gitCurrentBranchAsync:      async () => null,
+      gitDefaultBranchAsync:      async () => null,
+      gitListWorktreesAsync:      async () => [],
+      gitBranchAndHeadAsync:      async () => null,
+      gitSubmodulePathsAsync:     async () => [],
+      gitUntrackedPathsAsync:     async () => [],
+      gitDiffNameStatusAsync:     async () => '',
+      gitStatusPorcelainAsync:    async () => '',
+      gitWorkingTreeStatusAsync:  async () => ({ hasUnstagedChanges: false, hasStagedChanges: false, hasUntrackedFiles: false }),
+      gitStatusPorcelainAllAsync: async () => null,
+      gitCurrentBranchRemoteAsync: async () => null,
+      gitWorkingTreeDiffStatsAsync: async () => ({ linesAdded: 0, linesRemoved: 0 }),
+    };
+    for (const [key, stub] of Object.entries(GIT_ASYNC_STUBS)) {
+      if (typeof result[key] === 'function') result[key] = stub;
+    }
+    if (typeof result.registerLogSink === 'function') {
+      result.registerLogSink = () => { throw new Error('[copilot-termux] registerLogSink disabled on bionic (no tokio thread)'); };
+    }
     if (typeof result.networkFetchGetExtraCaPems === 'function') {
       result.networkFetchGetExtraCaPems = () => ({ errors: [], pems: [] });
     }
+    // modelsFilterToPicker: native-first。native が空のとき（model_picker_enabled=true のモデルが
+    // 全くない場合）のみ全インデックス fallback。
+    // free アカウントでは全モデルが model_picker_enabled=false → native 空 → fallback で全通し
+    //（auto モードが enterprise 向けモデルを選んで 400 になる副作用は AUTH-001 解決後に再評価）。
+    // enterprise アカウントでは native が正しくフィルタする。
+    if (typeof result.modelsFilterToPicker === 'function') {
+      const _nativeModelsFilterToPicker = result.modelsFilterToPicker;
+      result.modelsFilterToPicker = function(modelsJson) {
+        const nativeResult = _nativeModelsFilterToPicker(modelsJson);
+        _dbg('modelsFilterToPicker', { nativeResult, modelCount: (() => { try { return JSON.parse(modelsJson).length; } catch(_) { return -1; } })() });
+        if (Array.isArray(nativeResult) && nativeResult.length > 0) return nativeResult;
+        try {
+          const models = JSON.parse(modelsJson);
+          return Array.isArray(models) ? models.map((_, i) => i) : [];
+        } catch(_) { return []; }
+      };
+    }
+    // authGetCopilotApiUrl: type=token/env/user/gh-cli/api-key では native が null を返す。
+    // _b() はこれを見て models=[] を返しモデル選択が "No supported model" になる。
+    // OAuth token でも標準 copilot API URL は固定のため、null 時はデフォルト URL を返す。
+    if (typeof result.authGetCopilotApiUrl === 'function') {
+      const _nativeGetCopilotApiUrl = result.authGetCopilotApiUrl;
+      result.authGetCopilotApiUrl = function(authInfoJson, token) {
+        const r = _nativeGetCopilotApiUrl(authInfoJson, token);
+        if (r != null) return r;
+        try {
+          const info = JSON.parse(authInfoJson);
+          if (info && info.type !== 'hmac') {
+            return process.env.COPILOT_API_URL || 'https://api.githubcopilot.com';
+          }
+        } catch (_) {}
+        return r;
+      };
+    }
     // capiClientListModels を Node.js fetch で実装（Rust tokio SIGSEGV 回避）
     if (typeof result.capiClientListModels === 'function') {
       result.capiClientListModels = async function(handle, _includeHidden, _skipCache, _applyModelLimitCaps, _networkingConfigId) {
@@ -84,7 +155,8 @@ Module._load = function (request, parent, isMain) {
         } catch (e) {
           throw new Error(JSON.stringify({kind: 'network', message: `prepareHeaders failed: ${e.message}`}));
         }
-        const baseUrl = 'https://api.githubcopilot.com';
+        const baseUrl = process.env.COPILOT_API_URL || 'https://api.githubcopilot.com';
+        _dbg('capiClientListModels:fetch', { baseUrl });
         let res;
         try {
           res = await globalThis.fetch(`${baseUrl}/models`, {method: 'GET', headers: authHeaders});
@@ -315,6 +387,7 @@ Module._load = function (request, parent, isMain) {
     if (typeof result.anthropicMessageStreamAccumulatorFinish === 'function') {
       result.anthropicMessageStreamAccumulatorFinish = function(id) {
         const acc = _jsAccs.get(id) || { message: null };
+        _dbg('accumulatorFinish', { id, message: acc.message ? { stop_reason: acc.message.stop_reason, contentTypes: (acc.message.content||[]).map(b=>b.type+':'+(b.text||'').slice(0,30)) } : null });
         _jsAccs.delete(id);
         return { json: JSON.stringify({ message: acc.message }) };
       };
@@ -330,6 +403,7 @@ Module._load = function (request, parent, isMain) {
     // 4. modelHttpStreamStart → fetch full SSE body, parse events
     result.modelHttpStreamStart = async function(jsonArg) {
       const req = JSON.parse(jsonArg);
+      _dbg('modelHttpStreamStart', { url: req.url, method: req.method });
       let body = req.body;
       if (body !== null && body !== undefined && typeof body === 'object') {
         if (body.type === 'Buffer' && Array.isArray(body.data)) {
@@ -355,12 +429,42 @@ Module._load = function (request, parent, isMain) {
         return { json: JSON.stringify({ bodyText, status: res.status, statusText: res.statusText, headers, streamId: null }) };
       }
       const events = _parseAnthropicSSE(bodyText);
+      _dbg('modelHttpStreamStart:parsed', { status: res.status, eventCount: events.length, bodySnippet: bodyText.slice(0, 300) });
       const finalMessage = _reconstructFinalMessage(events);
       const streamId = 'js-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2);
       _jsStreams.set(streamId, { events, index: 0, finalMessage });
       return { json: JSON.stringify({ bodyText: null, status: res.status, statusText: res.statusText, headers, streamId }) };
     };
 
+    // Helper: convert Anthropic SSE event → chunkContext for processAnthropicStreamingChunkContext
+    function _toChunkContext(event, streamId) {
+      const base = { content: '', size: 0, chunkBoundary: false, messageStart: false, streamingId: streamId };
+      if (!event || !event.type) return base;
+      switch (event.type) {
+        case 'message_start':
+          return { ...base, messageStart: true };
+        case 'content_block_delta': {
+          const d = event.delta;
+          if (!d) return base;
+          if (d.type === 'text_delta') {
+            const t = d.text || '';
+            return { ...base, content: t, size: Buffer.byteLength(t, 'utf8') };
+          }
+          if (d.type === 'thinking_delta') {
+            const r = d.thinking || '';
+            return { ...base, reasoningContent: r, size: Buffer.byteLength(r, 'utf8') };
+          }
+          return base;
+        }
+        case 'content_block_stop':
+        case 'message_delta':
+        case 'message_stop':
+          return { ...base, chunkBoundary: true };
+        default:
+          return base;
+      }
+    }
+
     // 5. modelHttpStreamNextAnthropicMessageEvent → yield events one by one
     result.modelHttpStreamNextAnthropicMessageEvent = async function(streamId, accId) {
       const st = _jsStreams.get(streamId);
@@ -372,7 +476,10 @@ Module._load = function (request, parent, isMain) {
         }
         return null;
       }
-      return { json: JSON.stringify({ kind: 'ok', processResult: { event: st.events[st.index++] } }) };
+      const event = st.events[st.index++];
+      const chunkContext = _toChunkContext(event, streamId);
+      const tokenEvent = event.type === 'content_block_delta' && !!(event.delta && event.delta.type === 'text_delta');
+      return { json: JSON.stringify({ kind: 'ok', processResult: { event, chunkContext, tokenEvent, copilotUsage: null } }) };
     };
 
     // 6. modelHttpStreamCancel → cleanup
@@ -417,6 +524,7 @@ Module._load = function (request, parent, isMain) {
       if (!st) {
         throw new Error(`Native mod HTTP stream was not found: ${streamId}`);
       }
+      _dbg('responsesStreamDrive:start', { streamId, eventCount: st.events.length, hasProcessors, sample: st.events.slice(0,2) });
       _jsStreams.delete(streamId);
       let copilotUsage = null;
       for (const event of st.events) {
@@ -427,6 +535,7 @@ Module._load = function (request, parent, isMain) {
         if (parsed && parsed.copilotUsage !== undefined && parsed.copilotUsage !== null)
           copilotUsage = parsed.copilotUsage;
         const cc = parsed && parsed.chunkContext;
+        _dbg('responsesStreamDrive:chunk', { eventType: event.type, cc: cc ? { content: cc.content, size: cc.size, messageStart: !!cc.messageStart, chunkBoundary: !!cc.chunkBoundary } : null });
         if (hasProcessors && typeof onChunkCallback === 'function' && cc &&
             (cc.content || cc.messageStart || cc.reportIntentArguments || cc.chunkBoundary || cc.size > 0)) {
           try { onChunkCallback(JSON.stringify(cc)); } catch (_) {}
@@ -434,14 +543,459 @@ Module._load = function (request, parent, isMain) {
       }
       return { json: JSON.stringify({ kind: 'ok', copilotUsage, ttftMs: null, interTokenLatencyMs: null }) };
     };
+    // === authManager* JS stubs (1.0.64: tokio thread spawn → SIGSEGV on bionic) ===
+    const _authMgr = new Map(); // uuid → { cachedInfo, pendingInfo, cachedToken, cachedHost, gen }
+
+    result.authManagerCreate = function(uuid, hostUri, userAgent, path, normSpec, header, envVar, disableAutoLogin) {
+      _authMgr.set(uuid, { cachedInfo: null, pendingInfo: null, cachedToken: null, cachedHost: null, gen: 0 });
+      // native 非呼び出し: tokio runtime 生成を阻止
+    };
+
+    async function _buildAuthInfo(token, hostUri) {
+      let login = null;
+      let copilotUser = null;
+      _dbg('buildAuthInfo:start', { tokenHash: _tokenHash(token), hostUri });
+      try {
+        const apiHost = hostUri.replace('https://github.com', 'https://api.github.com');
+        const res = await globalThis.fetch(`${apiHost}/user`, {
+          headers: { Authorization: `token ${token}`, 'User-Agent': `copilot-termux/${_pkgVersion}` },
+          signal: AbortSignal.timeout(5000),
+        });
+        if (res.ok) login = (await res.json()).login;
+        _dbg('buildAuthInfo:/user', { status: res.status, login });
+      } catch (e) {
+        _dbg('buildAuthInfo:/user:error', { err: e.message });
+      }
+      // copilot_internal/user から copilotUser 全体を取得して authInfo に含める。
+      // app.js の Wa(authInfo) は authInfo.copilotUser.endpoints.api から CAPI base URL を導く。
+      // copilotUser: null のままでは is_mcp_enabled・quota・plan 情報も失われる。
+      // env var は後続の capiClientListModels stub / authGetCopilotApiUrl stub でも参照するため並記する。
+      try {
+        const apiHost = hostUri.replace('https://github.com', 'https://api.github.com');
+        const r = await globalThis.fetch(`${apiHost}/copilot_internal/user`, {
+          headers: { Authorization: `token ${token}`, 'User-Agent': `copilot-termux/${_pkgVersion}`, 'Copilot-Integration-Id': 'copilot-chat' },
+          signal: AbortSignal.timeout(5000),
+        });
+        if (r.ok) {
+          const info = await r.json();
+          copilotUser = info;
+          const apiUrl = info?.endpoints?.api;
+          if (apiUrl && typeof apiUrl === 'string') process.env.COPILOT_API_URL = apiUrl;
+          _dbg('buildAuthInfo:/copilot_internal/user', {
+            status: r.status,
+            access_type_sku: info?.access_type_sku ?? null,
+            copilot_plan: info?.copilot_plan ?? null,
+            endpoints_api: apiUrl ?? null,
+            COPILOT_API_URL: process.env.COPILOT_API_URL ?? null,
+          });
+        } else {
+          _dbg('buildAuthInfo:/copilot_internal/user', { status: r.status, ok: false });
+        }
+      } catch (e) {
+        _dbg('buildAuthInfo:/copilot_internal/user:error', { err: e.message });
+      }
+      return JSON.stringify({
+        authInfo: { type: 'token', host: hostUri, token, login, copilotUser },
+        token,
+      });
+    }
+
+    async function _resolveOrCache(uuid, token, env) {
+      const entry = _authMgr.get(uuid);
+      if (!entry) return null;
+      const hostUri = ((typeof result.githubGetUri === 'function'
+        ? result.githubGetUri(
+            (env && env.COPILOT_GH_HOST) || undefined,
+            (env && env.GH_HOST) || undefined
+          )
+        : null) || 'https://github.com').replace(/\/+$/, '');
+      if (entry.cachedInfo !== null && (entry.cachedToken !== token || entry.cachedHost !== hostUri)) {
+        _dbg('resolveOrCache:cache-invalidate', {
+          reason: entry.cachedToken !== token ? 'token-changed' : 'host-changed',
+          oldTokenHash: _tokenHash(entry.cachedToken), newTokenHash: _tokenHash(token),
+        });
+        entry.cachedInfo = null;
+        entry.pendingInfo = null;
+      }
+      if (entry.cachedInfo !== null) {
+        _dbg('resolveOrCache:cache-hit', { tokenHash: _tokenHash(token) });
+        return entry.cachedInfo;
+      }
+      if (!entry.pendingInfo) {
+        const gen = entry.gen;
+        entry.pendingInfo = _buildAuthInfo(token, hostUri).then(info => {
+          if (entry.gen !== gen) return info; // stale: a newer switch superseded this fetch
+          entry.cachedInfo = info;
+          entry.cachedToken = token;
+          entry.cachedHost = hostUri;
+          entry.pendingInfo = null;
+          try {
+            const parsed = JSON.parse(info);
+            if (parsed && parsed.authInfo &&
+                typeof parsed.authInfo.login === 'string' && parsed.authInfo.login.length > 0) {
+              _loginTokens.set(`${hostUri}:${parsed.authInfo.login}`, token);
+            }
+          } catch (_) {}
+          return info;
+        }).catch(err => {
+          if (entry.gen === gen) entry.pendingInfo = null;
+          throw err;
+        });
+      }
+      return entry.pendingInfo;
+    }
+
+    result.authManagerLoadAuthInfo = async function(uuid, env, _storeTokenPlaintext) {
+      const token = await _readGhToken(env);
+      if (!token) return null;
+      return _resolveOrCache(uuid, token, env);
+    };
+    result.authManagerGetCurrentAuthInfo = async function(uuid, env, _storeTokenPlaintext) {
+      const entry = _authMgr.get(uuid);
+      if (!entry) return null;
+      if (entry.cachedInfo !== null) return entry.cachedInfo;
+      if (entry.pendingInfo) return entry.pendingInfo;
+      const token = await _readGhToken(env);
+      if (!token) return null;
+      return _resolveOrCache(uuid, token, env);
+    };
+    result.authManagerGetAllAuthAvailable = async function(uuid, env, _storeTokenPlaintext) {
+      const token = await _readGhToken(env);
+      if (!token) return [];
+      const info = await _resolveOrCache(uuid, token, env);
+      return info ? [info] : [];
+    };
+    result.authManagerGetLastAuthErrors = function(uuid) { return []; };
+    result.authManagerClearCache = function(uuid) {
+      const e = _authMgr.get(uuid);
+      if (e) { e.gen++; e.cachedInfo = null; e.pendingInfo = null; e.cachedToken = null; e.cachedHost = null; }
+    };
+    result.authManagerSwitchToAuth = async function(uuid, authInfoJson, token) {
+      const entry = _authMgr.get(uuid);
+      if (!entry) return;
+      // Clear stale enterprise endpoint and cache regardless of token presence
+      delete process.env.COPILOT_API_URL;
+      const gen = ++entry.gen;
+      entry.cachedInfo = null;
+      entry.cachedToken = null;
+      entry.cachedHost = null;
+      entry.pendingInfo = null;
+      if (!token) return;
+      const hostUri = (() => {
+        try { return (JSON.parse(authInfoJson)?.host || 'https://github.com').replace(/\/+$/, ''); }
+        catch (_) { return 'https://github.com'; }
+      })();
+      entry.pendingInfo = _buildAuthInfo(token, hostUri).then(info => {
+        if (entry.gen !== gen) return info; // stale: a newer switch superseded this fetch
+        entry.cachedInfo = info;
+        entry.cachedToken = token;
+        entry.cachedHost = hostUri;
+        entry.pendingInfo = null;
+        return info;
+      }).catch(err => {
+        if (entry.gen === gen) entry.pendingInfo = null;
+        _dbg('authManagerSwitchToAuth:error', { err: err.message });
+      });
+      await entry.pendingInfo;
+      _dbg('authManagerSwitchToAuth:done', {
+        tokenHash: _tokenHash(token), hostUri,
+        COPILOT_API_URL_after: process.env.COPILOT_API_URL ?? null,
+      });
+    };
+    result.authManagerLoginUser = async function(uuid, host, login, token) {
+      _dbg('authManagerLoginUser:start', { host, login, tokenHash: _tokenHash(token) });
+      const entry = _authMgr.get(uuid);
+      if (!entry || !token) return;
+      const hostUri = (host || 'https://github.com').replace(/\/+$/, '');
+      _loginTokens.set(`${hostUri}:${login || ''}`, token);
+      const gen = ++entry.gen;
+      entry.pendingInfo = _buildAuthInfo(token, hostUri).then(info => {
+        if (entry.gen !== gen) return info; // stale: a newer switch superseded this fetch
+        entry.cachedInfo = info;
+        entry.cachedToken = token;
+        entry.cachedHost = hostUri;
+        entry.pendingInfo = null;
+        try {
+          const parsed = JSON.parse(info);
+          if (parsed && parsed.authInfo &&
+              typeof parsed.authInfo.login === 'string' && parsed.authInfo.login.length > 0) {
+            _loginTokens.set(`${hostUri}:${parsed.authInfo.login}`, token);
+          }
+        } catch (_) {}
+        return info;
+      }).catch(err => { if (entry.gen === gen) entry.pendingInfo = null; return null; });
+      await entry.pendingInfo; // ensure cachedInfo is set before app.js continues
+    };
+    result.authManagerLogout = async function(uuid, authInfoJson) {
+      const e = _authMgr.get(uuid);
+      if (e) { e.cachedInfo = null; e.pendingInfo = null; e.cachedToken = null; e.cachedHost = null; }
+      return true;
+    };
+    result.authManagerRefreshCopilotUser = async function(uuid) {
+      return null; // null → JS側 authInfoWithTokenPromise フォールバック
+    };
+    result.authManagerDestroy = function(uuid) { _authMgr.delete(uuid); };
+
+    result.authResolveAuthInfoFromToken = async function(token, hostUri, skipCache, userAgent) {
+      if (!token) return JSON.stringify(null);
+      let login = null;
+      try {
+        const apiHost = (hostUri || 'https://github.com').replace('://github.com', '://api.github.com');
+        const res = await globalThis.fetch(`${apiHost}/user`, {
+          headers: { Authorization: `token ${token}`, 'User-Agent': userAgent || `copilot-termux/${_pkgVersion}` },
+          signal: AbortSignal.timeout(5000),
+        });
+        if (res.ok) login = (await res.json()).login;
+      } catch (_) {}
+      const host = hostUri || 'https://github.com';
+      return JSON.stringify({ type: 'token', host, token, login, copilotUser: null });
+    };
+    // === end authManager* stubs ===
+    // === tokenStore* JS stubs (bionic: tokio ThreadsafeFunction crash) ===
+    // Verified tokens: set by authManagerLoginUser / _resolveOrCache after /user API check
+    const _loginTokens = new Map(); // "host:login" → oauthToken
+
+    const _tokStore = new Map();
+    let _tokSeq = 9e6;
+    result.tokenStoreCreate = function() { const id = ++_tokSeq; _tokStore.set(id, new Map()); return id; };
+    result.tokenStoreDestroy = function(h) { _tokStore.delete(h); };
+    result.tokenStoreGetToken = async function(h, host, login) {
+      const m = _tokStore.get(h);
+      const key = `${(host || 'https://github.com').replace(/\/+$/, '')}:${login || ''}`;
+      if (m) { const v = m.get(key); if (v != null) return v; }
+      const lt = _loginTokens.get(key);
+      if (lt != null) { if (m) m.set(key, lt); return lt; }
+      if (login) return null; // login specified: refuse unverified fallback
+      return _readGhToken(null);
+    };
+    result.tokenStoreStoreToken = function(h, token, host, login) {
+      const m = _tokStore.get(h);
+      if (m && token) m.set(`${(host || 'https://github.com').replace(/\/+$/, '')}:${login || ''}`, token);
+    };
+    result.tokenStoreRemoveToken = function(h, host, login) {
+      const m = _tokStore.get(h);
+      if (m) m.delete(`${(host || 'https://github.com').replace(/\/+$/, '')}:${login || ''}`);
+    };
+    result.tokenStoreGetAnyToken = async function(h) {
+      const m = _tokStore.get(h);
+      if (m && m.size > 0) return [...m.values()][0];
+      return _readGhToken(null);
+    };
+    result.tokenStoreStoreCurrentTokenInConfig = async function() {};
+    // === end tokenStore* stubs ===
+
+    // === urlManager* JS stubs ===
+    const _urlMgr = new Map();
+    let _urlSeq = 8e6;
+    result.urlManagerCreate = function(urls, unrestricted) {
+      const id = ++_urlSeq;
+      _urlMgr.set(id, { urls: Array.isArray(urls) ? [...urls] : [], unrestricted: !!unrestricted });
+      return id;
+    };
+    result.urlManagerAddUrl = function(h, url) { const e = _urlMgr.get(h); if (e) e.urls.push(url); };
+    result.urlManagerDispose = function(h) { _urlMgr.delete(h); };
+    result.urlManagerGetUrls = function(h) { return (_urlMgr.get(h) || {}).urls || []; };
+    result.urlManagerIsUrlAllowed = function(h, url) { return true; };
+    result.urlManagerIsUnrestrictedMode = function(h) { return true; };
+    result.urlManagerSetUnrestrictedMode = function(h, v) { const e = _urlMgr.get(h); if (e) e.unrestricted = v; };
+    // === end urlManager* stubs ===
+
+    // === pathManager* JS stubs ===
+    const _pathMgr = new Map();
+    let _pathSeq = 7e6;
+    result.pathManagerCreateRestricted = async function(dirs, primary) {
+      const id = ++_pathSeq;
+      _pathMgr.set(id, { dirs: Array.isArray(dirs) ? [...dirs] : [], primary: primary || null });
+      return id;
+    };
+    result.pathManagerCreateUnrestricted = async function(primary) {
+      const id = ++_pathSeq;
+      _pathMgr.set(id, { dirs: [], primary: primary || null });
+      return id;
+    };
+    result.pathManagerDispose = function(h) { _pathMgr.delete(h); };
+    result.pathManagerAddDirectory = function(h, dir) { const e = _pathMgr.get(h); if (e) e.dirs.push(dir); };
+    result.pathManagerGetDirectories = function(h) { return (_pathMgr.get(h) || {}).dirs || []; };
+    result.pathManagerGetPrimaryDirectory = function(h) { return (_pathMgr.get(h) || {}).primary || null; };
+    result.pathManagerIsPathWithinWorkspace = function(h, p) {
+      const e = _pathMgr.get(h);
+      if (!e || !e.primary) return true;
+      return p === e.primary || p.startsWith(e.primary + '/');
+    };
+    result.pathManagerUpdatePrimaryDirectory = function(h, dir) { const e = _pathMgr.get(h); if (e) e.primary = dir; };
+    result.pathManagerIsPathWithinAllowedDirectories = function(h, p) {
+      const e = _pathMgr.get(h);
+      if (!e || e.dirs.length === 0) return true;
+      return e.dirs.some(dir => p === dir || p.startsWith(dir + '/'));
+    };
+    // === end pathManager* stubs ===
+
+    // === telemetryQueue* JS stubs ===
+    let _telSeq = 6e6;
+    result.telemetryQueueCreate = function(name, _config) { return ++_telSeq; };
+    result.telemetryQueueDispose = function(h) {};
+    result.telemetryQueueEnqueue = function(h, event) {};
+    result.telemetryQueueSetDebugLogPayload = function(h, v) {};
+    // === end telemetryQueue* stubs ===
+
+    // === telemetryAppInsightsServiceState* JS stubs (1.0.65+: Azure AppInsights HTTP I/O → tokio SIGSEGV on bionic) ===
+    if (typeof result.telemetryAppInsightsServiceStateCreate === 'function') {
+      result.telemetryAppInsightsServiceStateCreate = function() { return ++_telSeq; };
+      result.telemetryAppInsightsServiceStateDispose = function(h) {};
+      result.telemetryAppInsightsServiceStateEnqueue = function(h, e, n, r) { return JSON.stringify({}); };
+      result.telemetryAppInsightsServiceStateAuthSucceeded = function(h, e) { return JSON.stringify({}); };
+      result.telemetryAppInsightsServiceStateLogout = function(h) { return JSON.stringify({}); };
+    }
+    // === end telemetryAppInsightsServiceState* stubs ===
+
+    // === telemetryDelegatingSender* JS stubs (1.0.65+: fire-and-forget HTTP send → tokio SIGSEGV on bionic) ===
+    if (typeof result.telemetryDelegatingSenderCreate === 'function') {
+      result.telemetryDelegatingSenderCreate = function() { return ++_telSeq; };
+      result.telemetryDelegatingSenderDispose = function(h) { return JSON.stringify({ disposeDelegate: false }); };
+      result.telemetryDelegatingSenderConfigure = function(h, hasDelegate) {
+        return JSON.stringify({ disposePreviousDelegate: false, disposeNewDelegate: false });
+      };
+      result.telemetryDelegatingSenderIsConfigured = function(h) { return false; };
+      result.telemetryDelegatingSenderRequiresDelegate = function(h) {};
+      result.telemetryDelegatingSenderSetInternalCorrelationIds = function(h, ids) {
+        return JSON.stringify({ applyToDelegate: false });
+      };
+    }
+    // === end telemetryDelegatingSender* stubs ===
+
+    // === telemetrySessionTelemetryState* JS stubs (1.0.65+) ===
+    if (typeof result.telemetrySessionTelemetryStateCreate === 'function') {
+      result.telemetrySessionTelemetryStateCreate = function(h, e) { return ++_telSeq; };
+      result.telemetrySessionTelemetryStateDispose = function(h) {};
+      result.telemetrySessionTelemetryStateSnapshot = function(h) { return JSON.stringify({ telemetryEvents: [] }); };
+      result.telemetrySessionTelemetryStateProcessSessionEvent = function(h, e, n) {
+        return JSON.stringify({ telemetryEvents: [] });
+      };
+      result.telemetrySessionTelemetryStateProcessToolsUpdated = function(h, e) {};
+    }
+    // === end telemetrySessionTelemetryState* stubs ===
+
+    // === telemetryLegacyUsageHandler* JS stubs (1.0.65+) ===
+    if (typeof result.telemetryLegacyUsageHandlerCreate === 'function') {
+      result.telemetryLegacyUsageHandlerCreate = function(h, e) { return ++_telSeq; };
+      result.telemetryLegacyUsageHandlerDispose = function(h) {};
+      result.telemetryLegacyUsageHandlerProcessEvent = function(h, e) { return JSON.stringify([]); };
+    }
+    // === end telemetryLegacyUsageHandler* stubs ===
+
+    // === permissionService* JS stubs ===
+    const _permSvc = new Map();
+    let _permSeq = 5e6;
+    result.permissionServiceCreate = function(config) {
+      const id = ++_permSeq;
+      _permSvc.set(id, { approveAll: !!(config && config.approveAllTool) });
+      return id;
+    };
+    result.permissionServiceDispose = function(h) { _permSvc.delete(h); };
+    result.permissionServiceRequest = async function(h, reqJson) {
+      return JSON.stringify({ kind: 'approved' });
+    };
+    result.permissionServiceComplete = function(h, token, ok, resultJson) {};
+    result.permissionServiceConfigure = function(h, approveAllTool, approveAllRead, approvedRules, deniedRules, pathMgr, urlMgr) {};
+    result.permissionServiceAddApprovedRules = function(h, rules) {};
+    result.permissionServiceGetApproveAllTool = function(h) { return (_permSvc.get(h) || {}).approveAll ?? false; };
+    result.permissionServiceSetApproveAllTool = function(h, v) { const e = _permSvc.get(h); if (e) e.approveAll = v; };
+    result.permissionServiceRemoveApprovedRules = function(h, rules) {};
+    result.permissionServiceCheckSamplingApproval = function(h, k) { return true; };
+    result.permissionServiceResetSessionApprovals = function(h) {};
+    result.permissionServiceAddLocationApprovedRules = function(h, rules) {};
+    result.permissionServiceRemoveLocationApprovedRules = function(h, rules) {};
+    // === end permissionService* stubs ===
+
+    // === lspManager* JS stubs ===
+    let _lspMgrSeq = 4e6;
+    result.lspManagerCreate = function() { return ++_lspMgrSeq; };
+    result.lspManagerClear = function(h) {};
+    result.lspManagerPlanForFile = function(h, file, lang, config) { return null; };
+    result.lspManagerRemoveClient = function(h, key) {};
+    result.lspManagerShutdownKeys = function(h) { return []; };
+    result.lspManagerPlanForServerId = function(h, id) { return null; };
+    result.lspManagerCachedClientCount = function(h) { return 0; };
+    result.lspManagerRelevantServerIds = function(h, file, lang) { return []; };
+    // === end lspManager* stubs ===
+
+    // === ifcEngine* JS stubs ===
+    const _ifc = new Map();
+    let _ifcSeq = 3e6;
+    result.ifcEngineCreate = function(config) { const id = ++_ifcSeq; _ifc.set(id, {}); return id; };
+    result.ifcEngineDispose = function(h) { _ifc.delete(h); };
+    result.ifcEngineToJson = function(h) { return '{}'; };
+    result.ifcEnginePreToolHook = async function(h, tool, argsJson, fetchHandler) { return { converged: true }; };
+    result.ifcEngineFetchComplete = function(h, resp) {};
+    result.ifcEngineGetContextLabel = function(h) { return null; };
+    result.ifcEngineSetContextLabel = function(h, label) {};
+    result.ifcEnginePostToolExecution = async function(h, tool, argsJson, fetchHandler) {
+      return { converged: true, applied: false, updated: false };
+    };
+    // === end ifcEngine* stubs ===
     // --- end JS model HTTP implementation ---
   }
+
+  // === cli-native.node stubs (1.0.64+: color scheme fns use Rust tokio → SIGSEGV on bionic) ===
+  if (typeof request === 'string' && path.basename(request) === 'cli-native.node') {
+    if (!result.__copilotTermuxCliPatched) {
+      result.__copilotTermuxCliPatched = true;
+      // Rust tokio background thread → SIGSEGV on bionic. Return null so callers
+      // fall back to "unspecified" color scheme (uses default theme).
+      if (typeof result.getColorScheme === 'function') {
+        result.getColorScheme = () => null;
+      }
+      if (typeof result.startColorSchemeListener === 'function') {
+        result.startColorSchemeListener = (_cb) => undefined;
+      }
+      if (typeof result.stopColorSchemeListener === 'function') {
+        result.stopColorSchemeListener = () => undefined;
+      }
+    }
+  }
+  // === end cli-native.node stubs ===
+
   return result;
 };
 
 // [Android bionic 対応] app.js の oPt() が globalThis.fetch を Rust ベースの B7 に
 // 差し替えるのを阻止する。linuxmusl-arm64/runtime.node の Rust ネットワークスタックは
 // bionic 上の実 I/O で動作しないため、Node.js ビルトイン fetch（動作確認済み）に固定する。
+// GitHub OAuth token via env var or gh CLI (keychain unavailable on bionic)
+// --- AUTH デバッグ計装 ---
+// COPILOT_TERMUX_DEBUG_AUTH=1 を設定すると認証の各ステップを stderr に JSON で出力する。
+// token はセキュリティのため先頭8文字のみ表示。
+const _authDebug = process.env.COPILOT_TERMUX_DEBUG_AUTH === '1';
+function _dbg(event, data) {
+  if (!_authDebug) return;
+  process.stderr.write('[copilot-termux-auth] ' + JSON.stringify({ event, ...data, ts: new Date().toISOString() }) + '\n');
+}
+function _tokenHash(t) { return t ? t.slice(0, 8) + '...' : null; }
+// --- end 計装 ---
+
+async function _readGhToken(env) {
+  const envToken =
+    (env && (env.GITHUB_TOKEN || env.GH_TOKEN || env.COPILOT_GITHUB_TOKEN)) ||
+    process.env.GITHUB_TOKEN || process.env.GH_TOKEN || process.env.COPILOT_GITHUB_TOKEN;
+  if (envToken) {
+    _dbg('readGhToken', { source: 'env', tokenHash: _tokenHash(envToken) });
+    return envToken;
+  }
+  try {
+    const { execFile } = require('child_process');
+    const ghToken = await new Promise(resolve => {
+      execFile('gh', ['auth', 'token'], { encoding: 'utf8', timeout: 5000 }, (err, stdout) => {
+        resolve(err ? null : (stdout.trim() || null));
+      });
+    });
+    _dbg('readGhToken', { source: ghToken ? 'gh-cli' : 'null', tokenHash: _tokenHash(ghToken) });
+    return ghToken;
+  } catch (_) {
+    _dbg('readGhToken', { source: 'error', tokenHash: null });
+    return null;
+  }
+}
+
 const _nativeFetch = globalThis.fetch;
 Object.defineProperty(globalThis, 'fetch', {
   configurable: true,

package/lib/setup.js

@@ -48,20 +48,20 @@ async function fetchWithIntegrity(url, expectedIntegrity) {
 }
 
 async function setup() {
-  const { version, integrity } = manifest.copilot;
+  const { package: pkg = '@github/copilot-linuxmusl-arm64', 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...`);
+    console.log(`${pkg}@${version} already installed, refreshing symlink...`);
   } else {
-    console.log(`Fetching @github/copilot@${version} metadata...`);
-    const metaBuf = await httpsGet(`${REGISTRY}/@github/copilot/${version}`, { Accept: 'application/json' });
+    console.log(`Fetching ${pkg}@${version} metadata...`);
+    const metaBuf = await httpsGet(`${REGISTRY}/${pkg}/${version}`, { Accept: 'application/json' });
     const meta = JSON.parse(metaBuf.toString());
     const tarballUrl = meta.dist.tarball;
 
-    console.log(`Downloading @github/copilot@${version}...`);
+    console.log(`Downloading ${pkg}@${version}...`);
     const tarball = await fetchWithIntegrity(tarballUrl, integrity);
 
     const tarballPath = path.join(CACHE_DIR, `copilot-${version}.tgz`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash0816/copilot-termux",
-  "version": "1.0.63",
+  "version": "1.0.65",
   "description": "GitHub Copilot CLI for Termux (Android aarch64)",
   "license": "GPL-3.0-only",
   "readme": "README.md",
@@ -9,16 +9,39 @@
     "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"],
+  "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"],
+  "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"]
+  "os": [
+    "android",
+    "linux"
+  ],
+  "cpu": [
+    "arm64"
+  ]
 }

package/scripts/bionic-compat.c

@@ -58,6 +58,7 @@ typedef float  (*fn_ff)(float);
 static fn_ddd _pow;
 static fn_dd  _log;
 static fn_dd  _log2;
+static fn_dd  _exp2;
 static fn_ff  _expf;
 static fn_ff  _log10f;
 static fn_ff  _sinf;
@@ -67,6 +68,7 @@ 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");
+    _exp2   = (fn_dd) dlsym(RTLD_NEXT, "exp2");
     _expf   = (fn_ff) dlsym(RTLD_NEXT, "expf");
     _log10f = (fn_ff) dlsym(RTLD_NEXT, "log10f");
     _sinf   = (fn_ff) dlsym(RTLD_NEXT, "sinf");
@@ -77,6 +79,7 @@ static void compat_init(void) {
 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); }
+double exp2(double x)            { if (!_exp2)   abort(); return _exp2(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); }