osintkit 0.1.2 → 0.1.4

package/bin/osintkit.js

@@ -1,41 +1,58 @@
 #!/usr/bin/env node
-const { spawn } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
-// The npm package root is one level up from bin/
 const packageDir = path.dirname(path.dirname(__filename));
+const isWin = process.platform === 'win32';
+
+const venvPython = isWin
+    ? path.join(packageDir, '.venv', 'Scripts', 'python.exe')
+    : path.join(packageDir, '.venv', 'bin', 'python3');
+
+// If venv doesn't exist yet, run postinstall first (self-healing first run)
+if (!fs.existsSync(venvPython)) {
+    const postinstall = path.join(packageDir, 'postinstall.js');
+    if (fs.existsSync(postinstall)) {
+        console.log('osintkit: first run — setting up Python environment...');
+        const r = spawnSync(process.execPath, [postinstall], {
+            stdio: 'inherit',
+            cwd: packageDir,
+        });
+        if (!fs.existsSync(venvPython)) {
+            console.error('\nosintkit: setup failed. Run manually:');
+            console.error(`  node ${postinstall}`);
+            process.exit(1);
+        }
+    }
+}
 
-// Prefer venv Python (installed by postinstall), fall back to system Python
 function findPython() {
+    // Prefer venv Python (Unix + Windows)
     const venvCandidates = [
         path.join(packageDir, '.venv', 'bin', 'python3'),
         path.join(packageDir, '.venv', 'bin', 'python'),
+        path.join(packageDir, '.venv', 'Scripts', 'python.exe'),
         path.join(packageDir, 'venv', 'bin', 'python3'),
-        path.join(packageDir, 'venv', 'bin', 'python'),
+        path.join(packageDir, 'venv', 'Scripts', 'python.exe'),
     ];
     for (const p of venvCandidates) {
         if (fs.existsSync(p)) return p;
     }
-
     // Fall back to system Python
-    const systemCandidates = ['python3.11', 'python3', 'python'];
+    const systemCandidates = isWin ? ['python', 'python3'] : ['python3.11', 'python3', 'python'];
     for (const bin of systemCandidates) {
-        try {
-            require('child_process').execSync(`${bin} --version`, { stdio: 'ignore' });
-            return bin;
-        } catch (_) {}
+        const r = spawnSync(bin, ['--version'], { stdio: 'pipe' });
+        if (r.status === 0) return bin;
     }
     return 'python3';
 }
 
 const pythonBin = findPython();
-
-// Always set PYTHONPATH so the package is importable regardless of install method
 const env = {
     ...process.env,
     PYTHONPATH: process.env.PYTHONPATH
-        ? `${packageDir}:${process.env.PYTHONPATH}`
+        ? `${packageDir}${path.delimiter}${process.env.PYTHONPATH}`
         : packageDir,
 };
 

package/osintkit/__init__.py

@@ -1,3 +1,3 @@
 """osintkit - OSINT CLI tool for personal digital footprint analysis."""
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"

package/osintkit/__main__.py

@@ -1,4 +1,25 @@
 """Entry point for python -m osintkit"""
-from osintkit.cli import app
+import sys
+
+# CLI shortcuts — intercept before Typer parses argv:
+#   osintkit          → osintkit list
+#   osintkit <id>     → osintkit open <id>
+#   osintkit -v       → osintkit version
+_KNOWN_COMMANDS = {
+    "new", "list", "refresh", "open", "export",
+    "setup", "delete", "version", "update", "tag",
+}
 
+if len(sys.argv) == 1:
+    # bare `osintkit` → show list
+    sys.argv.append("list")
+elif len(sys.argv) == 2:
+    arg = sys.argv[1]
+    if arg in ("-v",):
+        sys.argv[1] = "version"
+    elif not arg.startswith("-") and arg not in _KNOWN_COMMANDS:
+        # `osintkit <id>` → open that profile
+        sys.argv = [sys.argv[0], "open", arg]
+
+from osintkit.cli import app
 app()

package/osintkit/cli.py

@@ -424,9 +424,11 @@ def new():
 
 
 @app.command()
-def list():
-    """List all profiles."""
-    profiles = store.list()
+def list(
+    filter_tag: Optional[str] = typer.Option(None, "--tag", "-t", help="Filter by tag"),
+):
+    """List all profiles. Filter with --tag <name>."""
+    profiles = store.list(tag=filter_tag)
     
     if not profiles:
         console.print("\n[yellow]No profiles found.[/yellow]")
@@ -664,12 +666,88 @@ def delete(profile_ref: str = typer.Argument(None, help="Profile ID or name")):
 
 @app.command()
 def version():
-    """Show version."""
+    """Show version. Also available as: osintkit -v"""
     if _update_thread:
         _update_thread.join(timeout=4)
     console.print(f"osintkit v{__version__}")
     _print_update_notice()
 
 
+@app.command()
+def update():
+    """Check for updates and install the latest version."""
+    import subprocess
+
+    console.print("\n[bold]Checking for updates...[/bold]")
+
+    if _update_thread:
+        _update_thread.join(timeout=5)
+
+    if _update_available:
+        console.print(f"[cyan]New version available: {_update_available}[/cyan]")
+        console.print(f"[dim]Current: {__version__}[/dim]\n")
+        if Confirm.ask("Install now?", default=True):
+            console.print("[dim]Running: npm install -g osintkit[/dim]\n")
+            result = subprocess.run(["npm", "install", "-g", "osintkit"], check=False)
+            if result.returncode == 0:
+                console.print(f"\n[green]✓[/green] Updated to osintkit {_update_available}")
+                console.print("[dim]Restart your terminal for changes to take effect.[/dim]")
+            else:
+                console.print("\n[red]Update failed.[/red] Try manually: npm install -g osintkit")
+    else:
+        console.print(f"[green]✓[/green] Already on latest version (v{__version__})")
+
+
+@app.command()
+def tag(
+    profile_ref: str = typer.Argument(..., help="Profile ID or name"),
+    add: Optional[str] = typer.Option(None, "--add", "-a", help="Tag to add"),
+    remove: Optional[str] = typer.Option(None, "--remove", "-r", help="Tag to remove"),
+    list_tags: bool = typer.Option(False, "--list", "-l", help="List tags on profile"),
+):
+    """Add, remove, or list tags on a profile.
+
+    Examples:
+      osintkit tag abc123 --add client
+      osintkit tag abc123 --remove client
+      osintkit tag abc123 --list
+      osintkit list --tag client        (filter list by tag)
+    """
+    profile = store.get(profile_ref)
+    if not profile:
+        profiles = store.list()
+        for p in profiles:
+            if p.name and p.name.lower() == profile_ref.lower():
+                profile = p
+                break
+    if not profile:
+        console.print(f"[red]Profile not found: {profile_ref}[/red]")
+        raise typer.Exit(1)
+
+    if add:
+        if add not in profile.tags:
+            profile.tags.append(add)
+            store.update(profile)
+            console.print(f"[green]✓[/green] Added tag '{add}' to {profile.name or profile.id}")
+        else:
+            console.print(f"[yellow]Tag '{add}' already exists[/yellow]")
+
+    elif remove:
+        if remove in profile.tags:
+            profile.tags.remove(remove)
+            store.update(profile)
+            console.print(f"[green]✓[/green] Removed tag '{remove}' from {profile.name or profile.id}")
+        else:
+            console.print(f"[yellow]Tag '{remove}' not found[/yellow]")
+
+    else:
+        # Default: list tags
+        if profile.tags:
+            console.print(f"\nTags on [cyan]{profile.name or profile.id}[/cyan]: " +
+                         ", ".join(f"[bold]{t}[/bold]" for t in profile.tags))
+        else:
+            console.print(f"[dim]No tags on {profile.name or profile.id}[/dim]")
+
+
 if __name__ == "__main__":
     app()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osintkit",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "OSINT CLI for personal digital footprint analysis",
   "bin": {
     "osintkit": "./bin/osintkit.js"
@@ -17,7 +17,13 @@
     "README.md",
     "postinstall.js"
   ],
-  "keywords": ["osint", "security", "privacy", "cli", "recon"],
+  "keywords": [
+    "osint",
+    "security",
+    "privacy",
+    "cli",
+    "recon"
+  ],
   "author": "",
   "license": "MIT",
   "engines": {

package/postinstall.js

@@ -1,75 +1,94 @@
 #!/usr/bin/env node
 /**
- * osintkit postinstall — installs all Python dependencies automatically.
- *
- * Runs after `npm install -g osintkit`.
- * Installs:
- *   1. Core Python deps (typer, rich, httpx, pydantic, etc.) from requirements.txt
- *   2. Optional OSINT tools (maigret, holehe, sherlock) from requirements-tools.txt
- *
- * Uses --break-system-packages on Linux/macOS where needed (Python 3.11+).
- * Falls back gracefully if pip isn't available.
+ * osintkit postinstall — creates a venv inside the package dir and installs
+ * all Python dependencies into it. The npm shim (bin/osintkit.js) will then
+ * always find and use this venv's Python, avoiding any system Python confusion.
  */
 
-const { execSync } = require('child_process');
+const { spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
 const packageDir = __dirname;
+const venvDir = path.join(packageDir, '.venv');
 const req = path.join(packageDir, 'requirements.txt');
 const reqTools = path.join(packageDir, 'requirements-tools.txt');
 
-function findPip() {
-    for (const bin of ['pip3', 'pip']) {
-        try {
-            execSync(`${bin} --version`, { stdio: 'ignore' });
-            return bin;
-        } catch (_) {}
+// Platform-aware paths inside the venv
+const isWin = process.platform === 'win32';
+const venvPython = isWin
+    ? path.join(venvDir, 'Scripts', 'python.exe')
+    : path.join(venvDir, 'bin', 'python3');
+const venvPip = isWin
+    ? path.join(venvDir, 'Scripts', 'pip.exe')
+    : path.join(venvDir, 'bin', 'pip3');
+
+function findSystemPython() {
+    const candidates = isWin
+        ? ['python', 'python3']
+        : ['python3.13', 'python3.12', 'python3.11', 'python3.10', 'python3'];
+    for (const bin of candidates) {
+        const r = spawnSync(bin, ['--version'], { encoding: 'utf8' });
+        if (r.status === 0) {
+            // Must be >= 3.10
+            const match = (r.stdout || r.stderr || '').match(/Python (\d+)\.(\d+)/);
+            if (match && (parseInt(match[1]) > 3 || parseInt(match[2]) >= 10)) {
+                return bin;
+            }
+        }
     }
     return null;
 }
 
-function pipInstall(pip, requirementsFile, label) {
-    if (!fs.existsSync(requirementsFile)) {
-        console.log(`  ⚠️  ${label}: requirements file not found, skipping`);
-        return;
-    }
+function run(cmd, args, opts = {}) {
+    const r = spawnSync(cmd, args, { encoding: 'utf8', cwd: packageDir, ...opts });
+    return r;
+}
 
-    const flags = ['-r', requirementsFile, '-q', '--disable-pip-version-check'];
+console.log('\nosintkit: setting up Python environment...\n');
 
-    // Try with --break-system-packages first (needed on modern Linux/macOS)
-    try {
-        execSync(`${pip} install ${flags.join(' ')} --break-system-packages`, {
-            stdio: 'pipe',
-            cwd: packageDir,
-        });
-        console.log(`  ✅  ${label} installed`);
-        return;
-    } catch (_) {}
+// Step 1: find a usable Python 3.10+
+const sysPython = findSystemPython();
+if (!sysPython) {
+    console.log('  ❌  Python 3.10+ not found.');
+    console.log('      Install from https://python.org then re-run: npm install -g osintkit\n');
+    process.exit(0);
+}
+console.log(`  ✅  Found Python: ${sysPython}`);
 
-    // Fall back without the flag (works on older systems / virtual envs)
-    try {
-        execSync(`${pip} install ${flags.join(' ')}`, {
-            stdio: 'pipe',
-            cwd: packageDir,
-        });
-        console.log(`  ✅  ${label} installed`);
-        return;
-    } catch (err) {
-        console.log(`  ⚠️  ${label}: could not install (${err.message.split('\n')[0]})`);
+// Step 2: create venv (skip if already exists)
+if (!fs.existsSync(venvPython)) {
+    console.log(`  🔧  Creating venv at ${venvDir} ...`);
+    const r = run(sysPython, ['-m', 'venv', venvDir]);
+    if (r.status !== 0) {
+        console.log('  ❌  Failed to create venv.');
+        console.log(`      ${(r.stderr || '').trim()}`);
+        console.log('      Try: python3 -m venv .venv (in the package dir)\n');
+        process.exit(0);
     }
+    console.log('  ✅  Venv created');
+} else {
+    console.log('  ✅  Venv already exists');
 }
 
-console.log('\nosintkit: installing Python dependencies...\n');
+// Step 3: upgrade pip inside venv
+run(venvPython, ['-m', 'pip', 'install', '--upgrade', 'pip', '-q']);
 
-const pip = findPip();
-if (!pip) {
-    console.log('  ⚠️  pip not found — skipping Python dependency install.');
-    console.log('  Run manually: pip3 install -r requirements.txt -r requirements-tools.txt');
-    process.exit(0);
+// Step 4: install deps into venv
+function pipInstall(requirementsFile, label) {
+    if (!fs.existsSync(requirementsFile)) return;
+    console.log(`  📦  Installing ${label}...`);
+    const r = run(venvPython, ['-m', 'pip', 'install', '-r', requirementsFile, '-q', '--disable-pip-version-check']);
+    if (r.status === 0) {
+        console.log(`  ✅  ${label} installed`);
+    } else {
+        const err = (r.stderr || r.stdout || '').trim().split('\n').slice(-3).join('\n');
+        console.log(`  ❌  ${label} failed:\n      ${err}`);
+        console.log(`      Fix: ${venvPython} -m pip install -r ${requirementsFile}`);
+    }
 }
 
-pipInstall(pip, req, 'Core dependencies');
-pipInstall(pip, reqTools, 'OSINT tools (maigret, holehe, sherlock)');
+pipInstall(req, 'Core dependencies (typer, rich, httpx...)');
+pipInstall(reqTools, 'OSINT tools (maigret, holehe, sherlock)');
 
-console.log('\nosintkit ready. Run: osintkit new\n');
+console.log('\n  ✅  osintkit ready. Run: osintkit new\n');

package/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "osintkit"
-version = "0.1.2"
+version = "0.1.4"
 description = "OSINT CLI tool for personal digital footprint analysis"
 authors = ["Your Name <you@example.com>"]
 license = "MIT"