prior-cli 1.6.1 → 1.6.3

package/bin/prior.js

@@ -709,7 +709,7 @@ async function startChat(opts = {}) {
   console.log(c.ok('  ◉') + c.muted('  Agent mode  ') + c.dim('· file  web  shell  image  prior-network'));
 
   console.log(DIVIDER);
-  console.log(c.muted('  /help  /clear  /compact  /censored  /uncensored  /exit'));
+  console.log(c.muted('  /help  /clear  /compact  /timer  /censored  /uncensored  /exit'));
   console.log(DIVIDER);
   console.log('');
 
@@ -727,6 +727,7 @@ async function startChat(opts = {}) {
 
     const SLASH_CMDS = [
       { cmd: '/compact',     desc: 'Compact conversation to save context' },
+      { cmd: '/timer',       desc: 'Set a countdown timer  e.g. /timer 30s' },
       { cmd: '/help',        desc: 'Show help'         },
       { cmd: '/clear',       desc: 'Clear screen'      },
       { cmd: '/censored',    desc: 'Load standard model (qwen)'  },
@@ -1164,10 +1165,67 @@ Be concise but thorough — this summary replaces the full history to save conte
             return loop();
           }
 
+          case '/timer': {
+            const timerArg = args.join(' ').trim();
+            // Parse duration: e.g. 30, 30s, 5m, 1m30s, 1h
+            const parseDuration = (str) => {
+              if (!str) return null;
+              let total = 0;
+              const re = /(\d+(?:\.\d+)?)\s*([hms]?)/gi;
+              let m, matched = false;
+              while ((m = re.exec(str)) !== null) {
+                const val = parseFloat(m[1]);
+                const unit = (m[2] || 's').toLowerCase();
+                if      (unit === 'h') total += val * 3600;
+                else if (unit === 'm') total += val * 60;
+                else                  total += val;
+                matched = true;
+              }
+              return matched ? Math.round(total) : null;
+            };
+            const fmtCountdown = (sec) => {
+              const h = Math.floor(sec / 3600);
+              const m = Math.floor((sec % 3600) / 60);
+              const s = sec % 60;
+              if (h > 0) return `${h}:${String(m).padStart(2,'0')}:${String(s).padStart(2,'0')}`;
+              return `${m > 0 ? m + ':' : ''}${m > 0 ? String(s).padStart(2,'0') : s + 's'}`;
+            };
+            const totalSec = parseDuration(timerArg);
+            if (!totalSec || totalSec <= 0) {
+              console.log(c.err('  Usage: /timer 30s  or  /timer 5m  or  /timer 1m30s\n'));
+              return loop();
+            }
+            console.log(c.brand(`  Timer set for ${timerArg} — starting now.\n`));
+            let remaining = totalSec;
+            const timerInterval = setInterval(() => {
+              if (process.stdout.isTTY) {
+                process.stdout.clearLine(0);
+                process.stdout.cursorTo(0);
+              }
+              if (remaining <= 0) {
+                clearInterval(timerInterval);
+                if (process.stdout.isTTY) {
+                  process.stdout.clearLine(0);
+                  process.stdout.cursorTo(0);
+                }
+                // Bell + done message
+                process.stdout.write('\x07');
+                console.log(c.bold(`  ⏰  Time's up!  (${timerArg})\n`));
+                rl.prompt(true);
+                return;
+              }
+              const bar = '█'.repeat(Math.ceil((remaining / totalSec) * 20)).padEnd(20, '░');
+              process.stdout.write(`  ${c.brand('⏱')}  ${c.brand(fmtCountdown(remaining).padStart(6))}  ${c.dim(bar)}`);
+              remaining--;
+            }, 1000);
+            return loop();
+          }
+
           case '/help':
             console.log('');
             console.log(c.bold('  Commands'));
             console.log(c.muted('  /compact             ') + 'Compact conversation to save context');
+            console.log(c.muted('  /timer <duration>    ') + 'Countdown timer  e.g. /timer 30s, /timer 5m');
             console.log(c.muted('  /clear               ') + 'Clear screen');
             console.log(c.muted('  /censored            ') + 'Load standard model (qwen)');
             console.log(c.muted('  /uncensored          ') + 'Load uncensored model (dolphin)');

package/lib/tools.js

@@ -416,6 +416,123 @@ const TOOLS = {
     const data = await res.json();
     return { output: data.output || JSON.stringify(data), summary: data.summary || `spider started for ${url}` };
   },
+
+  async ip_lookup({ target }, {}) {
+    if (!target) throw new Error('"target" is required — provide an IP address or domain');
+    const encoded = encodeURIComponent(target.trim());
+    const res = await fetch(`https://ipinfo.io/${encoded}/json`, {
+      headers: { 'User-Agent': 'prior-cli/1.0', Accept: 'application/json' },
+      timeout: 10000,
+    });
+    if (!res.ok) throw new Error(`ipinfo.io error: HTTP ${res.status}`);
+    const d = await res.json();
+    if (d.error) throw new Error(d.error.message || 'Lookup failed');
+    const lines = [
+      `IP        : ${d.ip || target}`,
+      d.hostname  ? `Hostname  : ${d.hostname}`  : null,
+      d.org       ? `Org / ASN : ${d.org}`        : null,
+      d.city      ? `Location  : ${[d.city, d.region, d.country].filter(Boolean).join(', ')}` : null,
+      d.postal    ? `Postal    : ${d.postal}`     : null,
+      d.timezone  ? `Timezone  : ${d.timezone}`  : null,
+      d.loc       ? `Coords    : ${d.loc}`        : null,
+    ].filter(Boolean);
+    return {
+      output:  lines.join('\n'),
+      summary: `${d.ip || target}${d.org ? ' · ' + d.org : ''}${d.city ? ' · ' + d.city : ''}`,
+    };
+  },
+
+  async dns_lookup({ domain, type = 'A' }, {}) {
+    if (!domain) throw new Error('"domain" is required');
+    const validTypes = ['A', 'AAAA', 'CNAME', 'MX', 'NS', 'TXT', 'SOA', 'PTR', 'SRV'];
+    const qtype = type.toUpperCase();
+    if (!validTypes.includes(qtype)) throw new Error(`Invalid type. Choose from: ${validTypes.join(', ')}`);
+    const res = await fetch(`https://dns.google/resolve?name=${encodeURIComponent(domain)}&type=${qtype}`, {
+      headers: { Accept: 'application/json' },
+      timeout: 10000,
+    });
+    if (!res.ok) throw new Error(`DNS query failed: HTTP ${res.status}`);
+    const data = await res.json();
+    if (data.Status !== 0) {
+      const STATUS = { 1: 'Format error', 2: 'Server failure', 3: 'NXDOMAIN (not found)', 5: 'Refused' };
+      throw new Error(STATUS[data.Status] || `DNS error code ${data.Status}`);
+    }
+    if (!data.Answer || data.Answer.length === 0) {
+      return { output: `No ${qtype} records found for ${domain}`, summary: `0 ${qtype} records` };
+    }
+    const lines = data.Answer.map(r => {
+      const ttl = `TTL ${r.TTL}s`;
+      return `  ${String(r.type).padEnd(6)} ${ttl.padEnd(12)} ${r.data}`;
+    });
+    const header = `${domain}  ${qtype} records (${data.Answer.length})\n`;
+    return {
+      output:  header + lines.join('\n'),
+      summary: `${data.Answer.length} ${qtype} record${data.Answer.length !== 1 ? 's' : ''} for ${domain}`,
+    };
+  },
+
+  async ssl_check({ domain }, {}) {
+    if (!domain) throw new Error('"domain" is required');
+    // Strip protocol if provided
+    const host = domain.replace(/^https?:\/\//, '').split('/')[0].split(':')[0];
+    // Use crt.sh to get cert info + check via HEAD for expiry details
+    const [certRes, headRes] = await Promise.allSettled([
+      fetch(`https://crt.sh/?q=${encodeURIComponent(host)}&output=json`, {
+        headers: { 'User-Agent': 'prior-cli/1.0' },
+        timeout: 12000,
+      }),
+      fetch(`https://${host}`, {
+        method: 'HEAD',
+        headers: { 'User-Agent': 'prior-cli/1.0' },
+        timeout: 8000,
+      }),
+    ]);
+
+    const lines = [`Domain : ${host}`];
+
+    // Live cert check via HTTPS HEAD — Node's TLS gives us nothing in headers,
+    // but we can confirm TLS works and check for errors
+    if (headRes.status === 'fulfilled') {
+      lines.push(`HTTPS  : ✓ reachable (HTTP ${headRes.value.status})`);
+    } else {
+      const msg = headRes.reason?.message || 'unreachable';
+      const expired = /certificate has expired|CERT_HAS_EXPIRED/i.test(msg);
+      lines.push(`HTTPS  : ✗ ${expired ? 'CERTIFICATE EXPIRED' : msg}`);
+    }
+
+    // crt.sh — most recent issuances
+    if (certRes.status === 'fulfilled' && certRes.value.ok) {
+      try {
+        const certs = await certRes.value.json();
+        const recent = certs
+          .filter(c => c.name_value && !c.name_value.startsWith('*'))
+          .sort((a, b) => new Date(b.not_after) - new Date(a.not_after))
+          .slice(0, 3);
+        if (recent.length) {
+          lines.push('');
+          lines.push('Recent certificates (crt.sh):');
+          for (const c of recent) {
+            const expiry  = new Date(c.not_after);
+            const issued  = new Date(c.not_before);
+            const daysLeft = Math.ceil((expiry - Date.now()) / 86400000);
+            const status  = daysLeft < 0 ? '✗ EXPIRED' : daysLeft < 14 ? `⚠ expires in ${daysLeft}d` : `✓ ${daysLeft}d left`;
+            lines.push(`  Issuer  : ${c.issuer_name?.replace(/^.*?CN=/, 'CN=') || '?'}`);
+            lines.push(`  Issued  : ${issued.toLocaleDateString()}`);
+            lines.push(`  Expires : ${expiry.toLocaleDateString()}  (${status})`);
+            lines.push(`  Names   : ${c.name_value.replace(/\n/g, ', ')}`);
+            lines.push('  ─────────────────────────────');
+          }
+        }
+      } catch { /* crt.sh parse failed, HTTPS check is enough */ }
+    }
+
+    // Summary line
+    const httpsOk = headRes.status === 'fulfilled';
+    return {
+      output:  lines.join('\n'),
+      summary: `${host} · HTTPS ${httpsOk ? '✓' : '✗'}`,
+    };
+  },
 };
 
 async function executeTool(name, args, context) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prior-cli",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "Prior Network AI — command-line interface",
   "bin": {
     "prior": "bin/prior.js"