autolimit 0.2.0

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "autolimit",
+  "version": "0.2.0",
+  "description": "Terminal-agnostic PTY wrapper that resumes CLI runners after reset-time usage limits.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/betive37/autolimit"
+  },
+  "bin": {
+    "autolimit": "bin/autolimit.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "prepublishOnly": "npm test",
+    "test": "python3 tests/test_autolimit.py && node tests/test_postinstall_star.js && node bin/autolimit.js --test-parser && node bin/autolimit.js --dry-run --cc --example"
+  },
+  "keywords": [
+    "terminal",
+    "pty",
+    "automation",
+    "claude-code",
+    "wrapper"
+  ],
+  "author": "Jae Hyun <betive37@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "files": [
+    "bin/autolimit.js",
+    "lib/autolimit.py",
+    "scripts/github-star.js",
+    "scripts/postinstall.js"
+  ]
+}

package/scripts/github-star.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const https = require('https');
+const path = require('path');
+const readline = require('readline');
+const { spawnSync } = require('child_process');
+
+function readRepositoryUrl(packageFile) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8'));
+    if (typeof pkg.repository === 'string') return pkg.repository;
+    if (pkg.repository && typeof pkg.repository.url === 'string') return pkg.repository.url;
+  } catch (_) {
+  }
+  return 'https://github.com/betive37/autolimit';
+}
+
+function stripGitSuffix(value) {
+  return value.endsWith('.git') ? value.slice(0, -4) : value;
+}
+
+function parseGitHubRepo(repositoryUrl) {
+  const normalized = stripGitSuffix(repositoryUrl.replace(/^git\+/, ''));
+
+  const sshMatch = normalized.match(/^git@github\.com:([^/]+)\/(.+)$/);
+  if (sshMatch) {
+    return { owner: sshMatch[1], repo: stripGitSuffix(sshMatch[2]) };
+  }
+
+  const shortcutMatch = normalized.match(/^github:([^/]+)\/(.+)$/);
+  if (shortcutMatch) {
+    return { owner: shortcutMatch[1], repo: stripGitSuffix(shortcutMatch[2]) };
+  }
+
+  try {
+    const url = new URL(normalized);
+    if (url.hostname.toLowerCase() !== 'github.com') return null;
+    const parts = url.pathname.split('/').filter(Boolean);
+    if (parts.length < 2) return null;
+    return { owner: parts[0], repo: stripGitSuffix(parts[1]) };
+  } catch (_) {
+    return null;
+  }
+}
+
+function repoSlug(repo) {
+  return `${repo.owner}/${repo.repo}`;
+}
+
+function envFlag(name) {
+  const value = process.env[name];
+  if (!value) return null;
+  if (/^(0|false|no|off)$/i.test(value)) return false;
+  if (/^(1|true|yes|on|force)$/i.test(value)) return true;
+  return null;
+}
+
+function hasAnsweredStarPrompt(stateFile, slug) {
+  try {
+    const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+    return state.repo === slug && (state.status === 'declined' || state.status === 'starred');
+  } catch (_) {
+    return false;
+  }
+}
+
+function writeStarPromptState(configDir, stateFile, slug, status) {
+  fs.mkdirSync(configDir, { recursive: true });
+  const state = {
+    repo: slug,
+    status,
+    answered_at: new Date().toISOString()
+  };
+  fs.writeFileSync(stateFile, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+function shouldAskForStar(stateFile, slug) {
+  const forcedPrompt = envFlag('AUTOLIMIT_GITHUB_STAR_PROMPT');
+  if (forcedPrompt === false) return false;
+  if (forcedPrompt === true) return true;
+  if (process.env.CI) return false;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  return !hasAnsweredStarPrompt(stateFile, slug);
+}
+
+function promptYesNo(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question(`${question} [y/N] `, (answer) => {
+      rl.close();
+      resolve(/^(y|yes)$/i.test(answer.trim()));
+    });
+  });
+}
+
+function starWithGh(slug) {
+  const result = spawnSync('gh', ['api', '--method', 'PUT', `/user/starred/${slug}`, '--silent'], {
+    env: {
+      ...process.env,
+      GH_PROMPT_DISABLED: '1'
+    },
+    stdio: 'ignore'
+  });
+  if (result.error) return false;
+  return result.status === 0;
+}
+
+function authToken() {
+  return process.env.GH_TOKEN || process.env.GITHUB_TOKEN || '';
+}
+
+function starWithToken(slug, token) {
+  return new Promise((resolve) => {
+    const req = https.request(
+      {
+        hostname: 'api.github.com',
+        method: 'PUT',
+        path: `/user/starred/${slug}`,
+        headers: {
+          Accept: 'application/vnd.github+json',
+          Authorization: `Bearer ${token}`,
+          'Content-Length': '0',
+          'User-Agent': 'autolimit-postinstall',
+          'X-GitHub-Api-Version': '2026-03-10'
+        }
+      },
+      (res) => {
+        res.resume();
+        resolve(res.statusCode === 204 || res.statusCode === 304);
+      }
+    );
+    req.on('error', () => resolve(false));
+    req.end();
+  });
+}
+
+async function starGitHubRepository(slug) {
+  if (starWithGh(slug)) return true;
+
+  const token = authToken();
+  if (!token) return false;
+
+  return starWithToken(slug, token);
+}
+
+async function maybeAskForGitHubStar(options) {
+  const repo = parseGitHubRepo(readRepositoryUrl(options.packageFile));
+  if (!repo) return;
+
+  const slug = repoSlug(repo);
+  const stateFile = path.join(options.configDir, 'github-star.json');
+  if (!shouldAskForStar(stateFile, slug)) return;
+
+  const accepted = await promptYesNo(`[autolimit] Star https://github.com/${slug} on GitHub?`);
+  if (!accepted) {
+    writeStarPromptState(options.configDir, stateFile, slug, 'declined');
+    return;
+  }
+
+  const starred = await starGitHubRepository(slug);
+  if (starred) {
+    writeStarPromptState(options.configDir, stateFile, slug, 'starred');
+    console.log(`[autolimit] Starred https://github.com/${slug}`);
+    return;
+  }
+
+  console.warn('[autolimit] Could not star automatically. Run `gh auth login` or set GH_TOKEN, then try again.');
+}
+
+module.exports = {
+  maybeAskForGitHubStar,
+  parseGitHubRepo
+};

package/scripts/postinstall.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { maybeAskForGitHubStar } = require('./github-star');
+
+const root = path.resolve(__dirname, '..');
+const binFile = path.join(root, 'bin', 'autolimit.js');
+const pyFile = path.join(root, 'lib', 'autolimit.py');
+const packageFile = path.join(root, 'package.json');
+const home = os.homedir();
+const configDir = path.join(home, '.config', 'autolimit');
+const legacyMessage = path.join(home, '.config', 'claude-auto', 'message.txt');
+const messageFile = path.join(configDir, 'message.txt');
+const configFile = path.join(configDir, 'config.json');
+const localBin = path.join(home, '.local', 'bin');
+const symlink = path.join(localBin, 'autolimit');
+
+const defaultMessage = '이어서 계속 진행해줘.\n';
+// Keep in sync with DEFAULT_PATTERN / DEFAULT_PATTERN_DATED in lib/autolimit.py.
+const defaultPatternTime = "You[\\u2019']?ve\\s+hit\\s+your(?:\\s+[\\w-]+)?\\s+limit.{0,120}?resets\\s+(?P<hour>\\d{1,2})(?::(?P<minute>\\d{2}))?\\s*(?P<ampm>[aApP]\\.?[mM]\\.?)?\\s*\\((?P<tzname>[^)]{1,64})\\)";
+const defaultPatternDated = "You[\\u2019']?ve\\s+hit\\s+your(?:\\s+[\\w-]+)?\\s+limit.{0,120}?resets\\s+(?P<month>[A-Za-z]{3,9})\\.?\\s+(?P<day>\\d{1,2})(?:st|nd|rd|th)?,?\\s*(?:at\\s+)?(?P<hour>\\d{1,2})(?::(?P<minute>\\d{2}))?\\s*(?P<ampm>[aApP]\\.?[mM]\\.?)?\\s*\\((?P<tzname>[^)]{1,64})\\)";
+
+function chmodX(file) {
+  try {
+    fs.chmodSync(file, 0o755);
+  } catch (error) {
+    console.warn(`[autolimit] Could not chmod +x ${file}: ${error.message}`);
+  }
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function ensureMessageFile() {
+  ensureDir(configDir);
+  if (fs.existsSync(messageFile)) return;
+  if (fs.existsSync(legacyMessage)) {
+    try {
+      fs.copyFileSync(legacyMessage, messageFile);
+      return;
+    } catch (_) {
+      // fall through
+    }
+  }
+  fs.writeFileSync(messageFile, defaultMessage, 'utf8');
+}
+
+function ensureConfigFile() {
+  ensureDir(configDir);
+  if (fs.existsSync(configFile)) return;
+  const config = {
+    version: 1,
+    message_file: messageFile,
+    log_file: path.join(configDir, 'limit-watch.log'),
+    default_timezone: 'Asia/Seoul',
+    send_grace_seconds: 5,
+    max_schedule_ahead_hours: 12,
+    max_fallback_wait_hours: 26,
+    patterns: [
+      {
+        name: 'Claude-style session limit',
+        regex: defaultPatternTime
+      },
+      {
+        name: 'Claude-style dated limit',
+        regex: defaultPatternDated
+      }
+    ],
+    runners: {
+      claude: {
+        fallback: ['{runner}', '{args}', '-c', '-p', '{message}']
+      },
+      cc: {
+        fallback: ['{runner}', '{args}', '-c', '-p', '{message}']
+      }
+    }
+  };
+  fs.writeFileSync(configFile, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+
+function ensureSymlink() {
+  ensureDir(localBin);
+  try {
+    if (fs.existsSync(symlink) || fs.lstatSync(symlink).isSymbolicLink()) {
+      const stat = fs.lstatSync(symlink);
+      if (stat.isSymbolicLink()) {
+        const current = fs.readlinkSync(symlink);
+        if (path.resolve(path.dirname(symlink), current) === binFile) return;
+        fs.unlinkSync(symlink);
+      } else {
+        console.warn(`[autolimit] ${symlink} exists and is not a symlink; leaving it unchanged.`);
+        return;
+      }
+    }
+  } catch (_) {
+    // lstat can fail when the link does not exist. Continue.
+  }
+
+  try {
+    fs.symlinkSync(binFile, symlink);
+  } catch (error) {
+    console.warn(`[autolimit] Could not create symlink ${symlink}: ${error.message}`);
+    console.warn('[autolimit] You can still run ./bin/autolimit.js or npx autolimit from this package.');
+  }
+}
+
+async function main() {
+  chmodX(binFile);
+  chmodX(pyFile);
+  ensureMessageFile();
+  ensureConfigFile();
+  ensureSymlink();
+
+  console.log('[autolimit] Installed. Try: autolimit --cc');
+  console.log(`[autolimit] Message file: ${messageFile}`);
+  console.log(`[autolimit] Config file:  ${configFile}`);
+  console.log(`[autolimit] PATH helper:  ${symlink}`);
+  console.log('[autolimit] If `autolimit` is not found, add ~/.local/bin to PATH.');
+
+  try {
+    await maybeAskForGitHubStar({ configDir, packageFile });
+  } catch (error) {
+    console.warn(`[autolimit] GitHub star prompt warning: ${error.message}`);
+  }
+}
+
+main().catch((error) => {
+  console.error(`[autolimit] Postinstall failed: ${error.message}`);
+  process.exitCode = 1;
+});