@xfey/tutti 0.1.0

package/dist/approvals/projections.js

@@ -0,0 +1,444 @@
+import { isAbsolute, relative, resolve } from "node:path";
+import { createApprovalRequestId } from "@tutti/shared/ids";
+import { redactText } from "@tutti/shared/utils";
+const MAX_TEXT_LENGTH = 500;
+const MAX_DETAIL_LENGTH = 180;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function compactText(value, maxLength) {
+    const normalized = value.replace(/\s+/gu, " ").trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength)}...`;
+}
+function underRoot(path, root) {
+    const relativePath = relative(root, path);
+    return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+function runtimeRoots(context) {
+    return [
+        { value: context.runWorkspaceRoot ?? "", label: "run workspace" },
+        { value: context.workspaceRoot ?? "", label: "workspace" },
+        { value: context.codexHome ?? "", label: "codex home" },
+        { value: context.tuttiHome ?? "", label: "tutti home" },
+        { value: context.builtInSkillsRoot ?? "", label: "built-in skills" },
+    ].filter((entry) => entry.value !== "");
+}
+function labelPath(value, context) {
+    const redacted = redactKnownValues(value, context);
+    if (!isAbsolute(value)) {
+        return compactText(redacted, MAX_DETAIL_LENGTH);
+    }
+    const resolved = resolve(value);
+    for (const root of runtimeRoots(context)) {
+        const resolvedRoot = resolve(root.value);
+        if (!underRoot(resolved, resolvedRoot)) {
+            continue;
+        }
+        const relativePath = relative(resolvedRoot, resolved);
+        return relativePath === ""
+            ? root.label
+            : `${root.label}/${relativePath.split(/[\\/]+/u).join("/")}`;
+    }
+    return "[REDACTED_PATH]";
+}
+function redactKnownValues(value, context) {
+    let redacted = redactText(value);
+    for (const root of runtimeRoots(context)) {
+        redacted = redacted.split(root.value).join(root.label);
+    }
+    for (const sensitiveValue of context.sensitiveValues ?? []) {
+        if (sensitiveValue !== "") {
+            redacted = redacted.split(sensitiveValue).join("[REDACTED]");
+        }
+    }
+    return redacted;
+}
+function safeText(value, context, maxLength = MAX_TEXT_LENGTH) {
+    return compactText(redactKnownValues(value, context), maxLength) || "[redacted]";
+}
+function commandText(value, context) {
+    if (typeof value === "string") {
+        return safeText(value, context);
+    }
+    if (Array.isArray(value)) {
+        const parts = value.filter((part) => typeof part === "string");
+        if (parts.length > 0) {
+            return safeText(parts.join(" "), context);
+        }
+    }
+    return undefined;
+}
+function reasonText(params, context) {
+    const reason = nonEmptyString(params.reason);
+    return reason === undefined ? undefined : safeText(reason, context, MAX_DETAIL_LENGTH);
+}
+function decisionOption(input) {
+    return {
+        projection: {
+            decision_id: input.decisionId,
+            kind: input.kind,
+            label: input.label,
+            tone: input.tone,
+        },
+        runtime: {
+            decisionId: input.decisionId,
+            label: input.label,
+            outcome: input.outcome,
+            response: input.response,
+        },
+    };
+}
+function requestedSimpleDecision(params, decision) {
+    if (!Array.isArray(params.availableDecisions)) {
+        return true;
+    }
+    return params.availableDecisions.includes(decision);
+}
+function commandDecisionOptions(params, legacy) {
+    const options = [
+        ...(requestedSimpleDecision(params, legacy ? "approved" : "accept")
+            ? [
+                decisionOption({
+                    decisionId: "allow_once",
+                    kind: "allow_once",
+                    label: "Allow once",
+                    tone: "primary",
+                    outcome: "accepted",
+                    response: {
+                        kind: "result",
+                        result: { decision: legacy ? "approved" : "accept" },
+                    },
+                }),
+            ]
+            : []),
+        ...(requestedSimpleDecision(params, legacy ? "approved_for_session" : "acceptForSession")
+            ? [
+                decisionOption({
+                    decisionId: "allow_session",
+                    kind: "allow_session",
+                    label: "Allow for session",
+                    tone: "neutral",
+                    outcome: "accepted",
+                    response: {
+                        kind: "result",
+                        result: { decision: legacy ? "approved_for_session" : "acceptForSession" },
+                    },
+                }),
+            ]
+            : []),
+        ...(requestedSimpleDecision(params, legacy ? "denied" : "decline")
+            ? [
+                decisionOption({
+                    decisionId: "deny",
+                    kind: "deny",
+                    label: "Deny",
+                    tone: "danger",
+                    outcome: "declined",
+                    response: {
+                        kind: "result",
+                        result: { decision: legacy ? "denied" : "decline" },
+                    },
+                }),
+            ]
+            : []),
+        ...(requestedSimpleDecision(params, legacy ? "abort" : "cancel")
+            ? [
+                decisionOption({
+                    decisionId: "cancel",
+                    kind: "cancel",
+                    label: "Cancel run",
+                    tone: "danger",
+                    outcome: "cancelled",
+                    response: {
+                        kind: "result",
+                        result: { decision: legacy ? "abort" : "cancel" },
+                    },
+                }),
+            ]
+            : []),
+    ];
+    return options.length === 0
+        ? [
+            decisionOption({
+                decisionId: "cancel",
+                kind: "cancel",
+                label: "Cancel run",
+                tone: "danger",
+                outcome: "cancelled",
+                response: {
+                    kind: "error",
+                    error: {
+                        code: "approval_cancelled",
+                        message: "Approval request was cancelled.",
+                    },
+                },
+            }),
+        ]
+        : options;
+}
+function permissionsDecisionOptions(permissions) {
+    return [
+        decisionOption({
+            decisionId: "allow_once",
+            kind: "allow_once",
+            label: "Allow once",
+            tone: "primary",
+            outcome: "accepted",
+            response: {
+                kind: "result",
+                result: { permissions, scope: "turn" },
+            },
+        }),
+        decisionOption({
+            decisionId: "allow_session",
+            kind: "allow_session",
+            label: "Allow for session",
+            tone: "neutral",
+            outcome: "accepted",
+            response: {
+                kind: "result",
+                result: { permissions, scope: "session" },
+            },
+        }),
+        decisionOption({
+            decisionId: "deny",
+            kind: "deny",
+            label: "Deny",
+            tone: "danger",
+            outcome: "declined",
+            response: {
+                kind: "error",
+                error: {
+                    code: "approval_declined",
+                    message: "Approval request was declined.",
+                },
+            },
+        }),
+        decisionOption({
+            decisionId: "cancel",
+            kind: "cancel",
+            label: "Cancel run",
+            tone: "danger",
+            outcome: "cancelled",
+            response: {
+                kind: "error",
+                error: {
+                    code: "approval_cancelled",
+                    message: "Approval request was cancelled.",
+                },
+            },
+        }),
+    ];
+}
+function decisionMap(options) {
+    return {
+        projections: options.map((option) => option.projection),
+        runtimes: new Map(options.map((option) => [option.runtime.decisionId, option.runtime])),
+    };
+}
+function commandActions(value, context) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const actions = value
+        .filter(isRecord)
+        .map((action) => {
+        const rawCommand = nonEmptyString(action.command);
+        const label = nonEmptyString(action.name) ??
+            nonEmptyString(action.type) ??
+            (rawCommand === undefined ? "Command action" : safeText(rawCommand, context, 80));
+        const rawDetail = nonEmptyString(action.path) ??
+            nonEmptyString(action.query) ??
+            (rawCommand === undefined ? undefined : safeText(rawCommand, context, MAX_DETAIL_LENGTH));
+        const detail = rawDetail === undefined
+            ? undefined
+            : action.path === rawDetail
+                ? labelPath(rawDetail, context)
+                : safeText(rawDetail, context, MAX_DETAIL_LENGTH);
+        return {
+            label: safeText(label, context, 80),
+            ...(detail === undefined ? {} : { detail }),
+        };
+    })
+        .slice(0, 6);
+    return actions.length === 0 ? undefined : actions;
+}
+function networkProjection(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const host = nonEmptyString(value.host);
+    const protocol = nonEmptyString(value.protocol);
+    if (host === undefined || protocol === undefined) {
+        return undefined;
+    }
+    return { host: redactText(host), protocol: redactText(protocol) };
+}
+function permissionsProjection(value, context) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const projection = {};
+    if (isRecord(value.network) && typeof value.network.enabled === "boolean") {
+        projection.network = { enabled: value.network.enabled };
+    }
+    if (isRecord(value.fileSystem)) {
+        const filesystem = {};
+        if (Array.isArray(value.fileSystem.read)) {
+            filesystem.read = value.fileSystem.read
+                .filter((item) => typeof item === "string" && item.trim() !== "")
+                .map((item) => labelPath(item, context))
+                .slice(0, 20);
+        }
+        if (Array.isArray(value.fileSystem.write)) {
+            filesystem.write = value.fileSystem.write
+                .filter((item) => typeof item === "string" && item.trim() !== "")
+                .map((item) => labelPath(item, context))
+                .slice(0, 20);
+        }
+        if (filesystem.read !== undefined || filesystem.write !== undefined) {
+            projection.filesystem = filesystem;
+        }
+    }
+    return projection.network === undefined && projection.filesystem === undefined
+        ? undefined
+        : projection;
+}
+function fileChangeProjection(params, context) {
+    const grantRoot = nonEmptyString(params.grantRoot);
+    const fileChanges = isRecord(params.fileChanges) ? Object.keys(params.fileChanges) : [];
+    const paths = fileChanges.map((path) => labelPath(path, context)).slice(0, 20);
+    if (grantRoot === undefined && paths.length === 0) {
+        return undefined;
+    }
+    return {
+        ...(grantRoot === undefined ? {} : { grant_root_label: labelPath(grantRoot, context) }),
+        ...(paths.length === 0 ? {} : { paths }),
+    };
+}
+function baseRequest(input) {
+    const request = {
+        approval_id: createApprovalRequestId(),
+        request_kind: input.kind,
+        title: input.title,
+        summary: input.summary,
+        requested_at: input.context.requestedAt,
+        decisions: input.decisions.projections,
+    };
+    const reason = reasonText(input.params, input.context);
+    if (reason !== undefined) {
+        request.reason = reason;
+    }
+    if (input.context.expiresAt !== undefined) {
+        request.expires_at = input.context.expiresAt;
+    }
+    if (input.context.taskId !== undefined) {
+        request.task_id = input.context.taskId;
+    }
+    if (input.context.activityRef !== undefined) {
+        request.activity_ref = input.context.activityRef;
+    }
+    return request;
+}
+function buildCommandApproval(input) {
+    if (!isRecord(input.request.params)) {
+        return null;
+    }
+    const params = input.request.params;
+    const text = commandText(params.command, input.context);
+    const decisions = decisionMap(commandDecisionOptions(params, input.legacy));
+    const request = baseRequest({
+        context: input.context,
+        kind: input.legacy ? "legacy_exec_command" : "command_execution",
+        title: "Approve command",
+        summary: text === undefined ? "Codex wants to run a command." : `Codex wants to run: ${text}`,
+        params,
+        decisions,
+    });
+    const cwd = nonEmptyString(params.cwd);
+    const actions = commandActions(params.commandActions ?? params.parsedCmd, input.context);
+    const network = networkProjection(params.networkApprovalContext);
+    request.command = {
+        text: text ?? "[redacted command]",
+    };
+    if (cwd !== undefined) {
+        request.command.cwd_label = labelPath(cwd, input.context);
+    }
+    if (actions !== undefined) {
+        request.command.actions = actions;
+    }
+    if (network !== undefined) {
+        request.command.network = network;
+    }
+    return { request, decisions: decisions.runtimes };
+}
+function buildFileChangeApproval(input) {
+    if (!isRecord(input.request.params)) {
+        return null;
+    }
+    const params = input.request.params;
+    const decisions = decisionMap(commandDecisionOptions(params, input.legacy));
+    const request = baseRequest({
+        context: input.context,
+        kind: input.legacy ? "legacy_apply_patch" : "file_change",
+        title: "Approve file changes",
+        summary: "Codex wants permission to write files.",
+        params,
+        decisions,
+    });
+    const fileChange = fileChangeProjection(params, input.context);
+    if (fileChange !== undefined) {
+        request.file_change = fileChange;
+    }
+    return { request, decisions: decisions.runtimes };
+}
+function buildPermissionsApproval(request, context) {
+    if (!isRecord(request.params)) {
+        return null;
+    }
+    const params = request.params;
+    const permissions = params.permissions;
+    const decisions = decisionMap(permissionsDecisionOptions(permissions));
+    const projection = baseRequest({
+        context,
+        kind: "permissions",
+        title: "Approve permissions",
+        summary: "Codex wants additional runtime permissions.",
+        params,
+        decisions,
+    });
+    const permissionsDetails = permissionsProjection(permissions, context);
+    if (permissionsDetails !== undefined) {
+        projection.permissions = permissionsDetails;
+    }
+    if (nonEmptyString(params.cwd) !== undefined) {
+        projection.command = {
+            text: "request permissions",
+            cwd_label: labelPath(String(params.cwd), context),
+        };
+    }
+    return { request: projection, decisions: decisions.runtimes };
+}
+export function buildApprovalProjection(request, context) {
+    switch (request.method) {
+        case "item/commandExecution/requestApproval":
+            return buildCommandApproval({ request, context, legacy: false });
+        case "item/fileChange/requestApproval":
+            return buildFileChangeApproval({ request, context, legacy: false });
+        case "item/permissions/requestApproval":
+            return buildPermissionsApproval(request, context);
+        case "execCommandApproval":
+            return buildCommandApproval({ request, context, legacy: true });
+        case "applyPatchApproval":
+            return buildFileChangeApproval({ request, context, legacy: true });
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=projections.js.map

package/dist/artifacts/index.d.ts

@@ -0,0 +1,4 @@
+export { ARTIFACT_MANIFEST_PATH, ARTIFACT_PREVIEW_BASE_PATH, buildArtifactPreviewUrl, readArtifactDeclaration, readArtifactProjection, type ArtifactDeclaration, type DeclaredArtifactRuntime, type ReadArtifactDeclarationOptions, } from "./manifest.js";
+export { ARTIFACT_PREVIEW_DEFAULT_BASE_PATH, ArtifactPreviewManager, type ArtifactPreviewCommandResult, type ArtifactPreviewHeartbeatResult, type ArtifactPreviewManagerOptions, type ArtifactPreviewProcessPlan, type ArtifactPreviewStartResult, type ArtifactPreviewStopResult, type ArtifactServerPreviewResponse, } from "./preview-runtime.js";
+export { ARTIFACT_PREVIEW_CSP, readArtifactStaticPreview, rewriteArtifactPreviewResourceUrls, type ArtifactStaticPreviewFile, type ReadArtifactStaticPreviewOptions, } from "./static-preview.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/artifacts/index.js

@@ -0,0 +1,4 @@
+export { ARTIFACT_MANIFEST_PATH, ARTIFACT_PREVIEW_BASE_PATH, buildArtifactPreviewUrl, readArtifactDeclaration, readArtifactProjection, } from "./manifest.js";
+export { ARTIFACT_PREVIEW_DEFAULT_BASE_PATH, ArtifactPreviewManager, } from "./preview-runtime.js";
+export { ARTIFACT_PREVIEW_CSP, readArtifactStaticPreview, rewriteArtifactPreviewResourceUrls, } from "./static-preview.js";
+//# sourceMappingURL=index.js.map

package/dist/artifacts/manifest.d.ts

@@ -0,0 +1,48 @@
+import type { ArtifactManifest, ArtifactProjection, GetArtifactsResponse } from "@tutti/shared/schemas/api";
+export declare const ARTIFACT_MANIFEST_PATH: "tutti.artifact.json";
+export declare const ARTIFACT_PREVIEW_BASE_PATH: "/artifacts/preview";
+type ArtifactInvalidProjection = Extract<ArtifactProjection, {
+    status: "invalid";
+}>;
+type ArtifactDeclaredProjection = Extract<ArtifactProjection, {
+    status: "declared";
+}>;
+export type DeclaredArtifactRuntime = {
+    kind: "static";
+    root_path: string;
+    entry_path: string;
+    entry_repo_path: string;
+} | {
+    kind: "server";
+    cwd_path: string;
+    ready_path: string;
+};
+export type ArtifactDeclaration = {
+    status: "not_declared";
+    projection: Extract<ArtifactProjection, {
+        status: "not_declared";
+    }>;
+} | {
+    status: "invalid";
+    projection: ArtifactInvalidProjection;
+} | {
+    status: "declared";
+    manifest: ArtifactManifest;
+    manifest_blob_oid: string;
+    runtime: DeclaredArtifactRuntime;
+    projection: ArtifactDeclaredProjection;
+};
+export type ReadArtifactDeclarationOptions = {
+    workspaceRoot: string;
+    previewBasePath?: string | undefined;
+    now?: () => Date;
+};
+export declare function buildArtifactPreviewUrl(options: {
+    basePath?: string | undefined;
+    entryPath: string;
+    manifestBlobOid: string;
+}): string;
+export declare function readArtifactDeclaration(options: ReadArtifactDeclarationOptions): ArtifactDeclaration;
+export declare function readArtifactProjection(options: ReadArtifactDeclarationOptions): GetArtifactsResponse;
+export {};
+//# sourceMappingURL=manifest.d.ts.map