@unitsvc/cc-helper 1.0.6

package/README.md

@@ -0,0 +1,126 @@
+# cc-helper
+
+> Enable/disable the `/loop` feature in Claude Code CLI
+
+## Requirements
+
+- Claude Code v2.1.71+
+
+```bash
+npm install -g @anthropic-ai/claude-code@v2.1.71
+```
+
+## Installation
+
+```bash
+# Using npx (no install)
+npx @unitsvc/cc-helper enable
+
+# Or install globally
+npm install -g @unitsvc/cc-helper
+cc-helper enable
+```
+
+## Usage
+
+### Command
+
+| Command               | Description             |
+| --------------------- | ----------------------- |
+| `cc-helper enable`    | Enable `/loop` feature  |
+| `cc-helper disable`   | Restore original        |
+| `cc-helper status`    | Check current status    |
+| `cc-helper uninstall` | Uninstall (clean cache) |
+
+## Sponsors
+
+🚀 **GLM Coding Plan**
+
+👉 [Enjoy full support for Claude Code, Cline, and 20+ top coding tools — starting at just $10/month. Subscribe now and grab the limited-time deal!](https://z.ai/subscribe?ic=1YVKN4IRCQ)
+
+---
+
+## What is `/loop`?
+
+`/loop` is a built-in command in Claude Code CLI that lets you schedule recurring prompts. It's useful for:
+
+- Polling deployments or builds
+- Babysitting PRs
+- Setting reminders
+- Running workflows on an interval
+
+### Usage Syntax
+
+```
+/loop [interval] <prompt>
+```
+
+**Examples:**
+
+```
+/loop 5m check if the deployment finished
+/loop 30m /review-pr 1234
+/loop remind me to push the release at 3pm
+```
+
+### Interval Formats
+
+| Form                    | Example                     | Parsed Interval              |
+| ----------------------- | --------------------------- | ---------------------------- |
+| Leading token           | `/loop 30m check`           | every 30 minutes             |
+| Trailing `every` clause | `/loop check every 2 hours` | every 2 hours                |
+| No interval             | `/loop check`               | defaults to every 10 minutes |
+
+Supported units: `s` (seconds), `m` (minutes), `h` (hours), `d` (days)
+
+### Key Features
+
+- **Session-scoped**: Tasks live in the current Claude Code session and are gone when you exit
+- **Auto-expiry**: Recurring tasks expire after 3 days
+- **Jitter protection**: Adds small offsets to prevent API thundering herd
+- **Low priority**: Scheduled prompts fire between your turns, not while Claude is busy
+
+### Managing Tasks
+
+```
+what scheduled tasks do I have?   # List all tasks
+cancel the deploy check job       # Cancel by description or ID
+```
+
+## Features
+
+- Enable `/loop` with one command
+- Easy restore functionality
+- Automatic backup
+
+### Examples
+
+After enabling, use the `/loop` command in Claude Code:
+
+![/loop command hint](./docs/images/loop-1.png)
+
+Example of executing a loop command:
+
+![/loop execution example](./docs/images/loop-2.png)
+
+## Platforms
+
+- macOS (amd64, arm64)
+- Linux (amd64, arm64)
+- Windows (amd64)
+
+## License
+
+AGPL-3.0 - see [LICENSE](./LICENSE)
+
+## Security
+
+### Reporting Vulnerabilities
+
+If you discover a security vulnerability in cc-helper, please report it responsibly:
+
+1. **Do not** open a public issue
+2. Send an email to the maintainer with details
+3. Allow reasonable time for the issue to be addressed before public disclosure
+
+We take security seriously and will respond to reports as quickly as possible.

package/bin/cc-helper.js

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, execSync } = require('child_process');
+
+const GITHUB_OWNER = 'next-bin';
+const GITHUB_REPO = 'cc-helper';
+const CACHE_DIR = path.join(os.homedir(), '.cache', 'cc-helper');
+const VERSION_FILE = path.join(CACHE_DIR, 'version.txt');
+
+// Handle uninstall command directly
+function handleUninstall() {
+  try {
+    if (fs.existsSync(CACHE_DIR)) {
+      console.log('Removing cached binaries...');
+      fs.rmSync(CACHE_DIR, { recursive: true, force: true });
+      console.log('Cleanup complete!');
+    } else {
+      console.log('No cached binaries found.');
+    }
+    console.log('\nTo complete uninstallation, run:');
+    console.log('  npm uninstall -g @unitsvc/cc-helper');
+    process.exit(0);
+  } catch (err) {
+    console.error('Error during uninstall:', err.message);
+    process.exit(1);
+  }
+}
+
+// Read version from package.json
+function getPackageVersion() {
+  try {
+    const packagePath = path.join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    return pkg.version;
+  } catch (err) {
+    throw new Error('Cannot read package version: ' + err.message);
+  }
+}
+
+function getPlatform() {
+  const platform = os.platform();
+  const arch = os.arch();
+
+  const platformMap = {
+    'darwin': 'darwin',
+    'linux': 'linux',
+    'win32': 'windows'
+  };
+
+  const archMap = {
+    'x64': 'amd64',
+    'arm64': 'arm64'
+  };
+
+  const mappedPlatform = platformMap[platform];
+  const mappedArch = archMap[arch];
+
+  if (!mappedPlatform || !mappedArch) {
+    throw new Error(`Unsupported platform: ${platform} ${arch}`);
+  }
+
+  // Windows arm64 not supported by GoReleaser
+  if (platform === 'win32' && arch === 'arm64') {
+    throw new Error('Windows arm64 is not supported. Please use Windows amd64 or macOS/Linux arm64.');
+  }
+
+  return { platform: mappedPlatform, arch: mappedArch };
+}
+
+function getArchiveName(version, platform, arch) {
+  // GitHub release uses version without 'v' prefix in filename
+  const ver = version.replace(/^v/, '');
+  if (platform === 'windows') {
+    return `cc-helper_${ver}_${platform}_${arch}.zip`;
+  }
+  return `cc-helper_${ver}_${platform}_${arch}.tar.gz`;
+}
+
+function getBinaryName(platform) {
+  return platform === 'windows' ? 'cc-helper.exe' : 'cc-helper';
+}
+
+function getBinaryPath() {
+  const { platform } = getPlatform();
+  const binaryName = getBinaryName(platform);
+  return path.join(CACHE_DIR, binaryName);
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+
+    const requestUrl = url.startsWith('https://') ? url : 'https://github.com' + url;
+
+    const request = https.get(requestUrl, { headers: { 'User-Agent': 'cc-helper-npm-installer' } }, (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        file.close();
+        if (fs.existsSync(dest)) {
+          fs.unlinkSync(dest);
+        }
+        downloadFile(response.headers.location, dest).then(resolve).catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        if (fs.existsSync(dest)) {
+          fs.unlinkSync(dest);
+        }
+        reject(new Error(`Download failed with status ${response.statusCode}: ${url}`));
+        return;
+      }
+
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+    });
+
+    request.on('error', (err) => {
+      if (fs.existsSync(dest)) {
+        fs.unlinkSync(dest);
+      }
+      reject(err);
+    });
+
+    file.on('error', (err) => {
+      if (fs.existsSync(dest)) {
+        fs.unlinkSync(dest);
+      }
+      reject(err);
+    });
+  });
+}
+
+function extractTarGz(tarGzPath, destDir) {
+  try {
+    // Use system tar command (available on macOS and Linux)
+    execSync(`tar -xzf "${tarGzPath}" -C "${destDir}"`, { stdio: 'pipe' });
+  } catch (err) {
+    throw new Error(`Failed to extract tar.gz archive: ${err.message}`);
+  }
+}
+
+function extractZip(zipPath, destDir) {
+  try {
+    if (process.platform === 'win32') {
+      // Use PowerShell on Windows (built-in, no external dependencies)
+      // -NoProfile: Skip loading user profile scripts (faster, more reliable)
+      // -ExecutionPolicy Bypass: Allow script execution without policy restrictions
+      // -Command: Execute inline command
+      const psCommand = `
+        try {
+          Expand-Archive -Path '${zipPath.replace(/'/g, "''")}' -DestinationPath '${destDir.replace(/'/g, "''")}' -Force -ErrorAction Stop
+          exit 0
+        } catch {
+          exit 1
+        }
+      `;
+      execSync(`powershell -NoProfile -ExecutionPolicy Bypass -Command "${psCommand}"`, { stdio: 'pipe' });
+    } else {
+      // Unix/Linux/macOS - use unzip
+      // Check if unzip is available first
+      try {
+        execSync('which unzip', { stdio: 'pipe' });
+      } catch {
+        throw new Error(
+          'unzip command not found. Please install unzip:\n' +
+          '  Ubuntu/Debian: sudo apt-get install unzip\n' +
+          '  macOS: brew install unzip\n' +
+          '  CentOS/RHEL: sudo yum install unzip'
+        );
+      }
+      execSync(`unzip -o "${zipPath}" -d "${destDir}"`, { stdio: 'pipe' });
+    }
+  } catch (err) {
+    if (err.message.includes('unzip command not found')) {
+      throw err;
+    }
+    throw new Error(`Failed to extract zip archive: ${err.message}`);
+  }
+}
+
+async function extractArchive(archivePath, destDir, platform) {
+  if (platform === 'windows') {
+    extractZip(archivePath, destDir);
+  } else {
+    extractTarGz(archivePath, destDir);
+  }
+}
+
+function findBinary(dir, platform) {
+  const binaryName = getBinaryName(platform);
+  const files = fs.readdirSync(dir);
+
+  // First check root
+  const rootBinary = path.join(dir, binaryName);
+  if (fs.existsSync(rootBinary)) {
+    return rootBinary;
+  }
+
+  // Check subdirectories
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      const binaryInSubdir = path.join(fullPath, binaryName);
+      if (fs.existsSync(binaryInSubdir)) {
+        return binaryInSubdir;
+      }
+    }
+  }
+
+  throw new Error(`Binary ${binaryName} not found in archive`);
+}
+
+async function ensureBinary() {
+  const binaryPath = getBinaryPath();
+  const packageVersion = getPackageVersion();
+
+  // Check if binary exists and matches package version
+  if (fs.existsSync(binaryPath) && fs.existsSync(VERSION_FILE)) {
+    const currentVersion = fs.readFileSync(VERSION_FILE, 'utf8').trim();
+    if (currentVersion === packageVersion) {
+      return binaryPath;
+    }
+    console.log(`Updating cc-helper from ${currentVersion} to ${packageVersion}...`);
+  }
+
+  // Create cache directory
+  if (!fs.existsSync(CACHE_DIR)) {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+  }
+
+  // Download archive with fixed version from package.json
+  const { platform, arch } = getPlatform();
+  const archiveName = getArchiveName(packageVersion, platform, arch);
+  const tagVersion = packageVersion.startsWith('v') ? packageVersion : `v${packageVersion}`;
+  const downloadUrl = `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/releases/download/${tagVersion}/${archiveName}`;
+  const archivePath = path.join(CACHE_DIR, archiveName);
+
+  console.log(`Downloading cc-helper ${packageVersion} for ${platform}-${arch}...`);
+
+  try {
+    await downloadFile(downloadUrl, archivePath);
+
+    // Extract archive
+    console.log('Extracting archive...');
+    const tempDir = path.join(CACHE_DIR, 'temp_extract_' + Date.now());
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    await extractArchive(archivePath, tempDir, platform);
+
+    // Find and move binary
+    const extractedBinaryPath = findBinary(tempDir, platform);
+
+    // Remove old binary if exists
+    if (fs.existsSync(binaryPath)) {
+      fs.unlinkSync(binaryPath);
+    }
+
+    // Move binary to cache dir
+    fs.copyFileSync(extractedBinaryPath, binaryPath);
+    fs.chmodSync(binaryPath, 0o755);
+
+    // Clean up
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    fs.unlinkSync(archivePath);
+
+    // Save version
+    fs.writeFileSync(VERSION_FILE, packageVersion);
+
+    console.log('Download complete!');
+  } catch (err) {
+    // Clean up on failure
+    if (fs.existsSync(archivePath)) {
+      fs.unlinkSync(archivePath);
+    }
+    throw err;
+  }
+
+  return binaryPath;
+}
+
+async function main() {
+  // Handle uninstall command
+  const args = process.argv.slice(2);
+  if (args.length > 0 && args[0] === 'uninstall') {
+    handleUninstall();
+    return;
+  }
+
+  try {
+    const binaryPath = await ensureBinary();
+
+    // Run the binary with all arguments
+    // Windows requires shell: true for .exe files
+    const isWindows = process.platform === 'win32';
+    const child = spawn(binaryPath, args, {
+      stdio: 'inherit',
+      detached: false,
+      shell: isWindows
+    });
+
+    child.on('close', (code) => {
+      process.exit(code);
+    });
+
+    child.on('error', (err) => {
+      console.error('Failed to start cc-helper:', err.message);
+      process.exit(1);
+    });
+  } catch (err) {
+    console.error('Error:', err.message);
+    process.exit(1);
+  }
+}
+
+// Export for use as module
+module.exports = { main, ensureBinary, getBinaryPath, getPlatform, getPackageVersion };
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}

package/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+const { main } = require('./bin/cc-helper.js');
+
+// Run the main function
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});