@bash0816/claude-code 2.1.228 → 2.1.231

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.227
+npm install -g @bash0816/claude-code@2.1.228
 ```
 
 ## Update / 更新

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

@@ -679,6 +679,15 @@
       "entry_end_offset": 297826425,
       "tarball_integrity": "sha512-rWSzUqON6kyIXUVz9KDU+9R6FdO11IVCO94D7kkWWyRPzFqzaAB80RmfgP//QgTIVFApEUzEUH2tfAGsUhD6ug==",
       "tarball_sha256": "31295a318aef235b1b818a8b46982757467fb4d13030520ac66d16a58c0d7e27",
+      "status": "termux_verified"
+    },
+    "2.1.231": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.231",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.231",
+      "entry_js_offset": 273809585,
+      "entry_end_offset": 299210420,
+      "tarball_integrity": "sha512-a0YGXTjk6N5yRWE30dkbtS0tTZ5hOEXFCjTTX2slSa7XULMlJJLQ1X8oFJwpXmlvZu9FHx1YRLKJnni05uNIQQ==",
+      "tarball_sha256": "f50fa4b2270707208a3ae870deae8c562ec6b2f4d7bf778fca6275d13908b714",
       "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.227",
-  "latest_candidate_version": "2.1.228",
-  "previous_stable_version": "2.1.226",
+  "latest_audited_version": "2.1.228",
+  "latest_candidate_version": "2.1.231",
+  "previous_stable_version": "2.1.227",
   "stable_pinned_version": "2.1.220-2",
   "manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/main/config/claude-termux-release-manifest.json"
 }

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

@@ -680,6 +680,58 @@ async function main() {
   }
   const printWaitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 5000);
 
+  function installPlainTextWriteWatcher() {
+    const hadOwnWrite = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
+    const originalWriteDescriptor = hadOwnWrite ? Object.getOwnPropertyDescriptor(process.stdout, 'write') : undefined;
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    let foundOutput = false;
+    let resultPromiseResolve = null;
+    let restored = false;
+
+    process.stdout.write = function wrappedWrite(chunk, encoding, callback) {
+      let cb = callback;
+      let enc = encoding;
+      if (typeof encoding === 'function') {
+        cb = encoding;
+        enc = undefined;
+      }
+      const combinedCallback = (err) => {
+        if (!err && !foundOutput) {
+          const len = typeof chunk === 'string'
+            ? Buffer.byteLength(chunk, typeof enc === 'string' ? enc : 'utf8')
+            : (Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(String(chunk ?? ''), 'utf8'));
+          if (len > 0) {
+            foundOutput = true;
+            if (typeof resultPromiseResolve === 'function') resultPromiseResolve();
+          }
+        }
+        if (typeof cb === 'function') cb(err);
+      };
+      return originalWrite(chunk, enc, combinedCallback);
+    };
+
+    return {
+      waitForResult() {
+        if (foundOutput) return Promise.resolve();
+        return new Promise((resolve) => {
+          resultPromiseResolve = resolve;
+        });
+      },
+      hasOutput() {
+        return foundOutput;
+      },
+      restore() {
+        if (restored) return;
+        restored = true;
+        if (hadOwnWrite) {
+          Object.defineProperty(process.stdout, 'write', originalWriteDescriptor);
+        } else {
+          delete process.stdout.write;
+        }
+      },
+    };
+  }
+
   function installStreamJsonTerminalWatcher() {
     const hadOwnWrite = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
     const originalWriteDescriptor = hadOwnWrite ? Object.getOwnPropertyDescriptor(process.stdout, 'write') : undefined;
@@ -768,6 +820,25 @@ async function main() {
       }
       return;
     }
+    if (streamJsonWatcher && typeof streamJsonWatcher.hasOutput === 'function') {
+      if (streamJsonWatcher.hasOutput()) {
+        return;
+      }
+      const gatingExitCode = process.exitCode;
+      const rawResultTimeoutMs = Number(process.env.CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS);
+      const extendedTimeoutMs = (Number.isFinite(rawResultTimeoutMs) && rawResultTimeoutMs > 0) ? rawResultTimeoutMs : 300000;
+      const noOutputTimeoutMs = (gatingExitCode !== undefined && gatingExitCode !== 0) ? printWaitMs : extendedTimeoutMs;
+      let timeoutHandle;
+      const timeoutPromise = new Promise(resolve => {
+        timeoutHandle = setTimeout(resolve, noOutputTimeoutMs);
+      });
+      try {
+        await Promise.race([streamJsonWatcher.waitForResult(), timeoutPromise]);
+      } finally {
+        clearTimeout(timeoutHandle);
+      }
+      return;
+    }
     if (Number.isFinite(printWaitMs) && printWaitMs > 0) {
       await new Promise(resolve => setTimeout(resolve, printWaitMs));
     }
@@ -882,6 +953,8 @@ async function main() {
 
     if (isStreamJsonPrintMode(argv)) {
       streamJsonWatcher = installStreamJsonTerminalWatcher();
+    } else {
+      streamJsonWatcher = installPlainTextWriteWatcher();
     }
 
     const moduleLike = { exports: {} };
@@ -1561,6 +1634,58 @@ async function main() {
     asyncErrors.push(error);
   }
 
+  function installPlainTextWriteWatcher() {
+    const hadOwnWrite = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
+    const originalWriteDescriptor = hadOwnWrite ? Object.getOwnPropertyDescriptor(process.stdout, 'write') : undefined;
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    let foundOutput = false;
+    let resultPromiseResolve = null;
+    let restored = false;
+
+    process.stdout.write = function wrappedWrite(chunk, encoding, callback) {
+      let cb = callback;
+      let enc = encoding;
+      if (typeof encoding === 'function') {
+        cb = encoding;
+        enc = undefined;
+      }
+      const combinedCallback = (err) => {
+        if (!err && !foundOutput) {
+          const len = typeof chunk === 'string'
+            ? Buffer.byteLength(chunk, typeof enc === 'string' ? enc : 'utf8')
+            : (Buffer.isBuffer(chunk) ? chunk.length : Buffer.byteLength(String(chunk ?? ''), 'utf8'));
+          if (len > 0) {
+            foundOutput = true;
+            if (typeof resultPromiseResolve === 'function') resultPromiseResolve();
+          }
+        }
+        if (typeof cb === 'function') cb(err);
+      };
+      return originalWrite(chunk, enc, combinedCallback);
+    };
+
+    return {
+      waitForResult() {
+        if (foundOutput) return Promise.resolve();
+        return new Promise((resolve) => {
+          resultPromiseResolve = resolve;
+        });
+      },
+      hasOutput() {
+        return foundOutput;
+      },
+      restore() {
+        if (restored) return;
+        restored = true;
+        if (hadOwnWrite) {
+          Object.defineProperty(process.stdout, 'write', originalWriteDescriptor);
+        } else {
+          delete process.stdout.write;
+        }
+      },
+    };
+  }
+
   function installStreamJsonTerminalWatcher() {
     const hadOwnWrite = Object.prototype.hasOwnProperty.call(process.stdout, 'write');
     const originalWriteDescriptor = hadOwnWrite ? Object.getOwnPropertyDescriptor(process.stdout, 'write') : undefined;
@@ -1650,6 +1775,26 @@ async function main() {
       }
       return;
     }
+    if (streamJsonWatcher && typeof streamJsonWatcher.hasOutput === 'function') {
+      if (streamJsonWatcher.hasOutput()) {
+        return;
+      }
+      const printWaitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 5000);
+      const gatingExitCode = process.exitCode;
+      const rawResultTimeoutMs = Number(process.env.CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS);
+      const extendedTimeoutMs = (Number.isFinite(rawResultTimeoutMs) && rawResultTimeoutMs > 0) ? rawResultTimeoutMs : 300000;
+      const noOutputTimeoutMs = (gatingExitCode !== undefined && gatingExitCode !== 0) ? printWaitMs : extendedTimeoutMs;
+      let timeoutHandle;
+      const timeoutPromise = new Promise(resolve => {
+        timeoutHandle = setTimeout(resolve, noOutputTimeoutMs);
+      });
+      try {
+        await Promise.race([streamJsonWatcher.waitForResult(), timeoutPromise]);
+      } finally {
+        clearTimeout(timeoutHandle);
+      }
+      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));
@@ -1765,6 +1910,8 @@ async function main() {
 
     if (isStreamJsonPrintMode(argv)) {
       streamJsonWatcher = installStreamJsonTerminalWatcher();
+    } else if (process.env.CLAUDE_TERMUX_PRINT_MODE === '1') {
+      streamJsonWatcher = installPlainTextWriteWatcher();
     }
 
     const moduleLike = { exports: {} };

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

@@ -709,11 +709,22 @@ function buildScenarioFixtureSource() {
       process.exit(0);
       return;
     }
+    if (scenario === 'plain-late-write') {
+      setTimeout(() => { process.stdout.write('late-output'); }, 800);
+      return;
+    }
+    if (scenario === 'plain-no-output-error') {
+      process.exitCode = 1;
+      return;
+    }
+    if (scenario === 'plain-no-output-success') {
+      return;
+    }
     process.stdout.write('ok');
   }`;
 }
 
-function runScenario({ printMode, stdinInherit, scenario, extraArgs }) {
+function runScenario({ printMode, stdinInherit, scenario, extraArgs, extraEnv }) {
   const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-stdin-test-'));
   const sourceBin = path.join(tmpBase, 'fake-source.js');
   const fixtureSource = buildScenarioFixtureSource();
@@ -735,6 +746,7 @@ function runScenario({ printMode, stdinInherit, scenario, extraArgs }) {
     CLAUDE_TERMUX_PRINT_WAIT_MS: '300',
     TMPDIR: tmpBase,
     TEST_SCENARIO: scenario,
+    ...(extraEnv || {}),
   };
   if (stdinInherit) env.CLAUDE_TERMUX_STDIN = 'inherit';
   else delete env.CLAUDE_TERMUX_STDIN;
@@ -808,15 +820,82 @@ test('bootstrap branch (-p + CLAUDE_TERMUX_STDIN=inherit): normal/sync-exit/asyn
     try {
       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`);
-      }
     } finally {
       fs.rmSync(r.tmpBase, { recursive: true, force: true });
     }
   }
 });
 
+test('helper branch plain mode waits for late write beyond default printWaitMs', () => {
+  const r = runScenario({ printMode: true, stdinInherit: false, scenario: 'plain-late-write' });
+  try {
+    assert.ok((r.stdout || '').includes('late-output'), `stdout=${r.stdout} stderr=${r.stderr}`);
+    assert.equal(r.status, 0, `status=${r.status} stderr=${r.stderr}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('bootstrap branch plain mode waits for late write beyond default printWaitMs', () => {
+  const r = runScenario({ printMode: true, stdinInherit: true, scenario: 'plain-late-write' });
+  try {
+    assert.ok((r.stdout || '').includes('late-output'), `stdout=${r.stdout} stderr=${r.stderr}`);
+    assert.equal(r.status, 0, `status=${r.status} stderr=${r.stderr}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('helper branch plain mode with no output and non-zero exitCode exits promptly (no extended wait)', () => {
+  const r = runScenario({ printMode: true, stdinInherit: false, scenario: 'plain-no-output-error' });
+  try {
+    assert.equal(r.status, 1, `status=${r.status} stderr=${r.stderr}`);
+    assert.ok(r.elapsedMs < 5000, `expected prompt exit, got elapsedMs=${r.elapsedMs}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('bootstrap branch plain mode with no output and non-zero exitCode exits promptly (no extended wait)', () => {
+  const r = runScenario({ printMode: true, stdinInherit: true, scenario: 'plain-no-output-error' });
+  try {
+    assert.equal(r.status, 1, `status=${r.status} stderr=${r.stderr}`);
+    assert.ok(r.elapsedMs < 5000, `expected prompt exit, got elapsedMs=${r.elapsedMs}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('helper branch plain mode with no output and successful exit waits up to configured ceiling', () => {
+  const r = runScenario({
+    printMode: true,
+    stdinInherit: false,
+    scenario: 'plain-no-output-success',
+    extraEnv: { CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS: '400' },
+  });
+  try {
+    assert.equal(r.status, 0, `status=${r.status} stderr=${r.stderr}`);
+    assert.ok(r.elapsedMs >= 350, `expected extended wait close to 400ms ceiling, got elapsedMs=${r.elapsedMs}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
+test('bootstrap branch plain mode with no output and successful exit waits up to configured ceiling', () => {
+  const r = runScenario({
+    printMode: true,
+    stdinInherit: true,
+    scenario: 'plain-no-output-success',
+    extraEnv: { CLAUDE_TERMUX_PRINT_RESULT_TIMEOUT_MS: '400' },
+  });
+  try {
+    assert.equal(r.status, 0, `status=${r.status} stderr=${r.stderr}`);
+    assert.ok(r.elapsedMs >= 350, `expected extended wait close to 400ms ceiling, got elapsedMs=${r.elapsedMs}`);
+  } finally {
+    fs.rmSync(r.tmpBase, { recursive: true, force: true });
+  }
+});
+
 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' });
   try {
@@ -1075,6 +1154,31 @@ test('helper and bootstrap installStreamJsonTerminalWatcher helpers stay identic
   assert.equal(helperWatcher, bootstrapWatcher, 'installStreamJsonTerminalWatcher must be identical in both heredocs');
 });
 
+test('helper and bootstrap installPlainTextWriteWatcher helpers stay identical', () => {
+  const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+  const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
+
+  const extractFn = (block) => {
+    const startMarker = 'function installPlainTextWriteWatcher() {';
+    const start = block.indexOf(startMarker);
+    assert.ok(start > -1, 'installPlainTextWriteWatcher function not found');
+    let depth = 0;
+    let i = start + startMarker.length - 1;
+    for (; i < block.length; i++) {
+      if (block[i] === '{') depth++;
+      if (block[i] === '}') {
+        depth--;
+        if (depth === 0) break;
+      }
+    }
+    return block.slice(start, i + 1);
+  };
+
+  const helperFn = extractFn(helperBlock);
+  const bootstrapFn = extractFn(bootstrapBlock);
+  assert.equal(helperFn, bootstrapFn, 'installPlainTextWriteWatcher must be identical in helper and bootstrap');
+});
+
 test('helper and bootstrap forceTimeoutExit helpers stay identical', () => {
   const helperBlock = extractBlock('cat <<\'NODE\' > "$_helper"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');
   const bootstrapBlock = extractBlock('cat <<\'NODE\' > "$_bootstrap"', '\n  export ENABLE_CLAUDEAI_MCP_SERVERS=');

package/package.json

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