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
import { createHash } from 'crypto';
import type { Model, Types } from 'mongoose';
import type {
ISkillSyncStatus,
SkillSyncProvider,
SkillSyncRunStatus,
ISkillSyncSkippedFile,
ISkillSyncSkippedSkill,
ISkillSyncStatusDocument,
ISkillSyncCredential,
ISkillSyncCredentialDocument,
} from '~/types/skillSync';
import { encryptV2, decryptV2 } from '~/crypto';
const LOCK_SOURCE_ID = '__global_lock__';
export type SkillSyncCredentialSummary = {
provider: SkillSyncProvider;
credentialKey: string;
credentialPresent: boolean;
tokenFingerprint?: string;
createdAt?: Date;
updatedAt?: Date;
};
export type UpsertSkillSyncCredentialInput = {
provider: SkillSyncProvider;
credentialKey: string;
token: string;
userId?: Types.ObjectId;
};
export type SkillSyncStatusInput = {
provider: SkillSyncProvider;
sourceId: string;
tenantId?: string;
status: SkillSyncRunStatus;
credentialKey?: string;
owner?: string;
repo?: string;
ref?: string;
paths?: string[];
startedAt?: Date;
finishedAt?: Date;
errorCode?: string;
errorMessage?: string;
syncedSkillCount?: number;
syncedFileCount?: number;
deletedSkillCount?: number;
deletedFileCount?: number;
skippedSkillCount?: number;
skippedSkills?: ISkillSyncSkippedSkill[];
skippedFileCount?: number;
skippedFiles?: ISkillSyncSkippedFile[];
};
export type SkillSyncLockInput = {
provider: SkillSyncProvider;
lockOwner: string;
leaseMs: number;
tenantId?: string;
};
export type SkillSyncReleaseLockInput = {
provider: SkillSyncProvider;
lockOwner: string;
tenantId?: string;
};
export type SkillSyncMethods = {
upsertSkillSyncCredential: (
input: UpsertSkillSyncCredentialInput,
) => Promise<SkillSyncCredentialSummary>;
deleteSkillSyncCredential: (
provider: SkillSyncProvider,
credentialKey: string,
) => Promise<{ deleted: boolean }>;
listSkillSyncCredentials: (provider: SkillSyncProvider) => Promise<SkillSyncCredentialSummary[]>;
getSkillSyncCredentialToken: (
provider: SkillSyncProvider,
credentialKey: string,
) => Promise<string | null>;
getSkillSyncCredentialSummary: (
provider: SkillSyncProvider,
credentialKey: string,
) => Promise<SkillSyncCredentialSummary | null>;
listSkillSyncStatuses: (provider: SkillSyncProvider) => Promise<ISkillSyncStatus[]>;
upsertSkillSyncStatus: (input: SkillSyncStatusInput) => Promise<ISkillSyncStatus>;
tryAcquireSkillSyncLock: (params: SkillSyncLockInput) => Promise<boolean>;
refreshSkillSyncLock: (params: SkillSyncLockInput) => Promise<boolean>;
releaseSkillSyncLock: (params: SkillSyncReleaseLockInput) => Promise<void>;
};
function hashToken(token: string): string {
return createHash('sha256').update(token).digest('hex');
}
function tenantStatusCondition(tenantId?: string) {
return tenantId ? { tenantId } : { tenantId: { $exists: false } };
}
function summarizeCredential(
credential: Pick<
ISkillSyncCredential,
'provider' | 'credentialKey' | 'tokenHash' | 'createdAt' | 'updatedAt'
>,
): SkillSyncCredentialSummary {
return {
provider: credential.provider,
credentialKey: credential.credentialKey,
credentialPresent: true,
tokenFingerprint: credential.tokenHash.slice(0, 12),
createdAt: credential.createdAt,
updatedAt: credential.updatedAt,
};
}
export function createSkillSyncMethods(mongoose: typeof import('mongoose')): SkillSyncMethods {
async function upsertSkillSyncCredential(
input: UpsertSkillSyncCredentialInput,
): Promise<SkillSyncCredentialSummary> {
const Credential = mongoose.models.SkillSyncCredential as Model<ISkillSyncCredentialDocument>;
const encryptedToken = await encryptV2(input.token);
const tokenHash = hashToken(input.token);
const update = {
$set: {
encryptedToken,
tokenHash,
updatedBy: input.userId,
},
$setOnInsert: {
provider: input.provider,
credentialKey: input.credentialKey,
createdBy: input.userId,
},
};
const credential = await Credential.findOneAndUpdate(
{ provider: input.provider, credentialKey: input.credentialKey },
update,
{ upsert: true, new: true, setDefaultsOnInsert: true },
)
.select('+tokenHash')
.lean();
return summarizeCredential(credential as ISkillSyncCredential);
}
async function deleteSkillSyncCredential(
provider: SkillSyncProvider,
credentialKey: string,
): Promise<{ deleted: boolean }> {
const Credential = mongoose.models.SkillSyncCredential as Model<ISkillSyncCredentialDocument>;
const result = await Credential.deleteOne({ provider, credentialKey });
return { deleted: (result.deletedCount ?? 0) > 0 };
}
async function listSkillSyncCredentials(
provider: SkillSyncProvider,
): Promise<SkillSyncCredentialSummary[]> {
const Credential = mongoose.models.SkillSyncCredential as Model<ISkillSyncCredentialDocument>;
const rows = await Credential.find({ provider })
.select('+tokenHash')
.sort({ credentialKey: 1 })
.lean();
return rows.map((row) => summarizeCredential(row as ISkillSyncCredential));
}
async function getSkillSyncCredentialToken(
provider: SkillSyncProvider,
credentialKey: string,
): Promise<string | null> {
const Credential = mongoose.models.SkillSyncCredential as Model<ISkillSyncCredentialDocument>;
const credential = await Credential.findOne({ provider, credentialKey })
.select('+encryptedToken')
.lean();
if (!credential) {
return null;
}
return decryptV2((credential as ISkillSyncCredential).encryptedToken);
}
async function getSkillSyncCredentialSummary(
provider: SkillSyncProvider,
credentialKey: string,
): Promise<SkillSyncCredentialSummary | null> {
const Credential = mongoose.models.SkillSyncCredential as Model<ISkillSyncCredentialDocument>;
const credential = await Credential.findOne({ provider, credentialKey })
.select('+tokenHash')
.lean();
if (!credential) {
return null;
}
return summarizeCredential(credential as ISkillSyncCredential);
}
async function listSkillSyncStatuses(provider: SkillSyncProvider): Promise<ISkillSyncStatus[]> {
const Status = mongoose.models.SkillSyncStatus as Model<ISkillSyncStatusDocument>;
const rows = await Status.find({ provider, sourceId: { $ne: LOCK_SOURCE_ID } })
.sort({ sourceId: 1 })
.lean<ISkillSyncStatus[]>();
return rows;
}
async function upsertSkillSyncStatus(input: SkillSyncStatusInput): Promise<ISkillSyncStatus> {
const Status = mongoose.models.SkillSyncStatus as Model<ISkillSyncStatusDocument>;
const now = new Date();
/* A partial run published skills, so it advances `lastSuccessAt` the same
way a clean run does; the dropped skills live in `skippedSkills`. */
const success = input.status === 'succeeded' || input.status === 'partial';
const failure = input.status === 'failed';
const setPayload: Partial<ISkillSyncStatus> = {
status: input.status,
credentialKey: input.credentialKey,
owner: input.owner,
repo: input.repo,
ref: input.ref,
paths: input.paths,
startedAt: input.startedAt,
finishedAt: input.finishedAt,
syncedSkillCount: input.syncedSkillCount ?? 0,
syncedFileCount: input.syncedFileCount ?? 0,
deletedSkillCount: input.deletedSkillCount ?? 0,
deletedFileCount: input.deletedFileCount ?? 0,
skippedSkillCount: input.skippedSkillCount ?? 0,
skippedSkills: input.skippedSkills ?? [],
skippedFileCount: input.skippedFileCount ?? 0,
skippedFiles: input.skippedFiles ?? [],
...(success ? { lastSuccessAt: input.finishedAt ?? now } : {}),
...(failure ? { lastFailureAt: input.finishedAt ?? now } : {}),
};
if (failure) {
setPayload.errorCode = input.errorCode;
setPayload.errorMessage = input.errorMessage;
}
const unsetPayload = failure ? {} : { errorCode: '', errorMessage: '' };
const row = await Status.findOneAndUpdate(
{
provider: input.provider,
sourceId: input.sourceId,
...tenantStatusCondition(input.tenantId),
},
{
$set: setPayload,
...(failure ? {} : { $unset: unsetPayload }),
$setOnInsert: {
provider: input.provider,
sourceId: input.sourceId,
...(input.tenantId ? { tenantId: input.tenantId } : {}),
},
},
{ upsert: true, new: true, setDefaultsOnInsert: true },
).lean<ISkillSyncStatus>();
return row;
}
async function tryAcquireSkillSyncLock(params: SkillSyncLockInput): Promise<boolean> {
const Status = mongoose.models.SkillSyncStatus as Model<ISkillSyncStatusDocument>;
const now = new Date();
const lockExpiresAt = new Date(now.getTime() + params.leaseMs);
const existing = await Status.findOne({
provider: params.provider,
sourceId: LOCK_SOURCE_ID,
...tenantStatusCondition(params.tenantId),
}).lean<ISkillSyncStatus | null>();
if (existing?.lockOwner && existing.lockExpiresAt && existing.lockExpiresAt > now) {
return false;
}
if (!existing) {
try {
await Status.create({
provider: params.provider,
sourceId: LOCK_SOURCE_ID,
...(params.tenantId ? { tenantId: params.tenantId } : {}),
status: 'running',
lockOwner: params.lockOwner,
lockExpiresAt,
startedAt: now,
});
return true;
} catch (error) {
if ((error as { code?: number }).code === 11000) {
return false;
}
throw error;
}
}
try {
const row = await Status.findOneAndUpdate(
{
provider: params.provider,
sourceId: LOCK_SOURCE_ID,
...tenantStatusCondition(params.tenantId),
$or: [{ lockExpiresAt: { $exists: false } }, { lockExpiresAt: { $lte: now } }],
},
{
$set: {
status: 'running',
lockOwner: params.lockOwner,
lockExpiresAt,
startedAt: now,
},
$setOnInsert: {
provider: params.provider,
sourceId: LOCK_SOURCE_ID,
...(params.tenantId ? { tenantId: params.tenantId } : {}),
},
},
{ upsert: true, new: true, setDefaultsOnInsert: true },
).lean();
return (row as ISkillSyncStatus | null)?.lockOwner === params.lockOwner;
} catch (error) {
if ((error as { code?: number }).code === 11000) {
return false;
}
throw error;
}
}
async function refreshSkillSyncLock(params: SkillSyncLockInput): Promise<boolean> {
const Status = mongoose.models.SkillSyncStatus as Model<ISkillSyncStatusDocument>;
const now = new Date();
const row = await Status.findOneAndUpdate(
{
provider: params.provider,
sourceId: LOCK_SOURCE_ID,
...tenantStatusCondition(params.tenantId),
lockOwner: params.lockOwner,
lockExpiresAt: { $gt: now },
},
{
$set: {
status: 'running',
lockExpiresAt: new Date(now.getTime() + params.leaseMs),
},
},
{ new: true },
).lean<ISkillSyncStatus | null>();
return Boolean(row);
}
async function releaseSkillSyncLock(params: SkillSyncReleaseLockInput): Promise<void> {
const Status = mongoose.models.SkillSyncStatus as Model<ISkillSyncStatusDocument>;
await Status.updateOne(
{
provider: params.provider,
sourceId: LOCK_SOURCE_ID,
...tenantStatusCondition(params.tenantId),
lockOwner: params.lockOwner,
},
{
$set: {
status: 'idle',
finishedAt: new Date(),
},
$unset: {
lockOwner: '',
lockExpiresAt: '',
},
},
);
}
return {
upsertSkillSyncCredential,
deleteSkillSyncCredential,
listSkillSyncCredentials,
getSkillSyncCredentialToken,
getSkillSyncCredentialSummary,
listSkillSyncStatuses,
upsertSkillSyncStatus,
tryAcquireSkillSyncLock,
refreshSkillSyncLock,
releaseSkillSyncLock,
};
}