@leonxin/meetgames 0.1.8 → 0.1.12

package/src/ios/pbxprojEditor.ts

@@ -0,0 +1,450 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import type { TextFileStore } from "../ops/fileStore.js";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type XcodeProject = any;
+
+const require = createRequire(import.meta.url);
+const xcode = require("xcode") as {
+  project: (pbxprojPath: string) => XcodeProject;
+};
+
+export interface PbxContext {
+  rel: string;
+  proj: XcodeProject;
+  srcRoot: string;
+  targetName: string;
+}
+
+function parseProjectFromContent(content: string): Promise<XcodeProject> {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "meet-pbx-"));
+  const pbxprojPath = path.join(dir, "project.pbxproj");
+  fs.writeFileSync(pbxprojPath, content, "utf8");
+  return new Promise((resolve, reject) => {
+    const proj = xcode.project(pbxprojPath);
+    proj.parse((err: Error | null) => {
+      if (err) reject(err);
+      else resolve(proj);
+    });
+  });
+}
+
+function ensureObjectSection(proj: XcodeProject, sectionName: string): void {
+  const objects = proj.hash?.project?.objects as Record<string, unknown> | undefined;
+  if (!objects) return;
+  if (!objects[sectionName]) objects[sectionName] = {};
+}
+
+function objectSection(proj: XcodeProject, sectionName: string): Record<string, unknown> {
+  ensureObjectSection(proj, sectionName);
+  return (proj.hash.project.objects as Record<string, Record<string, unknown>>)[sectionName];
+}
+
+export async function loadPbxFromStore(
+  store: TextFileStore,
+  projectRoot: string,
+  xcodeprojPath: string,
+  targetName: string
+): Promise<PbxContext> {
+  const rel = path.relative(projectRoot, path.join(xcodeprojPath, "project.pbxproj")).split(path.sep).join("/");
+  const content = store.read(rel);
+  const proj = await parseProjectFromContent(content);
+  // Newer Xcode projects can omit empty sections, while the `xcode` package assumes
+  // sections such as PBXBuildFile already exist before adding frameworks/resources.
+  ensureObjectSection(proj, "PBXBuildFile");
+  ensureObjectSection(proj, "PBXFileReference");
+  const xcodeprojDir = path.dirname(xcodeprojPath);
+  let srcRoot = xcodeprojDir;
+  const first = proj.getFirstProject?.()?.firstProject;
+  const projectDirPath = first?.projectDirPath
+    ? String(first.projectDirPath).replace(/^"|"$/g, "").trim()
+    : "";
+  if (projectDirPath.length > 0) {
+    srcRoot = path.resolve(xcodeprojDir, projectDirPath);
+  }
+  return { rel, proj, srcRoot, targetName };
+}
+
+export function savePbxToStore(store: TextFileStore, ctx: PbxContext): void {
+  stripUndefinedValues(ctx.proj.hash?.project?.objects);
+  sanitizePbxBuildSettings(ctx.proj);
+  store.write(ctx.rel, ctx.proj.writeSync());
+}
+
+function stripUndefinedValues(value: unknown): void {
+  if (Array.isArray(value)) {
+    for (const item of value) stripUndefinedValues(item);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+
+  const record = value as Record<string, unknown>;
+  for (const [key, nested] of Object.entries(record)) {
+    if (nested === undefined || nested === "undefined") {
+      delete record[key];
+      continue;
+    }
+    stripUndefinedValues(nested);
+  }
+}
+
+function sanitizePbxBuildSettings(proj: XcodeProject): void {
+  const buildConfigs = proj.pbxXCBuildConfigurationSection?.() ?? {};
+  for (const [uuid, cfg] of Object.entries(buildConfigs)) {
+    if (uuid.endsWith("_comment") || !cfg || typeof cfg !== "object") continue;
+    const settings = (cfg as { buildSettings?: Record<string, unknown> }).buildSettings;
+    if (!settings) continue;
+    for (const [key, raw] of Object.entries(settings)) {
+      if (typeof raw === "string") {
+        settings[key] = quotePbxStringIfNeeded(raw);
+        continue;
+      }
+      if (Array.isArray(raw)) {
+        settings[key] = raw.map((value) => (typeof value === "string" ? quotePbxStringIfNeeded(value) : value));
+      }
+    }
+  }
+}
+
+function isPbxQuotedString(value: string): boolean {
+  return value.length >= 2 && value.startsWith('"') && value.endsWith('"');
+}
+
+function unquotePbxString(value: string): string {
+  if (!isPbxQuotedString(value)) return value;
+  return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+
+function quotePbxStringIfNeeded(value: string): string {
+  if (isPbxQuotedString(value)) return value;
+  if (!pbxStringNeedsQuotes(value)) return value;
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function pbxStringNeedsQuotes(value: string): boolean {
+  if (value.length === 0 || value.startsWith("-")) return true;
+  return /[^A-Za-z0-9_.$/{}()+-]/.test(value);
+}
+
+function samePbxStringValue(a: unknown, b: string): boolean {
+  return typeof a === "string" && unquotePbxString(a) === unquotePbxString(b);
+}
+
+function targetUuid(proj: XcodeProject, targetName: string): string | undefined {
+  const targets = proj.pbxNativeTargetSection?.() ?? {};
+  for (const [uuid, t] of Object.entries(targets)) {
+    if (uuid.endsWith("_comment")) continue;
+    const name = (t as { name?: string }).name?.replace(/"/g, "");
+    if (name === targetName) return uuid;
+  }
+  return undefined;
+}
+
+function targetKey(proj: XcodeProject, targetName: string): string {
+  const uuid = targetUuid(proj, targetName);
+  if (!uuid) throw new Error(`Xcode target not found: ${targetName}`);
+  return uuid;
+}
+
+function ensureResourcesBuildPhase(proj: XcodeProject, targetName: string): void {
+  const target = targetKey(proj, targetName);
+  try {
+    proj.pbxResourcesBuildPhaseObj(target);
+    return;
+  } catch {
+    proj.addBuildPhase([], "PBXResourcesBuildPhase", "Resources", target);
+  }
+}
+
+export function addThirdPartyFramework(ctx: PbxContext, relPathFromSrcRoot: string, embed: boolean): void {
+  const file = relPathFromSrcRoot.split(path.sep).join("/");
+  const target = targetKey(ctx.proj, ctx.targetName);
+  ctx.proj.addFramework(file, {
+    customFramework: true,
+    embed,
+    sign: true,
+    target,
+  });
+}
+
+export function addCopyFile(ctx: PbxContext, relPathFromSrcRoot: string): void {
+  const file = relPathFromSrcRoot.split(path.sep).join("/");
+  const target = targetKey(ctx.proj, ctx.targetName);
+  if (copyFilesPhaseJson(ctx, target).includes(path.basename(file))) return;
+  ensureCopyFilesBuildPhase(ctx, target);
+  addCopyFileManually(ctx, target, file);
+}
+
+function copyFilesPhaseJson(ctx: PbxContext, target: string): string {
+  try {
+    return JSON.stringify(ctx.proj.pbxCopyfilesBuildPhaseObj?.(target) ?? {});
+  } catch {
+    return "";
+  }
+}
+
+function findFileRefUuid(ctx: PbxContext, file: string): string | null {
+  const basename = path.basename(file);
+  const fileRefSection = objectSection(ctx.proj, "PBXFileReference");
+  for (const [uuid, raw] of Object.entries(fileRefSection)) {
+    if (uuid.endsWith("_comment") || !raw || typeof raw !== "object") continue;
+    const ref = raw as Record<string, unknown>;
+    const comment = fileRefSection[`${uuid}_comment`];
+    const refPath = String(ref.path ?? "").replace(/^"|"$/g, "");
+    const refName = String(ref.name ?? "").replace(/^"|"$/g, "");
+    if (comment === basename || refPath === file || refPath.endsWith(`/${basename}`) || refName === basename) {
+      return uuid;
+    }
+  }
+  return null;
+}
+
+function ensureCopyFilesBuildPhase(ctx: PbxContext, target: string): Record<string, unknown> {
+  const section = objectSection(ctx.proj, "PBXCopyFilesBuildPhase");
+  for (const [uuid, raw] of Object.entries(section)) {
+    if (uuid.endsWith("_comment") || !raw || typeof raw !== "object") continue;
+    const phase = raw as Record<string, unknown>;
+    const name = String(phase.name ?? "").replace(/^"|"$/g, "");
+    if (name === "Copy Files" || section[`${uuid}_comment`] === "Copy Files") {
+      phase.files = (phase.files as unknown[]) ?? [];
+      return phase;
+    }
+  }
+
+  const uuid = ctx.proj.generateUuid();
+  const phase: Record<string, unknown> = {
+    isa: "PBXCopyFilesBuildPhase",
+    buildActionMask: 2147483647,
+    dstPath: '""',
+    dstSubfolderSpec: 10,
+    files: [],
+    name: '"Copy Files"',
+    runOnlyForDeploymentPostprocessing: 0,
+  };
+  section[uuid] = phase;
+  section[`${uuid}_comment`] = "Copy Files";
+  const native = ctx.proj.pbxNativeTargetSection?.()[target] as { buildPhases?: Array<{ value: string; comment: string }> };
+  native.buildPhases ??= [];
+  if (!native.buildPhases.some((p) => p.value === uuid)) {
+    native.buildPhases.push({ value: uuid, comment: "Copy Files" });
+  }
+  return phase;
+}
+
+function addCopyFileManually(ctx: PbxContext, target: string, file: string): void {
+  const basename = path.basename(file);
+  const phase = ensureCopyFilesBuildPhase(ctx, target);
+  const files = (phase.files ??= []) as Array<{ value?: string; comment?: string }>;
+  if (JSON.stringify(files).includes(basename)) return;
+
+  let fileRefUuid: string = findFileRefUuid(ctx, file) ?? "";
+  if (!fileRefUuid) {
+    fileRefUuid = ctx.proj.generateUuid();
+    const fileRefSection = objectSection(ctx.proj, "PBXFileReference");
+    fileRefSection[fileRefUuid] = {
+      isa: "PBXFileReference",
+      name: `"${basename}"`,
+      path: `"${file}"`,
+      sourceTree: '"<group>"',
+      lastKnownFileType: "wrapper.framework",
+      includeInIndex: 0,
+    };
+    fileRefSection[`${fileRefUuid}_comment`] = basename;
+  }
+
+  const buildUuid = ctx.proj.generateUuid();
+  const buildFileSection = objectSection(ctx.proj, "PBXBuildFile");
+  buildFileSection[buildUuid] = {
+    isa: "PBXBuildFile",
+    fileRef: fileRefUuid,
+    fileRef_comment: basename,
+  };
+  buildFileSection[`${buildUuid}_comment`] = `${basename} in Copy Files`;
+  files.push({ value: buildUuid, comment: `${basename} in Copy Files` });
+}
+
+export function addSystemFramework(ctx: PbxContext, frameworkName: string): void {
+  const target = targetKey(ctx.proj, ctx.targetName);
+  ctx.proj.addFramework(`System/Library/Frameworks/${frameworkName}`, {
+    customFramework: false,
+    weak: false,
+    target,
+  });
+}
+
+export function addSystemLib(ctx: PbxContext, libName: string): void {
+  const target = targetKey(ctx.proj, ctx.targetName);
+  ctx.proj.addFramework(`usr/lib/${libName}`, {
+    customFramework: false,
+    weak: false,
+    target,
+  });
+}
+
+export function addSourceOrResourceFile(ctx: PbxContext, relPathFromSrcRoot: string): void {
+  const file = relPathFromSrcRoot.split(path.sep).join("/");
+  const target = targetKey(ctx.proj, ctx.targetName);
+  if (file.endsWith(".h")) {
+    ctx.proj.addHeaderFile(file, { target });
+  } else if (file.endsWith(".m") || file.endsWith(".mm") || file.endsWith(".swift")) {
+    ctx.proj.addSourceFile(file, { target });
+  } else {
+    ensureResourcesBuildPhase(ctx.proj, ctx.targetName);
+    const opt: Record<string, unknown> = { target };
+    if (file.endsWith(".xcdatamodeld")) {
+      opt.lastKnownFileType = "wrapper.xcdatamodel";
+    }
+    try {
+      ctx.proj.addResourceFile(file, opt);
+    } catch (e) {
+      if (!String(e instanceof Error ? e.message : e).includes("path")) throw e;
+      addResourceFileManually(ctx, file, typeof opt.lastKnownFileType === "string" ? opt.lastKnownFileType : undefined);
+    }
+  }
+}
+
+function resourceFileType(file: string, lastKnownFileType?: string): string {
+  if (lastKnownFileType) return lastKnownFileType;
+  if (file.endsWith(".bundle")) return "wrapper.plug-in";
+  if (file.endsWith(".xcdatamodeld")) return "wrapper.xcdatamodel";
+  if (file.endsWith(".xcassets")) return "folder.assetcatalog";
+  if (file.endsWith(".plist")) return "text.plist.xml";
+  return "unknown";
+}
+
+function addResourceFileManually(ctx: PbxContext, file: string, lastKnownFileType?: string): void {
+  const basename = path.basename(file);
+  const resources = ctx.proj.pbxResourcesBuildPhaseObj(targetKey(ctx.proj, ctx.targetName));
+  const files = (resources.files ??= []) as Array<{ value?: string; comment?: string }>;
+  if (JSON.stringify(files).includes(basename)) return;
+
+  const fileRefUuid = ctx.proj.generateUuid();
+  const buildUuid = ctx.proj.generateUuid();
+  const fileRefSection = objectSection(ctx.proj, "PBXFileReference");
+  const buildFileSection = objectSection(ctx.proj, "PBXBuildFile");
+
+  fileRefSection[fileRefUuid] = {
+    isa: "PBXFileReference",
+    name: `"${basename}"`,
+    path: `"${file}"`,
+    sourceTree: '"<group>"',
+    lastKnownFileType: resourceFileType(file, lastKnownFileType),
+    includeInIndex: 0,
+  };
+  fileRefSection[`${fileRefUuid}_comment`] = basename;
+  buildFileSection[buildUuid] = {
+    isa: "PBXBuildFile",
+    fileRef: fileRefUuid,
+    fileRef_comment: basename,
+  };
+  buildFileSection[`${buildUuid}_comment`] = `${basename} in Resources`;
+  files.push({ value: buildUuid, comment: `${basename} in Resources` });
+}
+
+export function setBuildSetting(ctx: PbxContext, key: string, value: string): void {
+  const uuid = targetUuid(ctx.proj, ctx.targetName);
+  if (!uuid) return;
+  const native = ctx.proj.pbxNativeTargetSection?.()[uuid] as { buildConfigurationList?: string };
+  const listId = native?.buildConfigurationList;
+  const lists = ctx.proj.pbxXCConfigurationList?.() ?? {};
+  if (!listId || !lists[listId]) return;
+  const list = lists[listId] as { buildConfigurations?: Array<string | { value: string }> };
+  const buildConfigs = ctx.proj.pbxXCBuildConfigurationSection?.() ?? {};
+  for (const entry of list.buildConfigurations ?? []) {
+    const cfgId = typeof entry === "string" ? entry : entry.value;
+    const cfg = buildConfigs[cfgId];
+    if (!cfg || typeof cfg !== "object") continue;
+    const settings = (cfg as { buildSettings?: Record<string, unknown> }).buildSettings ?? {};
+    settings[key] = value;
+    (cfg as { buildSettings: Record<string, unknown> }).buildSettings = settings;
+  }
+}
+
+export function addOtherLinkerFlag(ctx: PbxContext, flag: string): void {
+  const uuid = targetUuid(ctx.proj, ctx.targetName);
+  if (!uuid) return;
+  const native = ctx.proj.pbxNativeTargetSection?.()[uuid] as { buildConfigurationList?: string };
+  const listId = native?.buildConfigurationList;
+  const lists = ctx.proj.pbxXCConfigurationList?.() ?? {};
+  if (!listId || !lists[listId]) return;
+  const list = lists[listId] as { buildConfigurations?: Array<string | { value: string }> };
+  const buildConfigs = ctx.proj.pbxXCBuildConfigurationSection?.() ?? {};
+  for (const entry of list.buildConfigurations ?? []) {
+    const cfgId = typeof entry === "string" ? entry : entry.value;
+    const cfg = buildConfigs[cfgId];
+    if (!cfg || typeof cfg !== "object") continue;
+    const settings = (cfg as { buildSettings?: Record<string, unknown> }).buildSettings ?? {};
+    const cur = settings.OTHER_LDFLAGS;
+    const normalizedFlag = unquotePbxString(flag);
+    const nextFlag = quotePbxStringIfNeeded(normalizedFlag);
+    if (typeof cur === "string") {
+      if (!unquotePbxString(cur).split(/\s+/).includes(normalizedFlag)) {
+        settings.OTHER_LDFLAGS = [quotePbxStringIfNeeded(cur), nextFlag];
+      }
+    } else if (Array.isArray(cur)) {
+      const values = cur.map((value) => (typeof value === "string" ? quotePbxStringIfNeeded(value) : value));
+      if (!values.some((value) => samePbxStringValue(value, normalizedFlag))) values.push(nextFlag);
+      settings.OTHER_LDFLAGS = values;
+    } else {
+      settings.OTHER_LDFLAGS = [nextFlag];
+    }
+    (cfg as { buildSettings: Record<string, unknown> }).buildSettings = settings;
+  }
+}
+
+export function getTargetBuildSettings(ctx: PbxContext): Array<Record<string, unknown>> {
+  const uuid = targetUuid(ctx.proj, ctx.targetName);
+  if (!uuid) return [];
+  const native = ctx.proj.pbxNativeTargetSection?.()[uuid] as { buildConfigurationList?: string };
+  const listId = native?.buildConfigurationList;
+  const lists = ctx.proj.pbxXCConfigurationList?.() ?? {};
+  if (!listId || !lists[listId]) return [];
+  const list = lists[listId] as { buildConfigurations?: Array<string | { value: string }> };
+  const buildConfigs = ctx.proj.pbxXCBuildConfigurationSection?.() ?? {};
+  const out: Array<Record<string, unknown>> = [];
+  for (const entry of list.buildConfigurations ?? []) {
+    const cfgId = typeof entry === "string" ? entry : entry.value;
+    const cfg = buildConfigs[cfgId];
+    if (!cfg || typeof cfg !== "object") continue;
+    const settings = (cfg as { buildSettings?: Record<string, unknown> }).buildSettings ?? {};
+    (cfg as { buildSettings: Record<string, unknown> }).buildSettings = settings;
+    out.push(settings);
+  }
+  return out;
+}
+
+export function findInfoPlistPathsFromPbx(ctx: PbxContext): string[] {
+  const paths = new Set<string>();
+  const uuid = targetUuid(ctx.proj, ctx.targetName);
+  if (!uuid) return [];
+  const native = ctx.proj.pbxNativeTargetSection?.()[uuid] as { buildConfigurationList?: string };
+  const listId = native?.buildConfigurationList;
+  const lists = ctx.proj.pbxXCConfigurationList?.() ?? {};
+  if (!listId || !lists[listId]) return [];
+  const list = lists[listId] as { buildConfigurations?: Array<string | { value: string }> };
+  const buildConfigs = ctx.proj.pbxXCBuildConfigurationSection?.() ?? {};
+  for (const entry of list.buildConfigurations ?? []) {
+    const cfgId = typeof entry === "string" ? entry : entry.value;
+    const cfg = buildConfigs[cfgId];
+    const settings = (cfg as { buildSettings?: Record<string, string> })?.buildSettings;
+    const info = settings?.INFOPLIST_FILE;
+    if (!info) continue;
+    let resolved = info.replace(/"/g, "");
+    if (resolved.includes("$(SRCROOT)")) {
+      resolved = resolved.replace(/\$\(SRCROOT\)/g, ctx.srcRoot);
+    } else if (!path.isAbsolute(resolved)) {
+      resolved = path.join(ctx.srcRoot, resolved);
+    }
+    resolved = path.normalize(resolved);
+    paths.add(resolved);
+  }
+  return [...paths];
+}
+
+export function ensureInfoPlistInProject(ctx: PbxContext, _targetName: string, relPlist: string): void {
+  setBuildSetting(ctx, "GENERATE_INFOPLIST_FILE", "NO");
+  setBuildSetting(ctx, "INFOPLIST_FILE", relPlist);
+}

package/src/ios/pluginConfig.ts

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { LoadedPluginConfig, PluginConfigJson } from "./types.js";
+
+const CONFIG_FILENAMES = ["config.t.json", "config.json"] as const;
+
+function findConfigFileInDir(dir: string): string | null {
+  for (const name of CONFIG_FILENAMES) {
+    const p = path.join(dir, name);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+function normalizePluginConfig(raw: Record<string, unknown>): PluginConfigJson {
+  const flags =
+    (raw.OtherLinkerFlags as string[] | undefined) ??
+    (raw.otherLinkerFlags as string[] | undefined) ??
+    [];
+  return {
+    ...(raw as unknown as PluginConfigJson),
+    OtherLinkerFlags: flags,
+  };
+}
+
+function parseConfigJson(filePath: string): PluginConfigJson {
+  const raw = JSON.parse(fs.readFileSync(filePath, "utf8")) as Record<string, unknown>;
+  const config = normalizePluginConfig(raw);
+  if (!config.name || typeof config.type !== "number") {
+    throw new Error(`invalid plugin config (missing name/type): ${filePath}`);
+  }
+  return config;
+}
+
+function resolveSourceDir(sdkRoot: string, config: PluginConfigJson, pluginDir: string): string {
+  const sdkDir = path.join(sdkRoot, "sdk");
+  if (config.type === 0) {
+    return path.join(sdkDir, "source");
+  }
+  return path.join(pluginDir, "source");
+}
+
+export function loadPluginConfig(configPath: string, sdkRoot: string): LoadedPluginConfig {
+  const abs = path.resolve(configPath);
+  const pluginDir = path.dirname(abs);
+  const config = parseConfigJson(abs);
+  const sourceDir = resolveSourceDir(sdkRoot, config, pluginDir);
+  return { configPath: abs, pluginDir, sourceDir, config };
+}
+
+/** Core SDK manifests: `sdk/*.json` (e.g. topsdkConfig.t.json). */
+export function listSdkCoreConfigs(sdkRoot: string): LoadedPluginConfig[] {
+  const sdkDir = path.join(sdkRoot, "sdk");
+  if (!fs.existsSync(sdkDir)) return [];
+  const out: LoadedPluginConfig[] = [];
+  for (const name of fs.readdirSync(sdkDir)) {
+    if (!name.endsWith(".json") || name.startsWith(".")) continue;
+    out.push(loadPluginConfig(path.join(sdkDir, name), sdkRoot));
+  }
+  return out;
+}
+
+export function findPluginByFolder(sdkRoot: string, folderName: string): LoadedPluginConfig | null {
+  const pluginDir = path.join(sdkRoot, "plugins", folderName);
+  const cfg = findConfigFileInDir(pluginDir);
+  if (!cfg) return null;
+  return loadPluginConfig(cfg, sdkRoot);
+}
+
+export function validateLoadedPluginResources(loaded: LoadedPluginConfig): string[] {
+  const errors: string[] = [];
+  const { config, sourceDir, pluginDir, configPath } = loaded;
+  const dirName = path.basename(pluginDir);
+  const isKnownDataManagerAlias = config.type === 4 && dirName.endsWith("Manager");
+  if (config.type !== 0 && dirName !== config.name && !isKnownDataManagerAlias) {
+    errors.push(`plugin config name mismatch: ${configPath} name=${config.name} dir=${path.basename(pluginDir)}`);
+  }
+  if (!fs.existsSync(sourceDir)) {
+    errors.push(`plugin source directory not found: ${sourceDir}`);
+    return errors;
+  }
+  for (const source of config.sources ?? []) {
+    const p = path.join(sourceDir, source);
+    if (!fs.existsSync(p)) errors.push(`missing source resource for ${config.name}: ${source}`);
+  }
+  for (const fw of config.frameworks ?? []) {
+    if (fw.system) continue;
+    const p = path.join(sourceDir, fw.name);
+    if (!fs.existsSync(p)) errors.push(`missing framework resource for ${config.name}: ${fw.name}`);
+  }
+  for (const lib of config.libs ?? []) {
+    if (lib.system) continue;
+    const p = path.join(sourceDir, lib.name);
+    if (!fs.existsSync(p)) errors.push(`missing lib resource for ${config.name}: ${lib.name}`);
+  }
+  return errors;
+}

package/src/ios/reserved.ts

@@ -0,0 +1,8 @@
+import type { IosToolingReserved } from "../contracts/types.js";
+
+export const iosToolingReserved: IosToolingReserved = {
+  status: "implemented",
+  plan: ["framework-copy", "pbxproj", "plist", "app-delegate"],
+};
+
+export { detectIOS as detectIOSPlaceholder } from "./detect.js";

package/src/ios/sdkBundle.ts

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+import { MEET_SDK_TOOL_CACHE_ROOT } from "../cache.js";
+
+/**
+ * TopSDK iOS package root from cache.
+ * Native iOS only.
+ */
+function findIosSdkRoot(container: string): string | null {
+  if (!fs.existsSync(container)) return null;
+  const children = fs
+    .readdirSync(container, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && !d.name.startsWith("."))
+    .map((d) => path.join(container, d.name))
+    .sort()
+    .reverse();
+  for (const dir of children) {
+    if (fs.existsSync(path.join(dir, "sdk")) && fs.existsSync(path.join(dir, "plugins"))) {
+      return dir;
+    }
+  }
+  if (fs.existsSync(path.join(container, "sdk")) && fs.existsSync(path.join(container, "plugins"))) {
+    return container;
+  }
+  return null;
+}
+
+function findLatestCachedIosSdkRoot(): string | null {
+  const iosCache = path.join(MEET_SDK_TOOL_CACHE_ROOT, "sdk", "ios");
+  if (!fs.existsSync(iosCache)) return null;
+  const candidates: string[] = [];
+  const walk = (dir: string): void => {
+    for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
+      const abs = path.join(dir, ent.name);
+      if (ent.name === "extracted") {
+        candidates.push(abs);
+      } else {
+        walk(abs);
+      }
+    }
+  };
+  walk(iosCache);
+  candidates.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+  for (const candidate of candidates) {
+    const found = findIosSdkRoot(candidate);
+    if (found) return found;
+  }
+  return null;
+}
+
+export function resolveIosSdkRoot(_packageRoot: string): string {
+  const cached = findLatestCachedIosSdkRoot();
+  if (cached) return cached;
+
+  throw new Error(
+    `iOS SDK not found in ${path.join(MEET_SDK_TOOL_CACHE_ROOT, "sdk", "ios")}; run download-ios-sdk or setup first.`
+  );
+}

package/src/ios/template.ts

@@ -0,0 +1,36 @@
+/** Substitute `{path.to.value}` placeholders using channel config (topsdk-tool-ios `checkStr`). */
+export function applyChannelTemplate(value: string, channelConfig: Record<string, unknown>): string {
+  let result = value;
+  const re = /\{([^}]+)\}/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(value)) !== null) {
+    const token = m[1].startsWith("$C.") ? m[1].slice(3) : m[1];
+    const parts = token.split(".");
+    let cur: unknown = channelConfig;
+    for (const p of parts) {
+      if (cur && typeof cur === "object" && p in (cur as Record<string, unknown>)) {
+        cur = (cur as Record<string, unknown>)[p];
+      } else {
+        cur = "";
+        break;
+      }
+    }
+    const replacement = cur == null ? "" : String(cur);
+    result = result.replace(m[0], replacement);
+  }
+  return result;
+}
+
+export function applyChannelTemplateValue(value: unknown, channelConfig: Record<string, unknown>): unknown {
+  if (typeof value === "string") return applyChannelTemplate(value, channelConfig);
+  if (Array.isArray(value)) return value.map((item) => applyChannelTemplateValue(item, channelConfig));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>).map(([key, item]) => [
+        key,
+        applyChannelTemplateValue(item, channelConfig),
+      ])
+    );
+  }
+  return value;
+}