Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
perf: Skip Unchanged Skills in GitHub Skill Sync
Marco Beretta565976be52d7
diff --git a/packages/api/src/skills/sync/github.spec.ts b/packages/api/src/skills/sync/github.spec.tsindex 52ab43e93a..d3fe5eb4c5 100644--- a/packages/api/src/skills/sync/github.spec.ts+++ b/packages/api/src/skills/sync/github.spec.ts@@ -1,6 +1,7 @@import crypto from 'crypto';-import { Types } from 'mongoose';-import { logger, getTenantId } from '@librechat/data-schemas';+import mongoose, { Types } from 'mongoose';+import { MongoMemoryServer } from 'mongodb-memory-server';+import { logger, getTenantId, createModels, createMethods } from '@librechat/data-schemas';import type {ISkill,ISkillFile,@@ -2861,7 +2862,7 @@ describe('createGitHubSkillSyncRunner', () => {);});- it('skips existing skill updates when the upstream package is unchanged', async () => {+ it('records a sync fingerprint once on an unchanged mirror that predates it', async () => {const skillMarkdown = '---\nname: research\ndescription: Research things\n---\nBody';const existing = makeSkill({name: 'research',@@ -2901,7 +2902,15 @@ describe('createGitHubSkillSyncRunner', () => {getSkillById: jest.fn(async () => existing),getSkillFileByPath: jest.fn(async () => unchangedFile),listSkillFiles: jest.fn(async () => [unchangedFile]),- updateSkill: jest.fn(),+ updateSkill: jest.fn(+ async ({ update }: { update: UpdateSkillInput }): Promise<UpdateSkillResult> => ({+ status: 'updated',+ skill: { ...existing, ...update, version: existing.version + 1 } as ISkill & {+ _id: Types.ObjectId;+ },+ warnings: [],+ }),+ ),});const runner = createGitHubSkillSyncRunner(deps);const result = await runner.runOnce();@@ -2909,7 +2918,18 @@ describe('createGitHubSkillSyncRunner', () => {expect(result.status).toBe('completed');expect(deps.saveBuffer).not.toHaveBeenCalled();expect(deps.upsertSkillFile).not.toHaveBeenCalled();- expect(deps.updateSkill).not.toHaveBeenCalled();+ expect(deps.updateSkill).toHaveBeenCalledTimes(1);+ expect(deps.updateSkill).toHaveBeenCalledWith(+ expect.objectContaining({+ update: expect.objectContaining({+ body: skillMarkdown,+ sourceMetadata: expect.objectContaining({+ skillBlobSha: 'skill-md-sha',+ syncFingerprint: expect.stringMatching(/^[0-9a-f]{64}$/),+ }),+ }),+ }),+ );expect(deps.grantPermission).toHaveBeenCalled();});@@ -3732,3 +3752,320 @@ describe('files whose paths cannot be mirrored', () => {);});});++describe('steady-state sync of an unchanged source', () => {+ const researchMarkdown = '---\nname: research\ndescription: Research things\n---\nBody';+ const writingMarkdown = '---\nname: writing\ndescription: Write things\n---\nBody';+ let server: MongoMemoryServer;+ let db: ReturnType<typeof createMethods>;++ beforeAll(async () => {+ server = await MongoMemoryServer.create();+ await mongoose.connect(server.getUri());+ createModels(mongoose);+ db = createMethods(mongoose);+ });++ afterAll(async () => {+ await mongoose.disconnect();+ await server.stop();+ });++ beforeEach(async () => {+ await mongoose.connection.dropDatabase();+ });++ type RepoFile = { content: string; revision?: number };++ /** The provider boundary: a repository held in memory whose content ids can move. */+ function createRepo(initial: Record<string, RepoFile>) {+ let files = initial;+ const fetchFileContent = jest.fn(async (_commit: unknown, entry: RepoTreeEntry) =>+ Buffer.from(files[entry.path].content),+ );+ const adapter: GitRepoAdapter = {+ resolveCommit: async () => ({ id: 'fake-commit', treeId: 'fake-tree' }),+ fetchTreeEntries: async (_commit, { pathPrefix }) =>+ Object.entries(files)+ .map(([path, file]) => ({+ path,+ type: 'blob' as const,+ id: `${path}@${file.revision ?? 1}`,+ size: Buffer.byteLength(file.content),+ }))+ .filter((entry) => !pathPrefix || entry.path.startsWith(`${pathPrefix}/`)),+ fetchFileContent,+ };+ return {+ adapter,+ fetchFileContent,+ setFiles: (next: Record<string, RepoFile>) => {+ files = next;+ },+ fetchedPaths: () => fetchFileContent.mock.calls.map(([, entry]) => entry.path),+ };+ }++ function createDbDeps(+ repo: ReturnType<typeof createRepo>,+ sourceOverrides: Partial<{ ref: string }> = {},+ ) {+ return createDeps({+ getConfig: () => ({+ github: {+ enabled: true,+ intervalMinutes: 60,+ runOnStartup: false,+ sources: [+ {+ id: 'librechat-skills',+ owner: 'LibreChat',+ repo: 'skills',+ ref: sourceOverrides.ref ?? 'main',+ paths: ['skills'],+ credentialKey: 'github-skills-prod',+ },+ ],+ },+ }),+ createAdapter: () => repo.adapter,+ createSkill: jest.fn(db.createSkill),+ updateSkill: jest.fn(db.updateSkill),+ getSkillById: jest.fn(db.getSkillById),+ findSkillBySourceIdentity: jest.fn(db.findSkillBySourceIdentity),+ listSkillsBySource: jest.fn(db.listSkillsBySource),+ listSkillFiles: jest.fn(db.listSkillFiles),+ getSkillFileByPath: jest.fn(db.getSkillFileByPath),+ upsertSkillFile: jest.fn(db.upsertSkillFile),+ deleteSkillFile: jest.fn(db.deleteSkillFile),+ deleteSkill: jest.fn(db.deleteSkill),+ saveBuffer: jest.fn(async ({ fileName }: { fileName: string }) => ({+ filepath: `/uploads/${fileName}`,+ source: 'local',+ })),+ });+ }++ async function seed(repo: ReturnType<typeof createRepo>) {+ const result = await createGitHubSkillSyncRunner(createDbDeps(repo)).runOnce();+ expect(result.status).toBe('completed');+ expect(result.sources[0]).toEqual(+ expect.objectContaining({ status: 'succeeded', syncedSkillCount: expect.any(Number) }),+ );+ repo.fetchFileContent.mockClear();+ }++ async function getMirror(rootPath = 'skills/research') {+ const skill = await db.findSkillBySourceIdentity({+ source: 'github',+ upstreamId: `librechat-skills:${rootPath}`,+ });+ if (!skill) {+ throw new Error(`missing mirror for ${rootPath}`);+ }+ return skill;+ }++ const baseRepo = (): Record<string, RepoFile> => ({+ 'skills/research/SKILL.md': { content: researchMarkdown },+ 'skills/research/scripts/run.sh': { content: 'echo hi' },+ 'skills/research/notes.md': { content: 'notes' },+ });++ it('neither downloads SKILL.md nor updates the skill on a second sync', async () => {+ const repo = createRepo(baseRepo());+ await seed(repo);+ const before = await getMirror();+ expect(before.sourceMetadata?.syncFingerprint).toEqual(expect.stringMatching(/^[0-9a-f]{64}$/));++ const deps = createDbDeps(repo);+ const result = await createGitHubSkillSyncRunner(deps).runOnce();++ expect(result.sources[0]).toEqual(+ expect.objectContaining({+ status: 'succeeded',+ syncedSkillCount: 1,+ syncedFileCount: 0,+ deletedSkillCount: 0,+ deletedFileCount: 0,+ }),+ );+ expect(repo.fetchFileContent).not.toHaveBeenCalled();+ expect(deps.updateSkill).not.toHaveBeenCalled();+ expect(deps.getSkillFileByPath).not.toHaveBeenCalled();+ expect(deps.upsertSkillFile).not.toHaveBeenCalled();+ expect(deps.grantPermission).toHaveBeenCalledWith(+ expect.objectContaining({ resourceId: before._id }),+ );+ expect((await getMirror()).version).toBe(before.version);+ });++ it('downloads SKILL.md and updates the skill when its blob changes', async () => {+ const repo = createRepo(baseRepo());+ await seed(repo);+ repo.setFiles({+ ...baseRepo(),+ 'skills/research/SKILL.md': {+ content: '---\nname: research\ndescription: Research more things\n---\nBody',+ revision: 2,+ },+ });++ const deps = createDbDeps(repo);+ await createGitHubSkillSyncRunner(deps).runOnce();++ expect(repo.fetchedPaths()).toEqual(['skills/research/SKILL.md']);+ expect(deps.updateSkill).toHaveBeenCalledTimes(1);+ const mirror = await getMirror();+ expect(mirror.description).toBe('Research more things');+ expect(mirror.sourceMetadata?.skillBlobSha).toBe('skills/research/SKILL.md@2');+ });++ it('updates the skill when a bundled file changes', async () => {+ const repo = createRepo(baseRepo());+ await seed(repo);+ repo.setFiles({+ ...baseRepo(),+ 'skills/research/scripts/run.sh': { content: 'echo bye', revision: 2 },+ });++ const deps = createDbDeps(repo);+ const result = await createGitHubSkillSyncRunner(deps).runOnce();++ expect(repo.fetchedPaths().sort()).toEqual([+ 'skills/research/SKILL.md',+ 'skills/research/scripts/run.sh',+ ]);+ expect(deps.updateSkill).toHaveBeenCalledTimes(1);+ expect(result.sources[0]).toEqual(expect.objectContaining({ syncedFileCount: 1 }));+ const mirror = await getMirror();+ const file = await db.getSkillFileByPath(mirror._id, 'scripts/run.sh');+ expect(file?.sourceMetadata?.blobSha).toBe('skills/research/scripts/run.sh@2');+ });++ it('updates the skill and deletes the file when a bundled file is removed upstream', async () => {+ const repo = createRepo(baseRepo());+ await seed(repo);+ const { 'skills/research/notes.md': _removed, ...remaining } = baseRepo();+ repo.setFiles(remaining);++ const deps = createDbDeps(repo);+ const result = await createGitHubSkillSyncRunner(deps).runOnce();++ expect(repo.fetchedPaths()).toEqual(['skills/research/SKILL.md']);+ expect(deps.updateSkill).toHaveBeenCalledTimes(1);+ expect(deps.deleteSkillFile).toHaveBeenCalledWith(expect.anything(), 'notes.md');+ expect(result.sources[0]).toEqual(expect.objectContaining({ deletedFileCount: 1 }));+ const files = await db.listSkillFiles((await getMirror())._id);+ expect(files.map((file) => file.relativePath)).toEqual(['scripts/run.sh']);+ });++ it('updates the skill when the source config it records changes', async () => {+ const repo = createRepo(baseRepo());+ await seed(repo);++ const deps = createDbDeps(repo, { ref: 'release' });+ await createGitHubSkillSyncRunner(deps).runOnce();++ expect(repo.fetchedPaths()).toEqual(['skills/research/SKILL.md']);+ expect(deps.updateSkill).toHaveBeenCalledTimes(1);+ expect((await getMirror()).sourceMetadata?.ref).toBe('release');+ });++ it('re-syncs a mirror whose stored definition was edited outside the sync', async () => {+ const repo = createRepo(baseRepo());+ await seed(repo);+ const mirror = await getMirror();+ await db.updateSkill({+ id: mirror._id.toString(),+ expectedVersion: mirror.version,+ update: { body: 'Edited body' },+ });++ const deps = createDbDeps(repo);+ await createGitHubSkillSyncRunner(deps).runOnce();++ expect(repo.fetchedPaths()).toEqual(['skills/research/SKILL.md']);+ expect(deps.updateSkill).toHaveBeenCalledTimes(1);+ expect((await getMirror()).body).toBe(researchMarkdown);+ });++ it('fully syncs a mirror without a fingerprint once, then skips it', async () => {+ const repo = createRepo(baseRepo());+ await seed(repo);+ const mirror = await getMirror();+ const { syncFingerprint: _fingerprint, ...legacyMetadata } = mirror.sourceMetadata ?? {};+ await db.updateSkill({+ id: mirror._id.toString(),+ expectedVersion: mirror.version,+ update: { sourceMetadata: legacyMetadata },+ });++ const legacyDeps = createDbDeps(repo);+ await createGitHubSkillSyncRunner(legacyDeps).runOnce();++ expect(repo.fetchedPaths()).toEqual(['skills/research/SKILL.md']);+ expect(legacyDeps.updateSkill).toHaveBeenCalledTimes(1);+ expect(legacyDeps.upsertSkillFile).not.toHaveBeenCalled();+ expect((await getMirror()).sourceMetadata?.syncFingerprint).toBe(+ mirror.sourceMetadata?.syncFingerprint,+ );++ repo.fetchFileContent.mockClear();+ const steadyDeps = createDbDeps(repo);+ await createGitHubSkillSyncRunner(steadyDeps).runOnce();++ expect(repo.fetchFileContent).not.toHaveBeenCalled();+ expect(steadyDeps.updateSkill).not.toHaveBeenCalled();+ });++ it('still reconciles a skill deleted upstream while skipping the unchanged ones', async () => {+ const repo = createRepo({+ ...baseRepo(),+ 'skills/writing/SKILL.md': { content: writingMarkdown },+ 'skills/writing/guide.md': { content: 'guide' },+ });+ await seed(repo);+ const writing = await getMirror('skills/writing');+ repo.setFiles(baseRepo());++ const deps = createDbDeps(repo);+ const result = await createGitHubSkillSyncRunner(deps).runOnce();++ expect(repo.fetchFileContent).not.toHaveBeenCalled();+ expect(deps.updateSkill).not.toHaveBeenCalled();+ expect(deps.deleteSkill).toHaveBeenCalledWith(writing._id.toString());+ expect(result.sources[0]).toEqual(+ expect.objectContaining({+ status: 'succeeded',+ syncedSkillCount: 1,+ deletedSkillCount: 1,+ deletedFileCount: 1,+ }),+ );+ expect(await db.getSkillById(writing._id)).toBeNull();+ });++ it('still rejects an unchanged skill that exceeds the import limits', async () => {+ const repo = createRepo(baseRepo());+ await seed(repo);+ const maxEntries = DEFAULT_SKILL_IMPORT_LIMITS.maxEntries;+ const tooMany = { ...baseRepo() };+ for (let index = 0; index < maxEntries; index++) {+ tooMany[`skills/research/extra/${index}.txt`] = { content: 'x' };+ }+ repo.setFiles(tooMany);++ const deps = createDbDeps(repo);+ const result = await createGitHubSkillSyncRunner(deps).runOnce();++ expect(result.sources[0]).toEqual(+ expect.objectContaining({+ skippedSkillCount: 1,+ skippedSkills: [expect.objectContaining({ errorCode: 'GITHUB_TOO_MANY_FILES' })],+ }),+ );+ expect(deps.findSkillBySourceIdentity).not.toHaveBeenCalled();+ expect(repo.fetchFileContent).not.toHaveBeenCalled();+ });+});diff --git a/packages/api/src/skills/sync/github.ts b/packages/api/src/skills/sync/github.tsindex aadc502f38..11d4da0647 100644--- a/packages/api/src/skills/sync/github.ts+++ b/packages/api/src/skills/sync/github.ts@@ -69,6 +69,12 @@ const VALIDATION_ISSUE_LIMIT = 5;const VALIDATION_ISSUE_FIELD_MAX = 100;const VALIDATION_ISSUE_CODE_MAX = 64;const VALIDATION_ISSUE_MESSAGE_MAX = 250;+/**+ * Bump when the mapping from an upstream package to a stored skill changes+ * (parsing, name fallback, frontmatter cleanup, metadata shape), so every+ * mirror takes the full sync path once and records the new fingerprint.+ */+const SYNC_FINGERPRINT_VERSION = 1;export { GITHUB_FINE_GRAINED_TOKEN_RECOMMENDATION };export type { GitHubRepoAdapterConfig };@@ -116,6 +122,8 @@ type PreparedExistingRemoteSkill = PreparedRemoteSkill & {type PreparedDiscoveredSkill = {discovered: DiscoveredSkill;prepared: PreparedRemoteSkill;+ /** The mirror already matches upstream, so syncing it writes nothing. */+ unchanged?: boolean;};type SaveBufferResult = {@@ -793,15 +801,181 @@ async function ensurePublicViewer(});}-async function prepareRemoteSkill(params: {+type SkillDefinition = Pick<+ UpdateSkillInput,+ 'name' | 'description' | 'body' | 'frontmatter' | 'alwaysApply'+>;++/**+ * Source metadata that identifies what a mirror was synced from, minus the+ * per-run `commitSha` and `syncedAt`. Key order matches the stored shape.+ */+function makeSyncIdentity(+ source: SkillSyncGitHubSourceConfig,+ discovered: DiscoveredSkill,+): Record<string, string> {+ return {+ provider: PROVIDER,+ sourceId: source.id,+ upstreamId: makeUpstreamId(source, discovered.rootPath),+ owner: source.owner,+ repo: source.repo,+ ref: source.ref,+ skillPath: discovered.rootPath,+ skillBlobSha: discovered.skillMd.id,+ syncStatus: 'synced',+ };+}++/**+ * Hashes everything that decides a mirror's stored skill row: the mapping+ * version, the upstream identity (including the SKILL.md blob id), and the+ * definition written from it. Recomputed from the stored row, it only matches+ * when neither upstream nor the row changed since the last write.+ */+function makeSyncFingerprint(+ identity: Record<string, string>,+ definition: SkillDefinition,+): string {+ const payload = JSON.stringify({+ version: SYNC_FINGERPRINT_VERSION,+ identity,+ name: definition.name,+ description: definition.description,+ body: definition.body,+ frontmatter: definition.frontmatter ?? {},+ alwaysApply: definition.alwaysApply ?? false,+ });+ return crypto.createHash('sha256').update(payload).digest('hex');+}++function makeCreateInput(+ source: SkillSyncGitHubSourceConfig,+ update: UpdateSkillInput,+ fallbackName: string,+): CreateSkillInput {+ return {+ ...(update as Omit<UpdateSkillInput, 'source'>),+ name: update.name ?? fallbackName,+ description: update.description ?? fallbackName,+ author: makeSourceAuthorId(source),+ authorName: SYSTEM_AUTHOR_NAME,+ source: PROVIDER,+ tenantId: source.tenantId,+ };+}++function getFallbackSkillName(+ source: SkillSyncGitHubSourceConfig,+ discovered: DiscoveredSkill,+): string {+ return toSkillName(path.posix.basename(discovered.rootPath) || source.id);+}++async function findExistingRemoteSkill(+ deps: GitHubSkillSyncDeps,+ source: SkillSyncGitHubSourceConfig,+ discovered: DiscoveredSkill,+): Promise<(ISkill & { _id: Types.ObjectId }) | null> {+ const sourceTenantId = source.tenantId ?? undefined;+ const foundExisting = await deps.findSkillBySourceIdentity({+ source: PROVIDER,+ upstreamId: makeUpstreamId(source, discovered.rootPath),+ tenantId: sourceTenantId,+ });+ return foundExisting && (foundExisting.tenantId ?? undefined) === sourceTenantId+ ? foundExisting+ : null;+}++function hasSameSyncMetadata(+ stored: Record<string, unknown> | undefined,+ expected: Record<string, string>,+): boolean {+ const { commitSha: _commitSha, syncedAt: _syncedAt, ...comparable } = stored ?? {};+ const keys = new Set([...Object.keys(comparable), ...Object.keys(expected)]);+ for (const key of keys) {+ if (comparable[key] !== expected[key]) {+ return false;+ }+ }+ return true;+}++/** True when `syncSkillFiles` would neither download, replace nor delete a file. */+function hasSameSyncedFiles(+ discovered: DiscoveredSkill,+ storedFiles: Array<ISkillFile & { _id: Types.ObjectId }>,+): boolean {+ const remoteBlobShas = new Map<string, string>();+ for (const entry of discovered.files) {+ const relativePath = getDiscoveredRelativePath(discovered, entry);+ if (!isSafeRelativePath(relativePath) || relativePath.toUpperCase() === 'SKILL.MD') {+ continue;+ }+ remoteBlobShas.set(relativePath, entry.id);+ }+ if (storedFiles.length !== remoteBlobShas.size) {+ return false;+ }+ return storedFiles.every(+ (file) =>+ remoteBlobShas.has(file.relativePath) &&+ getSourceMetadataString(file, 'blobSha') === remoteBlobShas.get(file.relativePath),+ );+}++/**+ * Returns a prepared skill without downloading SKILL.md when the mirror is+ * already current: its stored fingerprint matches the discovered upstream+ * package and its own definition, and its stored files match the discovered+ * blobs. Anything else returns null and takes the full sync path, which also+ * records the fingerprint on mirrors that predate it.+ */+async function prepareUnchangedRemoteSkill(params: {deps: GitHubSkillSyncDeps;source: SkillSyncGitHubSourceConfig;discovered: DiscoveredSkill;+ existing: ISkill & { _id: Types.ObjectId };+}): Promise<PreparedExistingRemoteSkill | null> {+ const { deps, source, discovered, existing } = params;+ const identity = makeSyncIdentity(source, discovered);+ const definition: SkillDefinition = {+ name: existing.name,+ description: existing.description,+ body: existing.body,+ frontmatter: existing.frontmatter,+ alwaysApply: existing.alwaysApply,+ };+ const syncFingerprint = makeSyncFingerprint(identity, definition);+ if (!hasSameSyncMetadata(existing.sourceMetadata, { ...identity, syncFingerprint })) {+ return null;+ }+ const storedFiles = await deps.listSkillFiles(existing._id);+ if (!hasSameSyncedFiles(discovered, storedFiles)) {+ return null;+ }+ const update: UpdateSkillInput = {+ ...definition,+ source: PROVIDER,+ sourceMetadata: existing.sourceMetadata,+ };+ return {+ existing,+ update,+ createInput: makeCreateInput(source, update, getFallbackSkillName(source, discovered)),+ };+}++async function prepareRemoteSkill(params: {+ source: SkillSyncGitHubSourceConfig;+ discovered: DiscoveredSkill;+ existing: (ISkill & { _id: Types.ObjectId }) | null;skillMdContent: string;commitSha: string;syncedAt: Date;}): Promise<PreparedRemoteSkill> {- const { deps, source, discovered, skillMdContent, commitSha, syncedAt } = params;+ const { source, discovered, existing, skillMdContent, commitSha, syncedAt } = params;const parsed = parseSkillMarkdown(skillMdContent);if (parsed.parseError) {throw new SkillSyncError(@@ -815,50 +989,31 @@ async function prepareRemoteSkill(params: {`${discovered.rootPath}/SKILL.md contains invalid boolean frontmatter`,);}- const upstreamId = makeUpstreamId(source, discovered.rootPath);- const fallbackName = toSkillName(path.posix.basename(discovered.rootPath) || source.id);- const sourceMetadata = {- provider: PROVIDER,- sourceId: source.id,- upstreamId,- owner: source.owner,- repo: source.repo,- ref: source.ref,- skillPath: discovered.rootPath,- commitSha,- skillBlobSha: discovered.skillMd.id,- syncedAt: serializeDate(syncedAt),- syncStatus: 'synced',- };- const update: UpdateSkillInput = {+ const fallbackName = getFallbackSkillName(source, discovered);+ const definition: SkillDefinition = {name: parsed.name || fallbackName,description: parsed.description || parsed.name || fallbackName,body: skillMdContent,frontmatter: toCleanFrontmatter(parsed.frontmatter),alwaysApply: parsed.alwaysApply,- source: PROVIDER,- sourceMetadata,};- const sourceTenantId = source.tenantId ?? undefined;- const foundExisting = await deps.findSkillBySourceIdentity({- source: PROVIDER,- upstreamId,- tenantId: sourceTenantId,- });- const existing =- foundExisting && (foundExisting.tenantId ?? undefined) === sourceTenantId- ? foundExisting- : null;- const createInput: CreateSkillInput = {- ...(update as Omit<UpdateSkillInput, 'source'>),- name: update.name ?? fallbackName,- description: update.description ?? fallbackName,- author: makeSourceAuthorId(source),- authorName: SYSTEM_AUTHOR_NAME,- source: PROVIDER,- tenantId: source.tenantId,+ const identity = makeSyncIdentity(source, discovered);+ const sourceMetadata = {+ provider: identity.provider,+ sourceId: identity.sourceId,+ upstreamId: identity.upstreamId,+ owner: identity.owner,+ repo: identity.repo,+ ref: identity.ref,+ skillPath: identity.skillPath,+ commitSha,+ skillBlobSha: identity.skillBlobSha,+ syncedAt: serializeDate(syncedAt),+ syncStatus: identity.syncStatus,+ syncFingerprint: makeSyncFingerprint(identity, definition),};- return { existing, update, createInput };+ const update: UpdateSkillInput = { ...definition, source: PROVIDER, sourceMetadata };+ return { existing, update, createInput: makeCreateInput(source, update, fallbackName) };}async function commitRemoteSkill(@@ -1609,14 +1764,23 @@ async function syncSource(params: {assertNotCancelled();try {assertGitHubSkillPackageManifest(discovered);+ const existing = await findExistingRemoteSkill(deps, source, discovered);+ assertNotCancelled();+ const unchanged = existing+ ? await prepareUnchangedRemoteSkill({ deps, source, discovered, existing })+ : null;+ if (unchanged) {+ preparedSkills.push({ discovered, prepared: unchanged, unchanged: true });+ continue;+ }const skillMdPath = getSkillMdPath(discovered);const skillMdBuffer = await adapter.fetchFileContent(commit, discovered.skillMd);assertNotCancelled();assertGitHubBufferSize(skillMdBuffer, skillMdPath);const prepared = await prepareRemoteSkill({- deps,source,discovered,+ existing,skillMdContent: skillMdBuffer.toString('utf-8'),commitSha: commit.id,syncedAt,@@ -1706,10 +1870,45 @@ async function syncSource(params: {}};+ /**+ * A current mirror keeps every side effect a no-op file sync and skipped+ * update would have had: the public viewer grant and the cleanup of a+ * stale mirror holding its name. It is still counted as synced.+ */+ const syncUnchangedSkill = async (+ discovered: DiscoveredSkill,+ prepared: PreparedExistingRemoteSkill,+ ): Promise<void> => {+ await ensurePublicViewer(deps, prepared.existing._id);+ if (canReconcileStaleSkills) {+ const staleConflictCleanup = await deleteNameConflictingStaleSkill({+ deps,+ source,+ prepared,+ existingSyncedSkills: await getExistingSyncedSkills(),+ discoveredUpstreamIds,+ assertNotCancelled,+ });+ existingSyncedSkills = staleConflictCleanup.remainingSkills;+ counts.deletedSkillCount += staleConflictCleanup.deletedSkillCount;+ counts.deletedFileCount += staleConflictCleanup.deletedFileCount;+ if (staleConflictCleanup.deletedSkill) {+ await cleanupDeletedSyncedSkillFiles(deps, staleConflictCleanup.deletedSkill);+ }+ }+ counts.syncedSkillCount++;+ recordUnsupportedFiles(discovered);+ };+const syncPreparedSkill = async ({discovered,prepared,+ unchanged,}: PreparedDiscoveredSkill): Promise<void> => {+ if (unchanged && prepared.existing) {+ await syncUnchangedSkill(discovered, { ...prepared, existing: prepared.existing });+ return;+ }if (!prepared.existing && !canReconcileStaleSkills) {const ambiguousMovedMirror = findMovedSourceSkill({source,