jobarbiter 0.3.12 → 0.4.0

package/dist/lib/launchd.js

@@ -0,0 +1,171 @@
+/**
+ * LaunchAgent Management for macOS
+ *
+ * Manages the ai.jobarbiter.observer LaunchAgent for periodic transcript polling.
+ * Generates plist, writes to ~/Library/LaunchAgents/, manages via launchctl.
+ */
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+// ── Constants ──────────────────────────────────────────────────────────
+const LABEL = "ai.jobarbiter.observer";
+const LAUNCH_AGENTS_DIR = join(homedir(), "Library", "LaunchAgents");
+const PLIST_PATH = join(LAUNCH_AGENTS_DIR, `${LABEL}.plist`);
+const OBSERVER_DIR = join(homedir(), ".config", "jobarbiter", "observer");
+const LOG_PATH = join(OBSERVER_DIR, "poll.log");
+// ── Helpers ────────────────────────────────────────────────────────────
+function resolveJobarbiterPath() {
+    // Try to find the jobarbiter binary
+    try {
+        const path = execSync("command -v jobarbiter", { encoding: "utf-8", timeout: 3000 }).trim();
+        if (path)
+            return path;
+    }
+    catch {
+        // Fall through
+    }
+    // Fallback: use process.execPath with the dist path
+    // This covers the case where jobarbiter is run via node directly
+    return process.execPath;
+}
+function generatePlist(intervalSeconds) {
+    const binaryPath = resolveJobarbiterPath();
+    // If the binary is node itself, we need to figure out the script path
+    const isNodeBinary = binaryPath.includes("node") || binaryPath.includes("bun");
+    let programArgs;
+    if (isNodeBinary) {
+        // Find the actual CLI entry point
+        const cliPath = join(__dirname, "..", "index.js");
+        programArgs = `    <string>${binaryPath}</string>
+    <string>${cliPath}</string>
+    <string>observe</string>
+    <string>poll</string>`;
+    }
+    else {
+        programArgs = `    <string>${binaryPath}</string>
+    <string>observe</string>
+    <string>poll</string>`;
+    }
+    return `<?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>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${programArgs}
+  </array>
+  <key>StartInterval</key>
+  <integer>${intervalSeconds}</integer>
+  <key>StandardOutPath</key>
+  <string>${LOG_PATH}</string>
+  <key>StandardErrorPath</key>
+  <string>${LOG_PATH}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>Nice</key>
+  <integer>10</integer>
+</dict>
+</plist>
+`;
+}
+function isLoaded() {
+    try {
+        const output = execSync(`launchctl list 2>/dev/null`, { encoding: "utf-8", timeout: 5000 });
+        return output.includes(LABEL);
+    }
+    catch {
+        return false;
+    }
+}
+// ── Public API ─────────────────────────────────────────────────────────
+export function installDaemon(intervalSeconds = 7200) {
+    mkdirSync(LAUNCH_AGENTS_DIR, { recursive: true });
+    mkdirSync(OBSERVER_DIR, { recursive: true });
+    // Unload existing if present
+    if (isLoaded()) {
+        try {
+            execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { timeout: 5000 });
+        }
+        catch {
+            // May not be loaded
+        }
+    }
+    // Write plist
+    const plist = generatePlist(intervalSeconds);
+    writeFileSync(PLIST_PATH, plist);
+    // Load
+    try {
+        execSync(`launchctl load "${PLIST_PATH}"`, { timeout: 5000 });
+    }
+    catch (err) {
+        throw new Error(`Failed to load LaunchAgent: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export function uninstallDaemon() {
+    // Unload
+    if (isLoaded()) {
+        try {
+            execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { timeout: 5000 });
+        }
+        catch {
+            // Best effort
+        }
+    }
+    // Delete plist
+    if (existsSync(PLIST_PATH)) {
+        try {
+            unlinkSync(PLIST_PATH);
+        }
+        catch {
+            // Best effort
+        }
+    }
+}
+export function getDaemonStatus() {
+    const installed = existsSync(PLIST_PATH);
+    const loaded = isLoaded();
+    let interval = null;
+    if (installed) {
+        try {
+            const content = readFileSync(PLIST_PATH, "utf-8");
+            const match = content.match(/<key>StartInterval<\/key>\s*<integer>(\d+)<\/integer>/);
+            if (match) {
+                interval = parseInt(match[1], 10);
+            }
+        }
+        catch {
+            // Best effort
+        }
+    }
+    return {
+        installed,
+        loaded,
+        interval,
+        plistPath: PLIST_PATH,
+    };
+}
+export function reloadDaemon() {
+    if (!existsSync(PLIST_PATH)) {
+        throw new Error("Daemon not installed. Run 'jobarbiter observe daemon install' first.");
+    }
+    try {
+        execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { timeout: 5000 });
+    }
+    catch {
+        // May not be loaded
+    }
+    try {
+        execSync(`launchctl load "${PLIST_PATH}"`, { timeout: 5000 });
+    }
+    catch (err) {
+        throw new Error(`Failed to reload daemon: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/lib/observe.js

@@ -91,9 +91,29 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 
-const OBSERVATIONS_FILE = path.join(
-  os.homedir(), ".config", "jobarbiter", "observer", "observations.json"
-);
+const OBSERVER_DIR = path.join(os.homedir(), ".config", "jobarbiter", "observer");
+const OBSERVATIONS_FILE = path.join(OBSERVER_DIR, "observations.json");
+const PAUSED_FILE = path.join(OBSERVER_DIR, "PAUSED");
+
+// Check PAUSED sentinel FIRST — if paused, exit immediately
+try {
+  if (fs.existsSync(PAUSED_FILE)) {
+    const raw = fs.readFileSync(PAUSED_FILE, "utf-8");
+    const pauseData = JSON.parse(raw);
+    if (pauseData.expiresAt) {
+      const expiresAt = new Date(pauseData.expiresAt).getTime();
+      if (Date.now() < expiresAt) {
+        process.exit(0); // Still paused
+      }
+      // Expired — clean up and continue
+      fs.unlinkSync(PAUSED_FILE);
+    } else {
+      process.exit(0); // Paused indefinitely
+    }
+  }
+} catch {
+  // If PAUSED file is corrupted, continue
+}
 
 // Read stdin
 let input = "";
@@ -249,8 +269,14 @@ function appendObservation(obs) {
   // Fire-and-forget: trigger analysis pipeline via CLI
   // Spawns detached process so the AI tool is never blocked
   try {
-    const { spawn } = require("child_process");
-    // Try npx jobarbiter first, fall back to direct node invocation
+    const { spawn, execSync } = require("child_process");
+    // Self-healing: verify jobarbiter binary exists before spawning
+    try {
+      execSync("command -v jobarbiter", { stdio: "ignore", timeout: 3000 });
+    } catch {
+      // jobarbiter CLI not found — exit silently
+      return;
+    }
     const child = spawn("jobarbiter", ["analyze", "--auto"], {
       detached: true,
       stdio: "ignore",

package/dist/lib/onboard.js

@@ -13,6 +13,7 @@ import { loadConfig, saveConfig, getConfigPath } from "./config.js";
 import { apiUnauthenticated, api, ApiError } from "./api.js";
 import { installObservers } from "./observe.js";
 import { detectAllTools, formatToolDisplay, } from "./detect-tools.js";
+import { installDaemon } from "./launchd.js";
 import { loadProviderKeys, saveProviderKey, validateProviderKey, } from "./providers.js";
 // ── ANSI Colors ────────────────────────────────────────────────────────
 const colors = {
@@ -160,19 +161,68 @@ export async function runOnboardWizard(opts) {
         const userType = await selectUserType(prompt);
         state.userType = userType;
         // Step 2: Email & Verification
-        const { email, apiKey, userId } = await handleEmailVerification(prompt, baseUrl, userType);
-        state.email = email;
-        state.apiKey = apiKey;
-        state.userId = userId;
+        const verificationResult = await handleEmailVerification(prompt, baseUrl, userType);
+        state.email = verificationResult.email;
+        state.apiKey = verificationResult.apiKey;
+        state.userId = verificationResult.userId;
+        // If returning user, override userType from backend
+        const effectiveUserType = verificationResult.isReturningUser && verificationResult.userType
+            ? verificationResult.userType
+            : userType;
+        state.userType = effectiveUserType;
         // Save config immediately after verification (with step progress)
         saveConfig({
-            apiKey,
+            apiKey: verificationResult.apiKey,
             baseUrl,
-            userType,
+            userType: effectiveUserType,
             onboardingStep: 1,
             onboardingComplete: false,
         });
-        if (userType === "worker") {
+        // Returning user: show progress and resume from first incomplete step
+        if (verificationResult.isReturningUser) {
+            const config = {
+                apiKey: verificationResult.apiKey,
+                baseUrl,
+                userType: effectiveUserType,
+            };
+            const progress = await fetchOnboardingProgress(config);
+            const { firstIncomplete } = showReturningUserProgress(progress);
+            if (firstIncomplete > (effectiveUserType === "worker" ? 6 : 5)) {
+                // Everything done except completion step
+                const continueAnyway = await prompt.confirm(`All steps look complete. Re-run onboarding anyway?`, false);
+                if (!continueAnyway) {
+                    saveConfig({ ...config, onboardingComplete: true, onboardingStep: effectiveUserType === "worker" ? 7 : 6 });
+                    console.log(`\n${sym.check} ${c.success("You're all set!")} Run ${c.highlight("jobarbiter status")} to check your account.\n`);
+                    prompt.close();
+                    return;
+                }
+            }
+            else {
+                const continueFromStep = await prompt.confirm(`Continue from step ${firstIncomplete}?`);
+                if (!continueFromStep) {
+                    // Let them start from step 2
+                    console.log(c.dim("Starting from the beginning...\n"));
+                    if (effectiveUserType === "worker") {
+                        await runWorkerFlow(prompt, state, 2);
+                    }
+                    else {
+                        await runEmployerFlow(prompt, state);
+                    }
+                    prompt.close();
+                    return;
+                }
+            }
+            // Resume from firstIncomplete
+            if (effectiveUserType === "worker") {
+                await runWorkerFlow(prompt, state, firstIncomplete);
+            }
+            else {
+                await runEmployerFlow(prompt, state);
+            }
+            prompt.close();
+            return;
+        }
+        if (effectiveUserType === "worker") {
             await runWorkerFlow(prompt, state);
         }
         else {
@@ -233,6 +283,7 @@ async function handleEmailVerification(prompt, baseUrl, userType) {
     }
     // Call register API
     console.log(c.dim("\nSending verification code..."));
+    let isReturningUser = false;
     try {
         await apiUnauthenticated(baseUrl, "POST", "/v1/auth/register", {
             email,
@@ -241,18 +292,34 @@ async function handleEmailVerification(prompt, baseUrl, userType) {
     }
     catch (err) {
         if (err instanceof ApiError && err.status === 409) {
-            // Email already registered and verified
-            throw new Error(`This email is already registered. Run 'jobarbiter verify-email --email ${email}' if you need to re-verify, or use a different email.`);
+            // Email already registered — switch to login flow
+            isReturningUser = true;
+            console.log(`\n${sym.rocket} ${c.bold("Welcome back!")} Sending verification code...`);
+            try {
+                await apiUnauthenticated(baseUrl, "POST", "/v1/auth/login", { email });
+            }
+            catch (loginErr) {
+                throw new Error("Could not send login verification code. Please try again later.");
+            }
+        }
+        else {
+            throw err;
         }
-        throw err;
     }
-    console.log(`\n${sym.check} Verification code sent to ${c.highlight(email)}`);
+    if (!isReturningUser) {
+        console.log(`\n${sym.check} Verification code sent to ${c.highlight(email)}`);
+    }
+    else {
+        console.log(`${sym.check} Verification code sent to ${c.highlight(email)}`);
+    }
     console.log(c.dim("   (Check your inbox and spam folder. Code expires in 15 minutes.)\n"));
     // Get verification code
     let apiKey;
     let userId;
+    let returnedUserType;
     let attempts = 0;
     const maxAttempts = 5;
+    const verifyEndpoint = isReturningUser ? "/v1/auth/verify-login" : "/v1/auth/verify";
     while (attempts < maxAttempts) {
         const code = await prompt.question(`Enter 6-digit code: `);
         if (!code || code.length !== 6) {
@@ -260,12 +327,15 @@ async function handleEmailVerification(prompt, baseUrl, userType) {
             continue;
         }
         try {
-            const result = await apiUnauthenticated(baseUrl, "POST", "/v1/auth/verify", {
+            const result = await apiUnauthenticated(baseUrl, "POST", verifyEndpoint, {
                 email,
                 code: code.trim(),
             });
             apiKey = result.apiKey;
             userId = result.id;
+            if (isReturningUser) {
+                returnedUserType = result.userType;
+            }
             break;
         }
         catch (err) {
@@ -287,8 +357,105 @@ async function handleEmailVerification(prompt, baseUrl, userType) {
     if (!apiKey || !userId) {
         throw new Error("Verification failed. Please try again.");
     }
-    console.log(`\n${sym.check} ${c.success("Email verified! Account created.")}\n`);
-    return { email, apiKey, userId };
+    if (isReturningUser) {
+        console.log(`\n${sym.check} ${c.success("Welcome back! Logged in successfully.")}\n`);
+    }
+    else {
+        console.log(`\n${sym.check} ${c.success("Email verified! Account created.")}\n`);
+    }
+    return { email, apiKey, userId, isReturningUser, userType: returnedUserType };
+}
+async function fetchOnboardingProgress(config) {
+    const progress = {
+        accountCreated: true,
+        userType: config.userType,
+        toolsDetected: [],
+        aiAccountsConnected: false,
+        domainsSet: [],
+        githubConnected: false,
+        linkedinConnected: false,
+    };
+    // Fetch profile
+    try {
+        const profile = await api(config, "GET", "/v1/profile");
+        if (profile.domains && Array.isArray(profile.domains) && profile.domains.length > 0) {
+            progress.domainsSet = profile.domains;
+        }
+        if (profile.tools && typeof profile.tools === "object") {
+            const tools = profile.tools;
+            if (tools.primary && Array.isArray(tools.primary) && tools.primary.length > 0) {
+                progress.toolsDetected = tools.primary;
+            }
+        }
+        if (profile.bio) {
+            progress.bio = profile.bio;
+        }
+        if (profile.githubUsername) {
+            progress.githubConnected = true;
+            progress.githubUsername = profile.githubUsername;
+        }
+    }
+    catch {
+        // Profile doesn't exist yet — that's fine
+    }
+    // Check AI accounts
+    const existingProviders = loadProviderKeys();
+    progress.aiAccountsConnected = existingProviders.length > 0;
+    // Check verification status (LinkedIn etc.)
+    try {
+        const verificationStatus = await api(config, "GET", "/v1/verification/status");
+        if (verificationStatus.linkedin) {
+            progress.linkedinConnected = true;
+        }
+    }
+    catch {
+        // Endpoint may not exist — gracefully ignore
+    }
+    return progress;
+}
+function showReturningUserProgress(progress) {
+    const isWorker = progress.userType === "worker";
+    const totalSteps = isWorker ? 7 : 6;
+    console.log(`${c.bold("Here's your onboarding progress:")}\n`);
+    if (isWorker) {
+        const steps = [
+            { done: true, label: `Account created (${progress.userType})` },
+            { done: progress.toolsDetected.length > 0, label: progress.toolsDetected.length > 0
+                    ? `AI Tools detected (${progress.toolsDetected.join(", ")})`
+                    : "AI Tools not detected" },
+            { done: progress.aiAccountsConnected, label: progress.aiAccountsConnected
+                    ? "AI Accounts connected"
+                    : "AI Accounts not connected" },
+            { done: progress.domainsSet.length > 0, label: progress.domainsSet.length > 0
+                    ? `Domains set (${progress.domainsSet.join(", ")})`
+                    : "Domains not set" },
+            { done: progress.githubConnected, label: progress.githubConnected
+                    ? `GitHub connected (${progress.githubUsername})`
+                    : "GitHub not connected" },
+            { done: progress.linkedinConnected, label: progress.linkedinConnected
+                    ? "LinkedIn connected"
+                    : "LinkedIn not connected" },
+            { done: false, label: "Completion" },
+        ];
+        let firstIncomplete = totalSteps; // default to last
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            const icon = step.done ? sym.check : sym.cross;
+            console.log(`   ${icon} Step ${i + 1}/${totalSteps} — ${step.label}`);
+            if (!step.done && firstIncomplete === totalSteps) {
+                firstIncomplete = i + 1;
+            }
+        }
+        console.log();
+        return { firstIncomplete };
+    }
+    else {
+        // Employer — simpler progress
+        console.log(`   ${sym.check} Step 1/6 — Account created (employer)`);
+        console.log(`   ${sym.cross} Step 2/6 — Remaining setup`);
+        console.log();
+        return { firstIncomplete: 2 };
+    }
 }
 // ── Worker Flow ────────────────────────────────────────────────────────
 async function runWorkerFlow(prompt, state, startStep = 2) {
@@ -479,6 +646,22 @@ async function runToolDetectionStep(prompt, config) {
             }
             if (result.installed.length > 0) {
                 console.log(`\n  ${sym.check} ${c.success(`${result.installed.length} observer${result.installed.length > 1 ? "s" : ""} installed!`)}`);
+                // Install background polling daemon
+                try {
+                    installDaemon(7200);
+                    console.log(`  ${sym.check} ${c.success("Background poller installed (every 2 hours)")}`);
+                }
+                catch {
+                    console.log(`  ${c.dim("Background poller skipped (install later: jobarbiter observe daemon install)")}`);
+                }
+                // Show poller-observable tools
+                const pollerTools = allTools.filter((t) => t.installed && t.observationMethod === "poller");
+                if (pollerTools.length > 0) {
+                    console.log(`\n  ${c.bold("Poller will also scan these tools:")}`);
+                    for (const t of pollerTools) {
+                        console.log(`    ${sym.bullet} ${formatToolDisplay(t)}`);
+                    }
+                }
                 console.log(`\n  ${c.bold("What happens now?")}`);
                 console.log(`  Observers activate each time you use your AI tools.`);
                 console.log(`  Just work normally — every session builds your profile.\n`);
@@ -487,6 +670,7 @@ async function runToolDetectionStep(prompt, config) {
                 console.log(`  a work report to JobArbiter. Our agents interpret these reports`);
                 console.log(`  to build and evolve your narrative profile over time.`);
                 console.log(`  Raw session data never leaves your machine.\n`);
+                console.log(`  ${c.dim("Manage observers: jobarbiter observe --help")}`);
             }
         }
         else {

package/dist/lib/poll-state.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Poll State Management
+ *
+ * Read/write ~/.config/jobarbiter/observer/poll-state.json
+ * Tracks per-source poll times, known sessions, pause windows,
+ * disabled sources, and interval configuration.
+ */
+export interface PauseWindow {
+    start: string;
+    end: string;
+}
+export interface PollState {
+    version: number;
+    lastPoll: Record<string, string>;
+    knownSessionIds: string[];
+    pauseWindows: PauseWindow[];
+    disabledSources: string[];
+    interval: number;
+}
+export declare function loadPollState(): PollState;
+export declare function savePollState(state: PollState): void;
+export declare function addPauseWindow(start: string, end: string): void;
+export declare function isInPauseWindow(timestamp: string): boolean;
+export declare function addKnownSession(sessionId: string): void;
+export declare function isKnownSession(sessionId: string): boolean;
+export declare function getDisabledSources(): string[];
+export declare function setDisabledSource(source: string): void;
+export declare function removeDisabledSource(source: string): void;

package/dist/lib/poll-state.js

@@ -0,0 +1,91 @@
+/**
+ * Poll State Management
+ *
+ * Read/write ~/.config/jobarbiter/observer/poll-state.json
+ * Tracks per-source poll times, known sessions, pause windows,
+ * disabled sources, and interval configuration.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+// ── Paths ──────────────────────────────────────────────────────────────
+const OBSERVER_DIR = join(homedir(), ".config", "jobarbiter", "observer");
+const POLL_STATE_FILE = join(OBSERVER_DIR, "poll-state.json");
+function defaultPollState() {
+    return {
+        version: 1,
+        lastPoll: {},
+        knownSessionIds: [],
+        pauseWindows: [],
+        disabledSources: [],
+        interval: 7200,
+    };
+}
+// ── Core Functions ─────────────────────────────────────────────────────
+export function loadPollState() {
+    try {
+        if (!existsSync(POLL_STATE_FILE))
+            return defaultPollState();
+        const raw = readFileSync(POLL_STATE_FILE, "utf-8");
+        const data = JSON.parse(raw);
+        return {
+            ...defaultPollState(),
+            ...data,
+        };
+    }
+    catch {
+        return defaultPollState();
+    }
+}
+export function savePollState(state) {
+    mkdirSync(OBSERVER_DIR, { recursive: true });
+    writeFileSync(POLL_STATE_FILE, JSON.stringify(state, null, 2) + "\n");
+}
+export function addPauseWindow(start, end) {
+    const state = loadPollState();
+    state.pauseWindows.push({ start, end });
+    // Keep last 50 windows
+    if (state.pauseWindows.length > 50) {
+        state.pauseWindows = state.pauseWindows.slice(-50);
+    }
+    savePollState(state);
+}
+export function isInPauseWindow(timestamp) {
+    const state = loadPollState();
+    const ts = new Date(timestamp).getTime();
+    return state.pauseWindows.some((w) => {
+        const start = new Date(w.start).getTime();
+        const end = new Date(w.end).getTime();
+        return ts >= start && ts <= end;
+    });
+}
+export function addKnownSession(sessionId) {
+    const state = loadPollState();
+    if (!state.knownSessionIds.includes(sessionId)) {
+        state.knownSessionIds.push(sessionId);
+        // Rolling window of 1000
+        if (state.knownSessionIds.length > 1000) {
+            state.knownSessionIds = state.knownSessionIds.slice(-1000);
+        }
+        savePollState(state);
+    }
+}
+export function isKnownSession(sessionId) {
+    const state = loadPollState();
+    return state.knownSessionIds.includes(sessionId);
+}
+export function getDisabledSources() {
+    return loadPollState().disabledSources;
+}
+export function setDisabledSource(source) {
+    const state = loadPollState();
+    if (!state.disabledSources.includes(source)) {
+        state.disabledSources.push(source);
+        savePollState(state);
+    }
+}
+export function removeDisabledSource(source) {
+    const state = loadPollState();
+    state.disabledSources = state.disabledSources.filter((s) => s !== source);
+    savePollState(state);
+}

package/dist/lib/privacy-pause.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Privacy Pause Management
+ *
+ * Manages the PAUSED sentinel file at ~/.config/jobarbiter/observer/PAUSED
+ * When paused, all observation hooks and pollers exit immediately.
+ */
+import { type PauseWindow } from "./poll-state.js";
+export interface PauseStatus {
+    paused: boolean;
+    pausedAt: string | null;
+    expiresAt: string | null;
+    pauseWindows: PauseWindow[];
+}
+export declare function pauseObservation(expiresAt?: Date): void;
+export declare function resumeObservation(): void;
+export declare function isPaused(): boolean;
+export declare function getPauseStatus(): PauseStatus;