habi-agent 0.1.3 → 0.1.5

package/src/daemon.ts

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * HABI Daemon — long-running background process
+ * Reads config from ~/.habi/config.json
+ * Managed by OS service layer (Windows Service / macOS LaunchAgent / Linux systemd)
+ */
+
+import { HabiLocalServer } from './server';
+import { readHardwareIdentity } from './hardware';
+import { registerDevice, sendHeartbeat } from './cloud';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+const CONFIG_PATH = path.join(os.homedir(), '.habi', 'config.json');
+const LOG_PATH    = path.join(os.homedir(), '.habi', 'habi.log');
+
+// ── Logging ────────────────────────────────────────────────────────────────
+function log(msg: string) {
+  const line = `[${new Date().toISOString()}] ${msg}`;
+  console.log(line);
+  try {
+    fs.appendFileSync(LOG_PATH, line + '\n');
+  } catch { /* ignore */ }
+}
+
+// ── Load config ────────────────────────────────────────────────────────────
+interface HabiConfig {
+  key:  string;
+  name: string;
+}
+
+function loadConfig(): HabiConfig {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    throw new Error(`HABI config not found at ${CONFIG_PATH}. Run: npx habi-agent@latest start --key <key> --name <name>`);
+  }
+  return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+async function main() {
+  log('HABI daemon starting...');
+
+  let config: HabiConfig;
+  try {
+    config = loadConfig();
+  } catch (err) {
+    log(`Config error: ${err}`);
+    process.exit(1);
+  }
+
+  // Inject into env so cloud.ts picks them up
+  process.env.HABI_KEY         = config.key;
+  process.env.HABI_DEVICE_NAME = config.name;
+
+  const server = new HabiLocalServer();
+
+  const shutdown = () => {
+    log('HABI daemon shutting down...');
+    server.stop();
+    process.exit(0);
+  };
+  process.on('SIGINT',  shutdown);
+  process.on('SIGTERM', shutdown);
+
+  try {
+    await server.start();
+    log(`Agent running on port 7432`);
+
+    const hw = readHardwareIdentity();
+    log(`Hardware: ${hw.fingerprint} (${hw.type})`);
+
+    log(`Registering "${config.name}" with cloud...`);
+    const cloudState = await registerDevice({
+      friendlyName:        config.name,
+      hardwareFingerprint: hw.fingerprint,
+      fingerprintType:     hw.type,
+      agentVersion:        '0.1.5',
+      osPlatform:          os.platform(),
+    });
+
+    if (cloudState) {
+      log(`✓ Registered — device ID: ${cloudState.deviceId.slice(0, 8)}...`);
+
+      let currentToken = cloudState.sessionToken;
+      setInterval(async () => {
+        const hb = await sendHeartbeat({
+          deviceId:            cloudState.deviceId,
+          sessionToken:        currentToken,
+          hardwareFingerprint: hw.fingerprint,
+        });
+        if (hb) {
+          currentToken = hb.sessionToken;
+          log('Heartbeat sent');
+        }
+      }, 30000);
+    } else {
+      log('Warning: cloud registration failed — running in local mode');
+    }
+
+    log('HABI daemon running. Logs: ' + LOG_PATH);
+    await new Promise(() => {}); // keep alive
+
+  } catch (err) {
+    log(`Fatal error: ${err}`);
+    process.exit(1);
+  }
+}
+
+main();

package/src/server.ts

@@ -158,7 +158,61 @@ export class HabiLocalServer {
     }
   }
 
-  // ── Internal helpers ────────────────────────────────────────────────────
+  private async handleLogActivity(req: import('http').IncomingMessage, res: import('http').ServerResponse): Promise<void> {
+    try {
+      const data = await readBody(req) as Record<string, string>;
+      const hw = readHardwareIdentity();
+      const habiKey = process.env.HABI_KEY || '';
+
+      // Console log always
+      const icons: Record<string, string> = {
+        'claude.ai': '🟠', 'chatgpt.com': '🟢', 'cursor.sh': '🔵',
+        'gemini.google.com': '🔷', 'github.com': '⚫', 'perplexity.ai': '🔵',
+        'copilot.microsoft.com': '🔷', 'v0.dev': '⬛', 'character.ai': '🟣',
+      };
+      const icon = icons[data.hostname ?? ''] ?? '🤖';
+      const toolName = data.toolName ?? 'Unknown';
+      const engine = data.engine ?? 'Unknown';
+      console.log(`[HABI Activity] ${icon} ${toolName} — ${engine}`);
+
+      // Cloud log via the post() function from cloud module
+      if (habiKey) {
+        const logPayload: Record<string, unknown> = {
+          eventType: 'ACTION_ALLOWED',
+          operation: `${toolName} — ${engine}`,
+          hardwareId: hw.fingerprint,
+          toolName,
+          engine,
+          visitUrl: data.url ?? '',
+          sessionId: data.sessionId ?? '',
+          ts: data.ts ?? new Date().toISOString(),
+        };
+        // Use dynamic import to avoid circular dependency
+        Promise.resolve().then(async () => {
+          const https = await import('https');
+          const body = JSON.stringify({ ...logPayload, habiKey });
+          const opts: import('https').RequestOptions = {
+            hostname: 'dokcixjitwihtbdlkbdb.supabase.co',
+            port: 443,
+            path: '/functions/v1/log-ai-activity',
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Content-Length': String(Buffer.byteLength(body)),
+              'x-habi-key': habiKey,
+            },
+          };
+          const r = https.default.request(opts, (res2) => { res2.resume(); });
+          r.on('error', () => {});
+          r.write(body); r.end();
+        }).catch(() => {});
+      }
+
+      json(res, 200, { ok: true, logged: true, tool: toolName, hw: hw.fingerprint });
+    } catch (err) {
+      json(res, 400, { ok: false, error: String(err) });
+    }
+  }
   private getHardware(): HardwareIdentity {
     if (!this.hardware) {
       this.hardware = readHardwareIdentity();
@@ -221,6 +275,7 @@ export class HabiLocalServer {
           if (url === '/verify' && method === 'POST')        return this.handleVerify(res);
           if (url === '/assert-context' && method === 'POST') return this.handleAssertContext(req, res);
           if (url === '/audit' && method === 'POST')         return this.handleAudit(req, res);
+          if (url === '/log-activity' && method === 'POST')  return this.handleLogActivity(req, res);
 
           json(res, 404, { error: `Unknown route: ${method} ${url}` });
         });

package/src/service.ts

@@ -0,0 +1,223 @@
+/**
+ * HABI Service Manager
+ * Installs/uninstalls the daemon as a persistent background service
+ * per operating system — no admin required on any platform.
+ *
+ * Windows  : Task Scheduler (schtasks) — runs at logon, no UAC prompt
+ * macOS    : launchd LaunchAgent       — ~/Library/LaunchAgents/
+ * Linux    : systemd user service      — ~/.config/systemd/user/
+ */
+
+import * as fs   from 'fs';
+import * as path from 'path';
+import * as os   from 'os';
+import { execSync, spawnSync } from 'child_process';
+
+const SERVICE_NAME  = 'com.onspot.habi';
+const CONFIG_DIR    = path.join(os.homedir(), '.habi');
+const CONFIG_PATH   = path.join(CONFIG_DIR, 'config.json');
+const DAEMON_PATH   = path.join(__dirname, 'daemon.js');  // resolved at runtime
+const NODE_BIN      = process.execPath;                    // exact node binary used right now
+const PID_PATH      = path.join(CONFIG_DIR, 'habi.pid');
+
+// ── Config helpers ─────────────────────────────────────────────────────────
+export function saveConfig(key: string, name: string): void {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify({ key, name, nodeBin: NODE_BIN, daemonPath: DAEMON_PATH }, null, 2));
+}
+
+export function configExists(): boolean {
+  return fs.existsSync(CONFIG_PATH);
+}
+
+// ── Install ────────────────────────────────────────────────────────────────
+export async function installService(): Promise<void> {
+  const platform = os.platform();
+  if      (platform === 'win32')  await installWindows();
+  else if (platform === 'darwin') await installMacos();
+  else                             await installLinux();
+}
+
+// ── Uninstall ──────────────────────────────────────────────────────────────
+export async function uninstallService(): Promise<void> {
+  const platform = os.platform();
+  if      (platform === 'win32')  uninstallWindows();
+  else if (platform === 'darwin') uninstallMacos();
+  else                             uninstallLinux();
+}
+
+// ── Stop ───────────────────────────────────────────────────────────────────
+export function stopService(): void {
+  const platform = os.platform();
+  try {
+    if (platform === 'win32') {
+      try { execSync(`schtasks /end /tn "${SERVICE_NAME}" > nul 2>&1`); } catch {}
+    } else if (platform === 'darwin') {
+      spawnSync('sh', ['-c', `launchctl unload ~/Library/LaunchAgents/${SERVICE_NAME}.plist 2>/dev/null || true`]);
+    } else {
+      spawnSync('sh', ['-c', 'systemctl --user stop habi 2>/dev/null || true']);
+    }
+  } catch { /* already stopped */ }
+}
+
+// ── Restart ────────────────────────────────────────────────────────────────
+export function restartService(): void {
+  stopService();
+  setTimeout(() => {
+    const platform = os.platform();
+    try {
+      if (platform === 'win32') {
+        try { execSync(`schtasks /run /tn "${SERVICE_NAME}" > nul 2>&1`); } catch {}
+      } else if (platform === 'darwin') {
+        spawnSync('sh', ['-c', `launchctl load ~/Library/LaunchAgents/${SERVICE_NAME}.plist 2>/dev/null || true`]);
+      } else {
+        spawnSync('sh', ['-c', 'systemctl --user start habi 2>/dev/null || true']);
+      }
+    } catch { /* ignore */ }
+  }, 1500);
+}
+
+// ── Service running check ──────────────────────────────────────────────────
+export function isServiceInstalled(): boolean {
+  const platform = os.platform();
+  try {
+    if (platform === 'win32') {
+      const r = spawnSync('schtasks', ['/query', '/tn', SERVICE_NAME], { encoding: 'utf8', stdio: ['ignore','pipe','pipe'] });
+      return r.status === 0;
+    } else if (platform === 'darwin') {
+      return fs.existsSync(`${os.homedir()}/Library/LaunchAgents/${SERVICE_NAME}.plist`);
+    } else {
+      return fs.existsSync(`${os.homedir()}/.config/systemd/user/habi.service`);
+    }
+  } catch { return false; }
+}
+
+// ── Windows: Task Scheduler ─────────────────────────────────────────────────
+async function installWindows(): Promise<void> {
+  // Wrap in a VBScript launcher so no console window flashes
+  const launcherPath = path.join(CONFIG_DIR, 'launch.vbs');
+  const vbsContent = `Set WshShell = CreateObject("WScript.Shell")\r\nWshShell.Run """${NODE_BIN}"" ""${DAEMON_PATH}""", 0, False\r\n`;
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(launcherPath, vbsContent);
+
+  // Delete existing task silently, then create fresh
+  spawnSync('schtasks', ['/delete', '/tn', SERVICE_NAME, '/f'], { stdio: ['ignore','ignore','ignore'] });
+
+  const result = spawnSync('schtasks', [
+    '/create',
+    '/tn',  SERVICE_NAME,
+    '/tr',  `wscript "${launcherPath}"`,
+    '/sc',  'onlogon',
+    '/rl',  'limited',       // no UAC elevation needed
+    '/f',                    // force overwrite
+    '/delay', '0000:30',     // 30s delay after logon (let desktop load first)
+  ], { encoding: 'utf8' });
+
+  if (result.status !== 0) {
+    throw new Error(`Task Scheduler error: ${result.stderr || result.stdout}`);
+  }
+
+  // Run it now without waiting for next logon
+  spawnSync('wscript', [launcherPath]);
+}
+
+function uninstallWindows(): void {
+  spawnSync('schtasks', ['/delete', '/tn', SERVICE_NAME, '/f'], { stdio: ['ignore','ignore','ignore'] });
+  const launcherPath = path.join(CONFIG_DIR, 'launch.vbs');
+  if (fs.existsSync(launcherPath)) fs.unlinkSync(launcherPath);
+}
+
+// ── macOS: launchd LaunchAgent ──────────────────────────────────────────────
+async function installMacos(): Promise<void> {
+  const plistDir  = path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(plistDir, `${SERVICE_NAME}.plist`);
+  const logPath   = path.join(CONFIG_DIR, 'habi.log');
+
+  if (!fs.existsSync(plistDir)) fs.mkdirSync(plistDir, { recursive: true });
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>             <string>${SERVICE_NAME}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${NODE_BIN}</string>
+    <string>${DAEMON_PATH}</string>
+  </array>
+  <key>RunAtLoad</key>         <true/>
+  <key>KeepAlive</key>         <true/>
+  <key>StandardOutPath</key>   <string>${logPath}</string>
+  <key>StandardErrorPath</key> <string>${logPath}</string>
+  <key>WorkingDirectory</key>  <string>${CONFIG_DIR}</string>
+</dict>
+</plist>`;
+
+  fs.writeFileSync(plistPath, plist);
+
+  // Unload if already loaded, then load fresh
+  spawnSync('launchctl', ['unload', plistPath], { stdio: ['ignore','ignore','ignore'] as any });
+  const result = spawnSync('launchctl', ['load', '-w', plistPath], { encoding: 'utf8' });
+  if (result.status !== 0) {
+    throw new Error(`launchctl error: ${result.stderr}`);
+  }
+}
+
+function uninstallMacos(): void {
+  const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${SERVICE_NAME}.plist`);
+  if (fs.existsSync(plistPath)) {
+    spawnSync('launchctl', ['unload', plistPath], { stdio: ['ignore','ignore','ignore'] as any });
+    fs.unlinkSync(plistPath);
+  }
+}
+
+// ── Linux: systemd user service ─────────────────────────────────────────────
+async function installLinux(): Promise<void> {
+  const unitDir  = path.join(os.homedir(), '.config', 'systemd', 'user');
+  const unitPath = path.join(unitDir, 'habi.service');
+  const logPath  = path.join(CONFIG_DIR, 'habi.log');
+
+  if (!fs.existsSync(unitDir)) fs.mkdirSync(unitDir, { recursive: true });
+
+  const unit = `[Unit]
+Description=HABI Hardware Identity Agent
+After=network.target
+
+[Service]
+ExecStart=${NODE_BIN} ${DAEMON_PATH}
+Restart=always
+RestartSec=10
+WorkingDirectory=${CONFIG_DIR}
+StandardOutput=append:${logPath}
+StandardError=append:${logPath}
+Environment=HOME=${os.homedir()}
+
+[Install]
+WantedBy=default.target
+`;
+
+  fs.writeFileSync(unitPath, unit);
+
+  spawnSync('systemctl', ['--user', 'daemon-reload'],             { stdio: ['ignore','ignore','ignore'] as any });
+  spawnSync('systemctl', ['--user', 'enable', 'habi'],            { stdio: ['ignore','ignore','ignore'] as any });
+  const result = spawnSync('systemctl', ['--user', 'start', 'habi'], { encoding: 'utf8' });
+
+  if (result.status !== 0) {
+    // systemd might not be running (WSL, older systems) — fall back to backgrounding
+    console.log('  (systemd not available — starting daemon directly)');
+    const { spawn } = require('child_process');
+    const child = spawn(NODE_BIN, [DAEMON_PATH], {
+      detached: true,
+      stdio:    ['ignore', fs.openSync(logPath, 'a'), fs.openSync(logPath, 'a')],
+    });
+    child.unref();
+  }
+}
+
+function uninstallLinux(): void {
+  spawnSync('systemctl', ['--user', 'stop',    'habi'], { stdio: ['ignore','ignore','ignore'] as any });
+  spawnSync('systemctl', ['--user', 'disable', 'habi'], { stdio: ['ignore','ignore','ignore'] as any });
+  const unitPath = path.join(os.homedir(), '.config', 'systemd', 'user', 'habi.service');
+  if (fs.existsSync(unitPath)) fs.unlinkSync(unitPath);
+  spawnSync('systemctl', ['--user', 'daemon-reload'], { stdio: ['ignore','ignore','ignore'] as any });
+}