@zewstid/zeye-capture 0.2.0

package/dist/src/providers.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromClaudeTranscriptJsonl = fromClaudeTranscriptJsonl;
+exports.fromClaudeCodeHook = fromClaudeCodeHook;
+exports.fromCodexJsonl = fromCodexJsonl;
+exports.fromVSCodeCopilotEvent = fromVSCodeCopilotEvent;
+const node_crypto_1 = require("node:crypto");
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function string(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function timestamp(value) {
+    const parsed = typeof value === "string" ? Date.parse(value) : Number.NaN;
+    return Number.isNaN(parsed)
+        ? new Date().toISOString()
+        : new Date(parsed).toISOString();
+}
+function opaqueId(value, fallback) {
+    const candidate = string(value);
+    return (candidate ||
+        (0, node_crypto_1.createHash)("sha256").update(fallback).digest("hex").slice(0, 32));
+}
+const relationships = new Set([
+    "ROOT",
+    "RESUMED_FROM",
+    "FORKED_FROM",
+    "SUBAGENT_OF",
+    "CONTINUATION_OF",
+]);
+function relationship(value, inferred, parent) {
+    const explicit = string(value)?.toUpperCase();
+    const candidate = explicit && relationships.has(explicit)
+        ? explicit
+        : inferred;
+    // The capture contract correctly rejects a non-root lineage without its
+    // parent. Do not publish a false relationship merely because an adapter saw
+    // a lifecycle label; retain ROOT until the provider supplies the parent.
+    return candidate !== "ROOT" && !parent ? "ROOT" : candidate;
+}
+function generation(record, payload) {
+    return (string(record.source_generation_id) ||
+        string(record.sourceGenerationId) ||
+        string(record.session_generation_id) ||
+        string(record.sessionGenerationId) ||
+        string(payload.source_generation_id) ||
+        string(payload.sourceGenerationId) ||
+        string(payload.session_generation_id) ||
+        string(payload.sessionGenerationId));
+}
+function usagePayload(value) {
+    const usage = {};
+    const aliases = {
+        inputTokens: ["inputTokens", "input_tokens"],
+        outputTokens: ["outputTokens", "output_tokens"],
+        cachedInputTokens: ["cachedInputTokens", "cached_input_tokens"],
+        reasoningTokens: ["reasoningTokens", "reasoning_tokens"],
+        costMicros: ["costMicros", "cost_micros"],
+    };
+    for (const [target, keys] of Object.entries(aliases)) {
+        const number = keys
+            .map((key) => value[key])
+            .find((candidate) => typeof candidate === "number");
+        if (typeof number === "number" &&
+            Number.isSafeInteger(number) &&
+            number >= 0)
+            usage[target] = number;
+    }
+    const model = string(value.model);
+    if (model && /^[a-zA-Z0-9._:/-]{1,100}$/.test(model))
+        usage.model = model;
+    return usage;
+}
+function textParts(value) {
+    if (typeof value === "string")
+        return value.trim() || undefined;
+    if (!Array.isArray(value))
+        return undefined;
+    const parts = value.flatMap((item) => {
+        const record = asRecord(item);
+        const text = string(record.text) || string(record.content) || string(record.output);
+        return text ? [text] : [];
+    });
+    return parts.length ? parts.join("\n") : undefined;
+}
+function transcript(kind, text, input) {
+    return text
+        ? {
+            kind,
+            text,
+            ...(string(input.id) ? { providerMessageId: string(input.id) } : {}),
+            ...(input.toolName ? { toolName: input.toolName } : {}),
+        }
+        : undefined;
+}
+function claudeVisibleContent(value) {
+    if (typeof value === "string")
+        return value.trim() || undefined;
+    if (!Array.isArray(value))
+        return undefined;
+    const visible = value.flatMap((item) => {
+        const block = asRecord(item);
+        const type = string(block.type);
+        if (type === "text")
+            return string(block.text) ? [string(block.text)] : [];
+        if (type === "tool_use")
+            return [`Tool ${string(block.name) || "unknown"} input:\n${JSON.stringify(block.input ?? {})}`];
+        if (type === "tool_result")
+            return [`Tool result:\n${textParts(block.content) || string(block.content) || ""}`];
+        // Thinking/signature and provider-private blocks are deliberately excluded.
+        return [];
+    });
+    return visible.length ? visible.join("\n\n") : undefined;
+}
+/** Parse provider-visible Claude transcript JSONL without hidden thinking blocks. */
+function fromClaudeTranscriptJsonl(input, fallbackSessionId) {
+    const record = asRecord(input);
+    const message = asRecord(record.message);
+    const role = string(message.role) || string(record.type);
+    const sessionId = string(record.sessionId) || string(record.session_id) || fallbackSessionId;
+    if (!sessionId ||
+        (role !== "user" && role !== "assistant" && role !== "system"))
+        return null;
+    const visibleText = claudeVisibleContent(message.content ?? record.content);
+    if (!visibleText)
+        return null;
+    const id = record.uuid || message.id || record.id;
+    return {
+        adapter: "claude-code",
+        provider: "claude_code",
+        clientName: "Claude Code",
+        sessionId,
+        sourceEventId: opaqueId(id, `${sessionId}:${record.timestamp || ""}:${role}:${visibleText}`),
+        occurredAt: timestamp(record.timestamp),
+        type: "message.recorded",
+        payload: { transcriptRecord: true, role },
+        transcript: transcript(role === "assistant"
+            ? "ASSISTANT_MESSAGE"
+            : role === "system"
+                ? "SYSTEM_MESSAGE"
+                : "USER_MESSAGE", visibleText, { id }),
+    };
+}
+/** Parse a Claude Code hook payload without retaining prompt/tool/file content. */
+function fromClaudeCodeHook(input, captureContent = false) {
+    const record = asRecord(input);
+    const hook = string(record.hook_event_name) || string(record.hookEventName);
+    const sessionId = string(record.session_id) || string(record.sessionId);
+    if (!hook || !sessionId)
+        return null;
+    const eventType = {
+        SessionStart: "session.started",
+        SessionEnd: "session.ended",
+        UserPromptSubmit: "message.recorded",
+        PreToolUse: "tool.started",
+        PostToolUse: "tool.completed",
+        PostToolUseFailure: "tool.completed",
+        SubagentStart: "subagent.started",
+        SubagentStop: "subagent.ended",
+        PreCompact: "session.compacted",
+    };
+    const type = eventType[hook] || "capture.warning";
+    const toolName = string(record.tool_name) || string(record.toolName);
+    const path = string(record.cwd);
+    const parent = string(record.parent_session_id) || string(record.parentSessionId);
+    const rawToolInput = record.tool_input ?? record.toolInput;
+    const visibleText = hook === "UserPromptSubmit"
+        ? string(record.prompt)
+        : hook === "PreToolUse" && rawToolInput !== undefined
+            ? typeof rawToolInput === "string"
+                ? rawToolInput
+                : JSON.stringify(rawToolInput)
+            : hook === "PostToolUse" || hook === "PostToolUseFailure"
+                ? textParts(record.tool_response ?? record.toolResponse)
+                : undefined;
+    const visibleKind = hook === "UserPromptSubmit"
+        ? "USER_MESSAGE"
+        : hook === "PreToolUse"
+            ? "TOOL_INPUT"
+            : hook === "PostToolUse" || hook === "PostToolUseFailure"
+                ? "TOOL_OUTPUT"
+                : undefined;
+    return {
+        adapter: "claude-code",
+        provider: "claude_code",
+        clientName: "Claude Code",
+        clientVersion: string(record.client_version) || string(record.clientVersion),
+        sessionId,
+        sourceEventId: opaqueId(record.event_id, `${sessionId}:${hook}:${record.timestamp || ""}`),
+        occurredAt: timestamp(record.timestamp),
+        type,
+        payload: {
+            hook,
+            ...(toolName ? { toolName } : {}),
+            // CWD presence is useful coverage metadata; do not retain the path.
+            workingDirectoryPresent: Boolean(path),
+            toolFailure: hook === "PostToolUseFailure",
+        },
+        sourceGenerationId: generation(record, {}),
+        relationship: relationship(record.relationship || record.session_relationship, hook === "SubagentStart" || hook === "SubagentStop"
+            ? "SUBAGENT_OF"
+            : "ROOT", parent),
+        relatedSourceSessionId: parent,
+        ...(captureContent && visibleKind && visibleText
+            ? {
+                transcript: transcript(visibleKind, visibleText, {
+                    id: record.event_id,
+                    toolName,
+                }),
+            }
+            : {}),
+    };
+}
+/**
+ * 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.
+ */
+function fromCodexJsonl(input, sourceFile = "session.jsonl", captureContent = false) {
+    const record = asRecord(input);
+    const payload = asRecord(record.payload);
+    const sourceSessionId = string(record.session_id) ||
+        string(record.sessionId) ||
+        string(payload.session_id) ||
+        string(payload.sessionId);
+    if (!sourceSessionId)
+        return null;
+    const kind = string(record.type) || string(record.kind) || "unknown";
+    const eventName = string(payload.type) || string(payload.event) || kind;
+    let type = "capture.warning";
+    if (kind === "session_meta" ||
+        eventName === "session_started" ||
+        eventName === "task_started")
+        type = "session.started";
+    else if (eventName === "session_resumed")
+        type = "session.resumed";
+    else if (eventName === "session_forked")
+        type = "session.forked";
+    else if (eventName === "context_compacted" || eventName === "compaction")
+        type = "session.compacted";
+    else if (eventName === "task_complete" || eventName === "session_ended")
+        type = "session.ended";
+    else if (kind === "response_item" &&
+        (string(payload.type) === "function_call" ||
+            string(payload.item_type) === "function_call"))
+        type = "tool.started";
+    else if (kind === "response_item" &&
+        (string(payload.type) === "function_call_output" ||
+            string(payload.item_type) === "function_call_output"))
+        type = "tool.completed";
+    else if (eventName === "subagent_started")
+        type = "subagent.started";
+    else if (eventName === "subagent_ended")
+        type = "subagent.ended";
+    else if (kind === "response_item" && string(payload.type) === "message")
+        type = "message.recorded";
+    else if (eventName === "user_message" || eventName === "agent_message")
+        type = "message.recorded";
+    else if (eventName === "usage" || eventName === "usage_recorded")
+        type = "usage.recorded";
+    const lineId = string(record.id) ||
+        string(payload.id) ||
+        `${sourceFile}:${kind}:${record.timestamp || ""}:${eventName}`;
+    const parent = string(payload.parent_session_id) ||
+        string(payload.parentSessionId) ||
+        string(record.parent_session_id) ||
+        string(record.parentSessionId);
+    const role = string(payload.role);
+    const messageText = textParts(payload.content) ||
+        string(payload.message) ||
+        string(payload.text);
+    const toolName = string(payload.name) || string(payload.tool_name);
+    const toolInput = string(payload.arguments) ||
+        (payload.arguments && typeof payload.arguments === "object"
+            ? JSON.stringify(payload.arguments)
+            : undefined);
+    const toolOutput = textParts(payload.output) || string(payload.result);
+    const visible = type === "message.recorded"
+        ? transcript(role === "assistant" || eventName === "agent_message"
+            ? "ASSISTANT_MESSAGE"
+            : role === "system"
+                ? "SYSTEM_MESSAGE"
+                : "USER_MESSAGE", messageText, { id: payload.id || record.id })
+        : type === "tool.started"
+            ? transcript("TOOL_INPUT", toolInput, {
+                id: payload.call_id || payload.id,
+                toolName,
+            })
+            : type === "tool.completed"
+                ? transcript("TOOL_OUTPUT", toolOutput, {
+                    id: payload.call_id || payload.id,
+                    toolName,
+                })
+                : undefined;
+    return {
+        adapter: "codex",
+        provider: "codex",
+        clientName: "Codex",
+        clientVersion: string(record.client_version) || string(record.clientVersion),
+        sessionId: sourceSessionId,
+        sourceEventId: opaqueId(lineId, sourceSessionId),
+        occurredAt: timestamp(record.timestamp || payload.timestamp),
+        type,
+        payload: {
+            recordKind: kind,
+            eventName,
+            sourceFilePresent: Boolean(sourceFile),
+            ...usagePayload(payload),
+        },
+        sourceGenerationId: generation(record, payload),
+        relationship: relationship(payload.relationship ||
+            payload.session_relationship ||
+            record.relationship ||
+            record.session_relationship, eventName === "subagent_started" || eventName === "subagent_ended"
+            ? "SUBAGENT_OF"
+            : eventName === "session_resumed"
+                ? "RESUMED_FROM"
+                : eventName === "session_forked"
+                    ? "FORKED_FROM"
+                    : "ROOT", parent),
+        relatedSourceSessionId: parent,
+        ...(captureContent && visible ? { transcript: visible } : {}),
+    };
+}
+/**
+ * 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.
+ */
+function fromVSCodeCopilotEvent(input) {
+    const record = asRecord(input);
+    const sessionId = string(record.sessionId) || string(record.session_id);
+    const eventName = string(record.event) || string(record.type) || string(record.kind);
+    if (!sessionId || !eventName)
+        return null;
+    const eventType = {
+        "session.started": "session.started",
+        "session.resumed": "session.resumed",
+        "session.ended": "session.ended",
+        "session.compacted": "session.compacted",
+        "chat.request.started": "message.recorded",
+        "chat.request.completed": "message.recorded",
+        "tool.started": "tool.started",
+        "tool.completed": "tool.completed",
+        "file.changed": "file.changed",
+        "git.observed": "git.observed",
+        "usage.recorded": "usage.recorded",
+        "subagent.started": "subagent.started",
+        "subagent.ended": "subagent.ended",
+    };
+    const type = eventType[eventName] || "capture.warning";
+    const toolName = string(record.toolName) || string(record.tool_name);
+    const parent = string(record.parentSessionId) || string(record.parent_session_id);
+    return {
+        adapter: "vscode-copilot",
+        provider: "github_copilot",
+        clientName: "VS Code / GitHub Copilot",
+        clientVersion: string(record.extensionVersion) || string(record.extension_version),
+        sessionId,
+        sourceEventId: opaqueId(record.eventId || record.event_id, `${sessionId}:${eventName}:${record.timestamp || ""}`),
+        occurredAt: timestamp(record.timestamp || record.occurredAt),
+        type,
+        payload: {
+            eventName,
+            ...(toolName ? { toolName } : {}),
+            workspacePresent: Boolean(string(record.workspaceUri) || string(record.workspace_uri)),
+            ...usagePayload(record),
+        },
+        sourceGenerationId: generation(record, {}),
+        relationship: relationship(record.relationship || record.sessionRelationship, eventName === "subagent.started" || eventName === "subagent.ended"
+            ? "SUBAGENT_OF"
+            : eventName === "session.resumed"
+                ? "RESUMED_FROM"
+                : "ROOT", parent),
+        relatedSourceSessionId: parent,
+    };
+}

package/dist/src/redaction.d.ts

@@ -0,0 +1,7 @@
+import type { RedactionBoundary } from './types';
+export declare const metadataRedactor: RedactionBoundary;
+export declare function redactTranscriptText(text: string): {
+    text: string;
+    redactionCount: number;
+};
+export declare const consentedTranscriptRedactor: RedactionBoundary;

package/dist/src/redaction.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consentedTranscriptRedactor = exports.metadataRedactor = void 0;
+exports.redactTranscriptText = redactTranscriptText;
+// A deny-first metadata boundary. Provider adapters should not emit content in
+// the first place; this boundary protects the durable queue if a future adapter
+// accidentally includes a conventional content field.
+const BLOCKED_KEY = /(?:prompt|message|content|transcript|command|argument|environment|secret|token|password|authorization|cookie)/i;
+const SAFE_USAGE_NUMBER_KEY = /^(?:inputTokens|outputTokens|cachedInputTokens|reasoningTokens|costMicros)$/;
+function redact(value, key) {
+    if (key && SAFE_USAGE_NUMBER_KEY.test(key) && typeof value === 'number' && Number.isSafeInteger(value) && value >= 0)
+        return { value, count: 0 };
+    if (key && BLOCKED_KEY.test(key))
+        return { value: '[REDACTED]', count: 1 };
+    if (value === null || typeof value === 'boolean' || typeof value === 'number')
+        return { value, count: 0 };
+    if (typeof value === 'string')
+        return { value: value.slice(0, 500), count: value.length > 500 ? 1 : 0 };
+    if (Array.isArray(value)) {
+        return value.reduce((result, item) => {
+            const nested = redact(item);
+            result.value.push(nested.value);
+            result.count += nested.count;
+            return result;
+        }, { value: [], count: 0 });
+    }
+    if (value && typeof value === 'object') {
+        return Object.entries(value).reduce((result, [nestedKey, nestedValue]) => {
+            const nested = redact(nestedValue, nestedKey);
+            result.value[nestedKey] = nested.value;
+            result.count += nested.count;
+            return result;
+        }, { value: {}, count: 0 });
+    }
+    return { value: '[REDACTED]', count: 1 };
+}
+exports.metadataRedactor = {
+    redact(event) {
+        const result = redact(event.payload);
+        return {
+            payload: result.value,
+            redactionCount: result.count,
+            redactionReasons: result.count ? ['content_or_sensitive_field'] : [],
+        };
+    },
+};
+const TRANSCRIPT_REDACTION_POLICY_VERSION = 'zeye-secrets-v1';
+const SECRET_PATTERNS = [
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, '[REDACTED_PRIVATE_KEY]'],
+    [/\b(?:sk(?:[-_]proj)?[-_]|zmp_|zem_|ghp_|github_pat_)[A-Za-z0-9_-]{16,}\b/g, '[REDACTED_TOKEN]'],
+    [/\b(?:authorization|api[_-]?key|access[_-]?token|password|secret)\s*[:=]\s*(?:Bearer\s+)?[^\s,;]{6,}/gi, '$1=[REDACTED]'],
+    [/\b[A-Za-z0-9+/]{40,}={0,2}\b/g, '[REDACTED_HIGH_ENTROPY_VALUE]'],
+];
+function redactTranscriptText(text) {
+    let output = text;
+    let redactionCount = 0;
+    for (const [pattern, replacement] of SECRET_PATTERNS) {
+        output = output.replace(pattern, match => { redactionCount += 1; return replacement.replace('$1', match.split(/[:=]/, 1)[0] || 'secret'); });
+    }
+    return { text: output.slice(0, 262_144), redactionCount: redactionCount + (output.length > 262_144 ? 1 : 0) };
+}
+exports.consentedTranscriptRedactor = {
+    redact(event) {
+        const metadata = exports.metadataRedactor.redact(event);
+        if (!event.transcript)
+            return metadata;
+        const redacted = redactTranscriptText(event.transcript.text);
+        return {
+            ...metadata,
+            transcript: {
+                ...event.transcript,
+                text: redacted.text,
+                redactionCount: redacted.redactionCount,
+                redactionPolicyVersion: TRANSCRIPT_REDACTION_POLICY_VERSION,
+            },
+            redactionCount: metadata.redactionCount + redacted.redactionCount,
+            redactionReasons: [...(metadata.redactionReasons || []), ...(redacted.redactionCount ? ['transcript_secret'] : [])],
+        };
+    },
+};

package/dist/src/service.d.ts

@@ -0,0 +1,28 @@
+export type ServiceEnrollment = {
+    endpoint: string;
+    token: string;
+    organizationId: string;
+    captureInstallationId: string;
+    actorJson: string;
+    contentConsentId?: string;
+    transcriptConsent?: 'yes';
+    intervalSeconds: number;
+};
+export type ServiceFiles = {
+    serviceId: string;
+    enrollmentPath: string;
+    definitionPath: string;
+    kind: 'launchd' | 'systemd' | 'windows-task';
+};
+export declare function serviceFiles(repositoryRoot: string, environment?: NodeJS.ProcessEnv, os?: NodeJS.Platform): ServiceFiles;
+export declare function serviceDefinition(files: ServiceFiles, repositoryRoot: string, nodePath: string, cliPath: string): string;
+export declare function installCaptureService(input: {
+    repositoryRoot: string;
+    enrollment: ServiceEnrollment;
+    cliPath: string;
+    nodePath?: string;
+    os?: NodeJS.Platform;
+}): Promise<ServiceFiles>;
+export declare function uninstallCaptureService(repositoryRoot: string, os?: NodeJS.Platform): Promise<ServiceFiles>;
+export declare function readServiceEnrollment(path: string): Promise<ServiceEnrollment>;
+export declare function applyServiceEnrollment(enrollment: ServiceEnrollment): void;

package/dist/src/service.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceFiles = serviceFiles;
+exports.serviceDefinition = serviceDefinition;
+exports.installCaptureService = installCaptureService;
+exports.uninstallCaptureService = uninstallCaptureService;
+exports.readServiceEnrollment = readServiceEnrollment;
+exports.applyServiceEnrollment = applyServiceEnrollment;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+function idFor(repositoryRoot) { return (0, node_crypto_1.createHash)('sha256').update(repositoryRoot).digest('hex').slice(0, 16); }
+function xml(value) { return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;'); }
+function systemd(value) { return `"${value.replace(/([\\"])/g, '\\$1')}"`; }
+function serviceFiles(repositoryRoot, environment = process.env, os = (0, node_os_1.platform)()) {
+    const serviceId = `com.zewst.zeye-capture.${idFor(repositoryRoot)}`;
+    const configHome = environment.XDG_CONFIG_HOME || (os === 'win32' ? environment.APPDATA : undefined) || (0, node_path_1.join)((0, node_os_1.homedir)(), '.config');
+    const enrollmentPath = (0, node_path_1.join)(configHome, 'zeye-capture', 'services', `${serviceId}.json`);
+    if (os === 'darwin')
+        return { serviceId, enrollmentPath, definitionPath: (0, node_path_1.join)((0, node_os_1.homedir)(), 'Library', 'LaunchAgents', `${serviceId}.plist`), kind: 'launchd' };
+    if (os === 'win32')
+        return { serviceId, enrollmentPath, definitionPath: (0, node_path_1.join)(configHome, 'zeye-capture', 'services', `${serviceId}.cmd`), kind: 'windows-task' };
+    return { serviceId, enrollmentPath, definitionPath: (0, node_path_1.join)(configHome, 'systemd', 'user', `${serviceId}.service`), kind: 'systemd' };
+}
+function serviceDefinition(files, repositoryRoot, nodePath, cliPath) {
+    if (files.kind === 'launchd')
+        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>${xml(files.serviceId)}</string>
+<key>ProgramArguments</key><array><string>${xml(nodePath)}</string><string>${xml(cliPath)}</string><string>service-run</string><string>--repo</string><string>${xml(repositoryRoot)}</string><string>--config</string><string>${xml(files.enrollmentPath)}</string></array>
+<key>RunAtLoad</key><true/><key>KeepAlive</key><true/><key>ProcessType</key><string>Background</string>
+</dict></plist>
+`;
+    if (files.kind === 'systemd')
+        return `[Unit]
+Description=Zeye Engineering Memory continuous capture for ${repositoryRoot.replace(/\n/g, ' ')}
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${systemd(nodePath)} ${systemd(cliPath)} service-run --repo ${systemd(repositoryRoot)} --config ${systemd(files.enrollmentPath)}
+Restart=always
+RestartSec=15
+NoNewPrivileges=true
+PrivateTmp=true
+
+[Install]
+WantedBy=default.target
+`;
+    return `@echo off\r\n"${nodePath.replace(/"/g, '""')}" "${cliPath.replace(/"/g, '""')}" service-run --repo "${repositoryRoot.replace(/"/g, '""')}" --config "${files.enrollmentPath.replace(/"/g, '""')}"\r\n`;
+}
+async function run(command, args) {
+    await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, { stdio: 'ignore', shell: false });
+        child.once('error', reject);
+        child.once('exit', code => code === 0 ? resolve() : reject(new Error(`${command} exited with status ${code}`)));
+    });
+}
+async function installCaptureService(input) {
+    const os = input.os || (0, node_os_1.platform)();
+    const files = serviceFiles(input.repositoryRoot, process.env, os);
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(files.enrollmentPath), { recursive: true, mode: 0o700 });
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(files.definitionPath), { recursive: true, mode: 0o700 });
+    await (0, promises_1.writeFile)(files.enrollmentPath, `${JSON.stringify(input.enrollment)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await (0, promises_1.writeFile)(files.definitionPath, serviceDefinition(files, input.repositoryRoot, input.nodePath || process.execPath, input.cliPath), { encoding: 'utf8', mode: 0o600 });
+    if (os === 'darwin') {
+        const domain = `gui/${process.getuid?.()}`;
+        await run('launchctl', ['bootout', domain, files.definitionPath]).catch(() => undefined);
+        await run('launchctl', ['bootstrap', domain, files.definitionPath]);
+        await run('launchctl', ['kickstart', '-k', `${domain}/${files.serviceId}`]);
+    }
+    else if (os === 'win32') {
+        await run('icacls', [files.enrollmentPath, '/inheritance:r', '/grant:r', `${process.env.USERNAME}:(F)`]);
+        await run('schtasks', ['/Create', '/F', '/SC', 'ONLOGON', '/TN', files.serviceId, '/TR', files.definitionPath]);
+        await run('schtasks', ['/Run', '/TN', files.serviceId]);
+    }
+    else {
+        await run('systemctl', ['--user', 'daemon-reload']);
+        await run('systemctl', ['--user', 'enable', '--now', files.serviceId]);
+    }
+    return files;
+}
+async function uninstallCaptureService(repositoryRoot, os = (0, node_os_1.platform)()) {
+    const files = serviceFiles(repositoryRoot, process.env, os);
+    if (os === 'darwin')
+        await run('launchctl', ['bootout', `gui/${process.getuid?.()}`, files.definitionPath]).catch(() => undefined);
+    else if (os === 'win32')
+        await run('schtasks', ['/Delete', '/F', '/TN', files.serviceId]).catch(() => undefined);
+    else {
+        await run('systemctl', ['--user', 'disable', '--now', files.serviceId]).catch(() => undefined);
+        await run('systemctl', ['--user', 'daemon-reload']).catch(() => undefined);
+    }
+    await (0, promises_1.rm)(files.definitionPath, { force: true });
+    await (0, promises_1.rm)(files.enrollmentPath, { force: true });
+    return files;
+}
+async function readServiceEnrollment(path) {
+    const parsed = JSON.parse(await (0, promises_1.readFile)(path, 'utf8'));
+    if (!parsed.endpoint || !parsed.token || !parsed.organizationId || !parsed.captureInstallationId || !parsed.actorJson)
+        throw new Error('Service enrollment is incomplete');
+    if (!Number.isInteger(parsed.intervalSeconds) || parsed.intervalSeconds < 15 || parsed.intervalSeconds > 3600)
+        throw new Error('Service interval is invalid');
+    return parsed;
+}
+function applyServiceEnrollment(enrollment) {
+    process.env.ZEYE_CAPTURE_ENDPOINT = enrollment.endpoint;
+    process.env.ZEYE_CAPTURE_TOKEN = enrollment.token;
+    process.env.ZEYE_CAPTURE_ORGANIZATION_ID = enrollment.organizationId;
+    process.env.ZEYE_CAPTURE_INSTALLATION_ID = enrollment.captureInstallationId;
+    process.env.ZEYE_CAPTURE_ACTOR_JSON = enrollment.actorJson;
+    if (enrollment.contentConsentId)
+        process.env.ZEYE_CAPTURE_CONTENT_CONSENT_ID = enrollment.contentConsentId;
+    if (enrollment.transcriptConsent)
+        process.env.ZEYE_CAPTURE_TRANSCRIPT_CONSENT = enrollment.transcriptConsent;
+}