Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
15.7 KB
Raw Blame
export type ResourceSnapshotConfigItem = {
  configItemId: string;
  lastUpdatedAt: string;
};

export type ResourceSnapshotPlugin = {
  pluginId: string;
  lastUpdatedAt: string;
  configItems: ResourceSnapshotConfigItem[];
};

export type ResourceSnapshotMarketplace = {
  lastUpdatedAt: string;
  plugins: ResourceSnapshotPlugin[];
};

export type ResourceSnapshot = {
  organizationId: string;
  orgMemberId: string;
  teamIds: string[];
  resources: {
    llmProviders: Record<string, string>;
    marketplaces: Record<string, ResourceSnapshotMarketplace>;
  };
};

export type DesktopCloudSyncChangeKind = "new" | "modified" | "removed";
export type DesktopCloudSyncResourceKind = "llmProvider" | "marketplace" | "plugin" | "configItem";

export type DesktopCloudSyncChange = {
  id: string;
  kind: DesktopCloudSyncChangeKind;
  resourceKind: DesktopCloudSyncResourceKind;
  marketplaceId?: string;
  pluginId?: string;
  previousLastUpdatedAt: string | null;
  nextLastUpdatedAt: string | null;
  queuedAt: number;
};

export type DesktopCloudSyncEntry = {
  contextKey: string;
  fetchedAt: number;
  organizationId: string;
  orgMemberId: string;
  pendingChanges: DesktopCloudSyncChange[];
  snapshot: ResourceSnapshot;
  teamIds: string[];
};

export type DesktopCloudSyncState = {
  entries: Record<string, DesktopCloudSyncEntry>;
  updatedAt: number;
  version: 1;
};

type CloudImportedProvider = {
  cloudProviderId: string;
  updatedAt: string | null;
};

type CloudImportedMarketplace = {
  marketplaceId: string;
  updatedAt: string | null;
};

type CloudImportedPluginFile = {
  configObjectId: string;
  updatedAt: string | null;
};

type CloudImportedPlugin = {
  pluginId: string;
  marketplaceId: string | null;
  updatedAt: string | null;
  files: CloudImportedPluginFile[];
};

type WorkspaceCloudImports = {
  providers: Record<string, CloudImportedProvider>;
  marketplaces: Record<string, CloudImportedMarketplace>;
  plugins: Record<string, CloudImportedPlugin>;
};

function isRecord(value: unknown): value is Record<string, unknown> {
  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
}

function readStringArray(value: unknown): string[] {
  return Array.isArray(value)
    ? value.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)
    : [];
}

function readTimestampRecord(value: unknown): Record<string, string> {
  if (!isRecord(value)) return {};

  const record: Record<string, string> = {};
  for (const [key, entry] of Object.entries(value)) {
    const id = key.trim();
    const timestampValue = typeof entry === "string" ? entry.trim() : "";
    if (id && timestampValue) {
      record[id] = timestampValue;
    }
  }
  return record;
}

function readResourceSnapshotConfigItems(value: unknown): ResourceSnapshotConfigItem[] {
  if (!Array.isArray(value)) return [];

  return value.flatMap((entry) => {
    if (!isRecord(entry)) return [];
    const configItemId = typeof entry.configItemId === "string" ? entry.configItemId.trim() : "";
    const lastUpdatedAt = typeof entry.lastUpdatedAt === "string" ? entry.lastUpdatedAt.trim() : "";
    return configItemId && lastUpdatedAt ? [{ configItemId, lastUpdatedAt }] : [];
  });
}

function readResourceSnapshotPlugins(value: unknown): ResourceSnapshotPlugin[] {
  if (!Array.isArray(value)) return [];

  return value.flatMap((entry) => {
    if (!isRecord(entry)) return [];
    const pluginId = typeof entry.pluginId === "string" ? entry.pluginId.trim() : "";
    const lastUpdatedAt = typeof entry.lastUpdatedAt === "string" ? entry.lastUpdatedAt.trim() : "";
    if (!pluginId || !lastUpdatedAt) return [];

    return [{
      pluginId,
      lastUpdatedAt,
      configItems: readResourceSnapshotConfigItems(entry.configItems),
    }];
  });
}

function readResourceSnapshotMarketplaces(value: unknown): Record<string, ResourceSnapshotMarketplace> {
  if (!isRecord(value)) return {};

  const marketplaces: Record<string, ResourceSnapshotMarketplace> = {};
  for (const [key, entry] of Object.entries(value)) {
    if (!isRecord(entry)) continue;
    const marketplaceId = key.trim();
    const lastUpdatedAt = typeof entry.lastUpdatedAt === "string" ? entry.lastUpdatedAt.trim() : "";
    if (!marketplaceId || !lastUpdatedAt) continue;
    marketplaces[marketplaceId] = {
      lastUpdatedAt,
      plugins: readResourceSnapshotPlugins(entry.plugins),
    };
  }
  return marketplaces;
}

export function normalizeResourceSnapshot(value: unknown): ResourceSnapshot | null {
  if (!isRecord(value)) return null;
  const organizationId = typeof value.organizationId === "string" ? value.organizationId.trim() : "";
  const orgMemberId = typeof value.orgMemberId === "string" ? value.orgMemberId.trim() : "";
  const resources = isRecord(value.resources) ? value.resources : null;
  if (!organizationId || !orgMemberId || !resources) return null;

  return {
    organizationId,
    orgMemberId,
    teamIds: readStringArray(value.teamIds),
    resources: {
      llmProviders: readTimestampRecord(resources.llmProviders),
      marketplaces: readResourceSnapshotMarketplaces(resources.marketplaces),
    },
  };
}

function readString(value: unknown): string | null {
  return typeof value === "string" ? value.trim() || null : null;
}

function readImportedProviders(value: unknown): Record<string, CloudImportedProvider> {
  if (!isRecord(value)) return {};

  const providers: Record<string, CloudImportedProvider> = {};
  for (const [key, entry] of Object.entries(value)) {
    if (!isRecord(entry)) continue;
    const cloudProviderId = readString(entry.cloudProviderId) ?? key.trim();
    if (!cloudProviderId) continue;
    providers[cloudProviderId] = {
      cloudProviderId,
      updatedAt: readString(entry.updatedAt),
    };
  }
  return providers;
}

function readImportedMarketplaces(value: unknown): Record<string, CloudImportedMarketplace> {
  if (!isRecord(value)) return {};

  const marketplaces: Record<string, CloudImportedMarketplace> = {};
  for (const [key, entry] of Object.entries(value)) {
    if (!isRecord(entry)) continue;
    const marketplaceId = readString(entry.marketplaceId) ?? key.trim();
    if (!marketplaceId) continue;
    marketplaces[marketplaceId] = {
      marketplaceId,
      updatedAt: readString(entry.updatedAt),
    };
  }
  return marketplaces;
}

function readImportedPluginFiles(value: unknown): CloudImportedPluginFile[] {
  if (!Array.isArray(value)) return [];

  return value.flatMap((entry) => {
    if (!isRecord(entry)) return [];
    const configObjectId = readString(entry.configObjectId);
    if (!configObjectId) return [];
    return [{
      configObjectId,
      updatedAt: readString(entry.updatedAt),
    }];
  });
}

function readImportedPlugins(value: unknown): Record<string, CloudImportedPlugin> {
  if (!isRecord(value)) return {};

  const plugins: Record<string, CloudImportedPlugin> = {};
  for (const [key, entry] of Object.entries(value)) {
    if (!isRecord(entry)) continue;
    const pluginId = readString(entry.pluginId) ?? key.trim();
    if (!pluginId) continue;
    plugins[pluginId] = {
      pluginId,
      marketplaceId: readString(entry.marketplaceId),
      updatedAt: readString(entry.updatedAt),
      files: readImportedPluginFiles(entry.files),
    };
  }
  return plugins;
}

export function readWorkspaceCloudImports(omnirush: Record<string, unknown>): WorkspaceCloudImports {
  const cloudImports = isRecord(omnirush.cloudImports) ? omnirush.cloudImports : {};
  return {
    providers: readImportedProviders(cloudImports.providers),
    marketplaces: readImportedMarketplaces(cloudImports.marketplaces),
    plugins: readImportedPlugins(cloudImports.plugins),
  };
}

function readChange(value: unknown): DesktopCloudSyncChange | null {
  if (!isRecord(value)) return null;
  const id = readString(value.id);
  const kind = value.kind === "new" || value.kind === "modified" || value.kind === "removed"
    ? value.kind
    : null;
  const resourceKind = value.resourceKind === "llmProvider" ||
    value.resourceKind === "marketplace" ||
    value.resourceKind === "plugin" ||
    value.resourceKind === "configItem"
    ? value.resourceKind
    : null;
  const queuedAt = typeof value.queuedAt === "number" && Number.isFinite(value.queuedAt)
    ? value.queuedAt
    : Date.now();
  if (!id || !kind || !resourceKind) return null;

  return {
    id,
    kind,
    resourceKind,
    marketplaceId: readString(value.marketplaceId) ?? undefined,
    pluginId: readString(value.pluginId) ?? undefined,
    previousLastUpdatedAt: readString(value.previousLastUpdatedAt),
    nextLastUpdatedAt: readString(value.nextLastUpdatedAt),
    queuedAt,
  };
}

function readDesktopCloudSyncEntry(contextKey: string, value: unknown): DesktopCloudSyncEntry | null {
  if (!isRecord(value)) return null;
  const snapshot = normalizeResourceSnapshot(value.snapshot);
  if (!snapshot) return null;

  return {
    contextKey,
    fetchedAt: typeof value.fetchedAt === "number" && Number.isFinite(value.fetchedAt) ? value.fetchedAt : 0,
    organizationId: readString(value.organizationId) ?? snapshot.organizationId,
    orgMemberId: readString(value.orgMemberId) ?? snapshot.orgMemberId,
    pendingChanges: Array.isArray(value.pendingChanges)
      ? value.pendingChanges.flatMap((entry) => {
          const change = readChange(entry);
          return change ? [change] : [];
        })
      : [],
    snapshot,
    teamIds: readStringArray(value.teamIds),
  };
}

export function readDesktopCloudSyncState(omnirush: Record<string, unknown>): DesktopCloudSyncState {
  const raw = isRecord(omnirush.desktopCloudSync) ? omnirush.desktopCloudSync : {};
  const rawEntries = isRecord(raw.entries) ? raw.entries : {};
  const entries: Record<string, DesktopCloudSyncEntry> = {};
  for (const [key, entry] of Object.entries(rawEntries)) {
    const contextKey = key.trim();
    const parsed = contextKey ? readDesktopCloudSyncEntry(contextKey, entry) : null;
    if (parsed) entries[contextKey] = parsed;
  }

  return {
    entries,
    updatedAt: typeof raw.updatedAt === "number" && Number.isFinite(raw.updatedAt) ? raw.updatedAt : 0,
    version: 1,
  };
}

function contextKey(snapshot: ResourceSnapshot): string {
  return [snapshot.organizationId, snapshot.orgMemberId].join("::");
}

function changeKey(change: Pick<DesktopCloudSyncChange, "id" | "marketplaceId" | "pluginId" | "resourceKind">) {
  return [change.resourceKind, change.marketplaceId ?? "", change.pluginId ?? "", change.id].join("::");
}

function mergePendingChanges(previous: DesktopCloudSyncChange[], next: DesktopCloudSyncChange[]) {
  if (next.length === 0) return previous;
  const nextKeys = new Set(next.map(changeKey));
  return [
    ...previous.filter((change) => !nextKeys.has(changeKey(change))),
    ...next,
  ];
}

function findRemotePlugin(snapshot: ResourceSnapshot, input: { marketplaceId?: string | null; pluginId: string }) {
  const preferredMarketplaceId = input.marketplaceId?.trim() ?? "";
  if (preferredMarketplaceId) {
    const marketplace = snapshot.resources.marketplaces[preferredMarketplaceId];
    const plugin = marketplace?.plugins.find((entry) => entry.pluginId === input.pluginId) ?? null;
    if (plugin) return { marketplaceId: preferredMarketplaceId, plugin };
  }

  for (const [marketplaceId, marketplace] of Object.entries(snapshot.resources.marketplaces)) {
    const plugin = marketplace.plugins.find((entry) => entry.pluginId === input.pluginId) ?? null;
    if (plugin) return { marketplaceId, plugin };
  }
  return null;
}

function queueInstalledChange(input: {
  changes: DesktopCloudSyncChange[];
  id: string;
  installedLastUpdatedAt: string | null;
  marketplaceId?: string;
  pluginId?: string;
  queuedAt: number;
  remoteLastUpdatedAt: string | null;
  resourceKind: DesktopCloudSyncResourceKind;
}) {
  if (!input.remoteLastUpdatedAt) {
    input.changes.push({
      id: input.id,
      kind: "removed",
      resourceKind: input.resourceKind,
      marketplaceId: input.marketplaceId,
      pluginId: input.pluginId,
      previousLastUpdatedAt: input.installedLastUpdatedAt,
      nextLastUpdatedAt: null,
      queuedAt: input.queuedAt,
    });
    return;
  }

  if (!input.installedLastUpdatedAt) {
    input.changes.push({
      id: input.id,
      kind: "new",
      resourceKind: input.resourceKind,
      marketplaceId: input.marketplaceId,
      pluginId: input.pluginId,
      previousLastUpdatedAt: null,
      nextLastUpdatedAt: input.remoteLastUpdatedAt,
      queuedAt: input.queuedAt,
    });
    return;
  }

  if (input.installedLastUpdatedAt !== input.remoteLastUpdatedAt) {
    input.changes.push({
      id: input.id,
      kind: "modified",
      resourceKind: input.resourceKind,
      marketplaceId: input.marketplaceId,
      pluginId: input.pluginId,
      previousLastUpdatedAt: input.installedLastUpdatedAt,
      nextLastUpdatedAt: input.remoteLastUpdatedAt,
      queuedAt: input.queuedAt,
    });
  }
}

function diffInstalledCloudResources(
  cloudImports: WorkspaceCloudImports,
  snapshot: ResourceSnapshot,
  queuedAt: number,
): DesktopCloudSyncChange[] {
  const changes: DesktopCloudSyncChange[] = [];

  for (const provider of Object.values(cloudImports.providers)) {
    queueInstalledChange({
      changes,
      id: provider.cloudProviderId,
      installedLastUpdatedAt: provider.updatedAt,
      queuedAt,
      remoteLastUpdatedAt: snapshot.resources.llmProviders[provider.cloudProviderId] ?? null,
      resourceKind: "llmProvider",
    });
  }

  for (const marketplace of Object.values(cloudImports.marketplaces)) {
    queueInstalledChange({
      changes,
      id: marketplace.marketplaceId,
      installedLastUpdatedAt: marketplace.updatedAt,
      queuedAt,
      remoteLastUpdatedAt: snapshot.resources.marketplaces[marketplace.marketplaceId]?.lastUpdatedAt ?? null,
      resourceKind: "marketplace",
    });
  }

  for (const plugin of Object.values(cloudImports.plugins)) {
    const remote = findRemotePlugin(snapshot, { marketplaceId: plugin.marketplaceId, pluginId: plugin.pluginId });
    queueInstalledChange({
      changes,
      id: plugin.pluginId,
      installedLastUpdatedAt: plugin.updatedAt,
      marketplaceId: remote?.marketplaceId ?? plugin.marketplaceId ?? undefined,
      queuedAt,
      remoteLastUpdatedAt: remote?.plugin.lastUpdatedAt ?? null,
      resourceKind: "plugin",
    });

    for (const file of plugin.files) {
      const remoteConfigItem = remote?.plugin.configItems.find((entry) => entry.configItemId === file.configObjectId) ?? null;
      queueInstalledChange({
        changes,
        id: file.configObjectId,
        installedLastUpdatedAt: file.updatedAt,
        marketplaceId: remote?.marketplaceId ?? plugin.marketplaceId ?? undefined,
        pluginId: plugin.pluginId,
        queuedAt,
        remoteLastUpdatedAt: remoteConfigItem?.lastUpdatedAt ?? null,
        resourceKind: "configItem",
      });
    }
  }

  return changes;
}

export function syncDesktopCloudResources(input: {
  now?: number;
  omnirush: Record<string, unknown>;
  snapshot: ResourceSnapshot;
}) {
  const now = input.now ?? Date.now();
  const state = readDesktopCloudSyncState(input.omnirush);
  const key = contextKey(input.snapshot);
  const previousEntry = state.entries[key] ?? null;
  const changes = diffInstalledCloudResources(readWorkspaceCloudImports(input.omnirush), input.snapshot, now);
  const entry: DesktopCloudSyncEntry = {
    contextKey: key,
    fetchedAt: now,
    organizationId: input.snapshot.organizationId,
    orgMemberId: input.snapshot.orgMemberId,
    pendingChanges: mergePendingChanges(previousEntry?.pendingChanges ?? [], changes),
    snapshot: input.snapshot,
    teamIds: input.snapshot.teamIds,
  };
  const nextState: DesktopCloudSyncState = {
    entries: {
      ...state.entries,
      [key]: entry,
    },
    updatedAt: now,
    version: 1,
  };

  return {
    changes,
    omnirush: {
      ...input.omnirush,
      desktopCloudSync: nextState,
    },
    state: nextState,
  };
}