onshape 0.1.0

package/bin/onshape.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+
+const { main } = require("../dist/cli");
+
+main(process.argv.slice(2)).catch((error) => {
+  const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  console.log(JSON.stringify({ ok: false, error: message, detail: null }, null, 2));
+  process.exit(1);
+});

package/dist/api/client.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnshapeClient = exports.HttpError = void 0;
+const node_url_1 = require("node:url");
+class HttpError extends Error {
+    status;
+    detail;
+    constructor(status, detail) {
+        super(`HTTP ${status}`);
+        this.name = "HttpError";
+        this.status = status;
+        this.detail = detail;
+    }
+}
+exports.HttpError = HttpError;
+class OnshapeClient {
+    creds;
+    constructor(creds) {
+        this.creds = creds;
+    }
+    async get(path, params) {
+        const url = new URL(path, this.creds.baseUrl);
+        if (params) {
+            const search = new node_url_1.URLSearchParams();
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined)
+                    search.set(key, String(value));
+            }
+            url.search = search.toString();
+        }
+        return this.requestJson(url);
+    }
+    async post(path, data) {
+        const response = await this.fetchWithAuthRedirects(new URL(path, this.creds.baseUrl), {
+            Accept: "application/json;charset=UTF-8; qs=0.09",
+            "Content-Type": "application/json;charset=UTF-8; qs=0.09",
+        }, "POST", data === undefined ? undefined : JSON.stringify(data));
+        if (!response.ok) {
+            throw new HttpError(response.status, await responseDetail(response));
+        }
+        return responseJsonOrStatus(response, "ok");
+    }
+    async delete(path) {
+        const response = await this.fetchWithAuthRedirects(new URL(path, this.creds.baseUrl), {
+            Accept: "application/json;charset=UTF-8; qs=0.09",
+        }, "DELETE");
+        if (!response.ok) {
+            throw new HttpError(response.status, await responseDetail(response));
+        }
+        return responseJsonOrStatus(response, "deleted");
+    }
+    async requestJson(url) {
+        const response = await this.fetchWithAuthRedirects(url, {
+            Accept: "application/json;charset=UTF-8; qs=0.09",
+        });
+        if (!response.ok) {
+            throw new HttpError(response.status, await responseDetail(response));
+        }
+        return response.json();
+    }
+    async fetchWithAuthRedirects(url, headers, method = "GET", body) {
+        const auth = Buffer.from(`${this.creds.accessKey}:${this.creds.secretKey}`).toString("base64");
+        const requestHeaders = { ...headers, Authorization: `Basic ${auth}` };
+        let current = url;
+        for (let hop = 0; hop < 5; hop += 1) {
+            const response = await fetch(current, { method, body, headers: requestHeaders, redirect: "manual" });
+            if (![301, 302, 303, 307, 308].includes(response.status))
+                return response;
+            const location = response.headers.get("location");
+            if (!location)
+                return response;
+            current = new URL(location, current);
+        }
+        return fetch(current, { method, body, headers: requestHeaders, redirect: "manual" });
+    }
+}
+exports.OnshapeClient = OnshapeClient;
+async function responseDetail(response) {
+    const text = await response.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text.slice(0, 1000);
+    }
+}
+async function responseJsonOrStatus(response, key) {
+    const text = await response.text();
+    if (!text)
+        return { [key]: true, status: response.status };
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { [key]: true, status: response.status, text: text.slice(0, 500) };
+    }
+}

package/dist/api/documents.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentManager = void 0;
+exports.normalizeDocumentList = normalizeDocumentList;
+exports.normalizeDocument = normalizeDocument;
+class DocumentManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async listDocuments(options) {
+        const response = await this.client.get("/api/v6/documents", {
+            sortColumn: options.sortBy ?? "modifiedAt",
+            sortOrder: options.sortOrder ?? "desc",
+            limit: options.limit ?? 20,
+            offset: options.offset ?? 0,
+            filter: options.filterType,
+        });
+        return normalizeDocumentList(response);
+    }
+    async searchDocuments(query, limit = 20, documentFilter = 0) {
+        const response = await this.client.get("/api/v6/documents", {
+            q: query,
+            limit,
+            filter: documentFilter || undefined,
+        });
+        return normalizeDocumentList(response);
+    }
+    async getDocument(documentId) {
+        return normalizeDocument(await this.client.get(`/api/v6/documents/${documentId}`));
+    }
+    async createDocument(name, isPublic = false, description) {
+        return this.client.post("/api/v6/documents", {
+            name,
+            isPublic,
+            ...(description ? { description } : {}),
+        });
+    }
+    async deleteDocument(documentId) {
+        return this.client.delete(`/api/v6/documents/${documentId}`);
+    }
+    async updateDocument(documentId, name, description) {
+        return this.client.post(`/api/v6/documents/${documentId}`, {
+            ...(name !== undefined ? { name } : {}),
+            ...(description !== undefined ? { description } : {}),
+        });
+    }
+    async getVersions(documentId) {
+        return this.client.get(`/api/v6/documents/d/${documentId}/versions`);
+    }
+    async createVersion(documentId, workspaceId, name, description) {
+        return this.client.post(`/api/v6/documents/d/${documentId}/versions`, {
+            documentId,
+            workspaceId,
+            name,
+            ...(description ? { description } : {}),
+        });
+    }
+    async getWorkspaces(documentId) {
+        const response = await this.client.get(`/api/v6/documents/d/${documentId}/workspaces`);
+        const items = Array.isArray(response) ? response : [];
+        return items.map(normalizeWorkspace);
+    }
+    async getElements(documentId, workspaceId, elementType) {
+        const response = await this.client.get(`/api/v6/documents/d/${documentId}/w/${workspaceId}/elements`);
+        const items = Array.isArray(response) ? response : [];
+        return items.map(normalizeElement).filter((element) => {
+            if (!elementType)
+                return true;
+            const normalizedElementType = String(element.element_type ?? "").replaceAll(" ", "").toUpperCase();
+            const normalizedFilter = elementType.replaceAll(" ", "").toUpperCase();
+            return normalizedElementType === normalizedFilter;
+        });
+    }
+    async findPartStudios(documentId, workspaceId, namePattern) {
+        const elements = await this.getElements(documentId, workspaceId, "PARTSTUDIO");
+        if (!namePattern)
+            return elements;
+        const pattern = namePattern.toLowerCase();
+        return elements.filter((element) => String(element.name ?? "").toLowerCase().includes(pattern));
+    }
+    async getDocumentSummary(documentId) {
+        const document = await this.getDocument(documentId);
+        const workspaces = await this.getWorkspaces(documentId);
+        const workspaceDetails = [];
+        for (const workspace of workspaces) {
+            const workspaceRecord = workspace;
+            const elements = await this.getElements(documentId, String(workspaceRecord.id));
+            workspaceDetails.push({ workspace, elements });
+        }
+        return { document, workspaces, workspace_details: workspaceDetails };
+    }
+}
+exports.DocumentManager = DocumentManager;
+function normalizeDocumentList(response) {
+    const items = isRecord(response) && Array.isArray(response.items) ? response.items : [];
+    return items.map(normalizeDocument).filter(Boolean);
+}
+function normalizeDocument(response) {
+    if (!isRecord(response))
+        return null;
+    const owner = isRecord(response.owner) ? response.owner : {};
+    const thumbnail = isRecord(response.thumbnail) ? response.thumbnail.href : null;
+    return {
+        id: response.id ?? null,
+        name: response.name ?? null,
+        created_at: response.createdAt ?? null,
+        modified_at: response.modifiedAt ?? null,
+        owner_id: owner.id ?? "",
+        owner_name: owner.name ?? null,
+        public: response.public ?? false,
+        description: response.description ?? null,
+        thumbnail,
+    };
+}
+function normalizeWorkspace(response) {
+    const item = isRecord(response) ? response : {};
+    return {
+        id: item.id ?? null,
+        name: item.name ?? null,
+        is_main: item.isMain ?? false,
+        created_at: item.createdAt ?? null,
+        modified_at: item.modifiedAt ?? null,
+    };
+}
+function normalizeElement(response) {
+    const item = isRecord(response) ? response : {};
+    return {
+        id: item.id ?? null,
+        name: item.name ?? null,
+        element_type: item.type ?? "UNKNOWN",
+        data_type: item.dataType ?? null,
+        thumbnail: item.thumbnail ?? null,
+    };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/api/edges.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeQuery = void 0;
+const fsvalue_1 = require("./fsvalue");
+const INCH_TO_METER = 0.0254;
+class EdgeQuery {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getEdges(documentId, workspaceId, elementId) {
+        const response = await this.client.get(`/api/v6/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/bodydetails`, {
+            includeTopology: "true",
+        });
+        const bodies = isRecord(response) && Array.isArray(response.bodies) ? response.bodies : [];
+        const edges = [];
+        for (const body of bodies) {
+            if (!isRecord(body))
+                continue;
+            const bodyId = body.id;
+            const bodyEdges = Array.isArray(body.edges) ? body.edges : [];
+            for (const edge of bodyEdges) {
+                if (!isRecord(edge))
+                    continue;
+                const geom = isRecord(edge.geometry) ? edge.geometry : {};
+                let geometryType = geom.type ?? edge.geometryType;
+                if (!geometryType) {
+                    const btType = String(geom.btType ?? "");
+                    if (geom.radius !== undefined || btType.includes("Circle") || btType.includes("Arc")) {
+                        geometryType = geom.startPoint !== geom.endPoint && geom.radius !== undefined ? "arc" : "circle";
+                    }
+                    else if (geom.startPoint !== undefined && geom.endPoint !== undefined) {
+                        geometryType = "line";
+                    }
+                    else {
+                        geometryType = "unknown";
+                    }
+                }
+                const info = {
+                    id: edge.id,
+                    body: bodyId,
+                    type: String(geometryType).toLowerCase(),
+                };
+                if (typeof geom.radius === "number")
+                    info.radius = geom.radius / INCH_TO_METER;
+                edges.push(info);
+            }
+        }
+        return { edges, count: edges.length, bodyCount: bodies.length };
+    }
+    async findCircularEdges(documentId, workspaceId, elementId, radius, tolerance = 0.001) {
+        const result = await this.getEdges(documentId, workspaceId, elementId);
+        const edges = isRecord(result) && Array.isArray(result.edges) ? result.edges : [];
+        return edges.filter((edge) => {
+            if (!isRecord(edge) || typeof edge.radius !== "number")
+                return false;
+            return radius === undefined || Math.abs(edge.radius - radius) <= tolerance;
+        });
+    }
+    async findEdgesByFeature(documentId, workspaceId, elementId, featureId) {
+        const script = `
+        function(context is Context, queries) {
+            const feature = qCreatedBy(makeId("${featureId}"), EntityType.EDGE);
+            const edges = evaluateQuery(context, feature);
+
+            const edgeIds = [];
+            for (var edge in edges) {
+                try {
+                    const detId = toString(qDeterministicIdQuery(edge));
+                    edgeIds = append(edgeIds, detId);
+                } catch {}
+            }
+
+            return edgeIds;
+        }
+        `;
+        const response = await this.client.post(`/api/v6/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/featurescript`, {
+            script,
+        });
+        const decoded = (0, fsvalue_1.unwrapFeatureScriptResult)(response);
+        return Array.isArray(decoded) ? decoded : [];
+    }
+}
+exports.EdgeQuery = EdgeQuery;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/api/fsvalue.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureScriptError = void 0;
+exports.featurescriptMessages = featurescriptMessages;
+exports.decodeFsValue = decodeFsValue;
+exports.unwrapFeatureScriptResult = unwrapFeatureScriptResult;
+class FeatureScriptError extends Error {
+    notices;
+    constructor(notices) {
+        super(String(notices[0]?.message ?? "unknown FeatureScript error"));
+        this.notices = notices;
+        this.name = "FeatureScriptError";
+    }
+}
+exports.FeatureScriptError = FeatureScriptError;
+function featurescriptMessages(response) {
+    if (!isRecord(response) || !Array.isArray(response.notices))
+        return [];
+    return response.notices
+        .filter((notice) => isRecord(notice) && Boolean(notice.message))
+        .map((notice) => ({ type: notice.type, message: notice.message }));
+}
+function decodeFsValue(value) {
+    if (!isRecord(value))
+        return value;
+    const btType = String(value.btType ?? "");
+    const payload = value.value === undefined && isRecord(value.message) ? value.message : value;
+    if (btType.includes("BTFSValueMap") && !btType.includes("Entry")) {
+        const out = {};
+        const entries = Array.isArray(payload.value) ? payload.value : [];
+        for (const entry of entries) {
+            if (!isRecord(entry))
+                continue;
+            out[String(decodeFsValue(entry.key))] = decodeFsValue(entry.value);
+        }
+        return out;
+    }
+    if (btType.includes("BTFSValueArray")) {
+        const items = Array.isArray(payload.value) ? payload.value : [];
+        return items.map(decodeFsValue);
+    }
+    return payload.value;
+}
+function unwrapFeatureScriptResult(response) {
+    if (!isRecord(response) || response.result === null || response.result === undefined)
+        return null;
+    return decodeFsValue(response.result);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/api/partstudio.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartStudioManager = void 0;
+exports.loadJson = loadJson;
+const node_fs_1 = require("node:fs");
+class PartStudioManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getFeatures(documentId, workspaceId, elementId, configuration) {
+        return this.client.get(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/features`, {
+            configuration,
+        });
+    }
+    async getFeatureSpecs(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/featurespecs`);
+    }
+    async getSketchInfo(documentId, workspaceId, elementId, sketchId) {
+        return this.client.get(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/sketches`, {
+            includeGeometry: "true",
+            sketchId,
+        });
+    }
+    async getBodyDetails(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v6/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/bodydetails`, {
+            includeTopology: "true",
+        });
+    }
+    async getParts(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v9/parts/d/${documentId}/w/${workspaceId}/e/${elementId}`);
+    }
+    async createPartStudio(documentId, workspaceId, name) {
+        return this.client.post(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}`, { name });
+    }
+    async deleteFeature(documentId, workspaceId, elementId, featureId) {
+        return this.client.delete(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/features/featureid/${featureId}`);
+    }
+    async addFeature(documentId, workspaceId, elementId, feature) {
+        return this.client.post(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/features`, feature);
+    }
+    async updateFeature(documentId, workspaceId, elementId, featureId, feature) {
+        return this.client.post(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/features/featureid/${featureId}`, feature);
+    }
+    async rollback(documentId, workspaceId, elementId, index) {
+        return this.client.post(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/features/rollback`, {
+            rollbackIndex: index,
+        });
+    }
+}
+exports.PartStudioManager = PartStudioManager;
+function loadJson(inline, file) {
+    const raw = file ? (0, node_fs_1.readFileSync)(file, "utf8") : inline;
+    if (!raw)
+        throw new Error("Expected JSON via --json or --json-file");
+    return JSON.parse(raw);
+}

package/dist/cli.js

@@ -0,0 +1,478 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const promises_1 = require("node:readline/promises");
+const node_process_1 = require("node:process");
+const credentials_1 = require("./credentials");
+const client_1 = require("./api/client");
+const documents_1 = require("./api/documents");
+const edges_1 = require("./api/edges");
+const partstudio_1 = require("./api/partstudio");
+const output_1 = require("./output");
+async function main(argv) {
+    try {
+        await run(argv);
+    }
+    catch (error) {
+        if (error instanceof credentials_1.CredentialError) {
+            (0, output_1.emitError)(error.message);
+            process.exitCode = 2;
+            return;
+        }
+        if (error instanceof output_1.CliError) {
+            (0, output_1.emitError)(error.message, error.detail);
+            process.exitCode = error.exitCode;
+            return;
+        }
+        if (error instanceof client_1.HttpError) {
+            (0, output_1.emitError)(`HTTP ${error.status}`, error.detail);
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+}
+async function run(argv) {
+    const parsed = parseArgs(argv);
+    if (parsed.options.help || parsed.options.h || !parsed.command) {
+        printHelp();
+        return;
+    }
+    switch (parsed.command) {
+        case "config":
+            await handleConfig(parsed);
+            return;
+        case "login":
+            await handleLogin(parsed.options);
+            return;
+        case "logout":
+            (0, output_1.emit)(new credentials_1.CredentialStore().clear());
+            return;
+        case "list-documents":
+        case "search-documents":
+        case "get-document":
+        case "get-document-summary":
+        case "create-document":
+        case "delete-document":
+        case "update-document":
+        case "get-elements":
+        case "find-part-studios":
+        case "get-workspaces":
+        case "list-versions":
+        case "create-version":
+        case "get-parts":
+        case "get-features":
+        case "get-feature-specs":
+        case "get-sketch-info":
+        case "get-body-details":
+        case "create-part-studio":
+        case "delete-feature":
+        case "delete-element":
+        case "add-feature":
+        case "update-feature":
+        case "rollback":
+        case "get-edges":
+        case "find-circular-edges":
+        case "find-edges-by-feature":
+        case "mass-properties":
+            await handleReadCommand(parsed);
+            return;
+        default:
+            throw new output_1.CliError(`Unknown command: ${parsed.command}`, null, 2);
+    }
+}
+function parseArgs(argv) {
+    const options = {};
+    const positionals = [];
+    let command = null;
+    for (let index = 0; index < argv.length; index += 1) {
+        const item = argv[index];
+        if (item.startsWith("--")) {
+            const eq = item.indexOf("=");
+            const rawKey = item.slice(2, eq === -1 ? undefined : eq);
+            const key = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+            if (eq !== -1) {
+                options[key] = item.slice(eq + 1);
+            }
+            else if (argv[index + 1] && !argv[index + 1].startsWith("-")) {
+                options[key] = argv[index + 1];
+                index += 1;
+            }
+            else {
+                options[key] = true;
+            }
+        }
+        else if (item.startsWith("-") && item.length > 1) {
+            options[item.slice(1)] = true;
+        }
+        else if (!command) {
+            command = item;
+        }
+        else {
+            positionals.push(item);
+        }
+    }
+    return { command, positionals, options };
+}
+async function handleConfig(parsed) {
+    const action = parsed.positionals[0];
+    const store = new credentials_1.CredentialStore();
+    switch (action) {
+        case "path":
+            (0, output_1.emit)({ path: store.configPath() });
+            return;
+        case "show":
+            (0, output_1.emit)(store.describe());
+            return;
+        case "clear":
+            (0, output_1.emit)(store.clear());
+            return;
+        case "set": {
+            const accessKey = stringOption(parsed.options, "accessKey");
+            const secretKey = stringOption(parsed.options, "secretKey");
+            if (!accessKey || !secretKey) {
+                throw new output_1.CliError("config set requires --access-key and --secret-key in the Node CLI.", null, 2);
+            }
+            const creds = {
+                accessKey,
+                secretKey,
+                baseUrl: stringOption(parsed.options, "baseUrl") ?? credentials_1.DEFAULT_BASE_URL,
+            };
+            const result = store.save(creds, storeMode(parsed.options));
+            (0, output_1.emit)({ ...result, verified: null });
+            return;
+        }
+        default:
+            throw new output_1.CliError("Usage: onshape config set|show|path|clear", null, 2);
+    }
+}
+async function handleLogin(options) {
+    let accessKey = stringOption(options, "accessKey") ?? process.env.ONSHAPE_ACCESS_KEY;
+    let secretKey = stringOption(options, "secretKey") ?? process.env.ONSHAPE_SECRET_KEY;
+    const baseUrl = stringOption(options, "baseUrl") ?? process.env.ONSHAPE_BASE_URL ?? credentials_1.DEFAULT_BASE_URL;
+    if ((!accessKey || !secretKey) && !process.stdin.isTTY) {
+        throw new output_1.CliError("login cannot prompt in a non-interactive terminal. Pass --access-key and --secret-key.", null, 2);
+    }
+    if (!accessKey || !secretKey) {
+        if (!options.noBrowser) {
+            const open = await Promise.resolve().then(() => __importStar(require("open")));
+            await open.default("https://dev.onshape.com/keys");
+        }
+        const rl = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+        try {
+            accessKey = accessKey ?? (await rl.question("Onshape access key: "));
+            secretKey = secretKey ?? (await rl.question("Onshape secret key: "));
+        }
+        finally {
+            rl.close();
+        }
+    }
+    if (!accessKey || !secretKey) {
+        throw new output_1.CliError("Both an access key and a secret key are required.", null, 2);
+    }
+    const creds = { accessKey, secretKey, baseUrl };
+    let verified = null;
+    let verifyError;
+    if (!options.noVerify) {
+        try {
+            await new client_1.OnshapeClient(creds).get("/api/v6/documents", { limit: 1 });
+            verified = true;
+        }
+        catch (error) {
+            verified = false;
+            verifyError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+        }
+    }
+    const result = {
+        ...new credentials_1.CredentialStore().save(creds, storeMode(options)),
+        verified,
+    };
+    if (verifyError)
+        result.verifyError = verifyError;
+    (0, output_1.emit)(result);
+}
+async function handleReadCommand(parsed) {
+    const creds = resolveCredentials(parsed.options);
+    const client = new client_1.OnshapeClient(creds);
+    const docs = new documents_1.DocumentManager(client);
+    const partstudios = new partstudio_1.PartStudioManager(client);
+    const edges = new edges_1.EdgeQuery(client);
+    switch (parsed.command) {
+        case "list-documents": {
+            const filterMap = { all: undefined, owned: 1, created: 4, shared: 5 };
+            const filter = stringOption(parsed.options, "filter") ?? "all";
+            (0, output_1.emit)(await docs.listDocuments({
+                filterType: filterMap[filter],
+                limit: numberOption(parsed.options, "limit", 20),
+                sortBy: stringOption(parsed.options, "sortBy") ?? "modifiedAt",
+                sortOrder: stringOption(parsed.options, "sortOrder") ?? "desc",
+            }));
+            return;
+        }
+        case "search-documents":
+            (0, output_1.emit)(await docs.searchDocuments(parsed.positionals[0] ?? missing("query"), numberOption(parsed.options, "limit", 20)));
+            return;
+        case "get-document":
+            (0, output_1.emit)(await docs.getDocument(requiredOption(parsed.options, "doc")));
+            return;
+        case "get-document-summary":
+            (0, output_1.emit)(await docs.getDocumentSummary(requiredOption(parsed.options, "doc")));
+            return;
+        case "create-document":
+            (0, output_1.emit)(await docs.createDocument(requiredOption(parsed.options, "name"), Boolean(parsed.options.public), stringOption(parsed.options, "description")));
+            return;
+        case "delete-document":
+            (0, output_1.emit)(await docs.deleteDocument(requiredOption(parsed.options, "doc")));
+            return;
+        case "update-document":
+            (0, output_1.emit)(await docs.updateDocument(requiredOption(parsed.options, "doc"), stringOption(parsed.options, "name"), stringOption(parsed.options, "description")));
+            return;
+        case "get-elements": {
+            const { doc, ws } = docWorkspace(parsed.options);
+            (0, output_1.emit)(await docs.getElements(doc, ws, stringOption(parsed.options, "type")));
+            return;
+        }
+        case "find-part-studios": {
+            const { doc, ws } = docWorkspace(parsed.options);
+            (0, output_1.emit)(await docs.findPartStudios(doc, ws, stringOption(parsed.options, "name")));
+            return;
+        }
+        case "get-workspaces":
+            (0, output_1.emit)(await docs.getWorkspaces(requiredOption(parsed.options, "doc")));
+            return;
+        case "list-versions":
+            (0, output_1.emit)(await docs.getVersions(requiredOption(parsed.options, "doc")));
+            return;
+        case "create-version": {
+            const { doc, ws } = docWorkspace(parsed.options);
+            (0, output_1.emit)(await docs.createVersion(doc, ws, requiredOption(parsed.options, "name"), stringOption(parsed.options, "description")));
+            return;
+        }
+        case "get-features": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await partstudios.getFeatures(doc, ws, elem, stringOption(parsed.options, "configuration")));
+            return;
+        }
+        case "get-feature-specs": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await partstudios.getFeatureSpecs(doc, ws, elem));
+            return;
+        }
+        case "get-sketch-info": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await partstudios.getSketchInfo(doc, ws, elem, stringOption(parsed.options, "sketch")));
+            return;
+        }
+        case "get-body-details": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await partstudios.getBodyDetails(doc, ws, elem));
+            return;
+        }
+        case "get-parts": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await partstudios.getParts(doc, ws, elem));
+            return;
+        }
+        case "create-part-studio": {
+            const { doc, ws } = docWorkspace(parsed.options);
+            (0, output_1.emit)(await partstudios.createPartStudio(doc, ws, requiredOption(parsed.options, "name")));
+            return;
+        }
+        case "delete-feature": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await partstudios.deleteFeature(doc, ws, elem, requiredOption(parsed.options, "feature")));
+            return;
+        }
+        case "delete-element": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await client.delete(`/api/v9/elements/d/${doc}/w/${ws}/e/${elem}`));
+            return;
+        }
+        case "add-feature": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            const feature = requiredJson(parsed.options);
+            (0, output_1.emit)(await withFeatureId(partstudios.addFeature(doc, ws, elem, feature)));
+            return;
+        }
+        case "update-feature": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            const feature = requiredJson(parsed.options);
+            (0, output_1.emit)(await partstudios.updateFeature(doc, ws, elem, requiredOption(parsed.options, "feature"), feature));
+            return;
+        }
+        case "rollback": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await partstudios.rollback(doc, ws, elem, requiredNumberOption(parsed.options, "index")));
+            return;
+        }
+        case "get-edges": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await edges.getEdges(doc, ws, elem));
+            return;
+        }
+        case "find-circular-edges": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await edges.findCircularEdges(doc, ws, elem, optionalNumberOption(parsed.options, "radius")));
+            return;
+        }
+        case "find-edges-by-feature": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await edges.findEdgesByFeature(doc, ws, elem, requiredOption(parsed.options, "feature")));
+            return;
+        }
+        case "mass-properties": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await client.get(`/api/v6/partstudios/d/${doc}/w/${ws}/e/${elem}/massproperties`, {
+                configuration: stringOption(parsed.options, "configuration"),
+            }));
+            return;
+        }
+    }
+}
+async function withFeatureId(responsePromise) {
+    const response = await responsePromise;
+    const featureId = isRecord(response) && isRecord(response.feature) ? response.feature.featureId ?? null : null;
+    return { featureId, response };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function resolveCredentials(options) {
+    return new credentials_1.CredentialStore().resolve({
+        accessKey: stringOption(options, "accessKey"),
+        secretKey: stringOption(options, "secretKey"),
+        baseUrl: stringOption(options, "baseUrl"),
+    });
+}
+function dwe(options) {
+    return {
+        doc: stringOption(options, "doc") ?? process.env.ONSHAPE_DOC ?? missing("doc"),
+        ws: stringOption(options, "ws") ?? process.env.ONSHAPE_WS ?? missing("ws"),
+        elem: stringOption(options, "elem") ?? process.env.ONSHAPE_ELEM ?? missing("elem"),
+    };
+}
+function docWorkspace(options) {
+    return {
+        doc: stringOption(options, "doc") ?? process.env.ONSHAPE_DOC ?? missing("doc"),
+        ws: stringOption(options, "ws") ?? process.env.ONSHAPE_WS ?? missing("ws"),
+    };
+}
+function stringOption(options, key) {
+    const value = options[key];
+    return typeof value === "string" ? value : undefined;
+}
+function numberOption(options, key, fallback) {
+    const value = stringOption(options, key);
+    return value === undefined ? fallback : Number(value);
+}
+function optionalNumberOption(options, key) {
+    const value = stringOption(options, key);
+    if (value === undefined)
+        return undefined;
+    const number = Number(value);
+    if (!Number.isFinite(number))
+        throw new output_1.CliError(`--${key} must be a number`, null, 2);
+    return number;
+}
+function requiredNumberOption(options, key) {
+    const value = stringOption(options, key);
+    if (value === undefined)
+        missing(key);
+    const number = Number(value);
+    if (!Number.isFinite(number))
+        throw new output_1.CliError(`--${key} must be a number`, null, 2);
+    return number;
+}
+function requiredOption(options, key) {
+    return stringOption(options, key) ?? missing(key);
+}
+function requiredJson(options) {
+    try {
+        return (0, partstudio_1.loadJson)(stringOption(options, "json"), stringOption(options, "jsonFile"));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new output_1.CliError(message, null, 2);
+    }
+}
+function missing(key) {
+    throw new output_1.CliError(`Missing required option --${key}`, null, 2);
+}
+function storeMode(options) {
+    const value = stringOption(options, "store") ?? "auto";
+    if (value === "auto" || value === "file" || value === "keychain")
+        return value;
+    throw new output_1.CliError("--store must be one of: auto, file, keychain", null, 2);
+}
+function printHelp() {
+    console.log(`onshape
+
+Usage:
+  onshape <command> [options]
+
+Commands:
+  login
+  logout
+  config set|show|path|clear
+  list-documents
+  search-documents
+  get-document
+  get-document-summary
+  create-document
+  delete-document
+  update-document
+  get-elements
+  find-part-studios
+  get-workspaces
+  list-versions
+  create-version
+  get-parts
+  get-features
+  get-feature-specs
+  get-sketch-info
+  get-body-details
+  create-part-studio
+  delete-feature
+  delete-element
+  add-feature
+  update-feature
+  rollback
+  get-edges
+  find-circular-edges
+  find-edges-by-feature
+  mass-properties
+`);
+}

package/dist/credentials.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredentialStore = exports.CredentialError = exports.DEFAULT_BASE_URL = void 0;
+exports.redactSecret = redactSecret;
+exports.accountForBaseUrl = accountForBaseUrl;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+exports.DEFAULT_BASE_URL = "https://cad.onshape.com";
+const KEYCHAIN_SERVICE = "onshape-cli";
+class CredentialError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CredentialError";
+    }
+}
+exports.CredentialError = CredentialError;
+function redactSecret(secret) {
+    return secret.length > 8 ? `${secret.slice(0, 3)}...${secret.slice(-3)}` : "***";
+}
+function accountForBaseUrl(baseUrl) {
+    try {
+        return new URL(baseUrl).hostname;
+    }
+    catch {
+        try {
+            return new URL(`https://${baseUrl}`).hostname;
+        }
+        catch {
+            return baseUrl;
+        }
+    }
+}
+function expandHome(value) {
+    if (value === "~")
+        return (0, node_os_1.homedir)();
+    if (value.startsWith("~/"))
+        return (0, node_path_1.join)((0, node_os_1.homedir)(), value.slice(2));
+    return value;
+}
+function readJson(path) {
+    if (!(0, node_fs_1.existsSync)(path))
+        return {};
+    try {
+        const value = JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+        return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeSecureJson(path, data) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    try {
+        (0, node_fs_1.chmodSync)((0, node_path_1.dirname)(path), 0o700);
+    }
+    catch {
+        // chmod is best-effort on some platforms.
+    }
+    (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(data, null, 2)}\n`);
+    try {
+        (0, node_fs_1.chmodSync)(path, 0o600);
+    }
+    catch {
+        // chmod is best-effort on some platforms.
+    }
+}
+function loadKeyringEntry(account) {
+    try {
+        // Optional dependency. Keep it lazy so headless/CI installs can use file storage.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const keyring = require("@napi-rs/keyring");
+        return new keyring.Entry(KEYCHAIN_SERVICE, account);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CredentialError(message);
+    }
+}
+class CredentialStore {
+    configPath() {
+        return process.env.ONSHAPE_CONFIG ? expandHome(process.env.ONSHAPE_CONFIG) : (0, node_path_1.join)((0, node_os_1.homedir)(), ".onshape", "credentials.json");
+    }
+    xdgConfigPath() {
+        if ((0, node_os_1.platform)() !== "linux" || !process.env.XDG_CONFIG_HOME)
+            return null;
+        return (0, node_path_1.join)(expandHome(process.env.XDG_CONFIG_HOME), "onshape", "credentials.json");
+    }
+    resolve(overrides = {}) {
+        const fileCreds = this.firstFileCredentials();
+        const mcpCreds = this.mcpCredentials();
+        const sourceBase = fileCreds?.baseUrl ?? mcpCreds?.baseUrl ?? exports.DEFAULT_BASE_URL;
+        const accessKey = overrides.accessKey ?? process.env.ONSHAPE_ACCESS_KEY ?? fileCreds?.accessKey ?? mcpCreds?.accessKey;
+        const secretKey = overrides.secretKey ?? process.env.ONSHAPE_SECRET_KEY ?? fileCreds?.secretKey ?? mcpCreds?.secretKey;
+        const baseUrl = overrides.baseUrl ?? process.env.ONSHAPE_BASE_URL ?? sourceBase;
+        if (!accessKey || !secretKey) {
+            throw new CredentialError("No credentials. Run 'onshape login', set ONSHAPE_ACCESS_KEY / ONSHAPE_SECRET_KEY, or pass --access-key/--secret-key.");
+        }
+        return { accessKey, secretKey, baseUrl };
+    }
+    save(creds, store = "auto") {
+        if (store !== "auto" && store !== "file" && store !== "keychain") {
+            throw new CredentialError("store must be one of: auto, file, keychain");
+        }
+        if (store === "auto" || store === "keychain") {
+            try {
+                return this.saveKeychain(creds);
+            }
+            catch (error) {
+                if (store === "keychain")
+                    throw error;
+            }
+        }
+        writeSecureJson(this.configPath(), {
+            backend: "file",
+            access_key: creds.accessKey,
+            secret_key: creds.secretKey,
+            base_url: creds.baseUrl,
+        });
+        return { saved: true, backend: "file", path: this.configPath() };
+    }
+    clear() {
+        const path = this.configPath();
+        const data = readJson(path);
+        const existed = (0, node_fs_1.existsSync)(path);
+        if (existed)
+            (0, node_fs_1.rmSync)(path);
+        let keychainDeleted = false;
+        if (data.backend === "keychain") {
+            const account = data.account ?? accountForBaseUrl(data.base_url ?? exports.DEFAULT_BASE_URL);
+            try {
+                keychainDeleted = loadKeyringEntry(account).deleteCredential();
+            }
+            catch {
+                keychainDeleted = false;
+            }
+        }
+        return { cleared: existed || keychainDeleted, path, keychain_deleted: keychainDeleted };
+    }
+    describe() {
+        const path = this.configPath();
+        const data = readJson(path);
+        if (!data.access_key)
+            return { configured: false, path, base_url: exports.DEFAULT_BASE_URL };
+        const backend = data.backend ?? (data.secret_key ? "file" : undefined);
+        const baseUrl = data.base_url ?? exports.DEFAULT_BASE_URL;
+        const result = {
+            configured: true,
+            path,
+            base_url: baseUrl,
+            backend,
+            source: "file",
+            access_key: data.access_key,
+        };
+        let secret = data.secret_key;
+        if (backend === "keychain") {
+            const account = data.account ?? accountForBaseUrl(baseUrl);
+            result.account = account;
+            try {
+                const raw = loadKeyringEntry(account).getPassword();
+                secret = raw ? JSON.parse(raw).secret_key : undefined;
+                result.keychain_available = true;
+            }
+            catch {
+                result.keychain_available = false;
+            }
+        }
+        if (secret)
+            result.secret_key = redactSecret(secret);
+        return result;
+    }
+    saveKeychain(creds) {
+        const account = accountForBaseUrl(creds.baseUrl);
+        const value = JSON.stringify({
+            access_key: creds.accessKey,
+            secret_key: creds.secretKey,
+            base_url: creds.baseUrl,
+        });
+        loadKeyringEntry(account).setPassword(value);
+        writeSecureJson(this.configPath(), {
+            backend: "keychain",
+            access_key: creds.accessKey,
+            base_url: creds.baseUrl,
+            account,
+        });
+        return { saved: true, backend: "keychain", path: this.configPath(), account };
+    }
+    firstFileCredentials() {
+        for (const path of [this.configPath(), this.xdgConfigPath()]) {
+            if (!path)
+                continue;
+            const creds = this.credentialsFromFile(path);
+            if (creds)
+                return creds;
+        }
+        return null;
+    }
+    credentialsFromFile(path) {
+        const data = readJson(path);
+        const baseUrl = data.base_url ?? exports.DEFAULT_BASE_URL;
+        if (data.backend === "keychain") {
+            const account = data.account ?? accountForBaseUrl(baseUrl);
+            try {
+                const raw = loadKeyringEntry(account).getPassword();
+                if (!raw)
+                    return null;
+                const stored = JSON.parse(raw);
+                if (!stored.secret_key)
+                    return null;
+                return {
+                    accessKey: stored.access_key ?? data.access_key ?? "",
+                    secretKey: stored.secret_key,
+                    baseUrl: stored.base_url ?? baseUrl,
+                };
+            }
+            catch {
+                return null;
+            }
+        }
+        if (data.access_key && data.secret_key) {
+            return { accessKey: data.access_key, secretKey: data.secret_key, baseUrl };
+        }
+        return null;
+    }
+    mcpCredentials() {
+        const data = readJson((0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "mcp.json"));
+        const env = data?.mcpServers?.onshape?.env;
+        if (!env?.ONSHAPE_ACCESS_KEY || !env?.ONSHAPE_SECRET_KEY)
+            return null;
+        return {
+            accessKey: env.ONSHAPE_ACCESS_KEY,
+            secretKey: env.ONSHAPE_SECRET_KEY,
+            baseUrl: env.ONSHAPE_BASE_URL ?? exports.DEFAULT_BASE_URL,
+        };
+    }
+}
+exports.CredentialStore = CredentialStore;

package/dist/output.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = void 0;
+exports.emit = emit;
+exports.emitError = emitError;
+function emit(result) {
+    console.log(JSON.stringify({ ok: true, result }, null, 2));
+}
+function emitError(error, detail = null) {
+    console.log(JSON.stringify({ ok: false, error, detail }, null, 2));
+}
+class CliError extends Error {
+    detail;
+    exitCode;
+    constructor(message, detail = null, exitCode = 1) {
+        super(message);
+        this.name = "CliError";
+        this.detail = detail;
+        this.exitCode = exitCode;
+    }
+}
+exports.CliError = CliError;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "onshape",
+  "version": "0.1.0",
+  "description": "Node.js CLI for Onshape CAD automation with the same JSON contract as onshape-cli.",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "onshape": "bin/onshape.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "open": "^10.2.0"
+  },
+  "optionalDependencies": {
+    "@napi-rs/keyring": "^1.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0"
+  }
+}