@nocville/npc 0.0.0-stage → 0.2.1

package/dist/npcs/codex/setup.js

@@ -0,0 +1,96 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { maskKey, persistCredentials } from '../../core/user-config.js';
+import { buildShimHookCommand, stableNodePath, installHookGroups, readJsonFile, removeHookGroups, resolveCliPath, writeJsonFile, } from '../agent-common/hook-settings.js';
+import { installHookShim } from '../agent-common/shim.js';
+import { ensureStableCliPath } from '../agent-common/runtime.js';
+import { CODEX_DEFAULTS, codexHome } from './defaults.js';
+/**
+ * Codex hook events we install (developers.openai.com/codex/hooks). PostCompact
+ * is omitted — it carries nothing displayable.
+ */
+export const CODEX_HOOK_EVENTS = [
+    'SessionStart',
+    'SessionEnd',
+    'UserPromptSubmit',
+    'PreToolUse',
+    'PostToolUse',
+    'PermissionRequest',
+    'Stop',
+    'Interrupt',
+    'PreCompact',
+    'SubagentStart',
+    'SubagentStop',
+];
+export function codexHooksPath() {
+    return join(codexHome(), 'hooks.json');
+}
+/** Install the nocville group into every Codex event. Mutates `file`. */
+export function installCodexHooksInto(file, command, opts = {}) {
+    return installHookGroups(file, command, CODEX_HOOK_EVENTS, {
+        perEvent: Object.fromEntries(CODEX_HOOK_EVENTS.map((event) => [
+            event,
+            event === 'SessionEnd' || event === 'Interrupt'
+                ? { timeout: 3 }
+                : { async: true, timeout: opts.timeout ?? 10 },
+        ])),
+    });
+}
+export function buildCodexHookCommand(_cliPath) {
+    return buildShimHookCommand('codex');
+}
+function out(opts, msg) {
+    if (!opts.quiet)
+        console.log(msg);
+}
+/**
+ * Install Nocville hooks into `~/.codex/hooks.json` (same matcher-group JSON
+ * format as Claude Code). Merges with existing hooks, idempotent, keeps a
+ * one-time `.nocville-backup`. Codex requires new hooks to be reviewed and
+ * trusted once via `/hooks` before they run — we print that instruction.
+ */
+export function setupCodexHooks(opts = {}) {
+    const hooksPath = opts.hooksPath ?? codexHooksPath();
+    const dir = join(hooksPath, '..');
+    if (!existsSync(dir)) {
+        console.error(`${dir} does not exist — is Codex installed? Skipping Codex setup.`);
+        return false;
+    }
+    const file = readJsonFile(hooksPath);
+    if (file === null) {
+        console.error(`Could not parse ${hooksPath}; fix it (or move it aside) and re-run setup.`);
+        return false;
+    }
+    const creds = persistCredentials(opts);
+    const resolved = resolveCliPath(opts.cliPath);
+    const cliPath = ensureStableCliPath(resolved);
+    installHookShim(stableNodePath(), cliPath);
+    const { installed } = installCodexHooksInto(file, buildCodexHookCommand(cliPath), {
+        timeout: CODEX_DEFAULTS.hookTimeoutSeconds,
+    });
+    writeJsonFile(hooksPath, file);
+    out(opts, `✓ Codex: installed Nocville hooks for ${installed} events in ${hooksPath}`);
+    out(opts, `  Hook runs: ${process.execPath} ${cliPath}`);
+    out(opts, `  API: ${creds.apiUrl ?? 'https://nocville.com'}  key: ${maskKey(creds.apiKey)}`);
+    if (!creds.apiKey) {
+        out(opts, '  ⚠ No API key saved yet — run: nocville-npc init --api-key=<your team key>');
+    }
+    out(opts, '  ➜ One-time step: start Codex and run /hooks to review and trust the Nocville');
+    out(opts, '    hooks (Codex skips new hooks until trusted).');
+    return true;
+}
+/** Remove all Nocville hooks from `~/.codex/hooks.json`. */
+export function uninstallCodexHooks(opts = {}) {
+    const hooksPath = opts.hooksPath ?? codexHooksPath();
+    const file = readJsonFile(hooksPath);
+    if (!file || !existsSync(hooksPath)) {
+        out(opts, 'Codex: no hooks.json — nothing to remove.');
+        return 0;
+    }
+    const removed = removeHookGroups(file);
+    if (removed > 0)
+        writeJsonFile(hooksPath, file);
+    out(opts, `✓ Codex: removed ${removed} Nocville hook(s) from ${hooksPath}`);
+    return removed;
+}
+//# sourceMappingURL=setup.js.map

package/dist/npcs/codex/watcher.d.ts

@@ -0,0 +1,65 @@
+import type { StatusUpdate } from '@nocville/node';
+import { type SessionFilter } from '../../core/session-filter.js';
+import type { NpcConfig } from '../../core/types.js';
+import type { AgentSessionState } from '../agent-common/session.js';
+/**
+ * `nocville-npc codex watch` — zero-config Codex integration that tails the
+ * session rollout logs Codex writes under ~/.codex/sessions/YYYY/MM/DD/.
+ *
+ * One NPC per live interactive session (subagent and guardian threads are
+ * skipped; `codex exec` runs only with --include-exec). Phase + activity are
+ * derived from the log; a session whose log stops growing for `idleTimeoutMs`
+ * despawns. Sessions whose hooks are active (any hook state file exists)
+ * are left to the hooks so nothing is pushed twice. Ctrl-C despawns all.
+ */
+export interface CodexWatcherOptions {
+    sessionsDir?: string;
+    pollMs?: number;
+    idleTimeoutMs?: number;
+    includeExec?: boolean;
+    minPushGapMs?: number;
+    /** Push override (tests). */
+    push?: (serviceId: string, payload: StatusUpdate) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    now?: () => number;
+    /** Hook state dir consulted for hook ownership (tests). */
+    hookStateDir?: string;
+    /** Override sessions.json (tests). */
+    sessionFilter?: SessionFilter;
+}
+/** Day directories to scan: today and yesterday (local time, like Codex). */
+export declare function recentDayDirs(root: string, now: number): string[];
+export declare class CodexWatcher {
+    private readonly config;
+    private readonly opts;
+    private readonly sessionsDir;
+    private readonly pollMs;
+    private readonly idleTimeoutMs;
+    private readonly includeExec;
+    private readonly minPushGapMs;
+    private readonly hookStateDir;
+    private readonly now;
+    private readonly logger;
+    private readonly sessions;
+    private interval?;
+    private clients;
+    constructor(config: NpcConfig, opts?: CodexWatcherOptions);
+    /** Active (non-ignored) sessions — exposed for tests/diagnostics. */
+    activeSessions(): AgentSessionState[];
+    start(): Promise<void>;
+    /** Stop polling and despawn every live session. */
+    stop(): Promise<void>;
+    /** One poll: discover files, read appended lines, push, expire quiet sessions. */
+    tick(): Promise<void>;
+    private discover;
+    private readAppended;
+    /** Reduce one signal into the session state. Exposed via tick for tests. */
+    private apply;
+    private hooksOwn;
+    private maybePush;
+    private despawn;
+    private send;
+}
+//# sourceMappingURL=watcher.d.ts.map

package/dist/npcs/codex/watcher.js

@@ -0,0 +1,356 @@
+import { closeSync, existsSync, mkdirSync, openSync, readSync, readdirSync, statSync, rmSync, writeFileSync, } from 'node:fs';
+import { join } from 'node:path';
+import { NocvilleClient } from '@nocville/node';
+import { Logger } from '../../core/logger.js';
+import { loadSessionFilter, sessionPublishDecision, } from '../../core/session-filter.js';
+import { buildAgentPayload, pushHistory, stateFilePath } from '../agent-common/session.js';
+import { CODEX_DEFAULTS } from './defaults.js';
+import { CODEX_ADAPTER, codexServiceId } from './hook-handler.js';
+import { parseRolloutLine } from './rollout.js';
+const pad = (n) => String(n).padStart(2, '0');
+/** Day directories to scan: today and yesterday (local time, like Codex). */
+export function recentDayDirs(root, now) {
+    const out = [];
+    for (const offset of [0, 1]) {
+        const d = new Date(now - offset * 24 * 60 * 60 * 1000);
+        out.push(join(root, String(d.getFullYear()), pad(d.getMonth() + 1), pad(d.getDate())));
+    }
+    return out;
+}
+/** Read the first line of a file (session_meta can be tens of KB). */
+function readFirstLine(file, maxBytes = 4 * 1024 * 1024) {
+    const fd = openSync(file, 'r');
+    try {
+        const chunk = Buffer.alloc(64 * 1024);
+        let acc = '';
+        let pos = 0;
+        while (pos < maxBytes) {
+            const n = readSync(fd, chunk, 0, chunk.length, pos);
+            if (n <= 0)
+                break;
+            const text = chunk.subarray(0, n).toString('utf-8');
+            const nl = text.indexOf('\n');
+            if (nl >= 0)
+                return acc + text.slice(0, nl);
+            acc += text;
+            pos += n;
+        }
+        return acc;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function readRange(file, start, end) {
+    if (end <= start)
+        return '';
+    const fd = openSync(file, 'r');
+    try {
+        const buf = Buffer.alloc(end - start);
+        const n = readSync(fd, buf, 0, buf.length, start);
+        return buf.subarray(0, n).toString('utf-8');
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export class CodexWatcher {
+    config;
+    opts;
+    sessionsDir;
+    pollMs;
+    idleTimeoutMs;
+    includeExec;
+    minPushGapMs;
+    hookStateDir;
+    now;
+    logger;
+    sessions = new Map();
+    interval;
+    clients = new Map();
+    constructor(config, opts = {}) {
+        this.config = config;
+        this.opts = opts;
+        this.sessionsDir = opts.sessionsDir ?? CODEX_DEFAULTS.sessionsDir;
+        this.pollMs = opts.pollMs ?? CODEX_DEFAULTS.pollMs;
+        this.idleTimeoutMs = opts.idleTimeoutMs ?? CODEX_DEFAULTS.idleTimeoutMs;
+        this.includeExec = opts.includeExec ?? false;
+        this.minPushGapMs = opts.minPushGapMs ?? CODEX_DEFAULTS.minPushGapMs;
+        this.hookStateDir = opts.hookStateDir ?? CODEX_ADAPTER.stateDir;
+        this.now = opts.now ?? Date.now;
+        this.logger = new Logger('codex-watch', config.debug);
+    }
+    /** Active (non-ignored) sessions — exposed for tests/diagnostics. */
+    activeSessions() {
+        return [...this.sessions.values()].filter((s) => !s.ignored).map((s) => s.state);
+    }
+    async start() {
+        mkdirSync(this.hookStateDir, { recursive: true, mode: 0o700 });
+        writeFileSync(join(this.hookStateDir, `watcher-${process.pid}.pid`), String(process.pid), {
+            mode: 0o600,
+        });
+        if (!existsSync(this.sessionsDir)) {
+            this.logger.warn(`${this.sessionsDir} not found yet — waiting for Codex sessions`);
+        }
+        this.logger.info(`Watching Codex sessions in ${this.sessionsDir}`);
+        await this.tick();
+        this.interval = setInterval(() => {
+            void this.tick().catch((err) => this.logger.warn('Watch tick failed', { error: err?.message }));
+        }, this.pollMs);
+        const onSignal = () => {
+            void this.stop().then(() => process.exit(0));
+        };
+        process.once('SIGINT', onSignal);
+        process.once('SIGTERM', onSignal);
+    }
+    /** Stop polling and despawn every live session. */
+    async stop() {
+        rmSync(join(this.hookStateDir, `watcher-${process.pid}.pid`), { force: true });
+        if (this.interval)
+            clearInterval(this.interval);
+        this.interval = undefined;
+        const live = [...this.sessions.values()].filter((s) => !s.ignored && s.spawned);
+        await Promise.all(live.map((s) => this.despawn(s)));
+        this.sessions.clear();
+    }
+    /** One poll: discover files, read appended lines, push, expire quiet sessions. */
+    async tick() {
+        const now = this.now();
+        for (const dir of recentDayDirs(this.sessionsDir, now)) {
+            let files;
+            try {
+                files = readdirSync(dir);
+            }
+            catch {
+                continue;
+            }
+            for (const name of files) {
+                if (!name.startsWith('rollout-') || !name.endsWith('.jsonl'))
+                    continue;
+                const file = join(dir, name);
+                let st;
+                try {
+                    st = statSync(file);
+                }
+                catch {
+                    continue;
+                }
+                const tracked = this.sessions.get(file);
+                if (!tracked) {
+                    if (now - st.mtimeMs > this.idleTimeoutMs)
+                        continue;
+                    this.discover(file, st.size, st.mtimeMs);
+                }
+                else if (st.size > tracked.offset) {
+                    if (!tracked.ignored) {
+                        if (st.size - tracked.offset > CODEX_DEFAULTS.maxReadBytes) {
+                            // Huge burst (rollouts can reach hundreds of MB): jump to the tail.
+                            tracked.offset = st.size - CODEX_DEFAULTS.initialTailBytes;
+                            tracked.partial = '';
+                            this.readAppended(tracked, st.size, true);
+                        }
+                        else {
+                            this.readAppended(tracked, st.size);
+                        }
+                    }
+                    else {
+                        tracked.offset = st.size;
+                    }
+                    tracked.lastGrowthAt = now;
+                }
+                else if (st.size < tracked.offset) {
+                    // Truncated/rewritten: restart from the top.
+                    tracked.offset = 0;
+                    tracked.partial = '';
+                }
+            }
+        }
+        const pushes = [];
+        for (const [file, s] of this.sessions) {
+            if (s.ignored) {
+                if (now - s.lastGrowthAt > this.idleTimeoutMs * 2)
+                    this.sessions.delete(file);
+                continue;
+            }
+            if (now - s.lastGrowthAt > this.idleTimeoutMs) {
+                if (s.spawned)
+                    pushes.push(this.despawn(s));
+                this.sessions.delete(file);
+                continue;
+            }
+            pushes.push(this.maybePush(s));
+        }
+        await Promise.all(pushes);
+    }
+    discover(file, size, mtimeMs) {
+        let meta = null;
+        try {
+            const sig = parseRolloutLine(readFirstLine(file));
+            if (sig?.kind === 'meta')
+                meta = sig;
+        }
+        catch {
+            meta = null;
+        }
+        const sessionId = meta?.sessionId ?? file;
+        const cwd = meta?.cwd ?? '';
+        const ignored = !meta || meta.subagent || (meta.exec && !this.includeExec);
+        const tracked = {
+            file,
+            offset: 0,
+            partial: '',
+            lastGrowthAt: Math.min(this.now(), mtimeMs),
+            ignored,
+            spawned: false,
+            lastPushAt: 0,
+            pushedRev: 0,
+            state: {
+                sessionId,
+                serviceId: codexServiceId(sessionId, cwd || 'codex'),
+                state: 'IDLE',
+                projectDir: cwd,
+                lastEvent: 'discover',
+                lastUpdate: this.now(),
+                activity: ['Ready for a task'],
+                status: 'healthy',
+                mood: 'idle',
+                rev: 1,
+            },
+        };
+        this.sessions.set(file, tracked);
+        if (ignored) {
+            tracked.offset = size;
+            return;
+        }
+        // Replay only the tail of a long-running session to establish its state.
+        const start = Math.max(0, size - CODEX_DEFAULTS.initialTailBytes);
+        tracked.offset = start;
+        tracked.partial = '';
+        const skipFirst = start > 0;
+        this.readAppended(tracked, size, skipFirst);
+        this.logger.info(`Tracking Codex session ${sessionId} (${tracked.state.projectDir || '?'})`);
+    }
+    readAppended(s, size, skipFirstLine = false) {
+        let text;
+        try {
+            text = s.partial + readRange(s.file, s.offset, size);
+        }
+        catch {
+            return;
+        }
+        s.offset = size;
+        const lines = text.split('\n');
+        s.partial = lines.pop() ?? '';
+        if (skipFirstLine)
+            lines.shift();
+        for (const line of lines) {
+            const sig = parseRolloutLine(line, s.state.projectDir || undefined);
+            if (sig)
+                this.apply(s, sig);
+        }
+    }
+    /** Reduce one signal into the session state. Exposed via tick for tests. */
+    apply(s, sig) {
+        const st = s.state;
+        const set = (phase, activity, mood) => {
+            const history = pushHistory(st.activity, activity);
+            if (st.state === phase && history[0] === st.activity?.[0])
+                return;
+            st.state = phase;
+            st.activity = history;
+            st.status = phase === 'WAITING' ? 'warning' : 'healthy';
+            st.mood = mood;
+            st.lastUpdate = this.now();
+            st.rev = (st.rev ?? 0) + 1;
+        };
+        switch (sig.kind) {
+            case 'meta':
+                return;
+            case 'cwd':
+                if (sig.cwd && sig.cwd !== st.projectDir) {
+                    st.projectDir = sig.cwd;
+                    if (!s.spawned)
+                        st.serviceId = codexServiceId(st.sessionId, sig.cwd);
+                    st.rev = (st.rev ?? 0) + 1;
+                }
+                return;
+            case 'working':
+                return set('WORKING', sig.activity, 'happy');
+            case 'waiting':
+                return set('WAITING', sig.activity, 'concerned');
+            case 'idle':
+                return set('IDLE', sig.activity, 'idle');
+        }
+    }
+    hooksOwn(sessionId) {
+        return existsSync(stateFilePath(this.hookStateDir, sessionId));
+    }
+    async maybePush(s) {
+        const rev = s.state.rev ?? 0;
+        if (rev <= s.pushedRev)
+            return;
+        if (this.hooksOwn(s.state.sessionId)) {
+            s.pushedRev = rev;
+            return;
+        }
+        const verdict = sessionPublishDecision(this.opts.sessionFilter ?? loadSessionFilter(), {
+            projectDir: s.state.projectDir,
+            name: s.state.name,
+        });
+        if (!verdict.publish) {
+            // Filtered out by sessions.json: never show it, and remove it if it was showing.
+            s.pushedRev = rev;
+            if (s.spawned) {
+                s.spawned = false;
+                const offline = { ...s.state, offline: true };
+                await this.send(s.state.serviceId, buildAgentPayload(CODEX_ADAPTER, offline, this.config));
+            }
+            return;
+        }
+        const now = this.now();
+        if (s.spawned && now - s.lastPushAt < this.minPushGapMs) {
+            // Coalesce; the next tick after the gap pushes the latest state.
+            return;
+        }
+        s.pushedRev = rev;
+        s.lastPushAt = now;
+        s.spawned = true;
+        await this.send(s.state.serviceId, buildAgentPayload(CODEX_ADAPTER, s.state, this.config));
+    }
+    async despawn(s) {
+        if (this.hooksOwn(s.state.sessionId) || !s.spawned)
+            return;
+        const offline = { ...s.state, offline: true };
+        await this.send(s.state.serviceId, buildAgentPayload(CODEX_ADAPTER, offline, this.config));
+        this.logger.info(`Codex session ${s.state.sessionId} ended`);
+    }
+    async send(serviceId, payload) {
+        try {
+            if (this.opts.push) {
+                await this.opts.push(serviceId, payload);
+                return;
+            }
+            if (!this.config.apiKey)
+                return;
+            let client = this.clients.get(serviceId);
+            if (!client) {
+                client = new NocvilleClient({
+                    apiUrl: this.config.apiUrl,
+                    apiKey: this.config.apiKey,
+                    serviceId,
+                    timeout: 5000,
+                    retries: 1,
+                    debug: this.config.debug,
+                });
+                this.clients.set(serviceId, client);
+            }
+            const result = await client.pushStatus(payload);
+            if (!result.success)
+                this.logger.warn('Push failed', { serviceId, error: result.error });
+        }
+        catch (err) {
+            this.logger.warn('Push error', { serviceId, error: err?.message });
+        }
+    }
+}
+//# sourceMappingURL=watcher.js.map

package/dist/npcs/cursor/defaults.d.ts

@@ -0,0 +1,9 @@
+export declare const CURSOR_DEFAULTS: {
+    stateDir: string;
+    stateFileMaxAge: number;
+    heartbeatSeconds: number;
+    minPushGapMs: number;
+    hookTimeoutSeconds: number;
+};
+export declare const cursorHome: () => string;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/npcs/cursor/defaults.js

@@ -0,0 +1,11 @@
+import { homedir, tmpdir } from 'node:os';
+import { join } from 'node:path';
+export const CURSOR_DEFAULTS = {
+    stateDir: join(tmpdir(), 'nocville-cursor'),
+    stateFileMaxAge: 24 * 60 * 60 * 1000,
+    heartbeatSeconds: 90,
+    minPushGapMs: 1500,
+    hookTimeoutSeconds: 10,
+};
+export const cursorHome = () => join(homedir(), '.cursor');
+//# sourceMappingURL=defaults.js.map

package/dist/npcs/cursor/hook-handler.d.ts

@@ -0,0 +1,8 @@
+import type { NpcConfig } from '../../core/types.js';
+import type { AgentHookEvent, AgentHookSpec, HookRunOptions } from '../agent-common/hook-runner.js';
+import type { AgentAdapter } from '../agent-common/session.js';
+export declare const CURSOR_ADAPTER: AgentAdapter;
+export declare function cursorServiceId(sessionId: string, cwd: string): string;
+export declare const CURSOR_HOOK_SPEC: AgentHookSpec;
+export declare function handleCursorHookEvent(config: NpcConfig, rawInput?: string | AgentHookEvent, opts?: HookRunOptions, source?: 'native' | 'third-party'): Promise<void>;
+//# sourceMappingURL=hook-handler.d.ts.map

package/dist/npcs/cursor/hook-handler.js

@@ -0,0 +1,60 @@
+import { createHash } from 'node:crypto';
+import { describeToolUse } from '../agent-common/activity.js';
+import { readStdin, runAgentHook } from '../agent-common/hook-runner.js';
+import { projectNameOf, sanitizeServiceId } from '../agent-common/session.js';
+import { claudeTransition } from '../claude-code/state-machine.js';
+import { CURSOR_DEFAULTS } from './defaults.js';
+import { normalizeCursorEvent } from './normalize.js';
+export const CURSOR_ADAPTER = {
+    command: 'cursor',
+    label: 'Cursor',
+    family: 'cursor',
+    stateDir: CURSOR_DEFAULTS.stateDir,
+    heartbeatSeconds: 90,
+    processNames: [],
+};
+export function cursorServiceId(sessionId, cwd) {
+    return sanitizeServiceId(`cursor-${projectNameOf(cwd)}-${sessionId.slice(0, 8)}`);
+}
+export const CURSOR_HOOK_SPEC = {
+    adapter: CURSOR_ADAPTER,
+    serviceIdFor: cursorServiceId,
+    transition: (event, previous) => event.hook_event_name === 'PostToolUse'
+        ? {
+            state: 'WORKING',
+            status: 'healthy',
+            mood: 'happy',
+            activity: describeToolUse(event.tool_name, event.tool_input, event.cwd),
+        }
+        : claudeTransition(event, previous),
+    deliveryIdentity: (event) => ({
+        source: event['nocvilleHookSource'] === 'third-party' ? 'third-party' : 'native',
+        key: createHash('sha256')
+            .update(JSON.stringify([
+            event.hook_event_name,
+            event['generation_id'],
+            describeToolUse(event.tool_name, event.tool_input, event.cwd),
+        ]))
+            .digest('hex'),
+    }),
+};
+export async function handleCursorHookEvent(config, rawInput, opts = {}, source = 'native') {
+    try {
+        const input = rawInput ?? readStdin();
+        const event = typeof input === 'string' ? JSON.parse(input) : input;
+        if (!event || typeof event !== 'object' || Array.isArray(event))
+            return;
+        await runAgentHook(CURSOR_HOOK_SPEC, config, {
+            ...normalizeCursorEvent(event),
+            nocvilleHookSource: source,
+        }, { minPushGapMs: CURSOR_DEFAULTS.minPushGapMs, ...opts });
+    }
+    catch {
+        /* Hook failures never affect Cursor. */
+    }
+    finally {
+        // A schema-neutral response, including malformed/failed direct invocations.
+        process.stdout.write('{}\n');
+    }
+}
+//# sourceMappingURL=hook-handler.js.map

package/dist/npcs/cursor/index.d.ts

@@ -0,0 +1,18 @@
+import type { NpcConfig } from '../../core/types.js';
+export { CURSOR_DEFAULTS } from './defaults.js';
+export { CURSOR_ADAPTER, cursorServiceId, handleCursorHookEvent } from './hook-handler.js';
+export { setupCursorHooks, uninstallCursorHooks, installCursorHooksInto, CURSOR_HOOK_EVENTS, } from './setup.js';
+export type { CursorSetupOptions } from './setup.js';
+export interface CursorSubcommandOptions {
+    subcommand: string;
+    config: NpcConfig;
+    flags: Record<string, string | boolean>;
+    args?: string[];
+}
+/**
+ * cursor subcommands: setup | uninstall | hook | flush | watchdog | cleanup.
+ * All hooks and detached helpers stay silent.
+ */
+export declare function handleCursorCommand(opts: CursorSubcommandOptions): Promise<void>;
+export { isCursorInvocation, normalizeCursorEvent, CURSOR_TO_CANON } from './normalize.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/npcs/cursor/index.js

@@ -0,0 +1,57 @@
+import { numberFlag, stringFlag } from '../../core/config.js';
+import { readStdin, runFlushCommand } from '../agent-common/hook-runner.js';
+import { runWatchdog } from '../agent-common/watchdog.js';
+import { cleanupSessionStates } from '../agent-common/session.js';
+import { CURSOR_DEFAULTS } from './defaults.js';
+import { CURSOR_ADAPTER, handleCursorHookEvent } from './hook-handler.js';
+import { setupCursorHooks, uninstallCursorHooks } from './setup.js';
+export { CURSOR_DEFAULTS } from './defaults.js';
+export { CURSOR_ADAPTER, cursorServiceId, handleCursorHookEvent } from './hook-handler.js';
+export { setupCursorHooks, uninstallCursorHooks, installCursorHooksInto, CURSOR_HOOK_EVENTS, } from './setup.js';
+/**
+ * cursor subcommands: setup | uninstall | hook | flush | watchdog | cleanup.
+ * All hooks and detached helpers stay silent.
+ */
+export async function handleCursorCommand(opts) {
+    const { subcommand, config, flags } = opts;
+    switch (subcommand) {
+        case 'setup': {
+            if (flags['uninstall']) {
+                uninstallCursorHooks();
+                break;
+            }
+            const ok = setupCursorHooks({
+                apiUrl: stringFlag(flags, 'api-url') ?? process.env['NOCVILLE_API_URL'],
+                apiKey: stringFlag(flags, 'api-key') ?? process.env['NOCVILLE_API_KEY'],
+                map: stringFlag(flags, 'map'),
+                cliPath: process.argv[1],
+            });
+            if (!ok)
+                process.exitCode = 1;
+            break;
+        }
+        case 'uninstall':
+            uninstallCursorHooks();
+            break;
+        case 'hook':
+            await handleCursorHookEvent(config, readStdin(), { mode: 'detach' });
+            break;
+        case 'watchdog':
+            await runWatchdog(CURSOR_ADAPTER, config, opts.args?.[0]);
+            break;
+        case 'flush':
+            await runFlushCommand(CURSOR_ADAPTER, config, opts.args?.[0], numberFlag(flags, 'delay'), flags['stats'] === true);
+            break;
+        case 'cleanup': {
+            const removed = await cleanupSessionStates(CURSOR_DEFAULTS.stateDir, CURSOR_DEFAULTS.stateFileMaxAge);
+            console.log(`Cleanup complete: ${removed} stale file(s) removed`);
+            break;
+        }
+        default:
+            console.error(`Unknown cursor subcommand: ${subcommand}`);
+            console.error('Available subcommands: setup, uninstall, hook, cleanup');
+            process.exitCode = 1;
+    }
+}
+export { isCursorInvocation, normalizeCursorEvent, CURSOR_TO_CANON } from './normalize.js';
+//# sourceMappingURL=index.js.map