@zewstid/zeye-capture 0.2.0

package/dist/src/cli.js

@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fileOutbox_1 = require("./fileOutbox");
+const node_path_1 = require("node:path");
+const promises_1 = require("node:fs/promises");
+const host_1 = require("./host");
+const localHost_1 = require("./localHost");
+const providers_1 = require("./providers");
+const redaction_1 = require("./redaction");
+const transport_1 = require("./transport");
+const service_1 = require("./service");
+function required(name) {
+    const value = process.env[name]?.trim();
+    if (!value)
+        throw new Error(`${name} is required`);
+    return value;
+}
+function parseFlags(args) {
+    const positionals = [];
+    const flags = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (!value.startsWith("--")) {
+            positionals.push(value);
+            continue;
+        }
+        const key = value.slice(2);
+        const next = args[index + 1];
+        if (next && !next.startsWith("--")) {
+            flags[key] = next;
+            index += 1;
+        }
+        else
+            flags[key] = true;
+    }
+    return { positionals, flags };
+}
+function optional(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function print(value) {
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function resolveRepository(repoPath) {
+    const identity = await (0, localHost_1.discoverRepositoryIdentity)(repoPath, {
+        providerRepositoryId: process.env.ZEYE_CAPTURE_PROVIDER_REPOSITORY_ID,
+    });
+    if (!identity)
+        throw new Error(`No Git repository found at ${repoPath}. Run this command from a repository or pass --repo PATH.`);
+    return identity;
+}
+function captureContext(identity) {
+    return {
+        repositories: (0, localHost_1.captureRepositoryReference)(identity, process.env.ZEYE_CAPTURE_REPOSITORY_ID),
+    };
+}
+async function runtimeConfig(identity) {
+    const requiredNames = [
+        "ZEYE_CAPTURE_ENDPOINT",
+        "ZEYE_CAPTURE_TOKEN",
+        "ZEYE_CAPTURE_ORGANIZATION_ID",
+        "ZEYE_CAPTURE_INSTALLATION_ID",
+        "ZEYE_CAPTURE_ACTOR_JSON",
+    ];
+    if (requiredNames.every((name) => !process.env[name]))
+        return null;
+    for (const name of requiredNames)
+        required(name);
+    let actor;
+    try {
+        actor = JSON.parse(required("ZEYE_CAPTURE_ACTOR_JSON"));
+    }
+    catch {
+        throw new Error("ZEYE_CAPTURE_ACTOR_JSON must be valid JSON");
+    }
+    const contentConsentId = process.env.ZEYE_CAPTURE_CONTENT_CONSENT_ID?.trim();
+    if (contentConsentId && process.env.ZEYE_CAPTURE_TRANSCRIPT_CONSENT !== "yes")
+        throw new Error("ZEYE_CAPTURE_TRANSCRIPT_CONSENT=yes is required with a content consent ID");
+    return {
+        endpoint: (0, transport_1.validateCaptureEndpoint)(required("ZEYE_CAPTURE_ENDPOINT")),
+        token: required("ZEYE_CAPTURE_TOKEN"),
+        organizationId: required("ZEYE_CAPTURE_ORGANIZATION_ID"),
+        captureInstallationId: required("ZEYE_CAPTURE_INSTALLATION_ID"),
+        actor: actor,
+        privacy: {
+            classification: "INTERNAL",
+            contentMode: contentConsentId ? "REDACTED_CONTENT" : "METADATA_ONLY",
+            redactionApplied: true,
+            retentionClass: "STANDARD",
+            visibility: "ACTOR_ONLY",
+            ...(contentConsentId ? { contentConsentId } : {}),
+        },
+        // This is only a compatibility fallback for records written before capture
+        // context became durable. New records receive repository facts at enqueue.
+        repositories: captureContext(identity).repositories,
+    };
+}
+async function flushIfConfigured(outbox, configuration, adapter) {
+    if (!configuration)
+        return { uploadConfigured: false, delivered: 0, failed: 0, deferred: 0 };
+    const transport = new transport_1.CaptureHttpTransport(outbox, configuration);
+    await transport.publishManifest((0, transport_1.capabilityManifestForAdapter)(adapter, Boolean(configuration.privacy.contentConsentId)));
+    return { uploadConfigured: true, ...(await transport.flush()) };
+}
+async function withRepositoryCapture(identity, operation) {
+    const directory = (0, localHost_1.localOutboxDirectory)(identity.repositoryRoot);
+    const context = captureContext(identity);
+    return (0, localHost_1.withCaptureLock)(directory, async () => {
+        const runtime = await runtimeConfig(identity);
+        return operation(new fileOutbox_1.FileOutbox(directory, runtime?.privacy.contentMode === "REDACTED_CONTENT"
+            ? redaction_1.consentedTranscriptRedactor
+            : redaction_1.metadataRedactor), runtime, context);
+    });
+}
+async function status(repositoryRoot) {
+    const [config, identity] = await Promise.all([
+        (0, localHost_1.readLocalHostConfig)(),
+        resolveRepository(repositoryRoot),
+    ]);
+    const outboxDirectory = (0, localHost_1.localOutboxDirectory)(identity.repositoryRoot);
+    const [records, lock] = await Promise.all([
+        new fileOutbox_1.FileOutbox(outboxDirectory, redaction_1.metadataRedactor).list(),
+        (0, localHost_1.captureLockStatus)(outboxDirectory),
+    ]);
+    const counts = records.reduce((result, record) => {
+        result[record.status] = (result[record.status] || 0) + 1;
+        return result;
+    }, {});
+    const configured = await runtimeConfig(identity);
+    print({
+        repository: {
+            fullName: identity.fullName || null,
+            branch: identity.branch || null,
+            headCommitSha: identity.headCommitSha || null,
+            providerRepositoryId: identity.providerRepositoryId || null,
+        },
+        outbox: {
+            directory: outboxDirectory,
+            records: records.length,
+            counts,
+            lock,
+        },
+        claudeHooksInstalled: config.claudeInstalls.some((entry) => entry.repositoryRoot === identity.repositoryRoot),
+        codexSources: (0, localHost_1.configuredSourcesForRepository)(config, identity.repositoryRoot).map((source) => ({ jsonlPath: source.jsonlPath })),
+        uploadConfigured: Boolean(configured),
+        diagnostics: configured
+            ? []
+            : [
+                "Upload is offline-only until all ZEYE_CAPTURE_* runtime variables are supplied. The token is never stored by this CLI.",
+            ],
+    });
+}
+async function sync(repositoryRoot, exitOnFailure = true) {
+    const identity = await resolveRepository(repositoryRoot);
+    const config = await (0, localHost_1.readLocalHostConfig)();
+    const sources = (0, localHost_1.configuredSourcesForRepository)(config, identity.repositoryRoot);
+    const result = await withRepositoryCapture(identity, async (outbox, runtime, context) => {
+        const imports = [];
+        for (const source of sources) {
+            try {
+                imports.push({
+                    jsonlPath: source.jsonlPath,
+                    ...(await (0, host_1.importCodexJsonl)(outbox, source.jsonlPath, context, runtime?.privacy.contentMode === "REDACTED_CONTENT")),
+                });
+            }
+            catch (error) {
+                imports.push({
+                    jsonlPath: source.jsonlPath,
+                    error: error instanceof Error
+                        ? error.message.replace(source.jsonlPath, "[configured JSONL path]")
+                        : "read_failed",
+                });
+            }
+        }
+        if (!runtime)
+            return {
+                imports,
+                uploadConfigured: false,
+                delivered: 0,
+                failed: 0,
+                deferred: 0,
+                heartbeat: "not_configured",
+            };
+        try {
+            const transport = new transport_1.CaptureHttpTransport(outbox, runtime);
+            await transport.publishManifest((0, transport_1.capabilityManifestForAdapter)("codex", Boolean(runtime.privacy.contentConsentId)));
+            await transport.heartbeat();
+            return {
+                imports,
+                uploadConfigured: true,
+                heartbeat: "sent",
+                ...(await transport.flush()),
+            };
+        }
+        catch (error) {
+            return {
+                imports,
+                uploadConfigured: true,
+                delivered: 0,
+                failed: 1,
+                deferred: 0,
+                heartbeat: "failed",
+                error: error instanceof Error ? error.message : "capture_sync_failed",
+            };
+        }
+    });
+    print(result);
+    if (exitOnFailure &&
+        (result.imports.some((entry) => entry.error) ||
+            result.failed > 0 ||
+            result.deferred > 0 ||
+            result.heartbeat === "failed"))
+        process.exitCode = 1;
+}
+async function heartbeat(repositoryRoot) {
+    const identity = await resolveRepository(repositoryRoot);
+    const result = await withRepositoryCapture(identity, async (outbox, runtime) => {
+        if (!runtime)
+            return {
+                uploadConfigured: false,
+                heartbeat: "not_configured",
+                pending: (await outbox.nextBatch(10_000)).length,
+            };
+        const transport = new transport_1.CaptureHttpTransport(outbox, runtime);
+        await transport.heartbeat();
+        return {
+            uploadConfigured: true,
+            heartbeat: "sent",
+            pending: (await outbox.nextBatch(10_000)).length,
+        };
+    });
+    print(result);
+}
+function usage() {
+    throw new Error("Usage: zeye-capture <install|uninstall|service|status|sync|heartbeat|claude-hook|codex-jsonl|vscode-copilot-event> [claude|codex|install|uninstall] [--repo PATH]");
+}
+function serviceEnrollment(intervalSeconds) {
+    return {
+        endpoint: required("ZEYE_CAPTURE_ENDPOINT"),
+        token: required("ZEYE_CAPTURE_TOKEN"),
+        organizationId: required("ZEYE_CAPTURE_ORGANIZATION_ID"),
+        captureInstallationId: required("ZEYE_CAPTURE_INSTALLATION_ID"),
+        actorJson: required("ZEYE_CAPTURE_ACTOR_JSON"),
+        intervalSeconds,
+        ...(process.env.ZEYE_CAPTURE_CONTENT_CONSENT_ID
+            ? {
+                contentConsentId: required("ZEYE_CAPTURE_CONTENT_CONSENT_ID"),
+                transcriptConsent: "yes",
+            }
+            : {}),
+    };
+}
+async function runService(repositoryRoot, configPath) {
+    const enrollment = await (0, service_1.readServiceEnrollment)(configPath);
+    (0, service_1.applyServiceEnrollment)(enrollment);
+    let stopping = false;
+    process.once("SIGINT", () => {
+        stopping = true;
+    });
+    process.once("SIGTERM", () => {
+        stopping = true;
+    });
+    while (!stopping) {
+        await sync(repositoryRoot, false);
+        if (stopping)
+            break;
+        await new Promise((resolveWait) => setTimeout(resolveWait, enrollment.intervalSeconds * 1000));
+    }
+}
+async function main() {
+    const { positionals, flags } = parseFlags(process.argv.slice(2));
+    const command = positionals.shift();
+    const repoPath = optional(flags, "repo") || process.cwd();
+    if (command === "service-run") {
+        const configPath = optional(flags, "config");
+        if (!configPath)
+            throw new Error("Service configuration is required");
+        await runService(repoPath, configPath);
+        return;
+    }
+    if (command === "service") {
+        const action = positionals.shift();
+        const identity = await resolveRepository(repoPath);
+        if (action === "install") {
+            const intervalSeconds = Number(optional(flags, "interval") || "60");
+            if (!Number.isInteger(intervalSeconds) ||
+                intervalSeconds < 15 ||
+                intervalSeconds > 3600)
+                throw new Error("--interval must be between 15 and 3600 seconds");
+            if (process.env.ZEYE_CAPTURE_CONTENT_CONSENT_ID &&
+                process.env.ZEYE_CAPTURE_TRANSCRIPT_CONSENT !== "yes")
+                throw new Error("Transcript service installation requires ZEYE_CAPTURE_TRANSCRIPT_CONSENT=yes");
+            const files = await (0, service_1.installCaptureService)({
+                repositoryRoot: identity.repositoryRoot,
+                enrollment: serviceEnrollment(intervalSeconds),
+                cliPath: (0, node_path_1.resolve)(process.argv[1]),
+            });
+            print({
+                installed: true,
+                service: files.serviceId,
+                kind: files.kind,
+                intervalSeconds,
+                transcriptCapture: Boolean(process.env.ZEYE_CAPTURE_CONTENT_CONSENT_ID),
+            });
+            return;
+        }
+        if (action === "uninstall") {
+            const files = await (0, service_1.uninstallCaptureService)(identity.repositoryRoot);
+            print({
+                uninstalled: true,
+                service: files.serviceId,
+                credentialsRemoved: true,
+            });
+            return;
+        }
+        throw new Error("Usage: zeye-capture service <install|uninstall> [--repo PATH] [--interval SECONDS]");
+    }
+    if (command === "install") {
+        const target = positionals.shift();
+        const identity = await resolveRepository(repoPath);
+        if (target === "claude") {
+            const result = await (0, localHost_1.installClaudeHooks)({
+                repositoryRoot: identity.repositoryRoot,
+                settingsPath: optional(flags, "settings"),
+                command: optional(flags, "command"),
+            });
+            print({
+                installed: "claude",
+                ...result,
+                outboxDirectory: (0, localHost_1.localOutboxDirectory)(identity.repositoryRoot),
+            });
+            return;
+        }
+        if (target === "codex") {
+            const jsonlPath = optional(flags, "jsonl");
+            if (!jsonlPath)
+                throw new Error("Usage: zeye-capture install codex --jsonl PATH [--repo PATH]");
+            await (0, localHost_1.installCodexSource)({
+                repositoryRoot: identity.repositoryRoot,
+                jsonlPath,
+            });
+            print({
+                installed: "codex",
+                jsonlPath,
+                syncCommand: "zeye-capture sync",
+            });
+            return;
+        }
+        usage();
+    }
+    if (command === "uninstall") {
+        const target = positionals.shift();
+        const identity = await resolveRepository(repoPath);
+        if (target === "claude") {
+            print({
+                uninstalled: "claude",
+                ...(await (0, localHost_1.uninstallClaudeHooks)({
+                    repositoryRoot: identity.repositoryRoot,
+                    settingsPath: optional(flags, "settings"),
+                    command: optional(flags, "command"),
+                })),
+            });
+            return;
+        }
+        if (target === "codex") {
+            print({
+                uninstalled: "codex",
+                removedSources: await (0, localHost_1.uninstallCodexSource)({
+                    repositoryRoot: identity.repositoryRoot,
+                    jsonlPath: optional(flags, "jsonl"),
+                }),
+            });
+            return;
+        }
+        usage();
+    }
+    if (command === "status") {
+        await status(repoPath);
+        return;
+    }
+    if (command === "sync") {
+        await sync(repoPath);
+        return;
+    }
+    if (command === "heartbeat") {
+        await heartbeat(repoPath);
+        return;
+    }
+    const identity = await resolveRepository(repoPath);
+    if (command === "claude-hook") {
+        const source = await readStdin();
+        const hookPayload = JSON.parse(source);
+        print(await withRepositoryCapture(identity, async (outbox, runtime, context) => {
+            const capturesContent = runtime?.privacy.contentMode === "REDACTED_CONTENT";
+            const transcriptPath = typeof hookPayload.transcript_path === "string"
+                ? hookPayload.transcript_path
+                : typeof hookPayload.transcriptPath === "string"
+                    ? hookPayload.transcriptPath
+                    : undefined;
+            let transcriptImported = 0;
+            let transcriptSkipped = 0;
+            if (capturesContent && transcriptPath) {
+                const rawTranscript = await (0, promises_1.readFile)(transcriptPath, "utf8");
+                for (const line of rawTranscript.split(/\r?\n/).filter(Boolean)) {
+                    try {
+                        const observation = (0, providers_1.fromClaudeTranscriptJsonl)(JSON.parse(line), typeof hookPayload.session_id === "string"
+                            ? hookPayload.session_id
+                            : undefined);
+                        if (!observation) {
+                            transcriptSkipped += 1;
+                            continue;
+                        }
+                        const result = await outbox.enqueue(observation, context);
+                        if (result.status === "ENQUEUED")
+                            transcriptImported += 1;
+                        else
+                            transcriptSkipped += 1;
+                    }
+                    catch {
+                        transcriptSkipped += 1;
+                    }
+                }
+            }
+            const event = (0, providers_1.fromClaudeCodeHook)(hookPayload, capturesContent && !transcriptPath);
+            if (event)
+                await outbox.enqueue(event, context);
+            return {
+                transcriptImported,
+                transcriptSkipped,
+                ...(await flushIfConfigured(outbox, runtime, "claude-code")),
+            };
+        }));
+        return;
+    }
+    if (command === "codex-jsonl") {
+        const filePath = positionals.shift();
+        if (!filePath)
+            throw new Error("Usage: zeye-capture codex-jsonl PATH [--repo PATH]");
+        print(await withRepositoryCapture(identity, async (outbox, runtime, context) => ({
+            ...(await (0, host_1.importCodexJsonl)(outbox, filePath, context, runtime?.privacy.contentMode === "REDACTED_CONTENT")),
+            ...(await flushIfConfigured(outbox, runtime, "codex")),
+        })));
+        return;
+    }
+    if (command === "vscode-copilot-event") {
+        const source = await readStdin();
+        print(await withRepositoryCapture(identity, async (outbox, runtime, context) => {
+            const event = (0, providers_1.fromVSCodeCopilotEvent)(JSON.parse(source));
+            if (event)
+                await outbox.enqueue(event, context);
+            return flushIfConfigured(outbox, runtime, "vscode-copilot");
+        }));
+        return;
+    }
+    usage();
+}
+main().catch((error) => {
+    // Never print event payloads, paths, source records, actor metadata, or
+    // enrollment tokens. Details are deliberately safe enough for hook stderr.
+    process.stderr.write(`Zeye capture failed: ${error instanceof Error ? error.message.replace(/zem_[A-Za-z0-9_-]+/g, "[REDACTED]") : "unknown error"}\n`);
+    process.exitCode = 1;
+});

package/dist/src/fileOutbox.d.ts

@@ -0,0 +1,22 @@
+import type { CaptureEvent, CaptureDeliveryContext, DeliveryRecord, DurableOutbox, EnqueueResult, RedactionBoundary, SourceCheckpoint } from './types';
+export declare class FileOutbox implements DurableOutbox {
+    private readonly redactor;
+    private readonly statePath;
+    private writeQueue;
+    constructor(directory: string, redactor: RedactionBoundary);
+    enqueue(event: CaptureEvent, context?: CaptureDeliveryContext): Promise<EnqueueResult>;
+    nextBatch(limit: number): Promise<DeliveryRecord[]>;
+    markAttempt(deliveryId: string, error?: string): Promise<DeliveryRecord>;
+    acknowledge(deliveryId: string, receiptId: string): Promise<DeliveryRecord>;
+    checkpoint(adapter: string, scope: string, cursor: string): Promise<SourceCheckpoint>;
+    getCheckpoint(adapter: string, scope: string): Promise<SourceCheckpoint | undefined>;
+    list(): Promise<DeliveryRecord[]>;
+    private read;
+    private update;
+    private readState;
+    private writeState;
+    private sourceKey;
+    private checkpointKey;
+    private requireDelivery;
+    private validateEvent;
+}