@bash0816/claude-code 2.1.219 → 2.1.220-2

package/README.md

@@ -37,7 +37,7 @@ npm が `claude` bin link を管理する状態になれば、通常の `npm ins
 Latest audited version / 最新監査済み版:
 
 ```sh
-npm install -g @bash0816/claude-code@2.1.218
+npm install -g @bash0816/claude-code@2.1.220
 ```
 
 ## Update / 更新

package/config/claude-native-audited-versions.json

@@ -571,6 +571,33 @@
       "entry_end_offset": 265451802,
       "tarball_integrity": "sha512-G5yLidk2u6djL5PPuBYXVwVhTsZY5zLoZwh1Jnrd/IRyYb0P0x4gKTzVvGlsGepkBrOp0H2k/KuicyNPrXt57Q==",
       "tarball_sha256": "cf4ae671f08b91ac75ea63c8497e7ff4e3bdbe522b0f83bff2de162d44e0eb15",
+      "status": "termux_verified"
+    },
+    "2.1.220": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.220",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.220",
+      "entry_js_offset": 243831156,
+      "entry_end_offset": 265457701,
+      "tarball_integrity": "sha512-VHFI8mKruIntKn7eq81sbyS19/KWmQcmJQsS/C+j9M/E+w0s4UytgsL7DADPjBE/GByNiKoRtLYDMntCjRlOdA==",
+      "tarball_sha256": "e38454d73576a08a2e707f26539d73fc9ef33e890228ca5c58a2bbe810ac884d",
+      "status": "termux_verified"
+    },
+    "2.1.220-1": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.220",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.220",
+      "entry_js_offset": 243831156,
+      "entry_end_offset": 265457701,
+      "tarball_integrity": "sha512-VHFI8mKruIntKn7eq81sbyS19/KWmQcmJQsS/C+j9M/E+w0s4UytgsL7DADPjBE/GByNiKoRtLYDMntCjRlOdA==",
+      "tarball_sha256": "e38454d73576a08a2e707f26539d73fc9ef33e890228ca5c58a2bbe810ac884d",
+      "status": "offset_discovered"
+    },
+    "2.1.220-2": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.220",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.220",
+      "entry_js_offset": 243831156,
+      "entry_end_offset": 265457701,
+      "tarball_integrity": "sha512-VHFI8mKruIntKn7eq81sbyS19/KWmQcmJQsS/C+j9M/E+w0s4UytgsL7DADPjBE/GByNiKoRtLYDMntCjRlOdA==",
+      "tarball_sha256": "e38454d73576a08a2e707f26539d73fc9ef33e890228ca5c58a2bbe810ac884d",
       "status": "offset_discovered"
     }
   }

package/config/claude-termux-release-manifest.json

@@ -1,9 +1,9 @@
 {
   "manifest_version": 1,
   "package_name": "@bash0816/claude-code",
-  "latest_audited_version": "2.1.218",
-  "latest_candidate_version": "2.1.219",
-  "previous_stable_version": "2.1.217",
+  "latest_audited_version": "2.1.220",
+  "latest_candidate_version": "2.1.220-2",
+  "previous_stable_version": "2.1.219",
   "stable_pinned_version": "2.1.193",
   "manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/main/config/claude-termux-release-manifest.json"
 }

package/lib/termux-run-claude-native.sh

@@ -623,6 +623,7 @@ async function main() {
 
   const originalArgv = process.argv.slice();
   const originalExit = process.exit;
+  const originalKill = process.kill;
   const originalBun = process.versions.bun;
   const hadGlobalBun = Object.prototype.hasOwnProperty.call(globalThis, 'Bun');
   const originalGlobalBun = globalThis.Bun;
@@ -636,6 +637,12 @@ async function main() {
   function onAsyncError(error) {
     asyncErrors.push(error);
   }
+  const printWaitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 5000);
+  async function waitForPrintFlush() {
+    if (Number.isFinite(printWaitMs) && printWaitMs > 0) {
+      await new Promise(resolve => setTimeout(resolve, printWaitMs));
+    }
+  }
 
   try {
     process.once('uncaughtException', onAsyncError);
@@ -694,21 +701,26 @@ async function main() {
     globalThis.__claudeBun = globalThis.__claudeBunShim;
     globalThis.Bun = globalThis.__claudeBunShim;
     process.argv = ['node', extractedFile, ...argv];
+    let lastExitAttemptCode = 0;
     process.exit = code => {
-      throw new RequestedExit(code);
+      lastExitAttemptCode = code ?? 0;
+      throw new RequestedExit(lastExitAttemptCode);
+    };
+    process.kill = (pid, signal) => {
+      if (pid === process.pid && (signal === 'SIGKILL' || signal === 9)) {
+        throw new RequestedExit(lastExitAttemptCode);
+      }
+      return originalKill.call(process, pid, signal);
     };
-
-    const printWaitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 5000);
     const moduleLike = { exports: {} };
     const maybePromise = fn(moduleLike.exports, fakeRequire, moduleLike, extractedFile, workdir);
     if (maybePromise && typeof maybePromise.then === 'function') await maybePromise;
-    if (Number.isFinite(printWaitMs) && printWaitMs > 0) {
-      await new Promise(resolve => setTimeout(resolve, printWaitMs));
-    }
+    await waitForPrintFlush();
     if (asyncErrors.length > 0) throw asyncErrors[0];
   } catch (error) {
     if (error instanceof RequestedExit) {
       process.exitCode = error.code;
+      await waitForPrintFlush();
       return;
     }
     throw error;
@@ -722,6 +734,7 @@ async function main() {
     }
     process.argv = originalArgv;
     process.exit = originalExit;
+    process.kill = originalKill;
     try {
       if (originalBun === undefined) {
         delete process.versions.bun;
@@ -758,6 +771,7 @@ else
   _bootstrap=$(mktemp "${TERMUX_TMPDIR}/claude-bootstrap.XXXXXX.js")
   trap 'rm -f "$_bootstrap"' EXIT HUP INT TERM
   export CLAUDE_TERMUX_TUI="${_tui}"
+  export CLAUDE_TERMUX_PRINT_MODE="${_pf}"
   cat <<'NODE' > "$_bootstrap"
 const fs = require('fs');
 const path = require('path');
@@ -1316,6 +1330,7 @@ async function main() {
 
   const originalArgv = process.argv.slice();
   const originalExit = process.exit;
+  const originalKill = process.kill;
   const originalBun = process.versions.bun;
   const hadGlobalBun = Object.prototype.hasOwnProperty.call(globalThis, 'Bun');
   const originalGlobalBun = globalThis.Bun;
@@ -1329,6 +1344,13 @@ async function main() {
   function onAsyncError(error) {
     asyncErrors.push(error);
   }
+  async function waitForPrintFlushIfNeeded() {
+    if (process.env.CLAUDE_TERMUX_PRINT_MODE !== '1') return;
+    const printWaitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 5000);
+    if (Number.isFinite(printWaitMs) && printWaitMs > 0) {
+      await new Promise(resolve => setTimeout(resolve, printWaitMs));
+    }
+  }
 
   try {
     process.once('uncaughtException', onAsyncError);
@@ -1387,17 +1409,27 @@ async function main() {
     globalThis.__claudeBun = globalThis.__claudeBunShim;
     globalThis.Bun = globalThis.__claudeBunShim;
     process.argv = ['node', extractedFile, ...argv];
+    let lastExitAttemptCode = 0;
     process.exit = code => {
-      throw new RequestedExit(code);
+      lastExitAttemptCode = code ?? 0;
+      throw new RequestedExit(lastExitAttemptCode);
+    };
+    process.kill = (pid, signal) => {
+      if (pid === process.pid && (signal === 'SIGKILL' || signal === 9)) {
+        throw new RequestedExit(lastExitAttemptCode);
+      }
+      return originalKill.call(process, pid, signal);
     };
 
     const moduleLike = { exports: {} };
     const maybePromise = fn(moduleLike.exports, fakeRequire, moduleLike, extractedFile, workdir);
     if (maybePromise && typeof maybePromise.then === 'function') await maybePromise;
+    await waitForPrintFlushIfNeeded();
     if (asyncErrors.length > 0) throw asyncErrors[0];
   } catch (error) {
     if (error instanceof RequestedExit) {
       process.exitCode = error.code;
+      await waitForPrintFlushIfNeeded();
       return;
     }
     throw error;
@@ -1406,6 +1438,7 @@ async function main() {
     process.removeListener('unhandledRejection', onAsyncError);
     process.argv = originalArgv;
     process.exit = originalExit;
+    process.kill = originalKill;
     process.once('exit', () => {
       if (extractedFile) {
         try {

package/lib/termux-run-claude-native.test.js

@@ -191,12 +191,32 @@ test('print path does not defer cleanup to exit', () => {
 test('bootstrap path defers cleanup to exit', () => {
   const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
 
-  assert.equal(bootstrapBlock.includes('CLAUDE_TERMUX_PRINT_WAIT_MS'), false);
-  assert.equal(bootstrapBlock.includes('setTimeout(resolve, printWaitMs)'), false);
   assert.equal(bootstrapBlock.includes('process.once(\'exit\''), true);
   assert.equal(bootstrapBlock.includes('process.removeListener(\'uncaughtException\''), true);
 });
 
+test('bootstrap branch exports CLAUDE_TERMUX_PRINT_MODE before invoking node', () => {
+  const bootstrapShellRegion = extractFunction(
+    script,
+    'export CLAUDE_TERMUX_TUI="${_tui}"',
+    'cat <<\'NODE\' > "$_bootstrap"',
+  );
+  assert.equal(bootstrapShellRegion.includes('export CLAUDE_TERMUX_PRINT_MODE="${_pf}"'), true);
+});
+
+test('helper and bootstrap wait for print flush, including the RequestedExit path', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+
+  assert.equal(helperBlock.includes('async function waitForPrintFlush()'), true);
+  assert.equal(helperBlock.includes('await waitForPrintFlush();\n    if (asyncErrors.length > 0) throw asyncErrors[0];'), true);
+  assert.equal(helperBlock.includes('process.exitCode = error.code;\n      await waitForPrintFlush();\n      return;'), true);
+
+  assert.equal(bootstrapBlock.includes('async function waitForPrintFlushIfNeeded()'), true);
+  assert.equal(bootstrapBlock.includes('await waitForPrintFlushIfNeeded();\n    if (asyncErrors.length > 0) throw asyncErrors[0];'), true);
+  assert.equal(bootstrapBlock.includes('process.exitCode = error.code;\n      await waitForPrintFlushIfNeeded();\n      return;'), true);
+});
+
 test('entry extraction uses a process-unique filename', () => {
   const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
   const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
@@ -544,3 +564,173 @@ test('tarball contents match the workspace runner and test file', { skip: !fs.ex
 test('CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC is never forced (regression guard)', () => {
   assert.equal(script.includes('CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC'), false);
 });
+
+function buildScenarioFixtureSource() {
+  const typeofBun = Array.from({ length: 7 }, () => 'typeof Bun').join('; ');
+  const bunProps = Array.from({ length: 42 }, (_, i) => `Bun.p${i}`).join('; ');
+  return `function(exports, require, module, __filename, __dirname) {
+    ${typeofBun}; typeof globalThis.Bun; globalThis.Bun; ${bunProps};
+    npmInstallDeprecated:!0; npmInstallDeprecated:!0;
+    const scenario = process.env.TEST_SCENARIO;
+    if (scenario === 'sync-exit') { process.stdout.write('ok'); process.exit(0); return; }
+    if (scenario === 'async-exit') {
+      setTimeout(() => { process.stdout.write('ok'); }, 100).unref();
+      return;
+    }
+    if (scenario === 'self-sigkill-fallback-string') {
+      try {
+        process.exit(17);
+      } catch (e) {
+        process.kill(process.pid, 'SIGKILL');
+      }
+      return;
+    }
+    if (scenario === 'self-sigkill-fallback-numeric') {
+      try {
+        process.exit(17);
+      } catch (e) {
+        process.kill(process.pid, 9);
+      }
+      return;
+    }
+    if (scenario === 'self-sigkill-fallback-no-code') {
+      try {
+        process.exit();
+      } catch (e) {
+        process.kill(process.pid, 'SIGKILL');
+      }
+      return;
+    }
+    if (scenario === 'other-process-kill') {
+      const cp = require('child_process');
+      const child = cp.spawn('node', ['-e', 'setTimeout(() => {}, 5000)']);
+      const childPid = child.pid;
+      process.kill(childPid, 0);
+      child.kill();
+      process.stdout.write('ok');
+      return;
+    }
+    process.stdout.write('ok');
+  }`;
+}
+
+function runScenario({ printMode, stdinInherit, scenario }) {
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-stdin-test-'));
+  const sourceBin = path.join(tmpBase, 'fake-source.js');
+  const fixtureSource = buildScenarioFixtureSource();
+  fs.writeFileSync(sourceBin, fixtureSource, 'utf8');
+  const entryJsOffset = 0;
+  const entryEndOffset = Buffer.byteLength(fixtureSource, 'utf8');
+  const workdir = path.join(tmpBase, 'workdir');
+  fs.mkdirSync(workdir, { recursive: true });
+
+  const env = {
+    ...process.env,
+    SOURCE_BIN: sourceBin,
+    WORKDIR: workdir,
+    ENTRY_JS_OFFSET: String(entryJsOffset),
+    ENTRY_END_OFFSET: String(entryEndOffset),
+    CURRENT_CLAUDE_VERSION: '2.1.220',
+    CLAUDE_TERMUX_PACKAGE_DIR: path.join(__dirname, '..'),
+    MAGI_ENV: '1',
+    CLAUDE_TERMUX_PRINT_WAIT_MS: '300',
+    TMPDIR: tmpBase,
+    TEST_SCENARIO: scenario,
+  };
+  if (stdinInherit) env.CLAUDE_TERMUX_STDIN = 'inherit';
+  else delete env.CLAUDE_TERMUX_STDIN;
+
+  const args = printMode ? ['-p', 'x'] : [];
+  const start = Date.now();
+  const result = child_process.spawnSync('sh', [scriptPath, ...args], {
+    env,
+    input: 'test input\n',
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+  const elapsedMs = Date.now() - start;
+  fs.rmSync(tmpBase, { recursive: true, force: true });
+  return { ...result, elapsedMs };
+}
+
+test('helper and bootstrap intercept process.kill(self, SIGKILL) statically', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+
+  // Check helper branch
+  const helperOriginalKillIdx = helperBlock.indexOf('const originalKill = process.kill;');
+  assert.ok(helperOriginalKillIdx > -1, 'helper: missing originalKill declaration');
+
+  const helperProcessKillIdx = helperBlock.indexOf('process.kill = (pid, signal) => {', helperOriginalKillIdx);
+  assert.ok(helperProcessKillIdx > helperOriginalKillIdx, 'helper: process.kill override must come after originalKill declaration');
+
+  const helperRestoreIdx = helperBlock.indexOf('process.kill = originalKill;', helperProcessKillIdx);
+  assert.ok(helperRestoreIdx > helperProcessKillIdx, 'helper: process.kill restoration must come after override');
+
+  // Verify SIGKILL check within the override
+  const helperKillOverrideEnd = helperBlock.indexOf('};', helperProcessKillIdx);
+  const helperKillOverride = helperBlock.slice(helperProcessKillIdx, helperKillOverrideEnd);
+  assert.ok(helperKillOverride.includes('signal === \'SIGKILL\''), 'helper: process.kill must check for SIGKILL string');
+  assert.ok(helperKillOverride.includes('signal === 9'), 'helper: process.kill must check for SIGKILL numeric value');
+  assert.ok(helperKillOverride.includes('throw new RequestedExit'), 'helper: process.kill must throw RequestedExit for self SIGKILL');
+
+  // Check bootstrap branch
+  const bootstrapOriginalKillIdx = bootstrapBlock.indexOf('const originalKill = process.kill;');
+  assert.ok(bootstrapOriginalKillIdx > -1, 'bootstrap: missing originalKill declaration');
+
+  const bootstrapProcessKillIdx = bootstrapBlock.indexOf('process.kill = (pid, signal) => {', bootstrapOriginalKillIdx);
+  assert.ok(bootstrapProcessKillIdx > bootstrapOriginalKillIdx, 'bootstrap: process.kill override must come after originalKill declaration');
+
+  const bootstrapRestoreIdx = bootstrapBlock.indexOf('process.kill = originalKill;', bootstrapProcessKillIdx);
+  assert.ok(bootstrapRestoreIdx > bootstrapProcessKillIdx, 'bootstrap: process.kill restoration must come after override');
+
+  // Verify SIGKILL check within the override
+  const bootstrapKillOverrideEnd = bootstrapBlock.indexOf('};', bootstrapProcessKillIdx);
+  const bootstrapKillOverride = bootstrapBlock.slice(bootstrapProcessKillIdx, bootstrapKillOverrideEnd);
+  assert.ok(bootstrapKillOverride.includes('signal === \'SIGKILL\''), 'bootstrap: process.kill must check for SIGKILL string');
+  assert.ok(bootstrapKillOverride.includes('signal === 9'), 'bootstrap: process.kill must check for SIGKILL numeric value');
+  assert.ok(bootstrapKillOverride.includes('throw new RequestedExit'), 'bootstrap: process.kill must throw RequestedExit for self SIGKILL');
+});
+
+test('helper branch (CLI -p, no stdin inherit): normal/sync-exit/async-exit all produce output', () => {
+  for (const scenario of ['normal', 'sync-exit', 'async-exit']) {
+    const r = runScenario({ printMode: true, stdinInherit: false, scenario });
+    assert.ok((r.stdout || '').includes('ok'), `scenario=${scenario} stdout=${r.stdout} stderr=${r.stderr}`);
+    assert.equal(r.status, 0, `scenario=${scenario} status=${r.status} stderr=${r.stderr}`);
+  }
+});
+
+test('bootstrap branch (-p + CLAUDE_TERMUX_STDIN=inherit): normal/sync-exit/async-exit all produce output', () => {
+  for (const scenario of ['normal', 'sync-exit', 'async-exit']) {
+    const r = runScenario({ printMode: true, stdinInherit: true, scenario });
+    assert.ok((r.stdout || '').includes('ok'), `scenario=${scenario} stdout=${r.stdout} stderr=${r.stderr}`);
+    assert.equal(r.status, 0, `scenario=${scenario} status=${r.status} stderr=${r.stderr}`);
+    if (scenario === 'async-exit') {
+      assert.ok(r.elapsedMs >= 250, `expected wait >= 250ms, got ${r.elapsedMs}ms`);
+    }
+  }
+});
+
+test('helper branch intercepts self-directed SIGKILL (string signal) and exits with proper code', () => {
+  const r = runScenario({ printMode: true, stdinInherit: false, scenario: 'self-sigkill-fallback-string' });
+  assert.equal(r.status, 17, `expected status 17, got ${r.status}; stderr=${r.stderr}`);
+  assert.ok(!r.signal, `expected clean exit (no signal), but got signal: ${r.signal}`);
+});
+
+test('helper branch intercepts self-directed SIGKILL (numeric signal 9) and exits with proper code', () => {
+  const r = runScenario({ printMode: true, stdinInherit: false, scenario: 'self-sigkill-fallback-numeric' });
+  assert.equal(r.status, 17, `expected status 17, got ${r.status}; stderr=${r.stderr}`);
+  assert.ok(!r.signal, `expected clean exit (no signal), but got signal: ${r.signal}`);
+});
+
+test('helper branch intercepts self-directed SIGKILL with process.exit() (no code) and defaults to 0', () => {
+  const r = runScenario({ printMode: true, stdinInherit: false, scenario: 'self-sigkill-fallback-no-code' });
+  assert.equal(r.status, 0, `expected status 0, got ${r.status}; stderr=${r.stderr}`);
+  assert.ok(!r.signal, `expected clean exit (no signal), but got signal: ${r.signal}`);
+});
+
+test('helper branch allows process.kill to other processes (signal 0, passthrough)', () => {
+  const r = runScenario({ printMode: true, stdinInherit: false, scenario: 'other-process-kill' });
+  assert.ok((r.stdout || '').includes('ok'), `expected ok output, got stdout=${r.stdout} stderr=${r.stderr}`);
+  assert.equal(r.status, 0, `expected status 0, got ${r.status}; stderr=${r.stderr}`);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash0816/claude-code",
-  "version": "2.1.219",
+  "version": "2.1.220-2",
   "description": "Unofficial Termux-native Claude Code wrapper with audited native replay",
   "license": "GPL-3.0-only",
   "bin": {