@drawsy/companion 0.0.0-stage → 0.1.28

package/dist/drawsy/opencode-binary.js

@@ -0,0 +1,26 @@
+import { detectExecutable, resolveExecutable } from "./executable-resolver.js";
+const parseVersion = (value) => {
+    const match = value.match(/(?:opencode\s+)?(\d+)\.(\d+)\.(\d+)/i);
+    return match
+        ? [Number(match[1]), Number(match[2]), Number(match[3])]
+        : null;
+};
+export const resolveOpenCodeBinary = () => resolveExecutable({
+    configured: process.env.DRAWSY_OPENCODE_BIN,
+    names: process.platform === "win32"
+        ? ["opencode.cmd", "opencode.exe", "opencode"]
+        : ["opencode"],
+    parseVersion
+}) || null;
+export const detectOpenCodeBinary = () => {
+    const resolved = detectExecutable({
+        configured: process.env.DRAWSY_OPENCODE_BIN,
+        names: process.platform === "win32"
+            ? ["opencode.cmd", "opencode.exe", "opencode"]
+            : ["opencode"],
+        parseVersion
+    });
+    return resolved
+        ? { path: resolved.path, version: resolved.version.join(".") }
+        : null;
+};

package/dist/drawsy/protocol.js

@@ -0,0 +1,519 @@
+export const MAX_BODY_BYTES = 12 * 1024 * 1024;
+export const MAX_CANVAS_ASSET_BYTES = 8 * 1024 * 1024;
+export const MAX_DIAGRAM_SOURCE_BYTES = 256 * 1024;
+export const CANVAS_REQUEST_TIMEOUT_MS = 60_000;
+export const parseGenerationMode = (value) => {
+    if (value === undefined || value === "draw")
+        return "draw";
+    if (value === "fast")
+        return "fast";
+    throw new Error("generationMode must be 'fast' or 'draw'.");
+};
+export const surfaceSupportsLivePreview = (surfaceKind) => surfaceKind === "canvas" || surfaceKind === "presentation";
+export const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export const parseDrawsyTabId = (value) => {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "string" ||
+        value.length < 16 ||
+        value.length > 128 ||
+        !/^[A-Za-z0-9_-]+$/.test(value)) {
+        throw new Error("drawsyTabId is invalid.");
+    }
+    return value;
+};
+export const parseDrawsyTabUrl = (value) => {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "string" || value.length > 2_048) {
+        throw new Error("drawsyTabUrl is invalid.");
+    }
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("drawsyTabUrl is invalid.");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error("drawsyTabUrl is invalid.");
+    }
+    return url.href;
+};
+const renderedElementType = (element) => {
+    const type = typeof element.type === "string" ? element.type : "unknown";
+    const rounded = isRecord(element.roundness);
+    if (type === "ellipse") {
+        if (element.dimensionality === "3d") {
+            return "cylinder";
+        }
+        const width = typeof element.width === "number" ? Math.abs(element.width) : 0;
+        const height = typeof element.height === "number" ? Math.abs(element.height) : 0;
+        return width > 0 &&
+            height > 0 &&
+            Math.abs(width - height) / Math.max(width, height) <= 0.05
+            ? "circle"
+            : "ellipse";
+    }
+    if (type === "diamond") {
+        return rounded ? "rounded diamond" : "diamond";
+    }
+    if (type === "rectangle") {
+        return rounded ? "rounded rectangle" : "rectangle";
+    }
+    return type;
+};
+export const addCanvasRenderSemantics = (value) => {
+    if (!isRecord(value) || !Array.isArray(value.elements)) {
+        return value;
+    }
+    const renderContext = isRecord(value.renderContext)
+        ? value.renderContext
+        : {};
+    const visibleElements = value.elements.filter((element) => isRecord(element) &&
+        element.isDeleted !== true &&
+        typeof element.id === "string");
+    const appState = isRecord(value.appState) ? value.appState : {};
+    const selection = isRecord(value.selection) && Array.isArray(value.selection.elementIds)
+        ? value.selection.elementIds.filter((id) => typeof id === "string")
+        : isRecord(appState.selectedElementIds)
+            ? Object.entries(appState.selectedElementIds)
+                .filter(([, selected]) => selected === true)
+                .map(([id]) => id)
+            : [];
+    const countColors = (key) => {
+        const counts = new Map();
+        for (const element of visibleElements) {
+            const color = element[key];
+            if (typeof color === "string") {
+                counts.set(color, (counts.get(color) || 0) + 1);
+            }
+        }
+        return [...counts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([color, count]) => ({ color, count }));
+    };
+    return {
+        ...value,
+        renderSemantics: {
+            canvas: {
+                theme: renderContext.theme === "dark" || renderContext.theme === "light"
+                    ? renderContext.theme
+                    : "unknown",
+                backgroundColor: typeof renderContext.renderedCanvasBackgroundColor === "string"
+                    ? renderContext.renderedCanvasBackgroundColor
+                    : typeof renderContext.canvasBackgroundColor === "string"
+                        ? renderContext.canvasBackgroundColor
+                        : "unknown",
+                themePreset: typeof renderContext.themePreset === "string"
+                    ? renderContext.themePreset
+                    : "unknown",
+            },
+            selection,
+            styles: Array.isArray(value.styleSummary)
+                ? { rendered: value.styleSummary }
+                : {
+                    storedStrokeColors: countColors("strokeColor"),
+                    storedBackgroundColors: countColors("backgroundColor")
+                },
+            relationships: Array.isArray(value.relationships) ? value.relationships : visibleElements.flatMap((element) => element.type === "arrow"
+                ? [{
+                        arrowId: element.id,
+                        sourceId: isRecord(element.startBinding)
+                            ? element.startBinding.elementId ?? null
+                            : null,
+                        targetId: isRecord(element.endBinding)
+                            ? element.endBinding.elementId ?? null
+                            : null,
+                    }]
+                : []),
+            elements: visibleElements.map((element) => ({
+                id: element.id,
+                renderedType: renderedElementType(element),
+            })),
+        },
+    };
+};
+const CONNECTOR_CAPABILITIES = new Set([
+    "mail",
+    "calendar",
+    "drive",
+    "notion",
+    "slack",
+    "github",
+    "read-ai",
+    "fireflies",
+    "aws",
+]);
+export const isConnectorCapability = (value) => typeof value === "string" &&
+    CONNECTOR_CAPABILITIES.has(value);
+const boundedConnectorString = (value, label, maxLength) => {
+    if (typeof value !== "string" ||
+        !value.trim() ||
+        value.length > maxLength ||
+        /[\u0000-\u001f\u007f]/.test(value)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value.trim();
+};
+export const parseAgentConnectorTurn = (value) => {
+    if (value === undefined)
+        return null;
+    if (!isRecord(value)) {
+        throw new Error("connectors must be an object.");
+    }
+    const allowedKeys = new Set(["turnId", "sources", "grants"]);
+    if (Object.keys(value).some((key) => !allowedKeys.has(key))) {
+        throw new Error("connectors contains an unknown field.");
+    }
+    const turnId = boundedConnectorString(value.turnId, "turnId", 256);
+    if (!Array.isArray(value.sources) ||
+        value.sources.length < 1 ||
+        value.sources.length > 12) {
+        throw new Error("connectors.sources must contain 1 to 12 sources.");
+    }
+    const sources = value.sources.map((source) => {
+        if (!isRecord(source) ||
+            Object.keys(source).some((key) => !["connectionId", "capability", "label", "accountLabel"].includes(key)) ||
+            !isConnectorCapability(source.capability)) {
+            throw new Error("A connected source is invalid.");
+        }
+        return {
+            connectionId: boundedConnectorString(source.connectionId, "source connectionId", 256),
+            capability: source.capability,
+            label: boundedConnectorString(source.label, "source label", 64),
+            accountLabel: boundedConnectorString(source.accountLabel, "source accountLabel", 256),
+        };
+    });
+    if (new Set(sources.map((source) => `${source.connectionId}:${source.capability}`)).size !== sources.length) {
+        throw new Error("Connected sources must be unique.");
+    }
+    if (!Array.isArray(value.grants) ||
+        value.grants.length < 1 ||
+        value.grants.length > 6) {
+        throw new Error("connectors.grants must contain 1 to 6 grants.");
+    }
+    const grants = value.grants.map((grant) => {
+        if (!isRecord(grant) ||
+            Object.keys(grant).some((key) => !["connectionId", "grant", "expiresAt"].includes(key)) ||
+            typeof grant.expiresAt !== "number" ||
+            !Number.isInteger(grant.expiresAt) ||
+            grant.expiresAt <= Date.now() ||
+            grant.expiresAt > Date.now() + 15 * 60 * 1000) {
+            throw new Error("A connector grant is invalid or expired.");
+        }
+        return {
+            connectionId: boundedConnectorString(grant.connectionId, "grant connectionId", 256),
+            grant: boundedConnectorString(grant.grant, "connector grant", 8_192),
+            expiresAt: grant.expiresAt,
+        };
+    });
+    if (new Set(grants.map((grant) => grant.connectionId)).size !== grants.length) {
+        throw new Error("Connector grants must be unique per connection.");
+    }
+    const grantedConnections = new Set(grants.map((grant) => grant.connectionId));
+    if (sources.some((source) => !grantedConnections.has(source.connectionId))) {
+        throw new Error("Every connected source requires a matching grant.");
+    }
+    return { turnId, sources, grants };
+};
+const AI_RESOURCES = new Set(["kanban", "jira"]);
+export const parseAgentResourceTurn = (value) => {
+    if (value === undefined)
+        return null;
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !["turnId", "resources", "grant", "expiresAt"].includes(key)) ||
+        !Array.isArray(value.resources) ||
+        value.resources.length < 1 ||
+        value.resources.length > AI_RESOURCES.size ||
+        value.resources.some((resource) => typeof resource !== "string" ||
+            !AI_RESOURCES.has(resource)) ||
+        new Set(value.resources).size !== value.resources.length ||
+        typeof value.expiresAt !== "number" ||
+        !Number.isInteger(value.expiresAt) ||
+        value.expiresAt <= Date.now() ||
+        value.expiresAt > Date.now() + 15 * 60 * 1000) {
+        throw new Error("A Drawsy resource grant is invalid or expired.");
+    }
+    return {
+        turnId: boundedConnectorString(value.turnId, "resource turnId", 256),
+        resources: value.resources,
+        grant: boundedConnectorString(value.grant, "resource grant", 8_192),
+        expiresAt: value.expiresAt,
+    };
+};
+export const parseCanvasImageRequest = (value) => {
+    if (!isRecord(value)) {
+        throw new Error("Canvas image request must be an object.");
+    }
+    const finiteWithin = (candidate, min, max) => typeof candidate === "number" &&
+        Number.isFinite(candidate) &&
+        candidate >= min &&
+        candidate <= max;
+    if (typeof value.sourcePath !== "string" || !value.sourcePath.trim()) {
+        throw new Error("sourcePath must be a non-empty string.");
+    }
+    if (!finiteWithin(value.x, -1_000_000, 1_000_000) ||
+        !finiteWithin(value.y, -1_000_000, 1_000_000) ||
+        !finiteWithin(value.maxWidth, Number.EPSILON, 100_000) ||
+        (value.maxHeight !== undefined &&
+            !finiteWithin(value.maxHeight, Number.EPSILON, 100_000)) ||
+        (value.elementId !== undefined &&
+            (typeof value.elementId !== "string" ||
+                !value.elementId.trim() ||
+                value.elementId.length > 128)) ||
+        (value.frameId !== undefined &&
+            value.frameId !== null &&
+            (typeof value.frameId !== "string" ||
+                !value.frameId.trim() ||
+                value.frameId.length > 128))) {
+        throw new Error("Canvas image placement is invalid.");
+    }
+    return {
+        sourcePath: value.sourcePath.trim(),
+        x: value.x,
+        y: value.y,
+        maxWidth: value.maxWidth,
+        ...(value.maxHeight === undefined
+            ? {}
+            : { maxHeight: value.maxHeight }),
+        ...(value.elementId === undefined
+            ? {}
+            : { elementId: value.elementId.trim() }),
+        ...(value.frameId === undefined
+            ? {}
+            : {
+                frameId: value.frameId === null ? null : value.frameId.trim(),
+            }),
+    };
+};
+const finiteWithin = (candidate, min, max) => typeof candidate === "number" &&
+    Number.isFinite(candidate) &&
+    candidate >= min &&
+    candidate <= max;
+export const parseLivePreviewRequest = (value) => {
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !["previewId", "url", "title", "x", "y", "width", "height"].includes(key)) ||
+        typeof value.url !== "string" ||
+        !value.url.trim() ||
+        value.url.length > 2_048) {
+        throw new Error("Live preview request is invalid.");
+    }
+    let url;
+    try {
+        url = new URL(value.url.trim());
+    }
+    catch {
+        throw new Error("Live preview URL is invalid.");
+    }
+    if (url.hostname === "0.0.0.0")
+        url.hostname = "127.0.0.1";
+    if (url.hostname === "[::]")
+        url.hostname = "[::1]";
+    if (!["http:", "https:"].includes(url.protocol) ||
+        !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) ||
+        url.username ||
+        url.password) {
+        throw new Error("Live previews must use a local loopback URL.");
+    }
+    url.hash = "";
+    const optionalString = (candidate, maxLength) => candidate === undefined ||
+        (typeof candidate === "string" &&
+            !!candidate.trim() &&
+            candidate.length <= maxLength &&
+            !/[\u0000-\u001f\u007f]/.test(candidate));
+    if (!optionalString(value.previewId, 128) ||
+        !optionalString(value.title, 120) ||
+        (value.x !== undefined && !finiteWithin(value.x, -1_000_000, 1_000_000)) ||
+        (value.y !== undefined && !finiteWithin(value.y, -1_000_000, 1_000_000)) ||
+        (value.width !== undefined && !finiteWithin(value.width, 360, 4_000)) ||
+        (value.height !== undefined && !finiteWithin(value.height, 260, 4_000))) {
+        throw new Error("Live preview placement is invalid.");
+    }
+    return {
+        url: url.toString(),
+        ...(value.previewId === undefined
+            ? {}
+            : { previewId: value.previewId.trim() }),
+        ...(value.title === undefined
+            ? {}
+            : { title: value.title.trim() }),
+        ...(value.x === undefined ? {} : { x: value.x }),
+        ...(value.y === undefined ? {} : { y: value.y }),
+        ...(value.width === undefined ? {} : { width: value.width }),
+        ...(value.height === undefined ? {} : { height: value.height }),
+    };
+};
+const parseContextBounds = (value) => {
+    if (!isRecord(value) ||
+        !finiteWithin(value.x, -1_000_000, 1_000_000) ||
+        !finiteWithin(value.y, -1_000_000, 1_000_000) ||
+        !finiteWithin(value.width, Number.EPSILON, 2_000_000) ||
+        !finiteWithin(value.height, Number.EPSILON, 2_000_000)) {
+        throw new Error("Canvas context bounds are invalid.");
+    }
+    return {
+        x: value.x,
+        y: value.y,
+        width: value.width,
+        height: value.height,
+    };
+};
+const parseElementIds = (value) => {
+    if (!Array.isArray(value) ||
+        value.length > 250 ||
+        value.some((id) => typeof id !== "string" || !id.trim() || id.length > 128)) {
+        throw new Error("Canvas context elementIds are invalid.");
+    }
+    return [...new Set(value.map((id) => id.trim()))];
+};
+const canvasElementId = (value) => typeof value === "string" && value.trim().length > 0 && value.length <= 128;
+export const parseCanvasConnectorRequest = (value) => {
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !["sourceId", "targetId", "route", "waypoints", "arrowId"].includes(key)) ||
+        !canvasElementId(value.sourceId) ||
+        !canvasElementId(value.targetId) ||
+        value.sourceId === value.targetId ||
+        (value.arrowId !== undefined && !canvasElementId(value.arrowId)) ||
+        (value.route !== undefined &&
+            !["straight", "rounded", "elbow", "auto"].includes(value.route)) ||
+        (value.waypoints !== undefined &&
+            (!Array.isArray(value.waypoints) ||
+                value.waypoints.length > 16 ||
+                value.waypoints.some((point) => !Array.isArray(point) ||
+                    point.length !== 2 ||
+                    !point.every((coordinate) => finiteWithin(coordinate, -1_000_000, 1_000_000)))))) {
+        throw new Error("Canvas connector request is invalid.");
+    }
+    return value;
+};
+export const parseCanvasLabelRequest = (value) => {
+    const style = isRecord(value) ? value.style : undefined;
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !["containerId", "text", "style"].includes(key)) ||
+        !canvasElementId(value.containerId) ||
+        typeof value.text !== "string" ||
+        !value.text.trim() ||
+        value.text.length > 20_000 ||
+        (style !== undefined &&
+            (!isRecord(style) ||
+                Object.keys(style).some((key) => !["fontSize", "fontFamily", "strokeColor", "textAlign", "verticalAlign"].includes(key)) ||
+                (style.fontSize !== undefined && !finiteWithin(style.fontSize, 1, 256)) ||
+                (style.fontFamily !== undefined && !finiteWithin(style.fontFamily, 1, 100)) ||
+                (style.strokeColor !== undefined &&
+                    (typeof style.strokeColor !== "string" || style.strokeColor.length > 128)) ||
+                (style.textAlign !== undefined &&
+                    !["left", "center", "right"].includes(style.textAlign)) ||
+                (style.verticalAlign !== undefined &&
+                    !["top", "middle", "bottom"].includes(style.verticalAlign))))) {
+        throw new Error("Canvas label request is invalid.");
+    }
+    return value;
+};
+export const parseCanvasDiagramCodeRequest = (value) => {
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !["format", "source", "operationId", "replaceOperationId"].includes(key)) ||
+        value.format !== "mermaid" ||
+        typeof value.source !== "string" ||
+        !value.source.trim() ||
+        Buffer.byteLength(value.source, "utf8") > MAX_DIAGRAM_SOURCE_BYTES ||
+        typeof value.operationId !== "string" ||
+        !/^[A-Za-z0-9_-]{1,128}$/.test(value.operationId) ||
+        (value.replaceOperationId !== undefined &&
+            (typeof value.replaceOperationId !== "string" ||
+                !/^[A-Za-z0-9_-]{1,128}$/.test(value.replaceOperationId) ||
+                value.replaceOperationId === value.operationId))) {
+        throw new Error("Diagram code request is invalid or exceeds 256 KiB.");
+    }
+    return {
+        format: "mermaid",
+        source: value.source,
+        operationId: value.operationId,
+        ...(typeof value.replaceOperationId === "string"
+            ? { replaceOperationId: value.replaceOperationId }
+            : {})
+    };
+};
+export const parseCanvasContextRequest = (value) => {
+    if (!isRecord(value)) {
+        throw new Error("Canvas context request must be an object.");
+    }
+    const hasElementIds = value.elementIds !== undefined;
+    const hasBounds = value.bounds !== undefined;
+    if (hasElementIds === hasBounds) {
+        throw new Error("Choose either elementIds or bounds for canvas context.");
+    }
+    const elementIds = hasElementIds ? parseElementIds(value.elementIds) : null;
+    if (elementIds && !elementIds.length) {
+        throw new Error("Canvas context requires at least one element.");
+    }
+    const maxDimension = value.maxDimension ?? 2048;
+    if (!finiteWithin(maxDimension, 256, 4096)) {
+        throw new Error("Canvas context maxDimension must be 256 to 4096.");
+    }
+    return {
+        ...(elementIds ? { elementIds } : {}),
+        ...(hasBounds ? { bounds: parseContextBounds(value.bounds) } : {}),
+        includeSourceImages: value.includeSourceImages !== false,
+        maxDimension: maxDimension,
+    };
+};
+export const parseCanvasContextReference = (value) => {
+    if (!isRecord(value) ||
+        typeof value.id !== "string" ||
+        !/^[a-f0-9-]{36}$/i.test(value.id)) {
+        throw new Error("Canvas context reference is invalid.");
+    }
+    return {
+        id: value.id,
+        elementIds: parseElementIds(value.elementIds),
+        bounds: parseContextBounds(value.bounds),
+    };
+};
+export const parseCanvasOperations = (value) => {
+    if (!isRecord(value)) {
+        throw new Error("Canvas operations must be an object.");
+    }
+    const upsertElements = value.upsertElements ?? [];
+    const deleteElementIds = value.deleteElementIds ?? [];
+    const files = value.files ?? [];
+    if (!Array.isArray(upsertElements)) {
+        throw new Error("upsertElements must be an array.");
+    }
+    if (!Array.isArray(deleteElementIds) ||
+        deleteElementIds.some((id) => typeof id !== "string" || !id.trim())) {
+        throw new Error("deleteElementIds must contain non-empty strings.");
+    }
+    if (!Array.isArray(files) || files.length > 8) {
+        throw new Error("files must be an array of at most 8 canvas assets.");
+    }
+    const parsedFiles = files.map((file) => {
+        if (!isRecord(file) ||
+            typeof file.id !== "string" ||
+            !/^[a-zA-Z0-9_-]{1,128}$/.test(file.id) ||
+            (file.mimeType !== "image/png" &&
+                file.mimeType !== "image/jpeg" &&
+                file.mimeType !== "image/gif" &&
+                file.mimeType !== "image/webp") ||
+            typeof file.dataURL !== "string" ||
+            !file.dataURL.startsWith(`data:${file.mimeType};base64,`) ||
+            file.dataURL.length > Math.ceil((MAX_CANVAS_ASSET_BYTES * 4) / 3) + 64 ||
+            typeof file.created !== "number" ||
+            !Number.isFinite(file.created) ||
+            file.created <= 0) {
+            throw new Error("files contains an invalid canvas image asset.");
+        }
+        return {
+            id: file.id,
+            mimeType: file.mimeType,
+            dataURL: file.dataURL,
+            created: file.created,
+        };
+    });
+    if (new Set(parsedFiles.map((file) => file.id)).size !== parsedFiles.length) {
+        throw new Error("files must contain unique ids.");
+    }
+    return { upsertElements, deleteElementIds, files: parsedFiles };
+};

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@drawsy/companion",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.28",
+  "private": false,
+  "type": "module",
+  "description": "Drawsy's local Companion server and background command-line controls",
+  "license": "MIT",
+  "author": {
+    "name": "Drawsy",
+    "email": "a@drawsyai.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DrawsyAI/drawsy-ai-companion.git"
+  },
+  "homepage": "https://drawsyai.com",
+  "bugs": {
+    "url": "https://github.com/DrawsyAI/drawsy-ai-companion/issues"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "bin": {
+    "drawsy-companion": "dist/drawsy/cli.js",
+    "drawsy-ai-mcp": "dist/drawsy/mcp.js"
+  },
+  "files": [
+    "dist/drawsy",
+    "skills",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.25.2",
+    "cross-spawn": "7.0.6",
+    "zod": "^4.0.0"
+  }
+}