@public-tauri/raycast-convert 1.0.1

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2022 qwertyyb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,104 @@
+# @public-tauri/raycast-convert
+
+将 Raycast 插件转换为 Public Tauri 插件。
+
+当前阶段暂时只支持 Raycast `no-view` 命令；Raycast view 插件的适配正在进行中。
+
+仓库根目录提供了以下脚本：
+
+```bash
+pnpm raycast:convert <raycast-plugin-dir> --out <public-plugin-dir> [--build]
+pnpm raycast:convert:production <raycast-plugin-dir> --out <public-plugin-dir> [--build]
+```
+
+该包也提供 CLI：
+
+```bash
+raycast-convert <raycast-plugin-dir> --out <public-plugin-dir> [--build] [--mode development|production]
+```
+
+## 功能
+
+转换器读取一个 Raycast 插件目录，并生成一个 Public Tauri 插件目录。
+
+生成的插件包含：
+
+- `package.json`，包含 `publicPlugin` manifest。
+- `.raycast-build/public-main.ts`，浏览器侧桥接入口。
+- `.raycast-build/server.ts`，Node 侧命令运行入口。
+- `tsdown.config.ts`，用于打包转换后的插件。
+- `raycast-conversion-report.json`，记录已转换命令、跳过命令和 warnings。
+- `assets/`，当 Raycast 插件存在资源目录时会复制过来。
+
+如果传入 `--build`，转换器会在生成的 Public Tauri 插件目录中安装依赖，并执行 `tsdown` 构建。
+
+## 转换流程
+
+```text
+Raycast 插件源码
+-> 生成 Public Tauri 插件文件
+-> 写入 package.json 和 tsdown.config.ts
+-> 在生成的插件目录执行 pnpm install
+-> pnpm exec tsdown --config tsdown.config.ts
+```
+
+原始 Raycast 插件源码目录不会被安装依赖，也不会被修改。
+
+## 模式
+
+### development
+
+默认模式。
+
+用于在当前 monorepo 内开发和调试。生成的 `package.json` 会让 `@public-tauri/api` 指向本地开发代码：
+
+```json
+{
+  "dependencies": {
+    "@public-tauri/api": "file:/path/to/public-tauri/packages/api"
+  }
+}
+```
+
+### production
+
+用于生产环境或打包应用内转换。生成的插件依赖已发布的 API 包：
+
+```json
+{
+  "dependencies": {
+    "@public-tauri/api": "latest"
+  }
+}
+```
+
+## Raycast API 映射
+
+生成的 `tsdown.config.ts` 会将 Raycast API 映射到 Public Tauri 的兼容层：
+
+```ts
+alias: {
+  '@raycast/api': '@public-tauri/api/raycast',
+  '@raycast/utils': '@public-tauri/api/raycast/utils',
+}
+```
+
+原 Raycast 插件中的其它依赖会保留。
+
+## 当前支持范围
+
+目前暂时只转换以下类型的 Raycast 命令：
+
+```json
+{
+  "mode": "no-view"
+}
+```
+
+其它 command mode 会被跳过，并写入 `raycast-conversion-report.json`。这不是该包的长期边界，Raycast view 插件的适配正在进行中。
+
+## 限制
+
+- 暂时不转换 Raycast React UI 命令。
+- 命令入口文件需要符合常见 Raycast 布局，例如 `src/<command>.ts`、`src/<command>.tsx` 或 `src/<command>/index.ts`。
+- 运行时能力取决于 `@public-tauri/api/raycast` 提供的兼容层。

package/dist/cli.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { t as convertRaycastPlugin } from "./src-DPoXoCnp.mjs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+//#region src/cli.ts
+const usage = () => {
+	console.error("Usage: raycast-convert <raycast-plugin-dir> --out <public-plugin-dir> [--build] [--mode development|production]");
+};
+const parseCliArgs = () => parseArgs({
+	args: process.argv.slice(2),
+	allowPositionals: true,
+	options: {
+		out: { type: "string" },
+		build: {
+			type: "boolean",
+			default: false
+		},
+		mode: {
+			type: "string",
+			default: "development"
+		}
+	}
+});
+const getConvertMode = (value) => {
+	if (value !== "development" && value !== "production") throw new Error(`Unsupported --mode "${value}". Expected "development" or "production".`);
+	return value;
+};
+const runCli = async () => {
+	const { values, positionals } = parseCliArgs();
+	const inputArg = positionals[0];
+	if (!inputArg) {
+		usage();
+		process.exit(1);
+	}
+	const report = await convertRaycastPlugin({
+		inputDir: path.resolve(inputArg),
+		outputDir: values.out,
+		build: values.build,
+		mode: getConvertMode(values.mode),
+		invocationDir: process.cwd()
+	});
+	console.log(`Converted ${report.convertedCommands.length} command(s) to ${report.output}`);
+	if (report.skippedCommands.length) console.log(`Skipped ${report.skippedCommands.length} command(s). See raycast-conversion-report.json`);
+};
+if (import.meta.url === `file://${process.argv[1]}`) runCli().catch((error) => {
+	console.error(error instanceof Error ? error.message : error);
+	process.exit(1);
+});
+//#endregion
+export { runCli };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { t as convertRaycastPlugin } from "./src-DPoXoCnp.mjs";
+export { convertRaycastPlugin };

package/dist/src-DPoXoCnp.mjs

@@ -0,0 +1,414 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+//#region src/build.ts
+const installCommand = "pnpm";
+const installArgs = [
+	"install",
+	"--ignore-scripts",
+	"--frozen-lockfile=false"
+];
+const runInstall = (cwd, label) => {
+	console.log(`Installing ${label} dependencies...`);
+	const result = spawnSync(installCommand, installArgs, {
+		cwd,
+		stdio: "inherit"
+	});
+	if (result.status !== 0) throw new Error(`${label} dependency install failed with exit code ${result.status}`);
+};
+const installOutputDependencies = (options) => {
+	runInstall(options.outputDir, "converted plugin");
+};
+const getBuildCommand = (options) => {
+	return {
+		command: "pnpm",
+		args: [
+			"exec",
+			"tsdown",
+			"--config",
+			path.join(options.outputDir, "tsdown.config.ts")
+		],
+		cwd: options.outputDir
+	};
+};
+const buildConvertedPlugin = (options) => {
+	const { command, args: buildArgs, cwd } = getBuildCommand(options);
+	const result = spawnSync(command, buildArgs, {
+		cwd,
+		stdio: "inherit"
+	});
+	if (result.status !== 0) throw new Error(`Build failed with exit code ${result.status}`);
+};
+const installAndBuild = (options) => {
+	installOutputDependencies(options);
+	buildConvertedPlugin(options);
+};
+//#endregion
+//#region src/files.ts
+const readJson = async (filePath) => JSON.parse(await fs.readFile(filePath, "utf8"));
+const writeJson = async (filePath, value) => {
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+};
+const exists = async (filePath) => {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const copyAssetsDir = async (inputDir, assetsDir) => {
+	const source = path.join(inputDir, "assets");
+	if (!await exists(source)) return;
+	await fs.cp(source, assetsDir, { recursive: true });
+};
+//#endregion
+//#region src/commands.ts
+const findCommandEntry = async (inputDir, command) => {
+	const candidates = [
+		path.join(inputDir, "src", `${command.name}.tsx`),
+		path.join(inputDir, "src", `${command.name}.ts`),
+		path.join(inputDir, "src", `${command.name}.jsx`),
+		path.join(inputDir, "src", `${command.name}.js`),
+		path.join(inputDir, "src", command.name, "index.tsx"),
+		path.join(inputDir, "src", command.name, "index.ts"),
+		path.join(inputDir, "src", command.name, "index.jsx"),
+		path.join(inputDir, "src", command.name, "index.js")
+	];
+	for (const candidate of candidates) if (await exists(candidate)) return candidate;
+	return null;
+};
+const resolveNoViewCommands = async (inputDir, sourceCommands) => {
+	const convertedCommands = [];
+	const skippedCommands = [];
+	for (const command of sourceCommands) {
+		if (command.mode !== "no-view") {
+			skippedCommands.push({
+				name: command.name,
+				reason: `Unsupported mode: ${command.mode || "<empty>"}`
+			});
+			continue;
+		}
+		const entry = await findCommandEntry(inputDir, command);
+		if (!entry) {
+			skippedCommands.push({
+				name: command.name,
+				reason: "Command entry not found under src/"
+			});
+			continue;
+		}
+		convertedCommands.push({
+			...command,
+			entry
+		});
+	}
+	if (!convertedCommands.length) throw new Error("No Raycast no-view commands were converted");
+	return {
+		convertedCommands,
+		skippedCommands
+	};
+};
+//#endregion
+//#region src/generate/public-main.ts
+const generatePublicMain = () => `export default function createPlugin() {
+  const getApi = () => window.$wujie?.props;
+  return {
+  async onAction(command, action, query, options) {
+    const api = getApi();
+    try {
+      await api.channel.invoke('raycast:run', {
+        commandName: command.name,
+        query,
+        action,
+        options,
+        preferences: api.getPreferences?.() || {},
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await api.dialog.showToast(message);
+      throw error;
+    }
+  },
+  };
+}
+`;
+//#endregion
+//#region src/generate/server-module.ts
+const toImportName = (index) => `command${index}`;
+const generateServerModule = (commands, packageName, publicCommands) => {
+	return `import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { channel } from '@public-tauri/api/node';
+import { __setRaycastContext } from '@public-tauri/api/raycast';
+
+${commands.map((command, index) => `import * as ${toImportName(index)} from ${JSON.stringify(command.entry)};`).join("\n")}
+
+const commandModules: Record<string, any> = {
+${commands.map((command, index) => `  ${JSON.stringify(command.name)}: ${toImportName(index)},`).join("\n")}
+};
+
+const distDir = path.dirname(fileURLToPath(import.meta.url));
+const pluginRoot = path.dirname(distDir);
+const commandManifests = ${JSON.stringify(publicCommands, null, 2)};
+
+channel.handle('raycast:run', async (payload = {}) => {
+  const commandName = String(payload.commandName || '');
+  const commandModule = commandModules[commandName];
+  if (!commandModule) {
+    throw new Error(\`Unknown Raycast command: \${commandName}\`);
+  }
+  const run = commandModule.default;
+  if (typeof run !== 'function') {
+    throw new Error(\`Raycast command \${commandName} has no default function export\`);
+  }
+  const launchPayload = payload.options?.payload || {};
+  __setRaycastContext({
+    pluginName: ${JSON.stringify(packageName)},
+    commandName,
+    commands: commandManifests,
+    launchType: launchPayload.launchType,
+    preferences: payload.preferences || {},
+    supportPath: path.join(pluginRoot, '.raycast-compat'),
+    assetsPath: path.join(pluginRoot, 'assets'),
+  });
+  return await run({
+    arguments: launchPayload.arguments || {},
+    fallbackText: launchPayload.fallbackText ?? payload.query ?? '',
+    launchContext: launchPayload.context ?? payload,
+    launchType: launchPayload.launchType || 'userInitiated',
+  });
+});
+`;
+};
+//#endregion
+//#region src/generate/tsdown-config.ts
+const formatAlias = (aliases) => Object.entries(aliases).map(([key, value]) => `      ${JSON.stringify(key)}: ${JSON.stringify(value)},`).join("\n");
+const formatAliasProperty = (aliases) => {
+	const entries = formatAlias(aliases);
+	return entries ? `    alias: {\n${entries}\n    },` : "    alias: {},";
+};
+const getServerAliases = () => ({
+	"@raycast/api": "@public-tauri/api/raycast",
+	"@raycast/utils": "@public-tauri/api/raycast/utils"
+});
+const generateTsdownConfig = (options) => `export default [
+  {
+    entry: ${JSON.stringify(path.join(options.buildDir, "public-main.ts"))},
+    format: 'esm',
+    platform: 'browser',
+    target: 'es2022',
+    outDir: ${JSON.stringify(options.distDir)},
+    outExtensions: () => ({ js: '.js' }),
+    deps: {
+      alwaysBundle: () => true,
+    },
+${formatAliasProperty({})}
+  },
+  {
+    entry: ${JSON.stringify(path.join(options.buildDir, "server.ts"))},
+    format: 'esm',
+    platform: 'node',
+    target: 'es2022',
+    outDir: ${JSON.stringify(options.distDir)},
+    outExtensions: () => ({ js: '.js' }),
+    deps: {
+      alwaysBundle: () => true,
+    },
+${formatAliasProperty(getServerAliases())}
+  },
+];
+`;
+//#endregion
+//#region src/icons.ts
+const isUrlLike = (value) => /^(?:https?:|data:|asset:|public-icon:)/.test(value);
+const hasPathSegment = (value) => value.includes("/") || value.includes("\\");
+const normalizeRaycastIcon = (icon) => {
+	if (!icon) return void 0;
+	if (isUrlLike(icon)) return icon;
+	if (icon.startsWith("./") || icon.startsWith("../") || icon.startsWith("/")) return icon;
+	if (hasPathSegment(icon)) return `./${icon}`;
+	return `./assets/${icon}`;
+};
+//#endregion
+//#region src/options.ts
+const resolveMode = (mode) => mode || "development";
+const resolveConvertOptions = (options) => {
+	const inputDir = path.resolve(options.inputDir);
+	const outputDir = path.resolve(options.outputDir || `${inputDir}-public`);
+	const invocationDir = path.resolve(options.invocationDir || process.cwd());
+	const mode = resolveMode(options.mode);
+	return {
+		inputDir,
+		outputDir,
+		build: Boolean(options.build),
+		mode,
+		invocationDir,
+		publicApiDependency: mode === "development" ? `file:${path.join(invocationDir, "packages", "api")}` : "latest",
+		buildDir: path.join(outputDir, ".raycast-build"),
+		distDir: path.join(outputDir, "dist"),
+		assetsDir: path.join(outputDir, "assets")
+	};
+};
+//#endregion
+//#region src/package-json.ts
+const raycastApiPackages = new Set(["@raycast/api", "@raycast/utils"]);
+const rewriteDependencyMap = (dependencies) => {
+	const rewritten = { ...dependencies || {} };
+	let replacedRaycastApi = false;
+	for (const packageName of raycastApiPackages) if (packageName in rewritten) {
+		delete rewritten[packageName];
+		replacedRaycastApi = true;
+	}
+	return {
+		dependencies: rewritten,
+		replacedRaycastApi
+	};
+};
+const createConvertedPackage = (sourcePackage, publicPlugin, options) => {
+	const dependenciesResult = rewriteDependencyMap(sourcePackage.dependencies);
+	const devDependenciesResult = rewriteDependencyMap(sourcePackage.devDependencies);
+	if (dependenciesResult.replacedRaycastApi || devDependenciesResult.replacedRaycastApi) options.warnings.push({
+		type: "dependency",
+		message: "Replaced @raycast/api and/or @raycast/utils with @public-tauri/api"
+	});
+	return {
+		...sourcePackage,
+		version: sourcePackage.version || "1.0.0",
+		type: "module",
+		private: true,
+		publicPlugin,
+		scripts: {
+			...sourcePackage.scripts || {},
+			build: "tsdown --config tsdown.config.ts"
+		},
+		dependencies: {
+			...dependenciesResult.dependencies,
+			"@public-tauri/api": dependenciesResult.dependencies["@public-tauri/api"] || options.publicApiDependency
+		},
+		devDependencies: {
+			...devDependenciesResult.dependencies,
+			tsdown: devDependenciesResult.dependencies.tsdown || "^0.21.7"
+		}
+	};
+};
+//#endregion
+//#region src/preferences.ts
+const mapPreferenceType = (type, warnings) => {
+	switch (type) {
+		case "password": return "password";
+		case "textarea": return "textarea";
+		case "dropdown": return "select";
+		case "checkbox": return "select";
+		case "textfield":
+		case "appPicker":
+		case void 0: return "text";
+		default:
+			warnings.push({
+				type: "preference",
+				message: `Unsupported preference type "${type}", converted to text`
+			});
+			return "text";
+	}
+};
+const convertPreference = (preference, warnings) => {
+	const type = mapPreferenceType(preference.type, warnings);
+	const options = preference.type === "checkbox" ? [{
+		label: "Yes",
+		value: true
+	}, {
+		label: "No",
+		value: false
+	}] : preference.data?.map((item) => ({
+		label: item.title || item.label || String(item.value),
+		value: item.value
+	}));
+	return {
+		name: preference.name,
+		title: preference.title || preference.label || preference.name,
+		description: preference.description,
+		type,
+		required: Boolean(preference.required),
+		placeholder: preference.placeholder,
+		defaultValue: preference.defaultValue ?? preference.default,
+		...options?.length ? { options } : {}
+	};
+};
+const mergePreferences = (pluginPreferences, commandPreferences, warnings) => {
+	const preferenceNames = /* @__PURE__ */ new Set();
+	return [...pluginPreferences, ...commandPreferences].map((preference) => convertPreference(preference, warnings)).filter((preference) => {
+		if (preferenceNames.has(preference.name)) {
+			warnings.push({
+				type: "preference",
+				message: `Duplicate preference "${preference.name}" was skipped`
+			});
+			return false;
+		}
+		preferenceNames.add(preference.name);
+		return true;
+	});
+};
+//#endregion
+//#region src/index.ts
+const createPublicCommands = (commands, icon) => commands.map((command) => ({
+	name: command.name,
+	title: command.title || command.name,
+	subtitle: command.subtitle || command.description,
+	description: command.description,
+	icon: normalizeRaycastIcon(command.icon) || icon,
+	mode: "none",
+	matches: [{
+		type: "text",
+		keywords: command.keywords?.length ? command.keywords : [command.title || command.name]
+	}]
+}));
+const convertRaycastPlugin = async (rawOptions) => {
+	const options = resolveConvertOptions(rawOptions);
+	const warnings = [];
+	const sourcePackage = await readJson(path.join(options.inputDir, "package.json"));
+	const sourceCommands = sourcePackage.commands || [];
+	const { convertedCommands, skippedCommands } = await resolveNoViewCommands(options.inputDir, sourceCommands);
+	await fs.rm(options.outputDir, {
+		recursive: true,
+		force: true
+	});
+	await fs.mkdir(options.buildDir, { recursive: true });
+	await fs.mkdir(options.distDir, { recursive: true });
+	await copyAssetsDir(options.inputDir, options.assetsDir);
+	const icon = normalizeRaycastIcon(sourcePackage.icon || convertedCommands[0]?.icon) || "extension";
+	const commandPreferences = convertedCommands.flatMap((command) => command.preferences || []);
+	const preferences = mergePreferences(sourcePackage.preferences || [], commandPreferences, warnings);
+	const publicCommands = createPublicCommands(convertedCommands, icon);
+	const publicPlugin = {
+		title: sourcePackage.title || sourcePackage.name,
+		subtitle: sourcePackage.description || sourcePackage.name,
+		description: sourcePackage.description,
+		icon,
+		main: "./dist/public-main.js",
+		server: "./dist/server.js",
+		...preferences.length ? { preferences } : {},
+		commands: publicCommands
+	};
+	await writeJson(path.join(options.outputDir, "package.json"), createConvertedPackage(sourcePackage, publicPlugin, {
+		publicApiDependency: options.publicApiDependency,
+		warnings
+	}));
+	await fs.writeFile(path.join(options.buildDir, "public-main.ts"), generatePublicMain(), "utf8");
+	await fs.writeFile(path.join(options.buildDir, "server.ts"), generateServerModule(convertedCommands, sourcePackage.name, publicCommands), "utf8");
+	await fs.writeFile(path.join(options.outputDir, "tsdown.config.ts"), generateTsdownConfig(options), "utf8");
+	const report = {
+		source: options.inputDir,
+		output: options.outputDir,
+		convertedCommands: convertedCommands.map((command) => ({
+			name: command.name,
+			entry: command.entry
+		})),
+		skippedCommands,
+		warnings
+	};
+	await writeJson(path.join(options.outputDir, "raycast-conversion-report.json"), report);
+	if (options.build) installAndBuild(options);
+	return report;
+};
+//#endregion
+export { convertRaycastPlugin as t };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@public-tauri/raycast-convert",
+  "version": "1.0.1",
+  "description": "Convert Raycast extensions into Public Tauri plugins.",
+  "type": "module",
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "package.json"
+  ],
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./cli": "./dist/cli.mjs",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "raycast-convert": "./dist/cli.mjs"
+  },
+  "dependencies": {
+    "tsx": "^4.20.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.1.0",
+    "eslint": "^9.32.0",
+    "tsdown": "^0.21.7",
+    "typescript": "~5.9.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "convert": "tsx src/cli.ts",
+    "lint": "eslint src"
+  }
+}

package/src/build.ts

@@ -0,0 +1,46 @@
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import type { ResolvedConvertOptions } from './types';
+
+const installCommand = 'pnpm';
+const installArgs = ['install', '--ignore-scripts', '--frozen-lockfile=false'];
+
+const runInstall = (cwd: string, label: string) => {
+  console.log(`Installing ${label} dependencies...`);
+  const result = spawnSync(installCommand, installArgs, {
+    cwd,
+    stdio: 'inherit',
+  });
+  if (result.status !== 0) {
+    throw new Error(`${label} dependency install failed with exit code ${result.status}`);
+  }
+};
+
+const installOutputDependencies = (options: ResolvedConvertOptions) => {
+  runInstall(options.outputDir, 'converted plugin');
+};
+
+const getBuildCommand = (options: ResolvedConvertOptions) => {
+  const configPath = path.join(options.outputDir, 'tsdown.config.ts');
+  return {
+    command: 'pnpm',
+    args: ['exec', 'tsdown', '--config', configPath],
+    cwd: options.outputDir,
+  };
+};
+
+const buildConvertedPlugin = (options: ResolvedConvertOptions) => {
+  const { command, args: buildArgs, cwd } = getBuildCommand(options);
+  const result = spawnSync(command, buildArgs, {
+    cwd,
+    stdio: 'inherit',
+  });
+  if (result.status !== 0) {
+    throw new Error(`Build failed with exit code ${result.status}`);
+  }
+};
+
+export const installAndBuild = (options: ResolvedConvertOptions) => {
+  installOutputDependencies(options);
+  buildConvertedPlugin(options);
+};

package/src/cli.ts

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { convertRaycastPlugin } from './index';
+import type { ConvertMode } from './types';
+
+const usage = () => {
+  console.error('Usage: raycast-convert <raycast-plugin-dir> --out <public-plugin-dir> [--build] [--mode development|production]');
+};
+
+const parseCliArgs = () => parseArgs({
+  args: process.argv.slice(2),
+  allowPositionals: true,
+  options: {
+    out: {
+      type: 'string',
+    },
+    build: {
+      type: 'boolean',
+      default: false,
+    },
+    mode: {
+      type: 'string',
+      default: 'development',
+    },
+  },
+});
+
+const getConvertMode = (value: string): ConvertMode => {
+  if (value !== 'development' && value !== 'production') {
+    throw new Error(`Unsupported --mode "${value}". Expected "development" or "production".`);
+  }
+  return value;
+};
+
+export const runCli = async () => {
+  const { values, positionals } = parseCliArgs();
+  const inputArg = positionals[0];
+  if (!inputArg) {
+    usage();
+    process.exit(1);
+  }
+
+  const report = await convertRaycastPlugin({
+    inputDir: path.resolve(inputArg),
+    outputDir: values.out,
+    build: values.build,
+    mode: getConvertMode(values.mode),
+    invocationDir: process.cwd(),
+  });
+
+  console.log(`Converted ${report.convertedCommands.length} command(s) to ${report.output}`);
+  if (report.skippedCommands.length) {
+    console.log(`Skipped ${report.skippedCommands.length} command(s). See raycast-conversion-report.json`);
+  }
+};
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runCli().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  });
+}

package/src/commands.ts

@@ -0,0 +1,44 @@
+import path from 'node:path';
+import { exists } from './files';
+import type { ConvertedCommand, RaycastCommand } from './types';
+
+const findCommandEntry = async (inputDir: string, command: RaycastCommand) => {
+  const candidates = [
+    path.join(inputDir, 'src', `${command.name}.tsx`),
+    path.join(inputDir, 'src', `${command.name}.ts`),
+    path.join(inputDir, 'src', `${command.name}.jsx`),
+    path.join(inputDir, 'src', `${command.name}.js`),
+    path.join(inputDir, 'src', command.name, 'index.tsx'),
+    path.join(inputDir, 'src', command.name, 'index.ts'),
+    path.join(inputDir, 'src', command.name, 'index.jsx'),
+    path.join(inputDir, 'src', command.name, 'index.js'),
+  ];
+  for (const candidate of candidates) {
+    if (await exists(candidate)) return candidate;
+  }
+  return null;
+};
+
+export const resolveNoViewCommands = async (inputDir: string, sourceCommands: RaycastCommand[]) => {
+  const convertedCommands: ConvertedCommand[] = [];
+  const skippedCommands: { name: string, reason: string }[] = [];
+
+  for (const command of sourceCommands) {
+    if (command.mode !== 'no-view') {
+      skippedCommands.push({ name: command.name, reason: `Unsupported mode: ${command.mode || '<empty>'}` });
+      continue;
+    }
+    const entry = await findCommandEntry(inputDir, command);
+    if (!entry) {
+      skippedCommands.push({ name: command.name, reason: 'Command entry not found under src/' });
+      continue;
+    }
+    convertedCommands.push({ ...command, entry });
+  }
+
+  if (!convertedCommands.length) {
+    throw new Error('No Raycast no-view commands were converted');
+  }
+
+  return { convertedCommands, skippedCommands };
+};

package/src/files.ts

@@ -0,0 +1,24 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export const readJson = async <T>(filePath: string): Promise<T> => JSON.parse(await fs.readFile(filePath, 'utf8')) as T;
+
+export const writeJson = async (filePath: string, value: unknown) => {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+};
+
+export const exists = async (filePath: string) => {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const copyAssetsDir = async (inputDir: string, assetsDir: string) => {
+  const source = path.join(inputDir, 'assets');
+  if (!await exists(source)) return;
+  await fs.cp(source, assetsDir, { recursive: true });
+};

package/src/generate/public-main.ts

@@ -0,0 +1,22 @@
+export const generatePublicMain = () => `export default function createPlugin() {
+  const getApi = () => window.$wujie?.props;
+  return {
+  async onAction(command, action, query, options) {
+    const api = getApi();
+    try {
+      await api.channel.invoke('raycast:run', {
+        commandName: command.name,
+        query,
+        action,
+        options,
+        preferences: api.getPreferences?.() || {},
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await api.dialog.showToast(message);
+      throw error;
+    }
+  },
+  };
+}
+`;

package/src/generate/server-module.ts

@@ -0,0 +1,56 @@
+import type { ConvertedCommand } from '../types';
+
+const toImportName = (index: number) => `command${index}`;
+
+export const generateServerModule = (
+  commands: ConvertedCommand[],
+  packageName: string,
+  publicCommands: Record<string, unknown>[],
+) => {
+  const imports = commands.map((command, index) => `import * as ${toImportName(index)} from ${JSON.stringify(command.entry)};`).join('\n');
+  const commandMapEntries = commands.map((command, index) => `  ${JSON.stringify(command.name)}: ${toImportName(index)},`).join('\n');
+  const commandManifests = JSON.stringify(publicCommands, null, 2);
+  return `import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { channel } from '@public-tauri/api/node';
+import { __setRaycastContext } from '@public-tauri/api/raycast';
+
+${imports}
+
+const commandModules: Record<string, any> = {
+${commandMapEntries}
+};
+
+const distDir = path.dirname(fileURLToPath(import.meta.url));
+const pluginRoot = path.dirname(distDir);
+const commandManifests = ${commandManifests};
+
+channel.handle('raycast:run', async (payload = {}) => {
+  const commandName = String(payload.commandName || '');
+  const commandModule = commandModules[commandName];
+  if (!commandModule) {
+    throw new Error(\`Unknown Raycast command: \${commandName}\`);
+  }
+  const run = commandModule.default;
+  if (typeof run !== 'function') {
+    throw new Error(\`Raycast command \${commandName} has no default function export\`);
+  }
+  const launchPayload = payload.options?.payload || {};
+  __setRaycastContext({
+    pluginName: ${JSON.stringify(packageName)},
+    commandName,
+    commands: commandManifests,
+    launchType: launchPayload.launchType,
+    preferences: payload.preferences || {},
+    supportPath: path.join(pluginRoot, '.raycast-compat'),
+    assetsPath: path.join(pluginRoot, 'assets'),
+  });
+  return await run({
+    arguments: launchPayload.arguments || {},
+    fallbackText: launchPayload.fallbackText ?? payload.query ?? '',
+    launchContext: launchPayload.context ?? payload,
+    launchType: launchPayload.launchType || 'userInitiated',
+  });
+});
+`;
+};

package/src/generate/tsdown-config.ts

@@ -0,0 +1,44 @@
+import path from 'node:path';
+import type { ResolvedConvertOptions } from '../types';
+
+const formatAlias = (aliases: Record<string, string>) => Object.entries(aliases)
+  .map(([key, value]) => `      ${JSON.stringify(key)}: ${JSON.stringify(value)},`)
+  .join('\n');
+
+const formatAliasProperty = (aliases: Record<string, string>) => {
+  const entries = formatAlias(aliases);
+  return entries ? `    alias: {\n${entries}\n    },` : '    alias: {},';
+};
+
+const getServerAliases = (): Record<string, string> => ({
+  '@raycast/api': '@public-tauri/api/raycast',
+  '@raycast/utils': '@public-tauri/api/raycast/utils',
+});
+
+export const generateTsdownConfig = (options: ResolvedConvertOptions) => `export default [
+  {
+    entry: ${JSON.stringify(path.join(options.buildDir, 'public-main.ts'))},
+    format: 'esm',
+    platform: 'browser',
+    target: 'es2022',
+    outDir: ${JSON.stringify(options.distDir)},
+    outExtensions: () => ({ js: '.js' }),
+    deps: {
+      alwaysBundle: () => true,
+    },
+${formatAliasProperty({})}
+  },
+  {
+    entry: ${JSON.stringify(path.join(options.buildDir, 'server.ts'))},
+    format: 'esm',
+    platform: 'node',
+    target: 'es2022',
+    outDir: ${JSON.stringify(options.distDir)},
+    outExtensions: () => ({ js: '.js' }),
+    deps: {
+      alwaysBundle: () => true,
+    },
+${formatAliasProperty(getServerAliases())}
+  },
+];
+`;

package/src/icons.ts

@@ -0,0 +1,12 @@
+const isUrlLike = (value: string) => /^(?:https?:|data:|asset:|public-icon:)/.test(value);
+const hasPathSegment = (value: string) => value.includes('/') || value.includes('\\');
+
+export const DEFAULT_PLUGIN_ICON = 'extension';
+
+export const normalizeRaycastIcon = (icon: string | undefined) => {
+  if (!icon) return undefined;
+  if (isUrlLike(icon)) return icon;
+  if (icon.startsWith('./') || icon.startsWith('../') || icon.startsWith('/')) return icon;
+  if (hasPathSegment(icon)) return `./${icon}`;
+  return `./assets/${icon}`;
+};

package/src/index.ts

@@ -0,0 +1,81 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { installAndBuild } from './build';
+import { resolveNoViewCommands } from './commands';
+import { copyAssetsDir, readJson, writeJson } from './files';
+import { generatePublicMain } from './generate/public-main';
+import { generateServerModule } from './generate/server-module';
+import { generateTsdownConfig } from './generate/tsdown-config';
+import { DEFAULT_PLUGIN_ICON, normalizeRaycastIcon } from './icons';
+import { resolveConvertOptions } from './options';
+import { createConvertedPackage } from './package-json';
+import { mergePreferences } from './preferences';
+import type { ConversionReport, ConvertOptions, ConvertWarning, RaycastPackage } from './types';
+
+export type * from './types';
+
+const createPublicCommands = (commands: { name: string, title?: string, subtitle?: string, description?: string, icon?: string, keywords?: string[] }[], icon: string) => commands.map(command => ({
+  name: command.name,
+  title: command.title || command.name,
+  subtitle: command.subtitle || command.description,
+  description: command.description,
+  icon: normalizeRaycastIcon(command.icon) || icon,
+  mode: 'none',
+  matches: [
+    {
+      type: 'text',
+      keywords: command.keywords?.length ? command.keywords : [command.title || command.name],
+    },
+  ],
+}));
+
+export const convertRaycastPlugin = async (rawOptions: ConvertOptions): Promise<ConversionReport> => {
+  const options = resolveConvertOptions(rawOptions);
+  const warnings: ConvertWarning[] = [];
+  const sourcePackage = await readJson<RaycastPackage>(path.join(options.inputDir, 'package.json'));
+  const sourceCommands = sourcePackage.commands || [];
+  const { convertedCommands, skippedCommands } = await resolveNoViewCommands(options.inputDir, sourceCommands);
+
+  await fs.rm(options.outputDir, { recursive: true, force: true });
+  await fs.mkdir(options.buildDir, { recursive: true });
+  await fs.mkdir(options.distDir, { recursive: true });
+  await copyAssetsDir(options.inputDir, options.assetsDir);
+
+  const icon = normalizeRaycastIcon(sourcePackage.icon || convertedCommands[0]?.icon) || DEFAULT_PLUGIN_ICON;
+  const commandPreferences = convertedCommands.flatMap(command => command.preferences || []);
+  const preferences = mergePreferences(sourcePackage.preferences || [], commandPreferences, warnings);
+  const publicCommands = createPublicCommands(convertedCommands, icon);
+  const publicPlugin = {
+    title: sourcePackage.title || sourcePackage.name,
+    subtitle: sourcePackage.description || sourcePackage.name,
+    description: sourcePackage.description,
+    icon,
+    main: './dist/public-main.js',
+    server: './dist/server.js',
+    ...(preferences.length ? { preferences } : {}),
+    commands: publicCommands,
+  };
+
+  await writeJson(path.join(options.outputDir, 'package.json'), createConvertedPackage(sourcePackage, publicPlugin, {
+    publicApiDependency: options.publicApiDependency,
+    warnings,
+  }));
+  await fs.writeFile(path.join(options.buildDir, 'public-main.ts'), generatePublicMain(), 'utf8');
+  await fs.writeFile(path.join(options.buildDir, 'server.ts'), generateServerModule(convertedCommands, sourcePackage.name, publicCommands), 'utf8');
+  await fs.writeFile(path.join(options.outputDir, 'tsdown.config.ts'), generateTsdownConfig(options), 'utf8');
+
+  const report: ConversionReport = {
+    source: options.inputDir,
+    output: options.outputDir,
+    convertedCommands: convertedCommands.map(command => ({ name: command.name, entry: command.entry })),
+    skippedCommands,
+    warnings,
+  };
+  await writeJson(path.join(options.outputDir, 'raycast-conversion-report.json'), report);
+
+  if (options.build) {
+    installAndBuild(options);
+  }
+
+  return report;
+};

package/src/options.ts

@@ -0,0 +1,23 @@
+import path from 'node:path';
+import type { ConvertMode, ConvertOptions, ResolvedConvertOptions } from './types';
+
+const resolveMode = (mode: ConvertOptions['mode']): ConvertMode => mode || 'development';
+
+export const resolveConvertOptions = (options: ConvertOptions): ResolvedConvertOptions => {
+  const inputDir = path.resolve(options.inputDir);
+  const outputDir = path.resolve(options.outputDir || `${inputDir}-public`);
+  const invocationDir = path.resolve(options.invocationDir || process.cwd());
+  const mode = resolveMode(options.mode);
+
+  return {
+    inputDir,
+    outputDir,
+    build: Boolean(options.build),
+    mode,
+    invocationDir,
+    publicApiDependency: mode === 'development' ? `file:${path.join(invocationDir, 'packages', 'api')}` : 'latest',
+    buildDir: path.join(outputDir, '.raycast-build'),
+    distDir: path.join(outputDir, 'dist'),
+    assetsDir: path.join(outputDir, 'assets'),
+  };
+};

package/src/package-json.ts

@@ -0,0 +1,50 @@
+import type { ConvertWarning, RaycastPackage } from './types';
+
+const raycastApiPackages = new Set(['@raycast/api', '@raycast/utils']);
+
+const rewriteDependencyMap = (dependencies: Record<string, string> | undefined) => {
+  const rewritten = { ...(dependencies || {}) };
+  let replacedRaycastApi = false;
+  for (const packageName of raycastApiPackages) {
+    if (packageName in rewritten) {
+      delete rewritten[packageName];
+      replacedRaycastApi = true;
+    }
+  }
+  return { dependencies: rewritten, replacedRaycastApi };
+};
+
+export const createConvertedPackage = (
+  sourcePackage: RaycastPackage,
+  publicPlugin: Record<string, unknown>,
+  options: { publicApiDependency: string, warnings: ConvertWarning[] },
+) => {
+  const dependenciesResult = rewriteDependencyMap(sourcePackage.dependencies);
+  const devDependenciesResult = rewriteDependencyMap(sourcePackage.devDependencies);
+  if (dependenciesResult.replacedRaycastApi || devDependenciesResult.replacedRaycastApi) {
+    options.warnings.push({
+      type: 'dependency',
+      message: 'Replaced @raycast/api and/or @raycast/utils with @public-tauri/api',
+    });
+  }
+
+  return {
+    ...sourcePackage,
+    version: sourcePackage.version || '1.0.0',
+    type: 'module',
+    private: true,
+    publicPlugin,
+    scripts: {
+      ...(sourcePackage.scripts || {}),
+      build: 'tsdown --config tsdown.config.ts',
+    },
+    dependencies: {
+      ...dependenciesResult.dependencies,
+      '@public-tauri/api': dependenciesResult.dependencies['@public-tauri/api'] || options.publicApiDependency,
+    },
+    devDependencies: {
+      ...devDependenciesResult.dependencies,
+      tsdown: devDependenciesResult.dependencies.tsdown || '^0.21.7',
+    },
+  };
+};

package/src/preferences.ts

@@ -0,0 +1,62 @@
+import type { ConvertWarning, RaycastPreference } from './types';
+
+const mapPreferenceType = (type: string | undefined, warnings: ConvertWarning[]) => {
+  switch (type) {
+    case 'password':
+      return 'password';
+    case 'textarea':
+      return 'textarea';
+    case 'dropdown':
+      return 'select';
+    case 'checkbox':
+      return 'select';
+    case 'textfield':
+    case 'appPicker':
+    case undefined:
+      return 'text';
+    default:
+      warnings.push({ type: 'preference', message: `Unsupported preference type "${type}", converted to text` });
+      return 'text';
+  }
+};
+
+export const convertPreference = (preference: RaycastPreference, warnings: ConvertWarning[]) => {
+  const type = mapPreferenceType(preference.type, warnings);
+  const options = preference.type === 'checkbox'
+    ? [
+      { label: 'Yes', value: true },
+      { label: 'No', value: false },
+    ]
+    : preference.data?.map(item => ({
+      label: item.title || item.label || String(item.value),
+      value: item.value,
+    }));
+  return {
+    name: preference.name,
+    title: preference.title || preference.label || preference.name,
+    description: preference.description,
+    type,
+    required: Boolean(preference.required),
+    placeholder: preference.placeholder,
+    defaultValue: preference.defaultValue ?? preference.default,
+    ...(options?.length ? { options } : {}),
+  };
+};
+
+export const mergePreferences = (
+  pluginPreferences: RaycastPreference[],
+  commandPreferences: RaycastPreference[],
+  warnings: ConvertWarning[],
+) => {
+  const preferenceNames = new Set<string>();
+  return [...pluginPreferences, ...commandPreferences]
+    .map(preference => convertPreference(preference, warnings))
+    .filter((preference) => {
+      if (preferenceNames.has(preference.name)) {
+        warnings.push({ type: 'preference', message: `Duplicate preference "${preference.name}" was skipped` });
+        return false;
+      }
+      preferenceNames.add(preference.name);
+      return true;
+    });
+};

package/src/types.ts

@@ -0,0 +1,73 @@
+export type RaycastPreference = {
+  name: string;
+  title?: string;
+  label?: string;
+  description?: string;
+  type?: string;
+  required?: boolean;
+  placeholder?: string;
+  default?: unknown;
+  defaultValue?: unknown;
+  data?: { title?: string, label?: string, value: string | number | boolean }[];
+};
+
+export type RaycastCommand = {
+  name: string;
+  title?: string;
+  subtitle?: string;
+  description?: string;
+  mode?: string;
+  keywords?: string[];
+  icon?: string;
+  preferences?: RaycastPreference[];
+};
+
+export type RaycastPackage = {
+  name: string;
+  version?: string;
+  type?: string;
+  title?: string;
+  description?: string;
+  icon?: string;
+  commands?: RaycastCommand[];
+  preferences?: RaycastPreference[];
+  scripts?: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+} & Record<string, unknown>;
+
+export type ConvertWarning = {
+  type: string;
+  message: string;
+};
+
+export type ConvertedCommand = RaycastCommand & {
+  entry: string;
+};
+
+export type ConvertMode = 'development' | 'production';
+
+export type ConvertOptions = {
+  inputDir: string;
+  outputDir?: string;
+  build?: boolean;
+  mode?: ConvertMode;
+  invocationDir?: string;
+};
+
+export type ResolvedConvertOptions = Required<Omit<ConvertOptions, 'outputDir' | 'mode'>> & {
+  outputDir: string;
+  mode: ConvertMode;
+  publicApiDependency: string;
+  buildDir: string;
+  distDir: string;
+  assetsDir: string;
+};
+
+export type ConversionReport = {
+  source: string;
+  output: string;
+  convertedCommands: { name: string, entry: string }[];
+  skippedCommands: { name: string, reason: string }[];
+  warnings: ConvertWarning[];
+};