@legendapp/spark 0.0.1-next.2 → 0.0.1-next.3

package/schema.json

@@ -11,47 +11,94 @@
       "type": "string"
     },
     "name": {
-      "type": "string"
+      "type": "string",
+      "minLength": 1
     },
     "projectId": {
-      "type": "string"
+      "type": "string",
+      "minLength": 1
     },
     "version": {
-      "type": "string"
+      "type": "string",
+      "minLength": 1
     },
     "window": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "width": {
-          "type": "number",
-          "minimum": 100,
-          "maximum": 20000
-        },
-        "height": {
-          "type": "number",
-          "minimum": 100,
-          "maximum": 20000
-        },
-        "minWidth": {
-          "type": "number",
-          "minimum": 100,
-          "maximum": 20000
-        },
-        "minHeight": {
-          "type": "number",
-          "minimum": 100,
-          "maximum": 20000
+        "size": {
+          "type": "object",
+          "required": [
+            "width",
+            "height"
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "width": {
+              "type": "number",
+              "minimum": 100,
+              "maximum": 20000
+            },
+            "height": {
+              "type": "number",
+              "minimum": 100,
+              "maximum": 20000
+            }
+          }
         },
-        "maxWidth": {
-          "type": "number",
-          "minimum": 100,
-          "maximum": 20000
+        "minSize": {
+          "anyOf": [
+            {
+              "type": "object",
+              "required": [
+                "width",
+                "height"
+              ],
+              "additionalProperties": false,
+              "properties": {
+                "width": {
+                  "type": "number",
+                  "minimum": 100,
+                  "maximum": 20000
+                },
+                "height": {
+                  "type": "number",
+                  "minimum": 100,
+                  "maximum": 20000
+                }
+              }
+            },
+            {
+              "type": "null"
+            }
+          ]
         },
-        "maxHeight": {
-          "type": "number",
-          "minimum": 100,
-          "maximum": 20000
+        "maxSize": {
+          "anyOf": [
+            {
+              "type": "object",
+              "required": [
+                "width",
+                "height"
+              ],
+              "additionalProperties": false,
+              "properties": {
+                "width": {
+                  "type": "number",
+                  "minimum": 100,
+                  "maximum": 20000
+                },
+                "height": {
+                  "type": "number",
+                  "minimum": 100,
+                  "maximum": 20000
+                }
+              }
+            },
+            {
+              "type": "null"
+            }
+          ]
         },
         "resizable": {
           "type": "boolean"
@@ -71,10 +118,7 @@
         "hasShadow": {
           "type": "boolean"
         },
-        "trafficLights": {
-          "type": "boolean"
-        },
-        "restoreFrame": {
+        "restoreBounds": {
           "type": "boolean"
         },
         "titleBarStyle": {
@@ -92,21 +136,36 @@
             "dark"
           ]
         },
-        "material": {
-          "enum": [
-            "none",
-            "sidebar",
-            "windowBackground",
-            "hudWindow",
-            "popover"
-          ]
-        },
         "title": {
           "type": "string"
         },
         "backgroundColor": {
           "type": "string",
           "pattern": "^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$"
+        },
+        "macos": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "backgroundMaterial": {
+              "enum": [
+                "none",
+                "sidebar",
+                "windowBackground",
+                "hudWindow",
+                "popover"
+              ]
+            },
+            "titleBar": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "trafficLights": {
+                  "type": "boolean"
+                }
+              }
+            }
+          }
         }
       }
     },
@@ -117,7 +176,8 @@
       ],
       "properties": {
         "bundleIdentifier": {
-          "type": "string"
+          "type": "string",
+          "pattern": "^[A-Za-z0-9-]+(?:\\.[A-Za-z0-9-]+)+$"
         },
         "buildNumber": {
           "type": "string"
@@ -127,8 +187,92 @@
         },
         "infoPlist": {
           "type": "object"
+        },
+        "lifecycle": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "plugins": {
+              "type": "array",
+              "uniqueItems": true,
+              "items": {
+                "type": "string",
+                "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
+              }
+            },
+            "mainWindow": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "hidden": {
+                  "type": "boolean"
+                },
+                "glass": {
+                  "type": "boolean"
+                },
+                "autosaveName": {
+                  "type": "string",
+                  "minLength": 1
+                },
+                "closeBehavior": {
+                  "enum": [
+                    "close",
+                    "hide",
+                    "request"
+                  ]
+                },
+                "reopenBehavior": {
+                  "enum": [
+                    "default",
+                    "manual",
+                    "visibleWindows"
+                  ]
+                },
+                "toolbarStyle": {
+                  "enum": [
+                    "unified",
+                    "expanded"
+                  ]
+                },
+                "titlebarSeparatorStyle": {
+                  "enum": [
+                    "automatic",
+                    "none",
+                    "line",
+                    "shadow"
+                  ]
+                },
+                "backgroundColors": {
+                  "type": "object",
+                  "required": [
+                    "light",
+                    "dark"
+                  ],
+                  "additionalProperties": false,
+                  "properties": {
+                    "light": {
+                      "type": "string",
+                      "pattern": "^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$"
+                    },
+                    "dark": {
+                      "type": "string",
+                      "pattern": "^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$"
+                    }
+                  }
+                }
+              }
+            },
+            "appearance": {
+              "enum": [
+                "system",
+                "light",
+                "dark"
+              ]
+            }
+          }
         }
-      }
+      },
+      "additionalProperties": false
     },
     "scheme": {
       "oneOf": [
@@ -144,7 +288,35 @@
       ]
     },
     "documentTypes": {
-      "type": "array"
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "name",
+          "contentTypes"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "name": {
+            "type": "string",
+            "minLength": 1
+          },
+          "contentTypes": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "string",
+              "pattern": "\\."
+            }
+          },
+          "role": {
+            "enum": [
+              "Editor",
+              "Viewer"
+            ]
+          }
+        }
+      }
     },
     "menuBarOnly": {
       "type": "boolean"
@@ -160,9 +332,11 @@
           "type": "string"
         },
         "publicKey": {
-          "type": "string"
+          "type": "string",
+          "pattern": "^[A-Za-z0-9+/]{43}=$"
         }
-      }
+      },
+      "additionalProperties": false
     },
     "include": {
       "type": "array",
@@ -212,7 +386,30 @@
       }
     },
     "signing": {
-      "type": "object"
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "macos": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "identity": {
+              "type": "string",
+              "minLength": 1
+            },
+            "teamId": {
+              "type": "string",
+              "minLength": 1
+            },
+            "entitlementsByPath": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "object"
+              }
+            }
+          }
+        }
+      }
     },
     "expo": {
       "type": "object"
@@ -260,19 +457,40 @@
   "allOf": [
     {
       "if": {
-        "properties": {
-          "platforms": {
-            "const": [
-              "windows"
+        "allOf": [
+          {
+            "not": {
+              "required": [
+                "extends"
+              ]
+            }
+          },
+          {
+            "anyOf": [
+              {
+                "not": {
+                  "required": [
+                    "platforms"
+                  ]
+                }
+              },
+              {
+                "properties": {
+                  "platforms": {
+                    "contains": {
+                      "const": "macos"
+                    }
+                  }
+                },
+                "required": [
+                  "platforms"
+                ]
+              }
             ]
           }
-        },
-        "required": [
-          "platforms"
         ]
       },
-      "then": {},
-      "else": {
+      "then": {
         "required": [
           "macos"
         ]

package/settings-observable.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-settings/src/storage/index.ts";

package/settings-window.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-settings-ui/src/index.tsx";

package/shortcuts-commands.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-commands/src/index.tsx";

package/shortcuts-keyboard.ts

@@ -0,0 +1,3 @@
+export { addKeyboardListener, getKeyboardAvailability, hasModifier, createModifierMask, KeyCodes, KeyText } from "./vendor/node_modules/@legendapp/spark-desktop-shortcuts/src/keyboard-manager/index.ts";
+export type { KeyboardEvent, KeyboardEventListener, KeyboardListenerOptions } from "./vendor/node_modules/@legendapp/spark-desktop-shortcuts/src/keyboard-manager/index.ts";
+export type { AsyncRegistration } from "./vendor/node_modules/@legendapp/spark-desktop-shortcuts/src/keyboard-manager/index.ts";

package/ui-classnames.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-ui/src/classnames/index.ts";

package/ui-glass.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-ui/src/glass-effect-view/index.tsx";

package/ui-search.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-ui/src/text-input-search/index.tsx";

package/ui-sidebar.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-ui/src/sidebar/index.tsx";

package/ui-split-view.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-ui/src/appkit-split-view/index.tsx";

package/ui-symbol.ts

@@ -0,0 +1 @@
+export * from "./vendor/node_modules/@legendapp/spark-ui/src/sf-symbol/index.tsx";

package/vendor/node_modules/@legendapp/spark-ai/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@legendapp/spark-ai",
+  "version": "0.0.1-next.3",
+  "private": true,
+  "main": "src/index.ts",
+  "react-native": "src/index.ts",
+  "dependencies": {
+    "@legendapp/spark-desktop-app": "0.0.1-next.3",
+    "@legendapp/spark-processes": "0.0.1-next.3"
+  },
+  "peerDependencies": {
+    "react": "19.1.4",
+    "react-native": "0.81.6"
+  },
+  "license": "MIT",
+  "files": [
+    "src"
+  ]
+}

package/vendor/node_modules/@legendapp/spark-ai/src/availability.ts

@@ -0,0 +1,17 @@
+import { resolveCommand, getProcessAvailability } from "@legendapp/spark-processes";
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import type { AIAvailabilityOptions, AICommandAvailability, AIToolId } from "./types";
+export function selectPreferredAITool(availability: Pick<AICommandAvailability, "claude" | "codex">, options: AIAvailabilityOptions = {}): AIToolId | null {
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected AI availability options");
+  for (const key of Object.keys(options)) if (key !== "preferredTool") throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown availability option: ${key}`);
+  if (options.preferredTool !== undefined && !["claude", "codex"].includes(options.preferredTool)) throw new SparkError("E_INVALID_ARGUMENT", "Unknown preferred AI tool");
+  if (options.preferredTool && availability[options.preferredTool]) return options.preferredTool;
+  return availability.claude ? "claude" : availability.codex ? "codex" : null;
+}
+export async function getAICommandAvailability(options: AIAvailabilityOptions = {}): Promise<AICommandAvailability> {
+  selectPreferredAITool({ claude: false, codex: false }, options);
+  if (!getProcessAvailability().available) return { claude: false, codex: false, preferredTool: null };
+  const [claude, codex] = await Promise.all([resolveCommand("claude"), resolveCommand("codex")]);
+  const result = { claude: claude !== null, codex: codex !== null };
+  return { ...result, preferredTool: selectPreferredAITool(result, options) };
+}

package/vendor/node_modules/@legendapp/spark-ai/src/index.ts

@@ -0,0 +1,15 @@
+export { getAICommandAvailability, selectPreferredAITool } from "./availability";
+export { buildAIInvocation } from "./invocations";
+export { extractJsonCandidate, formatAIErrorOutput, parseAIJson } from "./output";
+export { runAITool } from "./run";
+export type {
+  AIAvailabilityOptions,
+  AICommandAvailability,
+  AICodexInvocationOptions,
+  AIInvocation,
+  AIInvocationOptions,
+  AIToolId,
+  AIToolRunResult,
+  RunAIToolOptions,
+} from "./types";
+export type { AIErrorOutputOptions } from "./output";

package/vendor/node_modules/@legendapp/spark-ai/src/invocations.ts

@@ -0,0 +1,34 @@
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import type { AIInvocation, AIInvocationOptions, AIToolId } from "./types";
+
+const defaultCodexReasoningEffort = "low";
+
+export function buildAIInvocation(tool: AIToolId, prompt: string, options: AIInvocationOptions = {}): AIInvocation {
+  if (!["claude", "codex"].includes(tool) || typeof prompt !== "string" || !prompt.trim() || prompt.includes("\0")) throw new SparkError("E_INVALID_ARGUMENT", "Expected an AI tool and nonempty prompt");
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected invocation options");
+  for (const key of Object.keys(options)) if (key !== "codex") throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown invocation option: ${key}`);
+  if (options.codex !== undefined) {
+    if (!options.codex || typeof options.codex !== "object" || Array.isArray(options.codex)) throw new SparkError("E_INVALID_ARGUMENT", "Expected Codex invocation options");
+    for (const key of Object.keys(options.codex)) if (!["model", "reasoningEffort"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown Codex option: ${key}`);
+    if (options.codex.model !== undefined && (typeof options.codex.model !== "string" || !options.codex.model.trim() || /[\0\r\n]/.test(options.codex.model))) throw new SparkError("E_INVALID_ARGUMENT", "Expected a model name");
+    if (options.codex.reasoningEffort !== undefined && !["minimal", "low", "medium", "high", "xhigh"].includes(options.codex.reasoningEffort)) throw new SparkError("E_INVALID_ARGUMENT", "Unknown reasoning effort");
+    if (tool !== "codex") throw new SparkError("E_UNSUPPORTED_OPTION", "Codex options require the Codex tool");
+  }
+  if (tool === "codex") {
+    const model = options.codex?.model;
+    const reasoningEffort = options.codex?.reasoningEffort ?? defaultCodexReasoningEffort;
+    const args: string[] = ["exec", "--ephemeral", "--ignore-user-config", "--ignore-rules", "--skip-git-repo-check"];
+    if (model) {
+      args.push("--model", model);
+    }
+    args.push("--config", `model_reasoning_effort=${reasoningEffort}`, "-");
+
+    return {
+      command: "codex",
+      args,
+      input: prompt,
+    };
+  }
+
+  return { command: "claude", args: ["-p", prompt] };
+}

package/vendor/node_modules/@legendapp/spark-ai/src/output.ts

@@ -0,0 +1,62 @@
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+export interface AIErrorOutputOptions { maxLength?: number }
+const defaultMaxErrorOutputLength = 300;
+
+export function extractJsonCandidate(text: string): string | null {
+  if (typeof text !== "string") throw new SparkError("E_INVALID_ARGUMENT", "Expected AI output text");
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenced?.[1]) {
+    return fenced[1].trim();
+  }
+
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return trimmed;
+  }
+
+  const firstBrace = trimmed.search(/[[{]/);
+  if (firstBrace === -1) {
+    return null;
+  }
+
+  const open = trimmed[firstBrace];
+  const close = open === "{" ? "}" : "]";
+  const lastBrace = trimmed.lastIndexOf(close);
+  if (lastBrace <= firstBrace) {
+    return null;
+  }
+
+  return trimmed.slice(firstBrace, lastBrace + 1);
+}
+
+export function parseAIJson(text: string): unknown {
+  const candidate = extractJsonCandidate(text);
+  if (!candidate) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    return null;
+  }
+}
+
+export function formatAIErrorOutput(output: string, options: AIErrorOutputOptions = {}): string {
+  if (typeof output !== "string" || !options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected output text and preview options");
+  for (const key of Object.keys(options)) if (key !== "maxLength") throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown preview option: ${key}`);
+  const maxLength = options.maxLength ?? defaultMaxErrorOutputLength;
+  if (!Number.isInteger(maxLength) || maxLength < 1) throw new SparkError("E_INVALID_ARGUMENT", "maxLength must be a positive integer");
+  const trimmed = output.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (trimmed.length <= maxLength) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, maxLength).trim()}...`;
+}

package/vendor/node_modules/@legendapp/spark-ai/src/run.ts

@@ -0,0 +1,12 @@
+import { runCommand } from "@legendapp/spark-processes";
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { buildAIInvocation } from "./invocations";
+import type { AIToolRunResult, RunAIToolOptions } from "./types";
+export async function runAITool(options: RunAIToolOptions): Promise<AIToolRunResult> {
+  if (!options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected AI run options");
+  for (const key of Object.keys(options)) if (!["prompt", "tool", "timeoutMs", "signal", "cwd", "invocationOptions"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown AI run option: ${key}`);
+  const invocation = buildAIInvocation(options.tool, options.prompt, options.invocationOptions);
+  const result = await runCommand({ target: { type: "command", name: invocation.command }, args: invocation.args, input: invocation.input, timeoutMs: options.timeoutMs, signal: options.signal, cwd: options.cwd });
+  const decoder = new TextDecoder();
+  return { ...result, output: decoder.decode(result.stdout).trim() || decoder.decode(result.stderr).trim(), tool: options.tool };
+}

package/vendor/node_modules/@legendapp/spark-ai/src/types.ts

@@ -0,0 +1,16 @@
+import type { ProcessResult } from "@legendapp/spark-processes";
+export type AIToolId = "claude" | "codex";
+export interface AICommandAvailability { claude: boolean; codex: boolean; preferredTool: AIToolId | null }
+export interface AIAvailabilityOptions { preferredTool?: AIToolId }
+export interface AIInvocation { command: string; args: readonly string[]; input?: string }
+export interface AICodexInvocationOptions { model?: string; reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" }
+export interface AIInvocationOptions { codex?: AICodexInvocationOptions }
+export interface RunAIToolOptions {
+  prompt: string;
+  tool: AIToolId;
+  timeoutMs?: number;
+  signal?: AbortSignal;
+  cwd?: string;
+  invocationOptions?: AIInvocationOptions;
+}
+export type AIToolRunResult = ProcessResult & { output: string; tool: AIToolId };

package/vendor/node_modules/@legendapp/spark-audio/macos/RNSparkAudio.h

@@ -1,4 +1,5 @@
 #import <Foundation/Foundation.h>
 #import <RNSparkAudioSpec/RNSparkAudioSpec.h>
-@interface RNSparkAudio : NSObject <NativeSparkAudioSpec>
+#import <React/RCTEventEmitter.h>
+@interface RNSparkAudio : RCTEventEmitter <NativeSparkAudioSpec>
 @end