@zewstid/zeye-capture 0.2.0

package/dist/src/localHost.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localHostConfigPath = localHostConfigPath;
+exports.localOutboxDirectory = localOutboxDirectory;
+exports.ensurePrivateDirectory = ensurePrivateDirectory;
+exports.readLocalHostConfig = readLocalHostConfig;
+exports.writeLocalHostConfig = writeLocalHostConfig;
+exports.discoverRepositoryIdentity = discoverRepositoryIdentity;
+exports.captureRepositoryReference = captureRepositoryReference;
+exports.captureLockStatus = captureLockStatus;
+exports.acquireCaptureLock = acquireCaptureLock;
+exports.withCaptureLock = withCaptureLock;
+exports.installClaudeHooks = installClaudeHooks;
+exports.uninstallClaudeHooks = uninstallClaudeHooks;
+exports.installCodexSource = installCodexSource;
+exports.uninstallCodexSource = uninstallCodexSource;
+exports.configuredSourcesForRepository = configuredSourcesForRepository;
+const promises_1 = require("node:fs/promises");
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
+const canonical_1 = require("./canonical");
+const execFile = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const ZEYE_HOOK_EVENTS = ['SessionStart', 'SessionEnd', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'PostToolUseFailure', 'SubagentStart', 'SubagentStop', 'PreCompact'];
+const EMPTY_CONFIG = { version: 1, claudeInstalls: [], codexSources: [] };
+function localHostConfigPath(environment = process.env) {
+    const base = environment.XDG_CONFIG_HOME || (0, node_path_1.join)(environment.HOME || (0, node_os_1.homedir)(), '.config');
+    return (0, node_path_1.join)(base, 'zeye-capture', 'host-v1.json');
+}
+function localOutboxDirectory(repositoryRoot, environment = process.env) {
+    const repositoryScope = (0, canonical_1.sha256)({ repositoryRoot: (0, node_path_1.resolve)(repositoryRoot) }).slice(0, 32);
+    // An override is a private *base* directory, not a shared outbox. Keeping a
+    // per-repository scope prevents events from separate checkouts being
+    // replayed under whichever repository is current when sync runs.
+    if (environment.ZEYE_CAPTURE_OUTBOX_DIR?.trim())
+        return (0, node_path_1.join)((0, node_path_1.resolve)(environment.ZEYE_CAPTURE_OUTBOX_DIR), repositoryScope);
+    const base = environment.XDG_STATE_HOME || (0, node_path_1.join)(environment.HOME || (0, node_os_1.homedir)(), '.local', 'state');
+    return (0, node_path_1.join)(base, 'zeye-capture', repositoryScope);
+}
+async function ensurePrivateDirectory(directory) {
+    await (0, promises_1.mkdir)(directory, { recursive: true, mode: 0o700 });
+    // chmod is meaningful on POSIX and harmless on platforms with a different
+    // ACL model. We never weaken an existing directory's mode.
+    await (0, promises_1.chmod)(directory, 0o700).catch(() => undefined);
+}
+async function writePrivateJson(path, value) {
+    await ensurePrivateDirectory((0, node_path_1.dirname)(path));
+    const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+    await (0, promises_1.writeFile)(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await (0, promises_1.rename)(temporary, path);
+    await (0, promises_1.chmod)(path, 0o600).catch(() => undefined);
+}
+async function readJsonObject(path) {
+    try {
+        const raw = await (0, promises_1.readFile)(path, 'utf8');
+        const value = JSON.parse(raw);
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error('expected an object');
+        return value;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw new Error(`Cannot safely read JSON configuration at ${path}: ${error instanceof Error ? error.message : 'invalid JSON'}`);
+    }
+}
+async function readLocalHostConfig(path = localHostConfigPath()) {
+    const value = await readJsonObject(path);
+    if (Object.keys(value).length === 0)
+        return structuredClone(EMPTY_CONFIG);
+    if (value.version !== 1 || !Array.isArray(value.claudeInstalls) || !Array.isArray(value.codexSources))
+        throw new Error(`Unsupported local host configuration at ${path}`);
+    const claudeInstalls = value.claudeInstalls.filter((entry) => Boolean(entry && typeof entry === 'object' && typeof entry.repositoryRoot === 'string' && typeof entry.settingsPath === 'string' && typeof entry.command === 'string'));
+    const codexSources = value.codexSources.filter((entry) => Boolean(entry && typeof entry === 'object' && typeof entry.repositoryRoot === 'string' && typeof entry.jsonlPath === 'string'));
+    return { version: 1, claudeInstalls, codexSources };
+}
+async function writeLocalHostConfig(config, path = localHostConfigPath()) {
+    await writePrivateJson(path, config);
+}
+async function git(repositoryPath, args) {
+    try {
+        const result = await execFile('git', ['-C', repositoryPath, ...args], { maxBuffer: 64 * 1024 });
+        return result.stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseRemoteFullName(remote) {
+    if (!remote)
+        return undefined;
+    const path = /^([^@]+@)?[^:]+:(.+)$/.exec(remote)?.[2]
+        || /^(?:https?|ssh):\/\/(?:[^@/]+@)?[^/]+\/(.+)$/.exec(remote)?.[1];
+    const fullName = path?.replace(/\.git$/i, '').replace(/^\/+|\/+$/g, '');
+    return fullName && /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+$/.test(fullName) ? fullName : undefined;
+}
+async function discoverRepositoryIdentity(repositoryPath, options = {}) {
+    const repositoryRoot = await git(repositoryPath, ['rev-parse', '--show-toplevel']);
+    if (!repositoryRoot)
+        return null;
+    const [remote, branch, headCommitSha] = await Promise.all([
+        git(repositoryRoot, ['config', '--get', 'remote.origin.url']),
+        git(repositoryRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']),
+        git(repositoryRoot, ['rev-parse', 'HEAD']),
+    ]);
+    return {
+        repositoryRoot,
+        fullName: parseRemoteFullName(remote),
+        providerRepositoryId: options.providerRepositoryId?.trim() || undefined,
+        branch: branch || undefined,
+        headCommitSha: headCommitSha && /^[a-f0-9]{7,64}$/i.test(headCommitSha) ? headCommitSha : undefined,
+        remoteUrlHash: remote ? (0, canonical_1.sha256)(remote) : undefined,
+    };
+}
+function captureRepositoryReference(identity, repositoryId) {
+    if (!identity)
+        return [];
+    const reference = {
+        ...(repositoryId?.trim() ? { repositoryId: repositoryId.trim() } : {}),
+        ...(identity.providerRepositoryId ? { providerRepositoryId: identity.providerRepositoryId } : {}),
+        ...(identity.fullName ? { canonicalName: identity.fullName } : {}),
+        ...(identity.remoteUrlHash ? { remoteUrlHash: identity.remoteUrlHash } : {}),
+        ...(identity.branch ? { branch: identity.branch } : {}),
+        ...(identity.headCommitSha ? { headCommitSha: identity.headCommitSha } : {}),
+        isPrimary: true,
+    };
+    // The wire contract accepts a provider ID or a hashed remote even when an
+    // internal Zeye repository mapping is not known locally.
+    return reference.repositoryId || reference.providerRepositoryId || reference.remoteUrlHash ? [reference] : [];
+}
+function lockPath(directory) { return (0, node_path_1.join)(directory, '.capture.lock'); }
+async function captureLockStatus(directory) {
+    try {
+        const raw = await (0, promises_1.readFile)(lockPath(directory), 'utf8');
+        const value = JSON.parse(raw);
+        const pid = typeof value.pid === 'number' && Number.isInteger(value.pid) && value.pid > 0 ? value.pid : undefined;
+        if (!pid)
+            return { held: true, stale: true };
+        try {
+            process.kill(pid, 0);
+            return { held: true, pid };
+        }
+        catch (error) {
+            return { held: true, pid, stale: error.code === 'ESRCH' };
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { held: false };
+        return { held: true, stale: true };
+    }
+}
+function delay(milliseconds) {
+    return new Promise(resolveDelay => setTimeout(resolveDelay, milliseconds));
+}
+async function acquireCaptureLock(directory, options = {}) {
+    await ensurePrivateDirectory(directory);
+    const path = lockPath(directory);
+    const maxWaitMs = options.maxWaitMs ?? 5_000;
+    const initialRetryDelayMs = options.initialRetryDelayMs ?? 25;
+    const maxRetryDelayMs = options.maxRetryDelayMs ?? 500;
+    const deadline = Date.now() + maxWaitMs;
+    let retryDelayMs = initialRetryDelayMs;
+    for (;;) {
+        try {
+            const handle = await (0, promises_1.open)(path, 'wx', 0o600);
+            await handle.writeFile(JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }));
+            await handle.close();
+            return { async release() { await (0, promises_1.rm)(path, { force: true }); } };
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const status = await captureLockStatus(directory);
+            if (status.stale) {
+                await (0, promises_1.rm)(path, { force: true });
+                continue;
+            }
+            if (Date.now() >= deadline)
+                throw new Error(`Capture already running${status.pid ? ` (pid ${status.pid})` : ''}`);
+            await delay(Math.min(retryDelayMs, Math.max(0, deadline - Date.now())));
+            retryDelayMs = Math.min(maxRetryDelayMs, retryDelayMs * 2);
+        }
+    }
+}
+async function withCaptureLock(directory, operation, options) {
+    const lock = await acquireCaptureLock(directory, options);
+    try {
+        return await operation();
+    }
+    finally {
+        await lock.release();
+    }
+}
+async function settingsPathIsTracked(repositoryRoot, settingsPath) {
+    if (!(0, node_path_1.isAbsolute)(settingsPath))
+        return false;
+    const rel = (0, node_path_1.relative)(repositoryRoot, settingsPath);
+    if (!rel || rel.startsWith('..') || (0, node_path_1.isAbsolute)(rel))
+        return false;
+    return Boolean(await git(repositoryRoot, ['ls-files', '--error-unmatch', '--', rel]));
+}
+function zeyeHookGroup(command) {
+    return { matcher: '', hooks: [{ type: 'command', command }] };
+}
+function isZeyeHookGroup(value, command) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const hooks = value.hooks;
+    return Array.isArray(hooks) && hooks.some(hook => Boolean(hook && typeof hook === 'object' && hook.type === 'command' && hook.command === command));
+}
+async function installClaudeHooks(input) {
+    const repositoryRoot = (0, node_path_1.resolve)(input.repositoryRoot);
+    const settingsPath = (0, node_path_1.resolve)(input.settingsPath || (0, node_path_1.join)(repositoryRoot, '.claude', 'settings.local.json'));
+    const command = input.command?.trim() || 'zeye-capture claude-hook';
+    if (await settingsPathIsTracked(repositoryRoot, settingsPath))
+        throw new Error(`Refusing to modify tracked Claude settings: ${settingsPath}. Use an untracked settings.local.json path.`);
+    const settings = await readJsonObject(settingsPath);
+    const hooks = settings.hooks;
+    if (hooks !== undefined && (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)))
+        throw new Error(`Claude settings hooks must be an object: ${settingsPath}`);
+    const hookMap = (hooks || {});
+    const installedEvents = [];
+    for (const event of ZEYE_HOOK_EVENTS) {
+        const groups = hookMap[event];
+        if (groups !== undefined && !Array.isArray(groups))
+            throw new Error(`Claude settings hook ${event} must be an array: ${settingsPath}`);
+        const current = (groups || []);
+        if (!current.some(group => isZeyeHookGroup(group, command))) {
+            hookMap[event] = [...current, zeyeHookGroup(command)];
+            installedEvents.push(event);
+        }
+    }
+    settings.hooks = hookMap;
+    await writePrivateJson(settingsPath, settings);
+    const config = await readLocalHostConfig(input.configPath);
+    config.claudeInstalls = [...config.claudeInstalls.filter(entry => entry.repositoryRoot !== repositoryRoot || entry.settingsPath !== settingsPath), { repositoryRoot, settingsPath, command }];
+    await writeLocalHostConfig(config, input.configPath);
+    return { settingsPath, installedEvents };
+}
+async function uninstallClaudeHooks(input) {
+    const repositoryRoot = (0, node_path_1.resolve)(input.repositoryRoot);
+    const config = await readLocalHostConfig(input.configPath);
+    const existing = config.claudeInstalls.find(entry => entry.repositoryRoot === repositoryRoot && (!input.settingsPath || (0, node_path_1.resolve)(input.settingsPath) === entry.settingsPath));
+    const settingsPath = (0, node_path_1.resolve)(input.settingsPath || existing?.settingsPath || (0, node_path_1.join)(repositoryRoot, '.claude', 'settings.local.json'));
+    const command = input.command?.trim() || existing?.command || 'zeye-capture claude-hook';
+    const settings = await readJsonObject(settingsPath);
+    const hooks = settings.hooks;
+    if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks))
+        return { settingsPath, removedEvents: [] };
+    const hookMap = hooks;
+    const removedEvents = [];
+    for (const event of ZEYE_HOOK_EVENTS) {
+        const groups = hookMap[event];
+        if (!Array.isArray(groups))
+            continue;
+        const next = groups.filter(group => !isZeyeHookGroup(group, command));
+        if (next.length !== groups.length)
+            removedEvents.push(event);
+        if (next.length)
+            hookMap[event] = next;
+        else
+            delete hookMap[event];
+    }
+    settings.hooks = hookMap;
+    await writePrivateJson(settingsPath, settings);
+    config.claudeInstalls = config.claudeInstalls.filter(entry => !(entry.repositoryRoot === repositoryRoot && entry.settingsPath === settingsPath && entry.command === command));
+    await writeLocalHostConfig(config, input.configPath);
+    return { settingsPath, removedEvents };
+}
+async function installCodexSource(input) {
+    const config = await readLocalHostConfig(input.configPath);
+    const source = { repositoryRoot: (0, node_path_1.resolve)(input.repositoryRoot), jsonlPath: (0, node_path_1.resolve)(input.jsonlPath) };
+    config.codexSources = [...config.codexSources.filter(entry => entry.repositoryRoot !== source.repositoryRoot || entry.jsonlPath !== source.jsonlPath), source];
+    await writeLocalHostConfig(config, input.configPath);
+}
+async function uninstallCodexSource(input) {
+    const config = await readLocalHostConfig(input.configPath);
+    const repositoryRoot = (0, node_path_1.resolve)(input.repositoryRoot);
+    const jsonlPath = input.jsonlPath ? (0, node_path_1.resolve)(input.jsonlPath) : undefined;
+    const before = config.codexSources.length;
+    config.codexSources = config.codexSources.filter(entry => entry.repositoryRoot !== repositoryRoot || (jsonlPath !== undefined && entry.jsonlPath !== jsonlPath));
+    await writeLocalHostConfig(config, input.configPath);
+    return before - config.codexSources.length;
+}
+function configuredSourcesForRepository(config, repositoryRoot) {
+    return config.codexSources.filter(source => source.repositoryRoot === (0, node_path_1.resolve)(repositoryRoot));
+}

package/dist/src/providers.d.ts

@@ -0,0 +1,18 @@
+import type { MetadataCaptureEvent } from "./types";
+/** Parse provider-visible Claude transcript JSONL without hidden thinking blocks. */
+export declare function fromClaudeTranscriptJsonl(input: unknown, fallbackSessionId?: string): MetadataCaptureEvent | null;
+/** Parse a Claude Code hook payload without retaining prompt/tool/file content. */
+export declare function fromClaudeCodeHook(input: unknown, captureContent?: boolean): MetadataCaptureEvent | null;
+/**
+ * Parse one JSONL record from Codex local session/rollout logs. The Codex log
+ * format evolves, so unknown record kinds become a safe capture warning rather
+ * than being misrepresented as a complete observation.
+ */
+export declare function fromCodexJsonl(input: unknown, sourceFile?: string, captureContent?: boolean): MetadataCaptureEvent | null;
+/**
+ * Convert a deliberately small event emitted by a VS Code/Copilot companion
+ * extension. This is not a transcript importer: workspace paths, chat text,
+ * tool arguments, file bodies, and authentication state are all excluded at
+ * the extension boundary and again by the outbox redactor.
+ */
+export declare function fromVSCodeCopilotEvent(input: unknown): MetadataCaptureEvent | null;