@xfey/tutti 0.1.0

package/dist/provider-usage/index.js

@@ -0,0 +1,227 @@
+const EMPTY_BREAKDOWN = {
+    input_tokens: 0,
+    cached_input_tokens: 0,
+    output_tokens: 0,
+    reasoning_output_tokens: 0,
+    total_tokens: 0,
+    event_count: 0,
+};
+const SOURCE_LABELS = {
+    workspace_write_run: { label: "Implementation", category: "implementation" },
+    follow_up_run: { label: "Follow-up run", category: "implementation" },
+    pipeline_self_correction: { label: "Self-correction", category: "implementation" },
+    task_compile: { label: "Worklist planning", category: "planning" },
+    scratchpad_refresh: { label: "Scratchpad sync", category: "planning" },
+    project_brief_refresh: { label: "Project brief", category: "context" },
+    project_context_bootstrap: { label: "Project context setup", category: "context" },
+    context_sync: { label: "Docs sync", category: "context" },
+    reference_summary_refresh: { label: "Reference processing", category: "context" },
+    follow_up_check: { label: "Follow-up check", category: "planning" },
+    chat_assistant: { label: "Project Q&A", category: "qna" },
+};
+export function providerUsageSourceMetadata(source) {
+    return SOURCE_LABELS[source] ?? { label: source, category: "other" };
+}
+function breakdownFromRow(row) {
+    if (row === undefined) {
+        return { ...EMPTY_BREAKDOWN };
+    }
+    return {
+        input_tokens: row.input_tokens ?? 0,
+        cached_input_tokens: row.cached_input_tokens ?? 0,
+        output_tokens: row.output_tokens ?? 0,
+        reasoning_output_tokens: row.reasoning_output_tokens ?? 0,
+        total_tokens: row.total_tokens ?? 0,
+        event_count: row.event_count ?? 0,
+    };
+}
+function usageBreakdownSelect(whereClause = "") {
+    return `
+    SELECT
+      COALESCE(SUM(input_tokens), 0) AS input_tokens,
+      COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+      COALESCE(SUM(output_tokens), 0) AS output_tokens,
+      COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+      COALESCE(SUM(total_tokens), 0) AS total_tokens,
+      COUNT(*) AS event_count
+    FROM provider_usage_events
+    ${whereClause}
+  `;
+}
+function usageAnchorWhereClause(anchors, options = {}) {
+    const clauses = [];
+    const params = [];
+    if (anchors.activity_ref !== undefined) {
+        clauses.push("activity_ref = ?");
+        params.push(anchors.activity_ref);
+    }
+    if (anchors.workflow_ref !== undefined) {
+        clauses.push("workflow_ref = ?");
+        params.push(anchors.workflow_ref);
+    }
+    if (anchors.task_id !== undefined) {
+        clauses.push("task_id = ?");
+        params.push(anchors.task_id);
+    }
+    if (anchors.run_result_id !== undefined) {
+        clauses.push("run_result_id = ?");
+        params.push(anchors.run_result_id);
+    }
+    if (clauses.length === 0) {
+        return null;
+    }
+    const sourceFilter = options.sources === undefined || options.sources.length === 0
+        ? ""
+        : ` AND source IN (${options.sources.map(() => "?").join(", ")})`;
+    return {
+        whereClause: `WHERE (${clauses.join(" OR ")})${sourceFilter}`,
+        params: [...params, ...(options.sources ?? [])],
+    };
+}
+export function recordProviderUsageEvent(db, input) {
+    const recordedAt = (input.now ?? (() => new Date()))().toISOString();
+    db.prepare(`
+      INSERT INTO provider_usage_events (
+        provider,
+        source,
+        model,
+        input_tokens,
+        cached_input_tokens,
+        output_tokens,
+        reasoning_output_tokens,
+        total_tokens,
+        recorded_at,
+        activity_ref,
+        workflow_ref,
+        task_id,
+        run_result_id,
+        run_lineage_kind
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(input.provider, input.source, input.model ?? null, input.usage.input_tokens, input.usage.cached_input_tokens, input.usage.output_tokens, input.usage.reasoning_output_tokens, input.usage.total_tokens, recordedAt, input.activity_ref ?? null, input.workflow_ref ?? null, input.task_id ?? null, input.run_result_id ?? null, input.run_lineage_kind ?? null);
+}
+export function readProviderUsageBreakdownForAnchors(db, anchors, options = {}) {
+    const anchorWhere = usageAnchorWhereClause(anchors, options);
+    if (anchorWhere === null) {
+        return { ...EMPTY_BREAKDOWN };
+    }
+    return breakdownFromRow(db
+        .prepare(usageBreakdownSelect(anchorWhere.whereClause))
+        .get(...anchorWhere.params));
+}
+export function readProviderUsageSourceSummariesForAnchors(db, anchors, options = {}) {
+    const anchorWhere = usageAnchorWhereClause(anchors, options);
+    if (anchorWhere === null) {
+        return [];
+    }
+    const rows = db
+        .prepare(`
+        SELECT
+          source,
+          COALESCE(SUM(input_tokens), 0) AS input_tokens,
+          COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+          COALESCE(SUM(output_tokens), 0) AS output_tokens,
+          COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+          COALESCE(SUM(total_tokens), 0) AS total_tokens,
+          COUNT(*) AS event_count
+        FROM provider_usage_events
+        ${anchorWhere.whereClause}
+        GROUP BY source
+        ORDER BY total_tokens DESC, source ASC
+      `)
+        .all(...anchorWhere.params);
+    return rows.map((row) => ({
+        source: row.source,
+        ...providerUsageSourceMetadata(row.source),
+        ...breakdownFromRow(row),
+    }));
+}
+export function readProviderUsageModelSummariesForAnchors(db, anchors, options = {}) {
+    const anchorWhere = usageAnchorWhereClause(anchors, options);
+    if (anchorWhere === null) {
+        return [];
+    }
+    const rows = db
+        .prepare(`
+        SELECT
+          model,
+          COALESCE(SUM(input_tokens), 0) AS input_tokens,
+          COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+          COALESCE(SUM(output_tokens), 0) AS output_tokens,
+          COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+          COALESCE(SUM(total_tokens), 0) AS total_tokens,
+          COUNT(*) AS event_count
+        FROM provider_usage_events
+        ${anchorWhere.whereClause}
+        GROUP BY model
+        ORDER BY total_tokens DESC, model ASC
+      `)
+        .all(...anchorWhere.params);
+    return rows.map((row) => ({
+        model: row.model ?? "unknown",
+        ...breakdownFromRow(row),
+    }));
+}
+export function readProviderUsageProjection(db, options = {}) {
+    const now = (options.now ?? (() => new Date()))();
+    const todayStart = new Date(now);
+    todayStart.setHours(0, 0, 0, 0);
+    const last7Days = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    const last30Days = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+    const totals = breakdownFromRow(db.prepare(usageBreakdownSelect()).get());
+    const bySourceRows = db
+        .prepare(`
+        SELECT
+          source,
+          COALESCE(SUM(input_tokens), 0) AS input_tokens,
+          COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+          COALESCE(SUM(output_tokens), 0) AS output_tokens,
+          COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+          COALESCE(SUM(total_tokens), 0) AS total_tokens,
+          COUNT(*) AS event_count
+        FROM provider_usage_events
+        GROUP BY source
+        ORDER BY total_tokens DESC, source ASC
+      `)
+        .all();
+    const byModelRows = db
+        .prepare(`
+        SELECT
+          model,
+          COALESCE(SUM(input_tokens), 0) AS input_tokens,
+          COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+          COALESCE(SUM(output_tokens), 0) AS output_tokens,
+          COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+          COALESCE(SUM(total_tokens), 0) AS total_tokens,
+          COUNT(*) AS event_count
+        FROM provider_usage_events
+        GROUP BY model
+        ORDER BY total_tokens DESC, model ASC
+      `)
+        .all();
+    return {
+        total_tokens: totals.total_tokens,
+        totals,
+        by_source: bySourceRows.map((row) => ({
+            source: row.source,
+            ...providerUsageSourceMetadata(row.source),
+            ...breakdownFromRow(row),
+        })),
+        by_model: byModelRows.map((row) => ({
+            model: row.model ?? "unknown",
+            ...breakdownFromRow(row),
+        })),
+        recent_windows: {
+            today: breakdownFromRow(db
+                .prepare(usageBreakdownSelect("WHERE recorded_at >= ?"))
+                .get(todayStart.toISOString())),
+            last_7_days: breakdownFromRow(db
+                .prepare(usageBreakdownSelect("WHERE recorded_at >= ?"))
+                .get(last7Days.toISOString())),
+            last_30_days: breakdownFromRow(db
+                .prepare(usageBreakdownSelect("WHERE recorded_at >= ?"))
+                .get(last30Days.toISOString())),
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./openai/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/index.js

@@ -0,0 +1,2 @@
+export * from "./openai/index.js";
+//# sourceMappingURL=index.js.map

package/dist/providers/openai/app-server/json-rpc.d.ts

@@ -0,0 +1,71 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+export type CodexAppServerRequestId = number | string;
+export type CodexAppServerJsonRpcResponse = {
+    id: CodexAppServerRequestId;
+    result?: unknown;
+    error?: {
+        code?: number | string;
+        message?: string;
+        data?: unknown;
+    };
+};
+export type CodexAppServerJsonRpcNotification = {
+    method: string;
+    params?: unknown;
+};
+export type CodexAppServerJsonRpcServerRequest = {
+    id: CodexAppServerRequestId;
+    method: string;
+    params?: unknown;
+};
+export type CodexAppServerJsonRpcError = {
+    code: number | string;
+    message: string;
+    data?: unknown;
+};
+export declare class CodexAppServerProtocolError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare class CodexAppServerJsonRpcClient {
+    private readonly child;
+    private readonly decoder;
+    private readonly pendingRequests;
+    private readonly notificationWaiters;
+    private readonly serverRequestWaiters;
+    private nextRequestId;
+    private stdoutBuffer;
+    private closed;
+    private stderrText;
+    private stdoutText;
+    private lastActivityIso;
+    private readonly notificationList;
+    private readonly serverRequestList;
+    private readonly unresolvedServerRequestIds;
+    constructor(child: ChildProcessWithoutNullStreams);
+    get notifications(): readonly CodexAppServerJsonRpcNotification[];
+    get serverRequests(): readonly CodexAppServerJsonRpcServerRequest[];
+    get stderr(): string;
+    get rawStdout(): string;
+    get lastActivityAt(): string | undefined;
+    isServerRequestPending(id: CodexAppServerRequestId): boolean;
+    waitForOutputSettle(options: {
+        quietMs: number;
+        maxWaitMs: number;
+    }): Promise<void>;
+    request<T = unknown>(method: string, params?: unknown, timeoutMs?: number): Promise<T>;
+    notify(method: string, params?: unknown): void;
+    waitForNotification(predicate: (notification: CodexAppServerJsonRpcNotification) => boolean, timeoutMs: number): Promise<CodexAppServerJsonRpcNotification>;
+    waitForServerRequest(timeoutMs: number): Promise<CodexAppServerJsonRpcServerRequest>;
+    respondToServerRequest(id: CodexAppServerRequestId, result: unknown): void;
+    rejectServerRequest(id: CodexAppServerRequestId, error: CodexAppServerJsonRpcError): void;
+    dispose(): void;
+    private rejectAll;
+    private writeServerRequestResponse;
+    private handleStdout;
+    private handleLine;
+    private recordNotification;
+    private recordServerRequest;
+    private recordActivity;
+}
+//# sourceMappingURL=json-rpc.d.ts.map

package/dist/providers/openai/app-server/json-rpc.js

@@ -0,0 +1,298 @@
+import { StringDecoder } from "node:string_decoder";
+import { redactText } from "@tutti/shared/utils";
+export class CodexAppServerProtocolError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "CodexAppServerProtocolError";
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeProtocolError(method, error) {
+    if (!isRecord(error)) {
+        return new CodexAppServerProtocolError(`Codex app-server request failed: ${method}`, "protocol_error");
+    }
+    const rawCode = error.code;
+    const code = typeof rawCode === "string" || typeof rawCode === "number" ? rawCode : "error";
+    const rawMessage = error.message;
+    const message = typeof rawMessage === "string" ? redactText(rawMessage) : "protocol_error";
+    return new CodexAppServerProtocolError(`Codex app-server request failed: ${method}: ${code}: ${message}`, "request_failed");
+}
+export class CodexAppServerJsonRpcClient {
+    child;
+    decoder = new StringDecoder("utf8");
+    pendingRequests = new Map();
+    notificationWaiters = new Set();
+    serverRequestWaiters = new Set();
+    nextRequestId = 1;
+    stdoutBuffer = "";
+    closed = false;
+    stderrText = "";
+    stdoutText = "";
+    lastActivityIso;
+    notificationList = [];
+    serverRequestList = [];
+    unresolvedServerRequestIds = new Set();
+    constructor(child) {
+        this.child = child;
+        child.stdout.on("data", (chunk) => this.handleStdout(chunk));
+        child.stderr.on("data", (chunk) => {
+            this.recordActivity();
+            this.stderrText += chunk.toString("utf8");
+        });
+        child.on("exit", (code, signal) => {
+            this.closed = true;
+            this.rejectAll(new CodexAppServerProtocolError(`Codex app-server exited before request completed: code=${code ?? "null"} signal=${signal ?? "null"}`, "process_exited"));
+        });
+        child.on("error", (error) => {
+            this.closed = true;
+            this.rejectAll(new CodexAppServerProtocolError(`Codex app-server process error: ${redactText(error.message)}`, "process_error"));
+        });
+    }
+    get notifications() {
+        return this.notificationList;
+    }
+    get serverRequests() {
+        return this.serverRequestList;
+    }
+    get stderr() {
+        return this.stderrText;
+    }
+    get rawStdout() {
+        return this.stdoutText;
+    }
+    get lastActivityAt() {
+        return this.lastActivityIso;
+    }
+    isServerRequestPending(id) {
+        return this.unresolvedServerRequestIds.has(id);
+    }
+    waitForOutputSettle(options) {
+        const startedAt = Date.now();
+        let lastChangedAt = startedAt;
+        let lastStdoutLength = this.stdoutText.length;
+        let lastStderrLength = this.stderrText.length;
+        return new Promise((resolve) => {
+            const tick = () => {
+                const now = Date.now();
+                if (this.stdoutText.length !== lastStdoutLength ||
+                    this.stderrText.length !== lastStderrLength) {
+                    lastStdoutLength = this.stdoutText.length;
+                    lastStderrLength = this.stderrText.length;
+                    lastChangedAt = now;
+                }
+                if (now - lastChangedAt >= options.quietMs || now - startedAt >= options.maxWaitMs) {
+                    resolve();
+                    return;
+                }
+                const remainingMaxWaitMs = Math.max(1, options.maxWaitMs - (now - startedAt));
+                setTimeout(tick, Math.min(options.quietMs, remainingMaxWaitMs));
+            };
+            setTimeout(tick, 0);
+        });
+    }
+    request(method, params, timeoutMs = 30_000) {
+        if (this.closed) {
+            return Promise.reject(new CodexAppServerProtocolError("Codex app-server process is closed", "process_closed"));
+        }
+        const id = this.nextRequestId;
+        this.nextRequestId += 1;
+        const message = params === undefined ? { id, method } : { id, method, params };
+        const payload = `${JSON.stringify(message)}\n`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new CodexAppServerProtocolError(`Codex app-server request timed out: ${method}`, "request_timeout"));
+            }, timeoutMs);
+            this.pendingRequests.set(id, {
+                method,
+                resolve: (value) => resolve(value),
+                reject,
+                timer,
+            });
+            this.child.stdin.write(payload, (error) => {
+                if (error === undefined || error === null) {
+                    return;
+                }
+                const pending = this.pendingRequests.get(id);
+                if (pending !== undefined) {
+                    clearTimeout(pending.timer);
+                    this.pendingRequests.delete(id);
+                    pending.reject(new CodexAppServerProtocolError(`Codex app-server stdin write failed: ${redactText(error.message)}`, "stdin_write_failed"));
+                }
+            });
+        });
+    }
+    notify(method, params) {
+        const message = params === undefined ? { method } : { method, params };
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    waitForNotification(predicate, timeoutMs) {
+        const existing = this.notificationList.find(predicate);
+        if (existing !== undefined) {
+            return Promise.resolve(existing);
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                predicate,
+                resolve,
+                reject,
+                timer: setTimeout(() => {
+                    this.notificationWaiters.delete(waiter);
+                    reject(new CodexAppServerProtocolError("Timed out waiting for Codex app-server notification", "notification_timeout"));
+                }, timeoutMs),
+            };
+            this.notificationWaiters.add(waiter);
+        });
+    }
+    waitForServerRequest(timeoutMs) {
+        const existing = this.serverRequestList.find((request) => this.unresolvedServerRequestIds.has(request.id));
+        if (existing !== undefined) {
+            return Promise.resolve(existing);
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve,
+                reject,
+                timer: setTimeout(() => {
+                    this.serverRequestWaiters.delete(waiter);
+                    reject(new CodexAppServerProtocolError("Timed out waiting for Codex app-server server request", "server_request_timeout"));
+                }, timeoutMs),
+            };
+            this.serverRequestWaiters.add(waiter);
+        });
+    }
+    respondToServerRequest(id, result) {
+        this.writeServerRequestResponse(id, { id, result });
+    }
+    rejectServerRequest(id, error) {
+        this.writeServerRequestResponse(id, { id, error });
+    }
+    dispose() {
+        if (!this.child.killed) {
+            this.child.kill("SIGTERM");
+        }
+    }
+    rejectAll(error) {
+        for (const pending of this.pendingRequests.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+        for (const waiter of this.notificationWaiters) {
+            clearTimeout(waiter.timer);
+            waiter.reject(error);
+        }
+        this.notificationWaiters.clear();
+        for (const waiter of this.serverRequestWaiters) {
+            clearTimeout(waiter.timer);
+            waiter.reject(error);
+        }
+        this.serverRequestWaiters.clear();
+        this.unresolvedServerRequestIds.clear();
+    }
+    writeServerRequestResponse(id, message) {
+        if (this.closed) {
+            throw new CodexAppServerProtocolError("Codex app-server process is closed", "process_closed");
+        }
+        if (!this.unresolvedServerRequestIds.has(id)) {
+            throw new CodexAppServerProtocolError(`Codex app-server server request is not pending: ${String(id)}`, "server_request_not_pending");
+        }
+        this.unresolvedServerRequestIds.delete(id);
+        this.child.stdin.write(`${JSON.stringify(message)}\n`, (error) => {
+            if (error === undefined || error === null) {
+                return;
+            }
+            this.rejectAll(new CodexAppServerProtocolError(`Codex app-server stdin write failed: ${redactText(error.message)}`, "stdin_write_failed"));
+        });
+    }
+    handleStdout(chunk) {
+        this.recordActivity();
+        const text = this.decoder.write(chunk);
+        this.stdoutText += text;
+        this.stdoutBuffer += text;
+        for (;;) {
+            const newlineIndex = this.stdoutBuffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                return;
+            }
+            const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+            this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+            if (line === "") {
+                continue;
+            }
+            this.handleLine(line);
+        }
+    }
+    handleLine(line) {
+        this.recordActivity();
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            this.rejectAll(new CodexAppServerProtocolError("Failed to parse Codex app-server JSONL message", "json_parse_failed"));
+            return;
+        }
+        if (!isRecord(message)) {
+            return;
+        }
+        if ("id" in message && (typeof message.id === "number" || typeof message.id === "string")) {
+            if ("method" in message && typeof message.method === "string") {
+                this.recordServerRequest({
+                    id: message.id,
+                    method: message.method,
+                    params: message.params,
+                });
+                return;
+            }
+            const pending = this.pendingRequests.get(message.id);
+            if (pending === undefined) {
+                return;
+            }
+            clearTimeout(pending.timer);
+            this.pendingRequests.delete(message.id);
+            if ("error" in message && message.error !== undefined) {
+                pending.reject(normalizeProtocolError(pending.method, message.error));
+                return;
+            }
+            pending.resolve(message.result);
+            return;
+        }
+        if ("method" in message && typeof message.method === "string") {
+            this.recordNotification({
+                method: message.method,
+                params: message.params,
+            });
+        }
+    }
+    recordNotification(notification) {
+        this.recordActivity();
+        this.notificationList.push(notification);
+        for (const waiter of Array.from(this.notificationWaiters)) {
+            if (!waiter.predicate(notification)) {
+                continue;
+            }
+            clearTimeout(waiter.timer);
+            this.notificationWaiters.delete(waiter);
+            waiter.resolve(notification);
+        }
+    }
+    recordServerRequest(request) {
+        this.recordActivity();
+        this.serverRequestList.push(request);
+        this.unresolvedServerRequestIds.add(request.id);
+        for (const waiter of Array.from(this.serverRequestWaiters)) {
+            clearTimeout(waiter.timer);
+            this.serverRequestWaiters.delete(waiter);
+            waiter.resolve(request);
+        }
+    }
+    recordActivity() {
+        this.lastActivityIso = new Date().toISOString();
+    }
+}
+//# sourceMappingURL=json-rpc.js.map

package/dist/providers/openai/app-server/permission-profile.d.ts

@@ -0,0 +1,64 @@
+export type ReadOnlyPermissionProfileOptions = {
+    networkEnabled?: boolean;
+};
+export type WorkspaceWritePermissionProfileOptions = {
+    networkEnabled?: boolean;
+};
+export declare function createReadOnlyPermissionProfile(readablePaths: string | string[], options?: ReadOnlyPermissionProfileOptions): {
+    type: "managed";
+    network: {
+        enabled: boolean;
+    };
+    fileSystem: {
+        type: "restricted";
+        entries: ({
+            access: "read";
+            path: {
+                type: "path";
+                path: string;
+            };
+        } | {
+            access: "read";
+            path: {
+                type: "special";
+                value: {
+                    kind: "minimal";
+                };
+            };
+        })[];
+    };
+};
+export declare function createWorkspaceWritePermissionProfile(writableRoot: string, options?: WorkspaceWritePermissionProfileOptions): {
+    type: "managed";
+    network: {
+        enabled: boolean;
+    };
+    fileSystem: {
+        type: "restricted";
+        entries: ({
+            access: "read";
+            path: {
+                type: "special";
+                value: {
+                    kind: "minimal";
+                };
+                path?: never;
+            };
+        } | {
+            access: "read";
+            path: {
+                type: "path";
+                path: string;
+                value?: never;
+            };
+        } | {
+            access: "write";
+            path: {
+                type: "path";
+                path: string;
+                value?: never;
+            };
+        })[];
+    };
+};
+//# sourceMappingURL=permission-profile.d.ts.map