@anh3d0nic/qwen-code-termux-ice 16.0.4 → 16.0.7

package/bin/qwen-ice

@@ -1,6 +1,7 @@
 #!/data/data/com.termux/files/usr/bin/node
 /**
- * ❄️ Qwen Code ICE v16.0.0 — Main Binary
+ * ❄️ Qwen Code ICE v16.0.6 — Main Binary
+ * Fixed: Auto-runs postinstall if core dir missing on fresh install
  */
 
 const fs = require('fs');
@@ -8,8 +9,8 @@ const path = require('path');
 const readline = require('readline');
 const { spawn } = require('child_process');
 
-const VERSION = '16.0.0';
-const INSTALL_DIR = '/data/data/com.termux/files/.qwen-ice';
+const VERSION = '16.0.6';
+const INSTALL_DIR = process.env.HOME + '/.qwen-ice';
 const CONFIG_DIR = path.join(INSTALL_DIR, 'config');
 const MEMORY_DIR = path.join(INSTALL_DIR, 'memory');
 const LOGS_DIR = path.join(INSTALL_DIR, 'logs');
@@ -280,11 +281,30 @@ function printColdStart() {
   }
 }
 
+function getLatestIceVersion() {
+  // Check if core directory exists, run postinstall if not
+  if (!fs.existsSync(CORE_DIR)) {
+    const { execSync } = require('child_process');
+    execSync('node ' + path.join(__dirname, '../scripts/postinstall.cjs'), { stdio: 'inherit' });
+  }
+  const versions = fs.readdirSync(CORE_DIR)
+    .filter(f => f.startsWith('ice-v') && f.endsWith('.js'))
+    .sort();
+  if (!versions || versions.length === 0) {
+    console.error('ICE core not found. Run: node scripts/postinstall.cjs');
+    process.exit(1);
+  }
+  return versions[versions.length - 1] || 'ice-v15.js';
+}
+
 async function processQuery(query) {
   try {
-    const { IceV16 } = require(path.join(CORE_DIR, 'ice-v16.js'));
+    // Dynamically load latest ICE version
+    const latest = getLatestIceVersion();
+    const iceModule = require(path.join(CORE_DIR, latest));
+    const IceV16 = iceModule.IceV16 || iceModule.UnifiedPipeline;
     const ice = new IceV16({ yolo, model: selectedModel });
-    return await ice.processQuery(query);
+    return ice.process(query);
   } catch (err) {
     return { error: true, message: `Failed to process query: ${err.message}` };
   }

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@anh3d0nic/qwen-code-termux-ice",
-  "version": "16.0.4",
-  "description": "Qwen Code ICE v16.0.0 — Consolidated from v1-v15. Unified pipeline with 14 steps.",
+  "version": "16.0.7",
+  "description": "Qwen Code ICE v16.0.5 — Compounding Intelligence with proper npm install structure",
   "main": "core/ice-v16.js",
   "bin": {
     "qwen-ice": "./bin/qwen-ice",
     "qwen-ice-api-setup": "./bin/qwen-ice-api-setup"
   },
   "scripts": {
-    "postinstall": "node core/install.js",
+    "postinstall": "node scripts/postinstall.cjs",
     "preuninstall": "node core/uninstall.js",
-    "test": "echo \"ICE v16.0.0 installed successfully\" && exit 0"
+    "test": "echo \"ICE v15.0.0 installed successfully\" && exit 0"
   },
   "keywords": [
     "qwen",
@@ -21,7 +21,7 @@
     "groq",
     "gemini",
     "multi-provider",
-    "consolidated"
+    "compounding-intelligence"
   ],
   "author": "anh3d0nic",
   "license": "MIT",
@@ -49,6 +49,7 @@
     "config/",
     "memory/",
     "logs/",
+    "scripts/",
     "manifest.json"
   ]
 }

package/scripts/build.js

@@ -0,0 +1,88 @@
+/**
+ * @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 } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+
+// npm install if node_modules was removed (e.g. via npm run clean or scripts/clean.js)
+if (!existsSync(join(root, 'node_modules'))) {
+  execSync('npm install', { stdio: 'inherit', cwd: root });
+}
+
+// build all workspaces/packages in dependency order
+
+
+// Build in dependency order:
+// 1. test-utils (no internal dependencies)
+// 2. core (foundation package)
+// 3. web-templates (embeddable web templates - used by cli)
+// 4. cli (depends on core, test-utils, web-templates)
+// 5. webui (shared UI components - used by vscode companion)
+// 6. sdk (no internal dependencies)
+// 7. vscode-ide-companion (depends on webui) - SKIPPED for Termux
+const buildOrder = [
+  'packages/test-utils',
+  'packages/core',
+  'packages/web-templates',
+  'packages/cli',
+  'packages/webui',
+  'packages/sdk-typescript',
+  // 'packages/vscode-ide-companion', // Not needed for Termux
+];
+
+for (const workspace of buildOrder) {
+  execSync(`npm run build --workspace=${workspace}`, {
+    stdio: 'inherit',
+    cwd: root,
+  });
+
+  // After cli is built, generate the JSON Schema for settings
+  // so the vscode-ide-companion extension can provide IntelliSense
+  if (workspace === 'packages/cli') {
+    execSync('npx tsx scripts/generate-settings-schema.ts', {
+      stdio: 'inherit',
+      cwd: root,
+    });
+  }
+}
+
+// also build container image if sandboxing is enabled
+// skip (-s) npm install + build since we did that above
+try {
+  execSync('node scripts/sandbox_command.js -q', {
+    stdio: 'inherit',
+    cwd: root,
+  });
+  if (
+    process.env.BUILD_SANDBOX === '1' ||
+    process.env.BUILD_SANDBOX === 'true'
+  ) {
+    execSync('node scripts/build_sandbox.js -s', {
+      stdio: 'inherit',
+      cwd: root,
+    });
+  }
+} catch {
+  // ignore
+}

package/scripts/build_package.js

@@ -0,0 +1,37 @@
+/**
+ * @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 { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+if (!process.cwd().includes('packages')) {
+  console.error('must be invoked from a package directory');
+  process.exit(1);
+}
+
+// build typescript files
+execSync('tsc --build', { stdio: 'inherit' });
+
+// copy .{md,json} files
+execSync('node ../../scripts/copy_files.js', { stdio: 'inherit' });
+
+// touch dist/.last_build
+writeFileSync(join(process.cwd(), 'dist', '.last_build'), '');
+process.exit(0);

package/scripts/build_sandbox.js

@@ -0,0 +1,174 @@
+/**
+ * @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,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import os from 'node:os';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import cliPkgJson from '../packages/cli/package.json' with { type: 'json' };
+
+const argv = yargs(hideBin(process.argv))
+  .option('s', {
+    alias: 'skip-npm-install-build',
+    type: 'boolean',
+    default: false,
+    description: 'skip npm install + npm run build',
+  })
+  .option('f', {
+    alias: 'dockerfile',
+    type: 'string',
+    default: 'Dockerfile',
+    description: 'use <dockerfile> for custom image',
+  })
+  .option('i', {
+    alias: 'image',
+    type: 'string',
+    default: cliPkgJson.config.sandboxImageUri,
+    description: 'use <image> name for custom image',
+  })
+  .option('output-file', {
+    type: 'string',
+    description:
+      'Path to write the final image URI. Used for CI/CD pipeline integration.',
+  }).argv;
+
+let sandboxCommand;
+try {
+  sandboxCommand = execSync('node scripts/sandbox_command.js')
+    .toString()
+    .trim();
+} catch (e) {
+  console.warn('ERROR: could not detect sandbox container command');
+  console.error(e);
+  process.exit(process.env.CI ? 1 : 0);
+}
+
+if (sandboxCommand === 'sandbox-exec') {
+  console.warn(
+    'WARNING: container-based sandboxing is disabled (see README.md#sandboxing)',
+  );
+  process.exit(0);
+}
+
+console.log(`using ${sandboxCommand} for sandboxing`);
+
+const image = argv.i;
+const dockerFile = argv.f;
+
+if (!image.length) {
+  console.warn(
+    'No default image tag specified in gemini-cli/packages/cli/package.json',
+  );
+}
+
+if (!argv.s) {
+  execSync('npm install', { stdio: 'inherit' });
+  execSync('npm run build', { stdio: 'inherit' });
+
+  console.log('bundling...');
+  execSync('npm run bundle', { stdio: 'inherit' });
+
+  console.log('preparing package...');
+  execSync('npm run prepare:package', { stdio: 'inherit' });
+
+  console.log('packing...');
+  const distDir = join(process.cwd(), 'dist');
+  for (const f of readdirSync(distDir)) {
+    if (f.endsWith('.tgz')) {
+      rmSync(join(distDir, f), { force: true });
+    }
+  }
+  execSync('npm pack', { stdio: 'ignore', cwd: distDir });
+}
+
+const buildStdout = process.env.VERBOSE ? 'inherit' : 'ignore';
+
+// Determine the appropriate shell based on OS
+const isWindows = os.platform() === 'win32';
+const shellToUse = isWindows ? 'powershell.exe' : '/bin/bash';
+
+function buildImage(imageName, dockerfile) {
+  console.log(`building ${imageName} ... (can be slow first time)`);
+
+  let buildCommandArgs = '';
+  let tempAuthFile = '';
+
+  if (sandboxCommand === 'podman') {
+    if (isWindows) {
+      // PowerShell doesn't support <() process substitution.
+      // Create a temporary auth file that we will clean up after.
+      tempAuthFile = join(os.tmpdir(), `qwen-auth-${Date.now()}.json`);
+      writeFileSync(tempAuthFile, '{}');
+      buildCommandArgs = `--authfile="${tempAuthFile}"`;
+    } else {
+      // Use bash-specific syntax for Linux/macOS
+      buildCommandArgs = `--authfile=<(echo '{}')`;
+    }
+  }
+
+  const npmPackageVersion = JSON.parse(
+    readFileSync(join(process.cwd(), 'package.json'), 'utf-8'),
+  ).version;
+
+  const imageTag =
+    process.env.QWEN_SANDBOX_IMAGE_TAG || imageName.split(':')[1];
+  const finalImageName = `${imageName.split(':')[0]}:${imageTag}`;
+
+  try {
+    execSync(
+      `${sandboxCommand} build ${buildCommandArgs} ${
+        process.env.BUILD_SANDBOX_FLAGS || ''
+      } --build-arg CLI_VERSION_ARG=${npmPackageVersion} -f "${dockerfile}" -t "${finalImageName}" .`,
+      { stdio: buildStdout, shell: shellToUse },
+    );
+    console.log(`built ${finalImageName}`);
+
+    // If an output file path was provided via command-line, write the final image URI to it.
+    if (argv.outputFile) {
+      console.log(
+        `Writing final image URI for CI artifact to: ${argv.outputFile}`,
+      );
+      // The publish step only supports one image. If we build multiple, only the last one
+      // will be published. Throw an error to make this failure explicit if the file already exists.
+      if (existsSync(argv.outputFile)) {
+        throw new Error(
+          `CI artifact file ${argv.outputFile} already exists. Refusing to overwrite.`,
+        );
+      }
+      writeFileSync(argv.outputFile, finalImageName);
+    }
+  } finally {
+    // If we created a temp file, delete it now.
+    if (tempAuthFile) {
+      rmSync(tempAuthFile, { force: true });
+    }
+  }
+}
+
+buildImage(image, dockerFile);
+
+execSync(`${sandboxCommand} image prune -f`, { stdio: 'ignore' });

package/scripts/build_vscode_companion.js

@@ -0,0 +1,30 @@
+/**
+ * @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 { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+
+execSync('npm --workspace=qwen-code-vscode-ide-companion run package', {
+  stdio: 'inherit',
+  cwd: root,
+});

package/scripts/check-build-status.js

@@ -0,0 +1,148 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os'; // Import os module
+
+// --- Configuration ---
+const cliPackageDir = path.resolve('packages', 'cli'); // Base directory for the CLI package
+const buildTimestampPath = path.join(cliPackageDir, 'dist', '.last_build'); // Path to the timestamp file within the CLI package
+const sourceDirs = [path.join(cliPackageDir, 'src')]; // Source directory within the CLI package
+const filesToWatch = [
+  path.join(cliPackageDir, 'package.json'),
+  path.join(cliPackageDir, 'tsconfig.json'),
+]; // Specific files within the CLI package
+const buildDir = path.join(cliPackageDir, 'dist'); // Build output directory within the CLI package
+const warningsFilePath = path.join(os.tmpdir(), 'qwen-code-warnings.txt'); // Temp file for warnings
+// ---------------------
+
+function getMtime(filePath) {
+  try {
+    return fs.statSync(filePath).mtimeMs; // Use mtimeMs for higher precision
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return null; // File doesn't exist
+    }
+    console.error(`Error getting stats for ${filePath}:`, err);
+    process.exit(1); // Exit on unexpected errors getting stats
+  }
+}
+
+function findSourceFiles(dir, allFiles = []) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    // Simple check to avoid recursing into node_modules or build dir itself
+    if (
+      entry.isDirectory() &&
+      entry.name !== 'node_modules' &&
+      fullPath !== buildDir
+    ) {
+      findSourceFiles(fullPath, allFiles);
+    } else if (entry.isFile()) {
+      allFiles.push(fullPath);
+    }
+  }
+  return allFiles;
+}
+
+console.log('Checking build status...');
+
+// Clean up old warnings file before check
+try {
+  if (fs.existsSync(warningsFilePath)) {
+    fs.unlinkSync(warningsFilePath);
+  }
+} catch (err) {
+  console.warn(
+    `[Check Script] Warning: Could not delete previous warnings file: ${err.message}`,
+  );
+}
+
+const buildMtime = getMtime(buildTimestampPath);
+if (!buildMtime) {
+  // If build is missing, write that as a warning and exit(0) so app can display it
+  const errorMessage = `ERROR: Build timestamp file (${path.relative(process.cwd(), buildTimestampPath)}) not found. Run \`npm run build\` first.`;
+  console.error(errorMessage); // Still log error here
+  try {
+    fs.writeFileSync(warningsFilePath, errorMessage);
+  } catch (writeErr) {
+    console.error(
+      `[Check Script] Error writing missing build warning file: ${writeErr.message}`,
+    );
+  }
+  process.exit(0); // Allow app to start and show the error
+}
+
+let newerSourceFileFound = false;
+const warningMessages = []; // Collect warnings here
+const allSourceFiles = [];
+
+// Collect files from specified directories
+sourceDirs.forEach((dir) => {
+  const dirPath = path.resolve(dir);
+  if (fs.existsSync(dirPath)) {
+    findSourceFiles(dirPath, allSourceFiles);
+  } else {
+    console.warn(`Warning: Source directory "${dir}" not found.`);
+  }
+});
+
+// Add specific files
+filesToWatch.forEach((file) => {
+  const filePath = path.resolve(file);
+  if (fs.existsSync(filePath)) {
+    allSourceFiles.push(filePath);
+  } else {
+    console.warn(`Warning: Watched file "${file}" not found.`);
+  }
+});
+
+// Check modification times
+for (const file of allSourceFiles) {
+  const sourceMtime = getMtime(file);
+  const relativePath = path.relative(process.cwd(), file);
+  const isNewer = sourceMtime && sourceMtime > buildMtime;
+
+  if (isNewer) {
+    const warning = `Warning: Source file "${relativePath}" has been modified since the last build.`;
+    console.warn(warning); // Keep console warning for script debugging
+    warningMessages.push(warning);
+    newerSourceFileFound = true;
+    // break; // Uncomment to stop checking after the first newer file
+  }
+}
+
+if (newerSourceFileFound) {
+  const finalWarning =
+    '\nRun "npm run build" to incorporate changes before starting.';
+  warningMessages.push(finalWarning);
+  console.warn(finalWarning);
+
+  // Write warnings to the temp file
+  try {
+    fs.writeFileSync(warningsFilePath, warningMessages.join('\n'));
+    // Removed debug log
+  } catch (err) {
+    console.error(`[Check Script] Error writing warnings file: ${err.message}`);
+    // Proceed without writing, app won't show warnings
+  }
+} else {
+  console.log('Build is up-to-date.');
+  // Ensure no stale warning file exists if build is ok
+  try {
+    if (fs.existsSync(warningsFilePath)) {
+      fs.unlinkSync(warningsFilePath);
+    }
+  } catch (err) {
+    console.warn(
+      `[Check Script] Warning: Could not delete previous warnings file: ${err.message}`,
+    );
+  }
+}
+
+process.exit(0); // Always exit successfully so the app starts