@mmmbuto/qwen-code-termux 0.6.4-termux → 0.6.401

package/scripts/local_telemetry.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawn, execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import {
+  BIN_DIR,
+  OTEL_DIR,
+  ensureBinary,
+  fileExists,
+  manageTelemetrySettings,
+  registerCleanup,
+  waitForPort,
+} from './telemetry_utils.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const OTEL_CONFIG_FILE = path.join(OTEL_DIR, 'collector-local.yaml');
+const OTEL_LOG_FILE = path.join(OTEL_DIR, 'collector.log');
+const JAEGER_LOG_FILE = path.join(OTEL_DIR, 'jaeger.log');
+const JAEGER_PORT = 16686;
+
+// This configuration is for the primary otelcol-contrib instance.
+// It receives from the CLI on 4317, exports traces to Jaeger on 14317,
+// and sends metrics/logs to the debug log.
+const OTEL_CONFIG_CONTENT = `
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: "localhost:4317"
+processors:
+  batch:
+    timeout: 1s
+exporters:
+  otlp:
+    endpoint: "localhost:14317"
+    tls:
+      insecure: true
+  debug:
+    verbosity: detailed
+service:
+  telemetry:
+    logs:
+      level: "debug"
+    metrics:
+      level: "none"
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [otlp]
+    metrics:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [debug]
+    logs:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [debug]
+`;
+
+async function main() {
+  // 1. Ensure binaries are available, downloading if necessary.
+  // Binaries are stored in the project's .qwen/otel/bin directory
+  // to avoid modifying the user's system.
+  if (!fileExists(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+
+  const otelcolPath = await ensureBinary(
+    'otelcol-contrib',
+    'open-telemetry/opentelemetry-collector-releases',
+    (version, platform, arch, ext) =>
+      `otelcol-contrib_${version}_${platform}_${arch}.${ext}`,
+    'otelcol-contrib',
+    false, // isJaeger = false
+  ).catch((e) => {
+    console.error(`🛑 Error getting otelcol-contrib: ${e.message}`);
+    return null;
+  });
+  if (!otelcolPath) process.exit(1);
+
+  const jaegerPath = await ensureBinary(
+    'jaeger',
+    'jaegertracing/jaeger',
+    (version, platform, arch, ext) =>
+      `jaeger-${version}-${platform}-${arch}.${ext}`,
+    'jaeger',
+    true, // isJaeger = true
+  ).catch((e) => {
+    console.error(`🛑 Error getting jaeger: ${e.message}`);
+    return null;
+  });
+  if (!jaegerPath) process.exit(1);
+
+  // 2. Kill any existing processes to ensure a clean start.
+  console.log('🧹 Cleaning up old processes and logs...');
+  try {
+    execSync('pkill -f "otelcol-contrib"');
+    console.log('✅ Stopped existing otelcol-contrib process.');
+  } catch (_e) {} // eslint-disable-line no-empty
+  try {
+    execSync('pkill -f "jaeger"');
+    console.log('✅ Stopped existing jaeger process.');
+  } catch (_e) {} // eslint-disable-line no-empty
+  try {
+    if (fileExists(OTEL_LOG_FILE)) fs.unlinkSync(OTEL_LOG_FILE);
+    console.log('✅ Deleted old collector log.');
+  } catch (e) {
+    if (e.code !== 'ENOENT') console.error(e);
+  }
+  try {
+    if (fileExists(JAEGER_LOG_FILE)) fs.unlinkSync(JAEGER_LOG_FILE);
+    console.log('✅ Deleted old jaeger log.');
+  } catch (e) {
+    if (e.code !== 'ENOENT') console.error(e);
+  }
+
+  let jaegerProcess, collectorProcess;
+  let jaegerLogFd, collectorLogFd;
+
+  const originalSandboxSetting = manageTelemetrySettings(
+    true,
+    'http://localhost:4317',
+    'local',
+  );
+
+  registerCleanup(
+    () => [jaegerProcess, collectorProcess],
+    () => [jaegerLogFd, collectorLogFd],
+    originalSandboxSetting,
+  );
+
+  if (!fileExists(OTEL_DIR)) fs.mkdirSync(OTEL_DIR, { recursive: true });
+  fs.writeFileSync(OTEL_CONFIG_FILE, OTEL_CONFIG_CONTENT);
+  console.log('📄 Wrote OTEL collector config.');
+
+  // Start Jaeger
+  console.log(`🚀 Starting Jaeger service... Logs: ${JAEGER_LOG_FILE}`);
+  jaegerLogFd = fs.openSync(JAEGER_LOG_FILE, 'a');
+  jaegerProcess = spawn(
+    jaegerPath,
+    ['--set=receivers.otlp.protocols.grpc.endpoint=localhost:14317'],
+    { stdio: ['ignore', jaegerLogFd, jaegerLogFd] },
+  );
+  console.log(`⏳ Waiting for Jaeger to start (PID: ${jaegerProcess.pid})...`);
+
+  try {
+    await waitForPort(JAEGER_PORT);
+    console.log(`✅ Jaeger started successfully.`);
+  } catch (_) {
+    console.error(`🛑 Error: Jaeger failed to start on port ${JAEGER_PORT}.`);
+    if (jaegerProcess && jaegerProcess.pid) {
+      process.kill(jaegerProcess.pid, 'SIGKILL');
+    }
+    if (fileExists(JAEGER_LOG_FILE)) {
+      console.error('📄 Jaeger Log Output:');
+      console.error(fs.readFileSync(JAEGER_LOG_FILE, 'utf-8'));
+    }
+    process.exit(1);
+  }
+
+  // Start the primary OTEL collector
+  console.log(`🚀 Starting OTEL collector... Logs: ${OTEL_LOG_FILE}`);
+  collectorLogFd = fs.openSync(OTEL_LOG_FILE, 'a');
+  collectorProcess = spawn(otelcolPath, ['--config', OTEL_CONFIG_FILE], {
+    stdio: ['ignore', collectorLogFd, collectorLogFd],
+  });
+  console.log(
+    `⏳ Waiting for OTEL collector to start (PID: ${collectorProcess.pid})...`,
+  );
+
+  try {
+    await waitForPort(4317);
+    console.log(`✅ OTEL collector started successfully.`);
+  } catch (_) {
+    console.error(`🛑 Error: OTEL collector failed to start on port 4317.`);
+    if (collectorProcess && collectorProcess.pid) {
+      process.kill(collectorProcess.pid, 'SIGKILL');
+    }
+    if (fileExists(OTEL_LOG_FILE)) {
+      console.error('📄 OTEL Collector Log Output:');
+      console.error(fs.readFileSync(OTEL_LOG_FILE, 'utf-8'));
+    }
+    process.exit(1);
+  }
+
+  [jaegerProcess, collectorProcess].forEach((proc) => {
+    if (proc) {
+      proc.on('error', (err) => {
+        console.error(`${proc.spawnargs[0]} process error:`, err);
+        process.exit(1);
+      });
+    }
+  });
+
+  console.log(`
+✨ Local telemetry environment is running.`);
+  console.log(
+    `
+🔎 View traces in the Jaeger UI: http://localhost:${JAEGER_PORT}`,
+  );
+  console.log(`📊 View metrics in the logs and metrics: ${OTEL_LOG_FILE}`);
+  console.log(
+    `
+📄 Tail logs and metrics in another terminal: tail -f ${OTEL_LOG_FILE}`,
+  );
+  console.log(`
+Press Ctrl+C to exit.`);
+}
+
+main();

package/scripts/postinstall.cjs

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// TERMUX: Minimal install message
+const os = require('node:os');
+
+if (os.platform() === 'android' || process.env.PREFIX?.includes('com.termux')) {
+  console.log('✓ qwen-code-termux installed');
+  console.log('  Run: qwen');
+}

package/scripts/pre-commit.js

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { execSync } from 'node:child_process';
+import lintStaged from 'lint-staged';
+
+try {
+  // Get repository root
+  const root = execSync('git rev-parse --show-toplevel').toString().trim();
+
+  // Run lint-staged with API directly
+  const passed = await lintStaged({ cwd: root });
+
+  // Exit with appropriate code
+  process.exit(passed ? 0 : 1);
+} catch {
+  // Exit with error code
+  process.exit(1);
+}

package/scripts/prepare-package.js

@@ -0,0 +1,162 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Prepares the bundled CLI package for npm publishing
+ * This script adds publishing metadata (package.json, README, LICENSE) to dist/
+ * All runtime assets (cli.js, vendor/, *.sb) are already in dist/ from the bundle step
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, '..');
+
+const distDir = path.join(rootDir, 'dist');
+const cliBundlePath = path.join(distDir, 'cli.js');
+const vendorDir = path.join(distDir, 'vendor');
+
+// Verify dist directory and bundle exist
+if (!fs.existsSync(distDir)) {
+  console.error('Error: dist/ directory not found');
+  console.error('Please run "npm run bundle" first');
+  process.exit(1);
+}
+
+if (!fs.existsSync(cliBundlePath)) {
+  console.error(`Error: Bundle not found at ${cliBundlePath}`);
+  console.error('Please run "npm run bundle" first');
+  process.exit(1);
+}
+
+if (!fs.existsSync(vendorDir)) {
+  console.error(`Error: Vendor directory not found at ${vendorDir}`);
+  console.error('Please run "npm run bundle" first');
+  process.exit(1);
+}
+
+// Copy README and LICENSE
+console.log('Copying documentation files...');
+const filesToCopy = ['README.md', 'LICENSE'];
+for (const file of filesToCopy) {
+  const sourcePath = path.join(rootDir, file);
+  const destPath = path.join(distDir, file);
+  if (fs.existsSync(sourcePath)) {
+    fs.copyFileSync(sourcePath, destPath);
+    console.log(`Copied ${file}`);
+  } else {
+    console.warn(`Warning: ${file} not found at ${sourcePath}`);
+  }
+}
+
+// Copy locales folder
+console.log('Copying locales folder...');
+const localesSourceDir = path.join(
+  rootDir,
+  'packages',
+  'cli',
+  'src',
+  'i18n',
+  'locales',
+);
+const localesDestDir = path.join(distDir, 'locales');
+
+if (fs.existsSync(localesSourceDir)) {
+  // Recursive copy function
+  function copyRecursiveSync(src, dest) {
+    const stats = fs.statSync(src);
+    if (stats.isDirectory()) {
+      if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+      }
+      const entries = fs.readdirSync(src);
+      for (const entry of entries) {
+        const srcPath = path.join(src, entry);
+        const destPath = path.join(dest, entry);
+        copyRecursiveSync(srcPath, destPath);
+      }
+    } else {
+      fs.copyFileSync(src, dest);
+    }
+  }
+
+  copyRecursiveSync(localesSourceDir, localesDestDir);
+  console.log('Copied locales folder');
+} else {
+  console.warn(`Warning: locales folder not found at ${localesSourceDir}`);
+}
+
+// Copy package.json from root and modify it for publishing
+console.log('Creating package.json for distribution...');
+const rootPackageJson = JSON.parse(
+  fs.readFileSync(path.join(rootDir, 'package.json'), 'utf-8'),
+);
+const corePackageJson = JSON.parse(
+  fs.readFileSync(
+    path.join(rootDir, 'packages', 'core', 'package.json'),
+    'utf-8',
+  ),
+);
+
+const runtimeDependencies = {};
+if (corePackageJson.dependencies?.tiktoken) {
+  runtimeDependencies.tiktoken = corePackageJson.dependencies.tiktoken;
+}
+const isTermuxBuild =
+  process.platform === 'android' ||
+  !!process.env['TERMUX_VERSION'] ||
+  !!(process.env['PREFIX'] && process.env['PREFIX'].includes('com.termux'));
+const optionalDependencies = isTermuxBuild
+  ? undefined
+  : {
+      '@lydell/node-pty': '1.1.0',
+      '@lydell/node-pty-darwin-arm64': '1.1.0',
+      '@lydell/node-pty-darwin-x64': '1.1.0',
+      '@lydell/node-pty-linux-x64': '1.1.0',
+      '@lydell/node-pty-win32-arm64': '1.1.0',
+      '@lydell/node-pty-win32-x64': '1.1.0',
+      'node-pty': '^1.0.0',
+    };
+
+// Create a clean package.json for the published package
+const distPackageJson = {
+  name: rootPackageJson.name,
+  version: rootPackageJson.version,
+  description:
+    rootPackageJson.description || 'Qwen Code - AI-powered coding assistant',
+  repository: rootPackageJson.repository,
+  type: 'module',
+  main: 'cli.js',
+  bin: {
+    qwen: 'cli.js',
+  },
+  files: [
+    'cli.js',
+    'vendor',
+    '*.sb',
+    'tiktoken_bg.wasm',
+    'README.md',
+    'LICENSE',
+    'locales',
+  ],
+  config: rootPackageJson.config,
+  dependencies: runtimeDependencies,
+  engines: rootPackageJson.engines,
+  ...(optionalDependencies ? { optionalDependencies } : {}),
+};
+
+fs.writeFileSync(
+  path.join(distDir, 'package.json'),
+  JSON.stringify(distPackageJson, null, 2) + '\n',
+);
+
+console.log('\n✅ Package prepared for publishing at dist/');
+console.log('\nPackage structure:');
+execSync('ls -lh dist/', { stdio: 'inherit', cwd: rootDir });

package/scripts/sandbox_command.js

@@ -0,0 +1,126 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import stripJsonComments from 'strip-json-comments';
+import os from 'node:os';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import dotenv from 'dotenv';
+
+const argv = yargs(hideBin(process.argv)).option('q', {
+  alias: 'quiet',
+  type: 'boolean',
+  default: false,
+}).argv;
+
+let geminiSandbox = process.env.GEMINI_SANDBOX;
+
+if (!geminiSandbox) {
+  const userSettingsFile = join(os.homedir(), '.qwen', 'settings.json');
+  if (existsSync(userSettingsFile)) {
+    const settings = JSON.parse(
+      stripJsonComments(readFileSync(userSettingsFile, 'utf-8')),
+    );
+    if (settings.sandbox) {
+      geminiSandbox = settings.sandbox;
+    }
+  }
+}
+
+if (!geminiSandbox) {
+  let currentDir = process.cwd();
+  while (true) {
+    const geminiEnv = join(currentDir, '.qwen', '.env');
+    const regularEnv = join(currentDir, '.env');
+    if (existsSync(geminiEnv)) {
+      dotenv.config({ path: geminiEnv, quiet: true });
+      break;
+    } else if (existsSync(regularEnv)) {
+      dotenv.config({ path: regularEnv, quiet: true });
+      break;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  geminiSandbox = process.env.GEMINI_SANDBOX;
+}
+
+geminiSandbox = (geminiSandbox || '').toLowerCase();
+
+const commandExists = (cmd) => {
+  const checkCommand = os.platform() === 'win32' ? 'where' : 'command -v';
+  try {
+    execSync(`${checkCommand} ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    if (os.platform() === 'win32') {
+      try {
+        execSync(`${checkCommand} ${cmd}.exe`, { stdio: 'ignore' });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+};
+
+let command = '';
+if (['1', 'true'].includes(geminiSandbox)) {
+  if (commandExists('docker')) {
+    command = 'docker';
+  } else if (commandExists('podman')) {
+    command = 'podman';
+  } else {
+    console.error(
+      'ERROR: install docker or podman or specify command in GEMINI_SANDBOX',
+    );
+    process.exit(1);
+  }
+} else if (geminiSandbox && !['0', 'false'].includes(geminiSandbox)) {
+  if (commandExists(geminiSandbox)) {
+    command = geminiSandbox;
+  } else {
+    console.error(
+      `ERROR: missing sandbox command '${geminiSandbox}' (from GEMINI_SANDBOX)`,
+    );
+    process.exit(1);
+  }
+} else {
+  if (os.platform() === 'darwin' && process.env.SEATBELT_PROFILE !== 'none') {
+    if (commandExists('sandbox-exec')) {
+      command = 'sandbox-exec';
+    } else {
+      process.exit(1);
+    }
+  } else {
+    process.exit(1);
+  }
+}
+
+if (!argv.q) {
+  console.log(command);
+}
+process.exit(0);

package/scripts/start.js

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law_or_agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { spawn, execSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8'));
+
+// check build status, write warnings to file for app to display if needed
+execSync('node ./scripts/check-build-status.js', {
+  stdio: 'inherit',
+  cwd: root,
+});
+
+const nodeArgs = [];
+let sandboxCommand = undefined;
+try {
+  sandboxCommand = execSync('node scripts/sandbox_command.js', {
+    cwd: root,
+  })
+    .toString()
+    .trim();
+} catch {
+  // ignore
+}
+// if debugging is enabled and sandboxing is disabled, use --inspect-brk flag
+// note with sandboxing this flag is passed to the binary inside the sandbox
+// inside sandbox SANDBOX should be set and sandbox_command.js should fail
+if (process.env.DEBUG && !sandboxCommand) {
+  if (process.env.SANDBOX) {
+    const port = process.env.DEBUG_PORT || '9229';
+    nodeArgs.push(`--inspect-brk=0.0.0.0:${port}`);
+  } else {
+    nodeArgs.push('--inspect-brk');
+  }
+}
+
+nodeArgs.push(join(root, 'packages', 'cli'));
+nodeArgs.push(...process.argv.slice(2));
+
+const env = {
+  ...process.env,
+  CLI_VERSION: pkg.version,
+  DEV: 'true',
+};
+
+if (process.env.DEBUG) {
+  // If this is not set, the debugger will pause on the outer process rather
+  // than the relaunched process making it harder to debug.
+  env.QWEN_CODE_NO_RELAUNCH = 'true';
+}
+// Use process.cwd() to inherit the working directory from launch.json cwd setting
+// This allows debugging from a specific directory (e.g., .todo)
+const workingDir = process.env.QWEN_WORKING_DIR || process.cwd();
+const child = spawn('node', nodeArgs, {
+  stdio: 'inherit',
+  env,
+  cwd: workingDir,
+});
+
+child.on('close', (code) => {
+  process.exit(code);
+});