toolcraft-openapi 0.0.26 → 0.0.33

package/dist/network-error.js

@@ -5,7 +5,7 @@ export function classifyNetworkError(error, url) {
     const urlParts = new URL(url);
     const host = getHost(networkError, urlParts);
     const redactedUrl = redactSensitiveQueryValues(url);
-    switch (networkError?.code) {
+    switch (readStringProperty(networkError, "code")) {
         case "ECONNREFUSED":
             return new UserError(`Connection refused: ${host}:${getPort(networkError, urlParts)}. Is the server running?`, { cause: error });
         case "ETIMEDOUT":
@@ -36,10 +36,10 @@ export function classifyNetworkError(error, url) {
 function findNetworkError(error) {
     let current = error;
     while (isErrorLikeObject(current)) {
-        if (typeof current.code === "string") {
+        if (readStringProperty(current, "code") !== undefined) {
             return current;
         }
-        current = current.cause;
+        current = readOwnProperty(current, "cause");
     }
     return null;
 }
@@ -52,19 +52,20 @@ function findAbortError(error) {
         if (isAbortError(current)) {
             return current;
         }
-        current = current.cause;
+        current = readOwnProperty(current, "cause");
     }
     return null;
 }
 function hasCause(error) {
-    return "cause" in error && error.cause !== undefined;
+    return readOwnProperty(error, "cause") !== undefined;
 }
 function getHost(error, url) {
-    return typeof error?.address === "string" ? error.address : url.hostname;
+    return readStringProperty(error, "address") ?? url.hostname;
 }
 function getPort(error, url) {
-    if (typeof error?.port === "number" || typeof error?.port === "string") {
-        return String(error.port);
+    const port = readStringOrNumberProperty(error, "port");
+    if (port !== undefined) {
+        return String(port);
     }
     if (url.port) {
         return url.port;
@@ -72,14 +73,30 @@ function getPort(error, url) {
     return url.protocol === "https:" ? "443" : "80";
 }
 function getTimeoutMs(error) {
-    if (typeof error.ms === "number" || typeof error.ms === "string") {
-        return String(error.ms);
+    const ms = readStringOrNumberProperty(error, "ms");
+    if (ms !== undefined) {
+        return String(ms);
     }
-    if (typeof error.timeout === "number" || typeof error.timeout === "string") {
-        return String(error.timeout);
+    const timeout = readStringOrNumberProperty(error, "timeout");
+    if (timeout !== undefined) {
+        return String(timeout);
     }
     return "unknown";
 }
 function isErrorLikeObject(value) {
     return typeof value === "object" && value !== null;
 }
+function readOwnProperty(value, name) {
+    if (value === null || value === undefined || !Object.prototype.hasOwnProperty.call(value, name)) {
+        return undefined;
+    }
+    return value[name];
+}
+function readStringProperty(value, name) {
+    const property = readOwnProperty(value, name);
+    return typeof property === "string" ? property : undefined;
+}
+function readStringOrNumberProperty(value, name) {
+    const property = readOwnProperty(value, name);
+    return typeof property === "string" || typeof property === "number" ? property : undefined;
+}

package/dist/normalize-swagger.d.ts

@@ -0,0 +1,2 @@
+import type { OpenApiDocument } from "./generate.js";
+export declare function normalizeOpenApiDocument(document: OpenApiDocument): OpenApiDocument;

package/dist/normalize-swagger.js

@@ -0,0 +1,201 @@
+const HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head", "options", "trace"];
+const SCHEMA_PARAMETER_KEYS = [
+    "type",
+    "format",
+    "items",
+    "default",
+    "enum",
+    "minimum",
+    "maximum",
+    "minLength",
+    "maxLength",
+    "pattern",
+    "minItems",
+    "maxItems"
+];
+export function normalizeOpenApiDocument(document) {
+    const source = document;
+    if (source.swagger !== "2.0") {
+        return document;
+    }
+    const consumes = readStringArray(source.consumes);
+    const produces = readStringArray(source.produces);
+    const paths = Object.fromEntries(Object.entries(source.paths ?? {}).map(([path, pathItem]) => [
+        path,
+        pathItem === undefined
+            ? undefined
+            : normalizePathItem(pathItem, consumes, produces, isRecord(source.parameters) ? source.parameters : {})
+    ]));
+    const components = {
+        ...(source.components ?? {}),
+        ...(!isRecord(source.definitions) ? {} : { schemas: rewriteReferences(source.definitions) }),
+        ...(!isRecord(source.parameters) ? {} : { parameters: rewriteReferences(source.parameters) }),
+        ...(!isRecord(source.responses) ? {} : { responses: rewriteReferences(source.responses) }),
+        ...(!isRecord(source.securityDefinitions)
+            ? {}
+            : { securitySchemes: rewriteReferences(source.securityDefinitions) })
+    };
+    return rewriteReferences({
+        ...source,
+        openapi: "3.0.3",
+        paths,
+        components
+    });
+}
+function normalizePathItem(pathItem, documentConsumes, documentProduces, reusableParameters) {
+    const normalized = {
+        ...pathItem,
+        ...(pathItem.parameters === undefined
+            ? {}
+            : { parameters: pathItem.parameters.map((parameter) => normalizeParameter(resolveReusableParameter(parameter, reusableParameters))).filter(isOpenApiParameter) })
+    };
+    for (const method of HTTP_METHODS) {
+        const operation = pathItem[method];
+        if (!isRecord(operation) || isReferenceObject(operation)) {
+            continue;
+        }
+        normalized[method] = normalizeOperation(operation, documentConsumes, documentProduces, reusableParameters);
+    }
+    return normalized;
+}
+function normalizeOperation(operation, documentConsumes, documentProduces, reusableParameters) {
+    const parameters = (operation.parameters ?? []).map((parameter) => normalizeParameter(resolveReusableParameter(parameter, reusableParameters)));
+    const body = parameters.find(isSwaggerBodyParameter);
+    const formParameters = parameters.filter(isSwaggerFormParameter);
+    const nonBodyParameters = parameters.filter((parameter) => isOpenApiParameter(parameter) && !isSwaggerFormParameter(parameter));
+    const consumes = readStringArray(operation.consumes).length > 0
+        ? readStringArray(operation.consumes)
+        : documentConsumes;
+    const produces = readStringArray(operation.produces).length > 0
+        ? readStringArray(operation.produces)
+        : documentProduces;
+    return {
+        ...operation,
+        parameters: nonBodyParameters,
+        ...(body !== undefined
+            ? { requestBody: normalizeBodyParameter(body, consumes) }
+            : formParameters.length === 0
+                ? {}
+                : { requestBody: normalizeFormParameters(formParameters, consumes) }),
+        responses: Object.fromEntries(Object.entries(operation.responses ?? {}).map(([status, response]) => [
+            status,
+            normalizeResponse(response, produces)
+        ]))
+    };
+}
+function resolveReusableParameter(parameter, reusableParameters) {
+    if (!isReferenceObject(parameter) || !parameter.$ref.startsWith("#/parameters/")) {
+        return parameter;
+    }
+    return reusableParameters[parameter.$ref.slice("#/parameters/".length)];
+}
+function normalizeParameter(parameter) {
+    if (isReferenceObject(parameter)) {
+        return { $ref: rewriteReference(parameter.$ref) };
+    }
+    if (parameter.in === "body") {
+        return {
+            in: "body",
+            required: parameter.required === true,
+            description: typeof parameter.description === "string" ? parameter.description : undefined,
+            schema: rewriteReferences(parameter.schema ?? {})
+        };
+    }
+    const parameterRecord = parameter;
+    const schema = isRecord(parameterRecord.schema)
+        ? parameterRecord.schema
+        : Object.fromEntries(SCHEMA_PARAMETER_KEYS.flatMap((key) => parameterRecord[key] === undefined ? [] : [[key, parameterRecord[key]]]));
+    const normalized = {
+        ...parameter,
+        schema: rewriteReferences(parameter.in === "formData" && parameterRecord.type === "file"
+            ? { type: "string", format: "binary" }
+            : schema)
+    };
+    return parameter.in === "formData"
+        ? normalized
+        : normalized;
+}
+function normalizeBodyParameter(parameter, consumes) {
+    const mediaTypes = consumes.length === 0 ? ["application/json"] : consumes;
+    return {
+        ...(parameter.description === undefined ? {} : { description: parameter.description }),
+        ...(parameter.required ? { required: true } : {}),
+        content: Object.fromEntries(mediaTypes.map((mediaType) => [mediaType, { schema: parameter.schema }]))
+    };
+}
+function normalizeResponse(response, produces) {
+    if (isReferenceObject(response)) {
+        return { $ref: rewriteReference(response.$ref) };
+    }
+    const responseRecord = response;
+    if (responseRecord.schema === undefined) {
+        return response;
+    }
+    const mediaTypes = produces.length === 0 ? ["application/json"] : produces;
+    return {
+        ...response,
+        content: Object.fromEntries(mediaTypes.map((mediaType) => [
+            mediaType,
+            { schema: rewriteReferences(responseRecord.schema) }
+        ]))
+    };
+}
+function isSwaggerBodyParameter(parameter) {
+    return !isReferenceObject(parameter) && parameter.in === "body";
+}
+function isSwaggerFormParameter(parameter) {
+    return !isReferenceObject(parameter) && parameter.in === "formData";
+}
+function normalizeFormParameters(parameters, consumes) {
+    const required = parameters.filter((parameter) => parameter.required === true).map((parameter) => parameter.name);
+    const mediaType = consumes.find((value) => value.toLowerCase() === "multipart/form-data") ??
+        "application/x-www-form-urlencoded";
+    return {
+        ...(required.length === 0 ? {} : { required: true }),
+        content: {
+            [mediaType]: {
+                schema: {
+                    type: "object",
+                    ...(required.length === 0 ? {} : { required }),
+                    properties: Object.fromEntries(parameters.map((parameter) => [
+                        parameter.name,
+                        {
+                            ...parameter.schema,
+                            ...(parameter.description === undefined ? {} : { description: parameter.description })
+                        }
+                    ]))
+                }
+            }
+        }
+    };
+}
+function isOpenApiParameter(parameter) {
+    return isReferenceObject(parameter) || (parameter.in !== "body" && parameter.in !== "formData");
+}
+function isReferenceObject(value) {
+    return isRecord(value) && typeof value.$ref === "string";
+}
+function rewriteReferences(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => rewriteReferences(entry));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+        key,
+        key === "$ref" && typeof entry === "string" ? rewriteReference(entry) : rewriteReferences(entry)
+    ]));
+}
+function rewriteReference(reference) {
+    return reference
+        .replace("#/definitions/", "#/components/schemas/")
+        .replace("#/parameters/", "#/components/parameters/")
+        .replace("#/responses/", "#/components/responses/");
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/render-inspection.d.ts

@@ -0,0 +1,2 @@
+import type { OpenApiInspectionReport } from "./inspect.js";
+export declare function renderOpenApiInspection(report: OpenApiInspectionReport): string;

package/dist/render-inspection.js

@@ -0,0 +1,130 @@
+import { getTheme, renderCatalog, resolveOutputFormat } from "toolcraft-design";
+const LARGE_API_OPERATION_THRESHOLD = 50;
+export function renderOpenApiInspection(report) {
+    if (resolveOutputFormat() === "json") {
+        return JSON.stringify(report, null, 2);
+    }
+    return renderCatalog({
+        theme: getTheme(),
+        title: report.title ?? "OpenAPI",
+        ...(report.version === undefined ? {} : { subtitle: `v${report.version}` }),
+        metrics: [
+            {
+                label: "compatible",
+                value: `${Math.round((report.supportedCount / Math.max(report.operationCount, 1)) * 100)}%`,
+                tone: report.unsupportedCount === 0 ? "success" : "accent"
+            },
+            { label: pluralize("operation", report.operationCount), value: report.operationCount },
+            { label: "supported", value: report.supportedCount, tone: "success" },
+            {
+                label: "unsupported",
+                value: report.unsupportedCount,
+                tone: report.unsupportedCount === 0 ? "muted" : "warning"
+            }
+        ],
+        groups: report.operationCount > LARGE_API_OPERATION_THRESHOLD
+            ? summarizeOperationGroups(report.operations)
+            : groupOperations(report.operations)
+    });
+}
+function groupOperations(operations) {
+    return collectOperationGroups(operations).map(([title, groupOperations]) => ({
+        title,
+        items: groupOperations.map((operation) => ({
+            label: operation.status === "supported" ? "ready" : "blocked",
+            value: `${operation.method} ${operation.path}`,
+            detail: operation.status === "supported"
+                ? (operation.commandPath ?? operation.operationId)
+                : (operation.reason ?? operation.operationId),
+            tone: operation.status === "supported" ? "success" : "warning"
+        }))
+    }));
+}
+function summarizeOperationGroups(operations) {
+    const groups = collectOperationGroups(operations);
+    const incompatibilities = summarizeIncompatibilities(operations);
+    const blockedGroups = groups
+        .filter(([, groupOperations]) => groupOperations.some((operation) => operation.status === "unsupported"))
+        .sort(([leftTitle, leftOperations], [rightTitle, rightOperations]) => {
+        const blockedCountDifference = countUnsupported(rightOperations) - countUnsupported(leftOperations);
+        return blockedCountDifference || leftTitle.localeCompare(rightTitle);
+    });
+    const resourceItems = blockedGroups.length === 0
+        ? [
+            {
+                label: `${operations.length}/${operations.length}`,
+                value: "all resources",
+                detail: `${groups.length} groups compatible`,
+                tone: "success"
+            }
+        ]
+        : blockedGroups.map(([title, groupOperations]) => {
+            const supportedCount = groupOperations.filter((operation) => operation.status === "supported").length;
+            const unsupportedCount = countUnsupported(groupOperations);
+            const firstUnsupported = groupOperations.find((operation) => operation.status === "unsupported");
+            return {
+                label: `${supportedCount}/${groupOperations.length}`,
+                value: title,
+                detail: `${unsupportedCount} unsupported · ${firstUnsupported?.reason ?? "inspect JSON output"}`,
+                tone: "warning"
+            };
+        });
+    return [
+        {
+            title: "resources",
+            description: blockedGroups.length === 0
+                ? "Every generated command group is compatible."
+                : `Showing ${blockedGroups.length} of ${groups.length} command groups that need attention. Use --output-format json for every route.`,
+            items: resourceItems
+        },
+        ...(incompatibilities.length === 0
+            ? []
+            : [
+                {
+                    title: "top incompatibilities",
+                    description: "First failing compatibility check per blocked route.",
+                    items: incompatibilities.map(([reason, count]) => ({
+                        label: `${count} ${pluralize("route", count)}`,
+                        value: reason,
+                        tone: "warning"
+                    }))
+                }
+            ])
+    ];
+}
+function countUnsupported(operations) {
+    return operations.filter((operation) => operation.status === "unsupported").length;
+}
+function summarizeIncompatibilities(operations) {
+    const counts = new Map();
+    for (const operation of operations) {
+        if (operation.status !== "unsupported" || operation.reason === undefined) {
+            continue;
+        }
+        const normalizedReason = operation.reason.replace(/^Operation "[^"]+" /, "Operation ");
+        counts.set(normalizedReason, (counts.get(normalizedReason) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .sort(([leftReason, leftCount], [rightReason, rightCount]) => rightCount - leftCount || leftReason.localeCompare(rightReason))
+        .slice(0, 5);
+}
+function collectOperationGroups(operations) {
+    const groups = new Map();
+    for (const operation of operations) {
+        const groupName = getGroupName(operation);
+        const group = groups.get(groupName) ?? [];
+        group.push(operation);
+        groups.set(groupName, group);
+    }
+    return [...groups.entries()].sort(([left], [right]) => left.localeCompare(right));
+}
+function getGroupName(operation) {
+    if (operation.commandPath !== undefined) {
+        return operation.commandPath.split(" ")[0] ?? "root";
+    }
+    return (operation.path.split("/").find((segment) => segment.length > 0 && !segment.startsWith("{")) ??
+        "root");
+}
+function pluralize(noun, count) {
+    return count === 1 ? noun : `${noun}s`;
+}

package/dist/request-shape.d.ts

@@ -6,6 +6,10 @@ export declare const REQUEST_PARAM_SECTIONS: readonly [{
     readonly location: "query";
     readonly key: "query";
     readonly omittable: false;
+}, {
+    readonly location: "header";
+    readonly key: "headers";
+    readonly omittable: false;
 }, {
     readonly location: "body";
     readonly key: "body";

package/dist/request-shape.js

@@ -1,5 +1,6 @@
 export const REQUEST_PARAM_SECTIONS = [
     { location: "path", key: "pathParams", omittable: false },
     { location: "query", key: "query", omittable: false },
+    { location: "header", key: "headers", omittable: false },
     { location: "body", key: "body", omittable: true }
 ];

package/dist/runtime.js

@@ -53,10 +53,15 @@ function createRuntimeHandler(command) {
         const resolvedValues = executePreflightBlocks(command.preflightBlocks, params);
         const requestShape = buildRequestShape(command.requestFields, command.sectionRenders, command.optionalSections, params, resolvedValues);
         return requestJson({
-            baseUrl,
+            baseUrl: command.baseUrl ?? baseUrl,
             path: command.path,
             method: command.method,
             auth: command.auth,
+            responseMode: command.responseMode,
+            accept: command.accept,
+            bodyMode: command.bodyMode,
+            contentType: command.contentType,
+            multipartBinaryFields: command.multipartBinaryFields,
             tokenSource,
             fetch,
             dryRun: params.dryRun,
@@ -80,6 +85,7 @@ const RUNTIME_DEFINITION_BUILDERS = {
     },
     boolean: (_definition, options) => options === undefined ? S.Boolean() : S.Boolean(options),
     enum: (definition, options) => options === undefined ? S.Enum(definition.enumValues) : S.Enum(definition.enumValues, options),
+    json: (_definition) => S.Json(),
     number: (_definition, options) => options === undefined ? S.Number() : S.Number(options),
     string: (_definition, options) => options === undefined ? S.String() : S.String(options)
 };

package/dist/spec-source.js

@@ -93,8 +93,11 @@ function formatParseErrorMessage(error, sourceText, filePath) {
         filePath
     })}`;
 }
+function hasOwnProperty(value, name) {
+    return Object.prototype.hasOwnProperty.call(value, name);
+}
 function getYamlLinePosition(error) {
-    if (typeof error !== "object" || error === null || !("linePos" in error)) {
+    if (typeof error !== "object" || error === null || !hasOwnProperty(error, "linePos")) {
         return null;
     }
     const linePos = error.linePos;
@@ -105,15 +108,15 @@ function getYamlLinePosition(error) {
     if (typeof firstPosition !== "object" || firstPosition === null) {
         return null;
     }
-    const line = "line" in firstPosition ? firstPosition.line : undefined;
-    const column = "col" in firstPosition ? firstPosition.col : undefined;
+    const line = hasOwnProperty(firstPosition, "line") ? firstPosition.line : undefined;
+    const column = hasOwnProperty(firstPosition, "col") ? firstPosition.col : undefined;
     if (typeof line !== "number" || typeof column !== "number") {
         return null;
     }
     return { line, column };
 }
 function getYamlOffsetPosition(error, sourceText) {
-    if (typeof error !== "object" || error === null || !("pos" in error)) {
+    if (typeof error !== "object" || error === null || !hasOwnProperty(error, "pos")) {
         return null;
     }
     const pos = error.pos;

package/node_modules/auth-store/dist/create-secret-store.js

@@ -27,7 +27,7 @@ export function createSecretStore(input) {
 }
 function resolveBackend(input) {
     const envVar = input.backendEnvVar ?? DEFAULT_BACKEND_ENV_VAR;
-    const configuredBackend = input.backend ?? input.env?.[envVar] ?? process.env[envVar];
+    const configuredBackend = input.backend ?? getOwnEnvValue(input.env, envVar) ?? getOwnEnvValue(process.env, envVar);
     if (configuredBackend === "keychain") {
         return "keychain";
     }
@@ -36,3 +36,8 @@ function resolveBackend(input) {
     }
     throw new Error(`Unsupported auth store backend: ${configuredBackend}`);
 }
+function getOwnEnvValue(env, key) {
+    return env !== undefined && Object.prototype.hasOwnProperty.call(env, key)
+        ? env[key]
+        : undefined;
+}

package/node_modules/auth-store/dist/encrypted-file-store.d.ts

@@ -42,6 +42,6 @@ export declare class EncryptedFileStore implements SecretStore {
     get(): Promise<string | null>;
     set(value: string): Promise<void>;
     delete(): Promise<void>;
-    private assertRegularCredentialPath;
+    private assertCredentialPathHasNoSymbolicLinks;
     private getEncryptionKey;
 }

package/node_modules/auth-store/dist/encrypted-file-store.js

@@ -1,7 +1,8 @@
-import { createCipheriv, createDecipheriv, randomBytes, scrypt } from "node:crypto";
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID, scrypt } from "node:crypto";
 import { promises as fs } from "node:fs";
 import { homedir, hostname, userInfo } from "node:os";
 import path from "node:path";
+import { hasOwnErrorCode } from "./error-codes.js";
 const derivedKeyCache = new Map();
 const ENCRYPTION_ALGORITHM = "aes-256-gcm";
 const ENCRYPTION_VERSION = 1;
@@ -9,7 +10,6 @@ const ENCRYPTION_KEY_BYTES = 32;
 const ENCRYPTION_IV_BYTES = 12;
 const ENCRYPTION_AUTH_TAG_BYTES = 16;
 const ENCRYPTION_FILE_MODE = 0o600;
-let temporaryFileSequence = 0;
 export class EncryptedFileStore {
     fs;
     filePath;
@@ -35,7 +35,7 @@ export class EncryptedFileStore {
         this.getRandomBytes = input.getRandomBytes ?? randomBytes;
     }
     async get() {
-        await this.assertRegularCredentialPath();
+        await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
         let rawDocument;
         try {
             rawDocument = await this.fs.readFile(this.filePath, "utf8");
@@ -69,7 +69,7 @@ export class EncryptedFileStore {
         }
     }
     async set(value) {
-        await this.assertRegularCredentialPath();
+        await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
         const key = await this.getEncryptionKey();
         const iv = this.getRandomBytes(ENCRYPTION_IV_BYTES);
         const cipher = createCipheriv(ENCRYPTION_ALGORITHM, key, iv);
@@ -85,26 +85,29 @@ export class EncryptedFileStore {
             ciphertext: ciphertext.toString("base64")
         };
         await this.fs.mkdir(path.dirname(this.filePath), { recursive: true });
-        await this.assertRegularCredentialPath();
-        const temporaryPath = `${this.filePath}.${process.pid}.${temporaryFileSequence++}.tmp`;
+        await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
+        const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID()}.tmp`;
+        let temporaryCreated = false;
         try {
+            await this.assertCredentialPathHasNoSymbolicLinks(temporaryPath);
             await this.fs.writeFile(temporaryPath, JSON.stringify(document), {
                 encoding: "utf8",
                 flag: "wx",
                 mode: ENCRYPTION_FILE_MODE
             });
+            temporaryCreated = true;
             await this.fs.chmod(temporaryPath, ENCRYPTION_FILE_MODE);
             await this.fs.rename(temporaryPath, this.filePath);
         }
         catch (error) {
-            if (!isAlreadyExistsError(error)) {
+            if (temporaryCreated || !isAlreadyExistsError(error)) {
                 await removeIfPresent(this.fs, temporaryPath).catch(() => undefined);
             }
             throw error;
         }
     }
     async delete() {
-        await this.assertRegularCredentialPath();
+        await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
         try {
             await this.fs.unlink(this.filePath);
         }
@@ -114,8 +117,8 @@ export class EncryptedFileStore {
             }
         }
     }
-    async assertRegularCredentialPath() {
-        const resolvedPath = path.resolve(this.filePath);
+    async assertCredentialPathHasNoSymbolicLinks(targetPath) {
+        const resolvedPath = path.resolve(targetPath);
         const protectedPaths = getProtectedCredentialPaths(resolvedPath, this.symbolicLinkCheckStartPath);
         for (const currentPath of protectedPaths) {
             try {
@@ -179,12 +182,6 @@ async function removeIfPresent(fileSystem, filePath) {
         }
     }
 }
-function isAlreadyExistsError(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === "EEXIST");
-}
 function defaultMachineIdentity() {
     return {
         hostname: hostname(),
@@ -222,19 +219,23 @@ function parseEncryptedDocument(raw) {
         if (!isRecord(parsed)) {
             return null;
         }
-        if (parsed.version !== ENCRYPTION_VERSION) {
+        const version = getOwnEntry(parsed, "version");
+        const iv = getOwnEntry(parsed, "iv");
+        const authTag = getOwnEntry(parsed, "authTag");
+        const ciphertext = getOwnEntry(parsed, "ciphertext");
+        if (version !== ENCRYPTION_VERSION) {
             return null;
         }
-        if (typeof parsed.iv !== "string" ||
-            typeof parsed.authTag !== "string" ||
-            typeof parsed.ciphertext !== "string") {
+        if (typeof iv !== "string" ||
+            typeof authTag !== "string" ||
+            typeof ciphertext !== "string") {
             return null;
         }
         return {
-            version: parsed.version,
-            iv: parsed.iv,
-            authTag: parsed.authTag,
-            ciphertext: parsed.ciphertext
+            version,
+            iv,
+            authTag,
+            ciphertext
         };
     }
     catch {
@@ -244,9 +245,12 @@ function parseEncryptedDocument(raw) {
 function isRecord(value) {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function getOwnEntry(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
+}
 function isNotFoundError(error) {
-    return Boolean(error &&
-        typeof error === "object" &&
-        "code" in error &&
-        error.code === "ENOENT");
+    return hasOwnErrorCode(error, "ENOENT");
+}
+function isAlreadyExistsError(error) {
+    return hasOwnErrorCode(error, "EEXIST");
 }

package/node_modules/auth-store/dist/error-codes.d.ts

@@ -0,0 +1 @@
+export declare function hasOwnErrorCode(error: unknown, code: string): boolean;